MBF.java

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Stack;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.Set;




public class MBF {


    static Random rand;
    static int m;
    static int n;
    static int d;


    public static void main(String[] args) {


        // read args
        String name=args[0];
        m=Integer.valueOf(args[1]);
        n=Integer.valueOf(args[2]);
        d=Integer.valueOf(args[3]);
        int d_cpu=Integer.valueOf(args[4]);
        float alpha=Float.parseFloat(args[5]);
        float beta=Float.parseFloat(args[6]);
        String app_path=args[7];
        String machine_path=args[8];
        String out_path=args[9];
        int seed=Integer.valueOf(args[10]);
        rand=new Random(seed);

        // read data
        int app=0;
        int machine=0;
        float[][] app_capacities=Main.read_app(app_path,n,d);
        float[][] machine_infomation=Main.read_machine(machine_path,m);

        float[][] machine_capacities=new float[m][d];
        float[] machine_cost=new float[m];
        int[] machine_type=new int[m];
        for(machine=0;machine<m;machine++){
            for(int i=0;i<d_cpu;i++){
                machine_capacities[machine][i]=machine_infomation[machine][0];
                machine_capacities[machine][i+d_cpu]=machine_infomation[machine][1];
            }
            machine_capacities[machine][d-1]=machine_infomation[machine][2];
            machine_cost[machine]=machine_infomation[machine][4];
            machine_type[machine]=(int)machine_infomation[machine][3];
        }

        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long start = threadMXBean.getCurrentThreadCpuTime();  // 获取当前线程 CPU 时间（纳秒）
        int[] app_target=new int[n];
        for(app=0;app<n;app++){
            app_target[app]=-1;
        }


        try {
            FileWriter result1 = new FileWriter(out_path+".txt");

            result1.write(name+"\n");
            result1.write(String.valueOf(seed)+"\n");
            
            //应用排序
            Integer[] apps=new Integer[n];
            for(app=0;app<n;app++){
                apps[app]=app;
            }
            List<Integer> list=Arrays.asList(apps);
            Collections.shuffle(list,rand);
            for(app=0;app<n;app++){
                apps[app]=list.get(app);
            }

            int total_type=0;
            for(machine=0;machine<m;machine++){
                if(total_type<machine_type[machine]){
                    total_type=machine_type[machine];
                }
            }
            total_type+=1;
            //初始化VM容量和开机情况
            float[][] tem_machine_capacities=new float[m][d];
            boolean[] machine_open=new boolean[m];
            for(machine=0;machine<m;machine++){
                tem_machine_capacities[machine]=machine_capacities[machine].clone();
                machine_open[machine]=false;
            }
            //初始化close_set,包含每种规格未打开的VM
            Set<Integer>[] close_sets = new HashSet[total_type];
            float[][] type_machine_capacities=new float[total_type][d];
            for(int i=0;i<total_type;i++){
                close_sets[i] = new HashSet<Integer>();
            }
            for(machine=0;machine<m;machine++){
                close_sets[machine_type[machine]].add(machine);
                type_machine_capacities[machine_type[machine]]=machine_capacities[machine].clone();
            }

            //计算各类资源的bottleneck程度
            double high_cpu=0;
            double high_mem=0;
            double high_disk=0;
            double[] app_sum=new double[d];
            double[] vm_sum=new double[d];
            double[] vm_avg=new double[d];
            for(app=0;app<n;app++){
                for(int i=0;i<d;i++){
                    app_sum[i]+=app_capacities[app][i];
                }
            }
            for(machine=0;machine<m;machine++){
                for(int i=0;i<d;i++){
                    vm_sum[i]+=machine_capacities[machine][i];
                }
            }
            for(int i=0;i<d;i++){
                vm_avg[i]+=vm_sum[i]/m;
            }
            for(int i=0;i<d;i++){
                if(i<d_cpu&&high_cpu<app_sum[i]/vm_sum[i]){
                    high_cpu=app_sum[i]/vm_sum[i];
                }
                if(i>=d_cpu&&i<2*d_cpu&&high_mem<app_sum[i]/vm_sum[i]){
                    high_mem=app_sum[i]/vm_sum[i];
                }
                if(i==d-1){
                    high_disk=app_sum[i]/vm_sum[i];
                }
            }

            //为每个应用分配VM
            for(int tem_app=0;tem_app<n;tem_app++){
                app=apps[tem_app];

                //place表示是否在不增大成本的基础上完成放置
                boolean place=false;

                //尝试在打开的主机上进行放置
                double min_fitness1=Double.MAX_VALUE;
                double min_fitness2=Double.MAX_VALUE;
                int target_machine=-1;
                for(machine=0;machine<m;machine++){
                    if(machine_open[machine]){
                        if(Main.check(app_capacities[app],tem_machine_capacities[machine])){
                            float[] tem_machine=tem_machine_capacities[machine].clone();
                            for(int i=0;i<d;i++){
                                tem_machine[i]-=app_capacities[app][i];
                            }
                            double fitness1=0;
                            double fitness2=0;
                            float cu=0;
                            boolean noover=true;
                            //计算放置后成本
                            for(int i=0;i<d_cpu;i++){
                                cu=1-tem_machine[i]/machine_capacities[machine][0];
                                fitness2+=(1+alpha*(Math.exp(cu)-1));
                                cu-=beta;
                                if(cu<=0){
                                    cu=0;
                                }else{
                                    noover=false;
                                }
                                fitness1+=(1+alpha*(Math.exp(cu)-1))*machine_cost[machine];
                            }
                            //优先选择不会带来额外成本（CPU>beta）的主机进行放置
                            if(noover){
                                place=true;
                                if(fitness1<min_fitness1 || (fitness1==min_fitness1 &&fitness2<min_fitness2)){
                                    min_fitness1=fitness1;
                                    min_fitness2=fitness2;
                                    target_machine=machine;
                                }
                            }else{
                                //如果都会带来额外成本（CPU>beta），则选择额外成本最小的主机
                                if(!place){
                                    if(fitness1-d_cpu*machine_cost[machine]<min_fitness1){
                                        min_fitness1=fitness1-d_cpu*machine_cost[machine];
                                        target_machine=machine;
                                    }
                                }
                            }
                        }
                    }
                }

                //如果在打开的主机上放置会带来额外成本，则尝试打开新的主机
                double min_score=Double.MAX_VALUE;
                int target_type=-1;
                if(!place){
                    for(int type=0;type<total_type;type++){
                        if(!close_sets[type].isEmpty()){
                            machine=close_sets[type].iterator().next();
                            if(Main.check(app_capacities[app],tem_machine_capacities[machine])){
                                float[] tem_machine=tem_machine_capacities[machine].clone();
                                for(int i=0;i<d;i++){
                                    tem_machine[i]-=app_capacities[app][i];
                                }
                                double fitness1=0;
                                float cu=0;
                                boolean noover=true;
                                for(int i=0;i<d_cpu;i++){
                                    cu=1-tem_machine[i]/machine_capacities[machine][0];
                                    cu-=beta;
                                    if(cu<=0){
                                        cu=0;
                                    }else{
                                        noover=false;
                                    }
                                    fitness1+=(1+alpha*(Math.exp(cu)-1))*machine_cost[machine];
                                }
                                //选择性价比最高的主机
                                if(noover){
                                    place=true;
                                    //计算机器CPU和内存性价比，越低越好（考虑资源bottleneck情况）
                                    double machine_score=Math.exp(high_cpu)*machine_cost[machine]/(machine_capacities[machine][0]/vm_avg[0])+Math.exp(high_mem)*machine_cost[machine]/(machine_capacities[machine][d_cpu]/vm_avg[d_cpu]);

                                    //考虑硬盘资源
                                    // double machine_score=Math.exp(high_cpu)*machine_cost[machine]/(machine_capacities[machine][0]/vm_avg[0])+Math.exp(high_mem)*machine_cost[machine]/(machine_capacities[machine][d_cpu]/vm_avg[d_cpu])+Math.exp(high_disk)*machine_cost[machine]/(machine_capacities[machine][2*d_cpu]/vm_avg[2*d_cpu]);

                                    if(machine_score<min_score){
                                        min_score=machine_score;
                                        target_machine=machine;
                                        target_type=type;
                                    }
                                }else{
                                    //如果仍有额外成本（CPU>beta），则选择额外成本最小的主机
                                    if(!place){
                                        if(fitness1-d_cpu*machine_cost[machine]<min_fitness1){
                                            min_fitness1=fitness1-d_cpu*machine_cost[machine];
                                            target_machine=machine;
                                            target_type=type;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if(target_machine==-1){
                    result1.write("error");
                    continue;
                }
                
                if(target_type!=-1){
                    close_sets[target_type].remove(target_machine);
                }
                machine_open[target_machine]=true;
                app_target[app]=target_machine;
                for(int i=0;i<d;i++){
                    tem_machine_capacities[target_machine][i]-=app_capacities[app][i];
                }
            }

            // write results
            long end = threadMXBean.getCurrentThreadCpuTime();
            result1.write(String.valueOf(end-start)+"\n");


            result1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        Main.write_result(out_path+".csv", app_target, n);


        
    }
    
}