負載平衡CloudSim

Question

我最近一直在努力將雲計算作為我學院任務的一部分。

我一直在嘗試使用CloudSim實現一種新的負載平衡算法（已在一些研究論文中提出）。

請幫我解決這個算法，我有一些實現它的主要問題。

這是代碼

/*
* Title: Load Balancing in Cloud Computing
*/
package org.cloudbus.cloudsim;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public final class MyPolicyNew extends VmAllocationPolicy {

    private Map<String, Host> vmTable;
    private Map<String, Integer> usedPes;
    private List<Integer> freePes;

    private int status[] = new int[100];

    public MyPolicyNew(List<? extends Host> list) {
        super(list);
        setFreePes(new ArrayList<Integer>());
        for (Host host : getHostList()) {
            getFreePes().add(host.getPesNumber());

        }

        setVmTable(new HashMap<String, Host>());
        setUsedPes(new HashMap<String, Integer>());
    }

@Override

public boolean allocateHostForVm(Vm vm) {
    int idx = -1;
    int requiredPes;
    requiredPes = vm.getPesNumber();
    boolean result = false;
    int tries = 0; 
    List<Integer> freePesTmp = new ArrayList<Integer>();

    for (Integer freePes : getFreePes()) {
        freePesTmp.add(freePes);
    }
    int tempstatus[] = new int[100];
    for(int j=0; j<100; j++){
        tempstatus[j]= status[j];
    }
    if (!getVmTable().containsKey(vm.getUid())) {
        do {
            int moreFree = Integer.MIN_VALUE;
            for (int i=0; i < freePesTmp.size(); i++) {
                if ((freePesTmp.get(i) > moreFree) && (tempstatus[i]!=1)) {
                    moreFree = freePesTmp.get(i);
                    idx = i;
                }
                tempstatus[idx]=1;
                int flag=0;
                for(int j=0; j< freePesTmp.size(); j++)
                { //
                    if(tempstatus[j]==1)
                        flag=1;
                    else
                        flag=0;
                }
                if(flag==1){
                    moreFree = Integer.MIN_VALUE;
                    for (int k=0; k < freePesTmp.size(); k++) {
                        if (freePesTmp.get(k) > moreFree) {
                            moreFree = freePesTmp.get(k);
                            idx = k;
                        }
                    }
                }
            }
            Host host = getHostList().get(idx);
            result = host.vmCreate(vm);

            if (result) {
                getVmTable().put(vm.getUid(), host);
                getUsedPes().put(vm.getUid(), requiredPes);

                getFreePes().set(idx, getFreePes().get(idx) - requiredPes);
                status[idx]=1;
                result = true;
                break;
            }
            else {
                freePesTmp.set(idx, Integer.MIN_VALUE);
                tempstatus[idx]=0;
            }
            tries++;
        }while(!result && tries < getFreePes().size());
    }
    return result;
}

@Override
public void deallocateHostForVm(Vm vm) {

    Host host = getVmTable().remove(vm.getUid());
    int idx = getHostList().indexOf(host);
    int pes = getUsedPes().remove(vm.getUid());
    if (host != null) {
        host.vmDestroy(vm);
        status[idx]= 0;
    }
}

getFreePes().set(idx, getFreePes().get(idx) + pes);

@Override
public Host getHost(Vm vm) {
    return getVmTable().get(vm.getUid());
}

@Override
public Host getHost(int vmId, int userId) {
    return getVmTable().get(Vm.getUid(userId, vmId));
}

public Map<String, Host> getVmTable() {
    return vmTable;
}

protected void setVmTable(Map<String, Host> vmTable) {
    this.vmTable = vmTable;
}

protected Map<String, Integer> getUsedPes() {
    return usedPes;
}

protected void setUsedPes(Map<String, Integer> usedPes) {
    this.usedPes = usedPes;
}

protected List<Integer> getFreePes() {
    return freePes;
}

protected void setFreePes(List<Integer> freePes) {
    this.freePes = freePes;
}

@Override
public List<Map<String, Object>> optimizeAllocation(List<? extends Vm> vmList) {
    return null;
}

@Override
public boolean allocateHostForVm(Vm vm, Host host) {
    if (host.vmCreate(vm)){
        getVmTable().put(vm.getUid(), host);
        Log.formatLine("%.2f: VM #" + vm.getId() + " has been allocated to the host #" + host.getId(), CloudSim.clock());
        return true;
    }
    return false;
}

}

我在哪里使用函數getFreePes()我的NetBeans編譯器給出了一個錯誤void cannot be deferenced cannot find symbol getFreePes()並且cannot find symbol getFreePes() 。

算法背后的基本思想::算法檢查數據中心是否有任何空閑主機，如果有，那么它會為該主機分配一個進程，並減少該主機的空閑處理器數量。 如果沒有空閑主機，但有一些免費處理器，那么它會檢查具有最大處理器數量的主機，並將新的傳入進程分配給該主機。

請幫我解決這個代碼，我也不是很擅長Java，我更多的是一個C / C ++編碼器，所以，我在處理事情時遇到了一些問題，而且這對我來說是一個新的庫，所以我我不習慣它的大部分特性和功能，我的一些老人幫我提出了這個代碼，但現在它不起作用，請幫助我們。

在此先感謝您的幫助。 :)

Answer 1

我不知道你使用的是哪個版本的cloudim。 但我也在使用cloudsim 3.0.3版本，我也實現了一些負載均衡策略。

This is the policy I have implemented. Code is not written in good optimized way but it is working. You can give it a try. This is mynewVmallocationpolicy. I think you can see what you have mistaken.

public boolean allocateHostForVm(Vm vm) {
        int requiredPes = vm.getNumberOfPes();
    //  int requiredram = vm.getRam();
        int freeramh1=0;
        int freeramh2=0;
        int freepesh1=0;
        int freepesh2=0;
        boolean result = false;
        int tries = 0;
        List<Integer> freePesTmp = new ArrayList<Integer>();
        for (Integer freePes : getFreePes()) {
            freePesTmp.add(freePes);
        }

        List <Host> hostList =getHostList();


        if (!getVmTable().containsKey(vm.getUid())) { // if this vm was not created
            do {// we still trying until we find a host or until we try all of them

                int idx = -1;

                // we want the host with less pes in use
                    Host h1=hostList.get(0);
                    int j=0;
                    idx=0;
                    for (int i = 1; i < freePesTmp.size(); i++) {
                        Host h2=hostList.get(i);
                        freeramh1=h1.getRamProvisioner().getAvailableRam();
                        freeramh2=h2.getRamProvisioner().getAvailableRam();
                        freepesh1=freePesTmp.get(j);
                        freepesh2=freePesTmp.get(i);
                    //  Log.printLine( " freeram "+ freeramh1 + "h2" + freeramh2 + "free pes " + freepesh1 + "h2" + freepesh2);
                        double diffram=0.0,diffpes=0.0;
                        if(freeramh2!=0 || freeramh1!=0){

                            diffram= (1.0*(freeramh2-freeramh1)/(freeramh2+freeramh1));

                        //  Log.printLine( " inside diffram " + diffram);
                        }
                        else
                            Log.printLine( " fault in ram " );
                        if(freepesh2!=0 || freepesh1!=0){
                            diffpes=(1.0*(freepesh1-freepesh2)/(freepesh1+freepesh2)) ;

                            //Log.printLine( " inside diffpes " + diffpes);
                        }
                        else
                            Log.printLine( " fault in pes ");

                        //Log.printLine( " diffram,diffpes "+ diffram + "diff pes " + diffpes );

                        if(diffram==diffpes || diffpes>diffram){
                            idx=j;  
                        }
                        else{
                            h1=h2;
                            j=i;
                            idx=i;
                            break;
                        }

                    }

                Host host = getHostList().get(idx);
                result = host.vmCreate(vm);

                if (result) { // if vm were succesfully created in the host
                    Log.printLine( " vm " +  "created" + "host" + idx);
                    getVmTable().put(vm.getUid(), host);
                    getUsedPes().put(vm.getUid(), requiredPes);
                    getFreePes().set(idx, getFreePes().get(idx) - requiredPes);
                    result = true;
                    break;
                } else {
                    freePesTmp.set(idx, Integer.MIN_VALUE);
                }
                tries++;
            } while (!result && tries < getFreePes().size());

        }

        return result;
    }

這段代碼工作正常。 你可以檢查什么是錯的。

Answer 2

這是VmAllocationPolicySimple定義的VmAllocationPolicySimple ，因此您無需實現它。 這是一個最差的策略，它選擇使用最少PE的主機來運行VM。

如果您想使用不同的策略，例如Best Fit，First Fit或實施您自己的策略，您可以嘗試CloudSim Plus ，這是一個最先進的，功能齊全，主動維護的CloudSim分支。 要創建自己的策略，您只需要擴展VmAllocationPolicyAbstract類並實現Optional<Host> findHostForVm(final Vm vm)方法。 這樣，您無需擔心類的所有內部細節。

例如，下面的方法是CloudSim Plus的VmAllocationPolicySimple類中用於實現主機最差適合主機分配策略的所有代碼：

public Optional<Host> findHostForVm(final Vm vm) {
    final Map<Host, Long> map = getHostFreePesMap();
    return map.entrySet()
        .stream()
        .filter(e -> e.getKey().isSuitableForVm(vm))
        .max(Comparator.comparingLong(Map.Entry::getValue))
        .map(Map.Entry::getKey);
}

在CloudSim Plus中，您甚至不需要創建VmAllocationPolicy子類來實現自定義策略。 檢查RandomVmAllocationPolicyExample.java以獲取詳細信息。