CloudSim源码分析之startSimulation()

                                                                 CloudSim源码分析之startSimulation()

在CloudSim源码中的example都是通过startSimulation()启动仿真过程，实际上startSimulation()方法内部做了非常多的工作，此次博客将详细分析startSimulation()方法的工作流程。

startSimulation()是CloudSim类的静态方法，该方法在所有的实体被创建和加载之后调用，开始执行CloudSim仿真，直到所有的实体完全执行（所有的实体线程到达non-RUNNABLE状态或者在future队列中没有事件）才结束。

startSimulation()方法完成的核心工作：

1、启动所有在startSimulation()方法之前定义好的实体（CloudSimShutdown、CloudInformationService、Datacenter、DatacenterBroker）。核心是根据不同实体间的逻辑关系创建相关事件，并将事件添加到等待队列（future）。比如：datacenter实体首先需要向CIS注册，因此datacenter会创建一个向CIS请求注册的事件，并将该事件添加到等待队列；datacenterBroker实体需要知道数据中心特征，因此datacenterBroker会创建一个向datacenter实体请求数据中心特征的事件，并将该事件添加到等待队列。在下面的源码中会按照方法调用的深度详细分析。
    （1）startSimulation()源码分析：    

// CloudSim类的静态方法，该方法在所有的实体被创建和加载之后调用，开始执行CloudSim仿真，直到所有的实体完全执行

    // （所有的实体线程到达non-RUNNABLE状态或者在future队列中没有事件）才结束。

    public static double startSimulation() throws NullPointerException {
        Log.printLine("Starting CloudSim version " + CLOUDSIM_VERSION_STRING);
        try {
            // 开始仿真至结束

            double clock = run();

            // reset all static variables

            // 仿真结束，重设所有的静态变量

            cisId = -1;
            shutdownId = -1;
            cis = null;
            calendar = null;
            traceFlag = false;

            return clock;
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            throw new NullPointerException("CloudSim.startCloudSimulation() :"
                    + " Error - you haven't initialized CloudSim.");
        }
    }

   （2）run()开始仿真：

// 开始仿真直到结束仿真

    public static double run() {
        if (!running) {
            runStart(); // 开始仿真，start所有实体
        }
    .......
    }

   （3）runStart()启动所有仿真实体：

// 启动仿真实体

    public static void runStart() {
        running = true;
        // Start all the entities

        for (SimEntity ent : entities) {
            Log.printLine("实体名称:"+ent.getName());
            // 每个实体都继承了SimEntity类的startEntity（）方法，实际工作是向其他实体发送一个请求事件，

            // 并将该事件添加到future队列中。

            ent.startEntity();
        }

        printMessage("Entities started.");
    }

   （4）启动云实体datacenterBroker

// 启动云实体
    @Override
    public void startEntity() {
        Log.printLine(getName() + " is starting...");
        // 通过id和数据向另一个实体发送事件，请求数据中心特征
        schedule(getId(), 0, CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST);
    }

   （5）向另外实体发送事件

// 向另外一个实体发送关联事件

    public void schedule(int dest, double delay, int tag, Object data) {
        if (!CloudSim.running()) {
            return;
        }
        CloudSim.send(id, dest, delay, tag, data);
    }

   （6）创建仿真事件，并添加到等待队列

// 一个实体向另一个实体发送事件

    public static void send(int src, int dest, double delay, int tag, Object data) {
        // 事件发生的延时不能为负值

        if (delay < 0) {
            throw new IllegalArgumentException("Send delay can't be negative.");
        }

        // 创建一个仿真事件对象

        SimEvent e = new SimEvent(SimEvent.SEND, clock + delay, src, dest, tag, data);
        Log.printLine("````````````````````"+e.getTag());
        // 将创建的事件添加到等待队列中

        future.addEvent(e);
    }

2、处理具体的仿真任务，实际是处理延时队列以及等待队列中的各种事件。CloudSim允许仿真突然中止、在特定时刻中止仿真、在某一时刻暂停仿真，最主要也最一般的情况是在一个时钟心跳期间处理事件队列中的事件。在下面的源码中会按照方法调用的深度详细分析。
    （1）处理仿真事件

// 开始仿真直到结束仿真

    public static double run() {
        if (!running) {
            runStart(); // 开始仿真，start所有实体
        }
        while (true) {
            // 运行一个时钟心跳如果future中没有事件了，则runClockTick（）返回true，或者突然中断，while循环终止，仿真结束。
            if (runClockTick() || abruptTerminate) {
                break;
            }

            // this block allows termination of simulation at a specific time
            // 允许在特定的时间点终止仿真。
            if (terminateAt > 0.0 && clock >= terminateAt) {
                terminateSimulation(); // 终止仿真

                clock = terminateAt;
                break;
            }
            // 在某一时刻（pauseAt）暂停仿真
            if (pauseAt != -1
                    && ((future.size() > 0 && clock <= pauseAt && pauseAt <= future.iterator().next()
                            .eventTime()) || future.size() == 0 && pauseAt <= clock)) {
                pauseSimulation(); // 设置paused为true

                clock = pauseAt;
            }

            // 如果paused为true，则线程休眠100毫秒，但是何时会重新设置paused为false，终止暂定仿真呢？
            while (paused) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        ........
    }

   （2）处理延时队列和等待队列中的事件，分析runClockTick()方法

    // 运行一个时钟滴答，首先处理延时队列（deferred）中跟各个实体相关的事件。当延时队列为空时，
    // 处理等待队列（future）中的事件，问题是deferred中的事件是何时从future中添加过来的？
    public static boolean runClockTick() {
        SimEntity ent;
        boolean queue_empty;
        int entities_size = entities.size(); // 实体的个数

        for (int i = 0; i < entities_size; i++) { // 逐个获取实体

            ent = entities.get(i);
            if (ent.getState() == SimEntity.RUNNABLE) { // 设置实体状态为RUNNABLE

                // run()是各实体类继承了SimEntity类的方法，作用是处理与各个实体相关的事件。
                ent.run();
            }
        }

        // If there are more future events then deal with them
        // 等待队列中还有未处理的事件
        if (future.size() > 0) {
            List<SimEvent> toRemove = new ArrayList<SimEvent>();
            Iterator<SimEvent> it = future.iterator();
            queue_empty = false;
            SimEvent first = it.next();
            processEvent(first);// 直接处理了！事件何时添加到future队列中呢？

            future.remove(first);

            it = future.iterator();

            // Check if next events are at same time...
            boolean trymore = it.hasNext();
            while (trymore) {
                SimEvent next = it.next();
                // 检查下一个事件的时间是否相同，相同则处理下一个事件，因为必须在同一个时钟心跳。
                if (next.eventTime() == first.eventTime()) {
                    processEvent(next);
                    toRemove.add(next);
                    trymore = it.hasNext();
                } else {
                    trymore = false;
                }
            }

            future.removeAll(toRemove);

        } else {
            queue_empty = true;
            running = false;
            printMessage("Simulation: No more future events");
        }

        return queue_empty;
    }

    （3）分析SimEntity类的run()方法

    //所有的实体都直接继承了run()方法，并没有重写。
    public void run() {

        // evbuf如果为null，则ev=getNextEvent(),否则ev=evbuf.
        // getNextEvent():获取延时队列（deferred）中第一个事件（可算找到你了）
        SimEvent ev = evbuf != null ? evbuf : getNextEvent();

        while (ev != null) {

            // 每个实体类都有自己的processEvent（）方法，哪个实体调用了run（）方法，就会调用其processEvent（）方法。
            processEvent(ev);
            if (state != RUNNABLE) {
                break;
            }

            ev = getNextEvent();
        }

        evbuf = null;
    }

    （4）每个实体类都重载了processEvent()方法，负责处理与自己相关的事件

// DatacenterBroker重载的processEvent（）方法
public void processEvent(SimEvent ev) {
        switch (ev.getTag()) {
        // Resource characteristics request

            case CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST:
                processResourceCharacteristicsRequest(ev);
                break;
            // Resource characteristics answer

            case CloudSimTags.RESOURCE_CHARACTERISTICS:
                processResourceCharacteristics(ev);
                break;
            // VM Creation answer

            case CloudSimTags.VM_CREATE_ACK:
                processVmCreate(ev);
                break;
            // A finished cloudlet returned

            case CloudSimTags.CLOUDLET_RETURN:
                processCloudletReturn(ev);
                break;
            // if the simulation finishes

            case CloudSimTags.END_OF_SIMULATION:
                shutdownEntity();
                break;
            // other unknown tags are processed by this method

            default:
                processOtherEvent(ev);
                break;
        }
    }

3、获取仿真运行时间，仿真完成，运行结束。

// 开始仿真直到结束仿真

    public static double run() {
        if (!running) {
            runStart(); // 开始仿真，start所有实体

        }
        while (true) {
            // 运行一个时钟心跳如果future中没有事件了，则runClockTick（）返回true，或者突然中断，while循环终止，仿真结束。
            if (runClockTick() || abruptTerminate) {
                break;
            }

            // this block allows termination of simulation at a specific time
            // 允许在特定的时间点终止仿真。
            if (terminateAt > 0.0 && clock >= terminateAt) {
                terminateSimulation(); // 终止仿真

                clock = terminateAt;
                break;
            }

            // 在某一时刻（pauseAt）暂停仿真
            if (pauseAt != -1
                    && (