import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
private void sendInternalEvent() {
	if(channelTable.size() != 0) {
		if(nextEventTime == CloudSim.clock() + NetworkOperatingSystem.getMinTimeBetweenNetworkEvents())
			return;
		
		// More to process. Send event again
		double delay = this.nextFinishTime();

		// Shape the delay
		delay=NetworkOperatingSystem.round(delay);

		if (delay < NetworkOperatingSystem.getMinTimeBetweenNetworkEvents()) { 
			//Log.printLine(CloudSim.clock() + ":Channel: delay is too short: "+ delay);
			delay = NetworkOperatingSystem.getMinTimeBetweenNetworkEvents();
		}

		//Log.printLine(CloudSim.clock() + ": " + getName() + ".sendInternalEvent(): next finish time: "+ delay);

		if((nextEventTime > CloudSim.clock() + delay) || nextEventTime <= CloudSim.clock() ) 
		{
			CloudSim.cancelAll(getId(), new PredicateType(Constants.SDN_INTERNAL_PACKET_PROCESS));
			send(this.getId(), delay, Constants.SDN_INTERNAL_PACKET_PROCESS);
			nextEventTime = CloudSim.clock()+delay;
		}
	}
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
protected void processpacket(SimEvent ev) {
	// send packet to itself with switching delay (discarding other)
	CloudSim.cancelAll(getId(), new PredicateType(CloudSimTags.Network_Event_UP));
	schedule(getId(), switching_delay, CloudSimTags.Network_Event_UP);
	pktlist.add((NetworkPacket) ev.getData());

	// add the packet in the list

}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
/**
 * Send Packet to switch connected through a downlink port
 * 
 * @param ev Event/packet to process
 */

@Override
protected void processpacket_down(SimEvent ev) {
	// packet coming from up level router.
	// has to send downward
	// check which switch to forward to
	// add packet in the switch list
	// add packet in the host list
	NetworkPacket hspkt = (NetworkPacket) ev.getData();
	int recvVMid = hspkt.pkt.reciever;
	CloudSim.cancelAll(getId(), new PredicateType(CloudSimTags.Network_Event_send));
	schedule(getId(), latency, CloudSimTags.Network_Event_send);

	if (level == NetworkConstants.Agg_LEVEL) {
		// packet is coming from root so need to be sent to edgelevel swich
		// find the id for edgelevel switch
		int switchid = dc.VmToSwitchid.get(recvVMid);
		List<NetworkPacket> pktlist = downlinkswitchpktlist.get(switchid);
		if (pktlist == null) {
			pktlist = new ArrayList<NetworkPacket>();
			downlinkswitchpktlist.put(switchid, pktlist);
		}
		pktlist.add(hspkt);
		return;
	}

}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
/**
 * Send Packet to switch connected through a downlink port
 * 
 * @param ev Event/packet to process
 */
@Override
protected void processpacket_up(SimEvent ev) {

	// packet coming from down level router.
	// has to send up
	// check which switch to forward to
	// add packet in the switch list

	NetworkPacket hspkt = (NetworkPacket) ev.getData();
	int recvVMid = hspkt.pkt.reciever;
	CloudSim.cancelAll(getId(), new PredicateType(CloudSimTags.Network_Event_send));
	schedule(getId(), switching_delay, CloudSimTags.Network_Event_send);

	if (level == NetworkConstants.ROOT_LEVEL) {
		// get id of edge router
		int edgeswitchid = dc.VmToSwitchid.get(recvVMid);
		// search which aggregate switch has it
		int aggSwtichid = -1;
		;
		for (Switch sw : downlinkswitches) {
			for (Switch edge : sw.downlinkswitches) {
				if (edge.getId() == edgeswitchid) {
					aggSwtichid = sw.getId();
					break;
				}
			}
		}
		if (aggSwtichid < 0) {
			System.out.println(" No destination for this packet");
		} else {
			List<NetworkPacket> pktlist = downlinkswitchpktlist.get(aggSwtichid);
			if (pktlist == null) {
				pktlist = new ArrayList<NetworkPacket>();
				downlinkswitchpktlist.put(aggSwtichid, pktlist);
			}
			pktlist.add(hspkt);
		}
	}
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
@Override
protected void processVmMigrate(SimEvent ev, boolean ack) {
	updateCloudetProcessingWithoutSchedulingFutureEvents();
	super.processVmMigrate(ev, ack);
	SimEvent event = CloudSim.findFirstDeferred(getId(), new PredicateType(CloudSimTags.VM_MIGRATE));
	if (event == null || event.eventTime() > CloudSim.clock()) {
		updateCloudetProcessingWithoutSchedulingFutureEventsForce();
	}
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
private void sendInternalEvent() {
	CloudSim.cancelAll(getId(), new PredicateType(Constants.SDN_INTERNAL_PACKAGE_PROCESS));
	
	if(channelTable.size() != 0) {
		// More to process. Send event again
		double delay = this.nextFinishTime();
		Log.printLine(CloudSim.clock() + ": " + getName() + ".sendInternalEvent(): next finish time: "+ delay);
		
		send(this.getId(), delay, Constants.SDN_INTERNAL_PACKAGE_PROCESS);
	}
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
/**
 * Sends a packet to Datacenter connected through a downlink port.
 *
 * @param ev Event/packet to process
 */
protected void processPacketDown(SimEvent ev) {
    // packet coming from up level router
    // has to send downward.
    // check which switch to forward to
    // add packet in the switch list
    // add packet in the host list
    // int src=ev.getSource();
    getSimulation().cancelAll(getId(), new PredicateType(CloudSimTags.NETWORK_EVENT_SEND));
    schedule(getId(), getSwitchingDelay(), CloudSimTags.NETWORK_EVENT_SEND);
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
/**
 * Sends a packet to Datacenter connected through a uplink port.
 *
 * @param ev Event/packet to process
 */
protected void processPacketUp(SimEvent ev) {
    // packet coming from down level router has to be sent up.
    // check which switch to forward to and add packet in the switch list
    getSimulation().cancelAll(getId(), new PredicateType(CloudSimTags.NETWORK_EVENT_SEND));
    schedule(getId(), switchingDelay, CloudSimTags.NETWORK_EVENT_SEND);
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
@Override
protected double updateCloudletProcessing() {
    if (getLastCloudletProcessingTime() == -1 || getLastCloudletProcessingTime() == getSimulation().clock()) {
        getSimulation().cancelAll(getId(), new PredicateType(CloudSimTags.VM_UPDATE_CLOUDLET_PROCESSING_EVENT));
        schedule(getId(), getSchedulingInterval(), CloudSimTags.VM_UPDATE_CLOUDLET_PROCESSING_EVENT);
        return Double.MAX_VALUE;
    }

    final double currentTime = getSimulation().clock();

    if (currentTime > getLastProcessTime()) {
        Log.printLine("\n");
        final double dcPowerUsageForTimeSpan = getDatacenterPowerUsageForTimeSpan();
        Log.printFormattedLine("\n%.2f: Consumed energy is %.2f W*sec\n", getSimulation().clock(), dcPowerUsageForTimeSpan);

        Log.printLine("\n\n--------------------------------------------------------------\n\n");
        final double nextCloudletFinishTime = getNextCloudletFinishTime(currentTime);

        setPower(getPower() + dcPowerUsageForTimeSpan);

        checkCloudletsCompletionForAllHosts();

        removeFinishedVmsFromEveryHost();
        Log.printLine();

        migrateVmsOutIfMigrationIsEnabled();
        scheduleUpdateOfCloudletsProcessingForFutureTime(nextCloudletFinishTime);
        setLastProcessTime(currentTime);
        return nextCloudletFinishTime;
    }

    return Double.MAX_VALUE;
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
/**
 * Schedules the next update of Cloudlets in this Host for a future time.
 *
 * @param nextCloudletFinishTime the time to schedule the update of Cloudlets in this Host, that is the expected
 *                               time of the next finishing Cloudlet among all existing Hosts.
 * @see #getNextCloudletFinishTime(double)
 */
private void scheduleUpdateOfCloudletsProcessingForFutureTime(double nextCloudletFinishTime) {
    if (nextCloudletFinishTime != Double.MAX_VALUE) {
        getSimulation().cancelAll(getId(), new PredicateType(CloudSimTags.VM_UPDATE_CLOUDLET_PROCESSING_EVENT));
        // getSimulation().cancelAll(getId(), CloudSim.SIM_ANY);
        send(getId(), getSchedulingInterval(), CloudSimTags.VM_UPDATE_CLOUDLET_PROCESSING_EVENT);
    }
}
 

import org.cloudbus.cloudsim.core.predicates.PredicateType; //导入依赖的package包/类
@Override
protected void processVmMigrate(SimEvent ev, boolean ack) {
    if (getSimulation().clock() <= getLastProcessTime()) {
        return;
    }

    super.updateHostsProcessing();
    super.processVmMigrate(ev, ack);
    final SimEvent event = getSimulation().findFirstDeferred(getId(), new PredicateType(CloudSimTags.VM_MIGRATE));
    if (Objects.isNull(event) || event.eventTime() > getSimulation().clock()) {
        super.updateHostsProcessing();
    }
}