Context Navigation

← Previous Change
Next Change →

example

Timestamp:

11/26/13 11:56:07 (11 years ago)

Author:

wojtekp

Message:

Location:

DCWoRMS/branches/coolemall/src/example

Files:

: 18 added
: 1 deleted
: 18 edited
: 1 moved

energy/BaseEnergyEstimationPlugin.java (modified) (2 diffs)
energy/ComputingNodeWithFanEnergyEstimationPlugin.java (deleted)
energy/DataCenterEnergyEstimationPlugin.java (modified) (2 diffs)
energy/DefaultEnergyEstimationPlugin.java (modified) (3 diffs)
energy/NodeEnergyEstimationPlugin.java (moved) (moved from DCWoRMS/branches/coolemall/src/example/energy/ComputingNodeEnergyEstimationPlugin.java) (2 diffs)
energy/ProcessorEnergyEstimationPlugin.java (modified) (2 diffs)
energy/coolemall/CB1EnergyEstimationPlugin.java (modified) (3 diffs)
energy/coolemall/CB2EnergyEstimationPlugin.java (added)
energy/coolemall/CoolEmAllTestbedMeasurements.java (added)
energy/coolemall/CoolingDeviceEnergyEstimationPlugin.java (added)
energy/coolemall/CoreEnergyEstimationPlugin.java (added)
energy/coolemall/FanEnergyEstimationPlugin.java (added)
energy/coolemall/FlowPumpInletEnergyEstimationPlugin.java (added)
energy/coolemall/FlowPumpOutletEnergyEstimationPlugin.java (added)
energy/coolemall/HeatsinkEnergyEstimationPlugin.java (added)
energy/coolemall/NodeEnergyEstimationPlugin.java (modified) (6 diffs)
energy/coolemall/NodeGroupEnergyEstimationPlugin.java (modified) (2 diffs)
energy/coolemall/ProcessorEnergyEstimationPlugin.java (modified) (3 diffs)
energy/device (added)
energy/device/FanEnergyEstimationPlugin.java (added)
localplugin/FCFSBF_ClusterPlugin.java (modified) (1 diff)
localplugin/FCFSBF_ConsolidationClusterPlugin.java (modified) (1 diff)
localplugin/FCFSBF_FanManagementClusterPlugin.java (modified) (3 diffs)
localplugin/FCFSBF_NodePowerManagementClusterPlugin.java (modified) (1 diff)
localplugin/FCFSBF_RandomClusterPlugin.java (modified) (1 diff)
localplugin/coolemall/FCFSBF_RECS_SP.java (modified) (3 diffs)
localplugin/coolemall/computebox1/CB1_FCFS_ConsolidationAtom_NodePowMan_SP.java (added)
localplugin/coolemall/computebox1/CB1_FCFS_Consolidation_NodePowMan_SP.java (added)
localplugin/coolemall/computebox1/CB1_FCFS_Consolidation_SP.java (added)
localplugin/coolemall/computebox1/CB1_FCFS_LoadBalancing_SP.java (added)
localplugin/coolemall/computebox1/CB1_FCFS_Random_SP.java (modified) (5 diffs)
localplugin/coolemall/computebox2/CB2_FCFS_Consolidation_NodePowMan_SP.java (added)
localplugin/coolemall/computebox2/CB2_FCFS_Consolidation_SP.java (added)
localplugin/coolemall/computebox2/CB2_FCFS_LoadBalancing_SP.java (added)
localplugin/coolemall/computebox2/CB2_FCFS_Random_SP.java (added)
localplugin/coolemall/recs/RECS_FCFS_Consolidation_SP.java (modified) (4 diffs)
localplugin/coolemall/recs/RECS_FCFS_LB_SP.java (modified) (4 diffs)
localplugin/coolemall/recs/RECS_FCFS_Random_SP.java (modified) (7 diffs)

Legend:

: Unmodified
: Added
: Removed

DCWoRMS/branches/coolemall/src/example/energy/BaseEnergyEstimationPlugin.java

r751	r1207
3	3	import schedframe.Parameters;
4	4	import schedframe.PluginConfiguration;
5		~~import schedframe.resources.computing.ComputingResource;~~
6	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
7	6	import schedframe.resources.computing.profiles.energy.power.plugin.EnergyEstimationPlugin;
	7	import schedframe.resources.devices.PhysicalResource;
8	8	import schedframe.scheduling.manager.tasks.JobRegistry;
9	9
…	…
17	17
18	18	@Override
19		public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, ~~Computing~~Resource resource) {
	19	public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
20	20	throw new RuntimeException("Not implemented.");
21	21	}
22	22
23	23	@Override
24		public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, ~~ComputingResource~~ resource) {
	24	public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
25	25	throw new RuntimeException("Not implemented.");
26	26	}

DCWoRMS/branches/coolemall/src/example/energy/DataCenterEnergyEstimationPlugin.java

r520	r1207
2	2
3	3	import schedframe.resources.computing.ComputingNode;
4		~~import schedframe.resources.computing.ComputingResource;~~
5	4	import schedframe.resources.computing.DataCenter;
6	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
7	6	import schedframe.resources.computing.profiles.energy.power.PowerUsage;
	7	import schedframe.resources.devices.PhysicalResource;
8	8	import schedframe.scheduling.manager.tasks.JobRegistry;
9	9
…	…
12	12	@Override
13	13	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
14		~~Computing~~Resource resource) {
	14	PhysicalResource resource) {
15	15	double power = 0;
16	16	DataCenter dataCenter = (DataCenter)resource;

DCWoRMS/branches/coolemall/src/example/energy/DefaultEnergyEstimationPlugin.java

r546	r1207
3	3	import schedframe.resources.computing.ComputingResource;
4	4	import schedframe.resources.computing.profiles.energy.EnergyEvent;
	5	import schedframe.resources.devices.PhysicalResource;
5	6	import schedframe.scheduling.manager.tasks.JobRegistry;
6	7
…	…
9	10
10	11
11		public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, ~~Computing~~Resource resource) {
	12	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
12	13	double powerConsumption = 0;
13	14	try {
…	…
17	18	}
18	19
19		powerConsumption = powerConsumption + getChildrenPowerConsumption(resource);
20
21		for(ComputingResource child:resource.getChildren()){
22		try {
23		//powerConsumption = powerConsumption + child.getPowerInterface().getRecentPowerUsage().getValue();
24		} catch (Exception e) {
	20	ComputingResource cr = (ComputingResource) resource;
	21	powerConsumption = powerConsumption + getChildrenPowerConsumption(cr);
25	22
26		}
27		}
28	23	return powerConsumption;
29	24	}

DCWoRMS/branches/coolemall/src/example/energy/NodeEnergyEstimationPlugin.java

r532	r1207
2	2
3	3	import schedframe.resources.computing.ComputingNode;
4		~~import schedframe.resources.computing.ComputingResource;~~
5	4	import schedframe.resources.computing.Processor;
6	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
	6	import schedframe.resources.devices.Device;
	7	import schedframe.resources.devices.PhysicalResource;
7	8	import schedframe.scheduling.manager.tasks.JobRegistry;
8	9
9		public class ~~Computing~~NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {
	10	public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {
10	11
11	12	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
12		~~Computing~~Resource resource) {
	13	PhysicalResource resource) {
13	14	double powerConsumption = 0;
14	15	ComputingNode node = (ComputingNode) resource;
…	…
22	23	try {
23	24	powerConsumption = powerConsumption + node.getPowerInterface().getPowerConsumption(node.getPowerInterface().getPowerState());
	25	for(Device dev: node.getResourceCharacteristic().getDevices()){
	26	powerConsumption = powerConsumption + dev.getPowerInterface().getRecentPowerUsage().getValue();
	27	}
24	28	} catch (NoSuchFieldException e) {
25	29	}

DCWoRMS/branches/coolemall/src/example/energy/ProcessorEnergyEstimationPlugin.java

r901	r1207
2	2
3	3	import schedframe.resources.ResourceStatus;
4		~~import schedframe.resources.computing.ComputingResource;~~
5	4	import schedframe.resources.computing.Processor;
6	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
7	6	import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
	7	import schedframe.resources.devices.PhysicalResource;
8	8	import schedframe.scheduling.manager.tasks.JobRegistry;
9	9
…	…
11	11
12	12	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
13		~~Computing~~Resource resource) {
	13	PhysicalResource resource) {
14	14	double powerConsumption;
	15
15	16	Processor cpu = (Processor)resource;
16	17	if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))

DCWoRMS/branches/coolemall/src/example/energy/coolemall/CB1EnergyEstimationPlugin.java

r913	r1207
1	1	package example.energy.coolemall;
2	2
3		import schedframe.~~Parameter~~;
4		import schedframe.resources.computing.~~ComputingResource~~;
	3	import schedframe.resources.computing.coolemall.ComputeBox1;
	4	import schedframe.resources.computing.coolemall.NodeGroup;
5	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
6		import schedframe.resources.computing.recs.ComputeBox1;
7		import schedframe.resources.computing.recs.NodeGroup;
	6	import schedframe.resources.devices.PhysicalResource;
8	7	import schedframe.scheduling.manager.tasks.JobRegistry;
9	8	import example.energy.BaseEnergyEstimationPlugin;
…	…
12	11
13	12	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
14		~~Computing~~Resource resource) {
	13	PhysicalResource resource) {
15	14	double powerConsumption = 0;
16	15	ComputeBox1 computeBox1 = (ComputeBox1)resource;
…	…
22	21	}
23	22	}
24
25		try {
26		powerConsumption = powerConsumption + computeBox1.getPowerInterface().getPowerConsumption(computeBox1.getPowerInterface().getPowerState());
27		} catch (NoSuchFieldException e) {
28		Parameter param = computeBox1.getResourceCharacteristic().getParameters().get("maxPower");
29		if(param != null)
30		powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent());
31		}
32
33
	23	powerConsumption = (powerConsumption + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION)/CoolEmAllTestbedMeasurements.POWER_SUPPLY_EFFICIENCY;
34	24	return powerConsumption;
35	25	}

DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeEnergyEstimationPlugin.java

r1146	r1207
1	1	package example.energy.coolemall;
2	2
3		~~import schedframe.Parameter;~~
4		~~import schedframe.events.scheduling.EventReason;~~
5		~~import schedframe.resources.computing.ComputingResource;~~
6	3	import schedframe.resources.computing.Processor;
	4	import schedframe.resources.computing.coolemall.Node;
7	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
8		import schedframe.resources.computing.recs.Node;
	6	import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
	7	import schedframe.resources.devices.Device;
	8	import schedframe.resources.devices.PhysicalResource;
9	9	import schedframe.scheduling.manager.tasks.JobRegistry;
	10	import testbed_hpc.Node_Fan_Mapping;
10	11	import example.energy.BaseEnergyEstimationPlugin;
11	12
12	13	public class NodeEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {
13	14
14		private static int OUT_START_ID = 0;
15		private static int OUT_END_ID = 8;
	15	//private static int OUT_START_ID = 0;
	16	//private static int OUT_END_ID = 8;
16	17
17	18	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
18		~~Computing~~Resource resource) {
	19	PhysicalResource resource) {
19	20	double powerConsumption = 0;
20	21	Node node = (Node) resource;
…	…
26	27	}
27	28	}
28		try {
29		powerConsumption = powerConsumption + node.getPowerInterface().getPowerConsumption(node.getPowerInterface().getPowerState());
30		} catch (NoSuchFieldException e) {
31		Parameter param = node.getResourceCharacteristic().getParameters().get("maxPower");
32		if(param != null)
33		powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent());
34		}
	29	if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.ON)){
	30	//powerConsumption = powerConsumption + CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION;
	31	for(Device device: node.getParent().getResourceCharacteristic().getDevices()){
	32	if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){
	33	if(device.getPowerInterface().getRecentPowerUsage().getValue() == -1){
	34	powerConsumption = powerConsumption + CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION;
	35	}else
	36	powerConsumption = powerConsumption + device.getPowerInterface().getRecentPowerUsage().getValue();
	37	break;
	38	}
	39	}
	40	}
	41
35	42
36	43	return powerConsumption;
37	44	}
38	45
39		~~public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, Computing~~Resource resource) {
	46	/*public double estimateAirThroughput(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
40	47
41	48	double airThroughput = 0;
…	…
44	51	return airThroughput;
45	52	//airThroughput = resource.getAirThroughputInterface().getAirFlow(StandardAirThroughputStateName.FAN_OFF);
46		else
	53	else {
47	54	airThroughput = resource.getAirThroughputInterface().getAirFlow(resource.getAirThroughputInterface().getAirThroughputState());
	55	//airThroughput = computingResource.getResourceCharacteristic().getDevices().get(0).getAirThroughputInterface().getAirFlow(resource.getAirThroughputInterface().getAirThroughputState());
	56	//airThroughput = 0.28;
	57	}
48	58	} catch (NoSuchFieldException e) {
49	59	// TODO Auto-generated catch block
…	…
51	61	}
52	62
53		Integer resId = Integer.parseInt(resource.getName().split("_")[1]);
	63	//Integer resId = Integer.parseInt(resource.getName().split("_")[1]);
	64	//ComputingResource computingResource = (ComputingResource) resource;
54	65	//we estimate the air flow related to the outlets (nodes placed in the outlet row of RECS)
55		if(resId >= OUT_START_ID && resId <= OUT_END_ID){
56		~~for(ComputingResource compResource: r~~esource.getParent().getChildren()){
57		Integer id = Integer.parseInt(compResource.getName().split("_")[1]);
58		//we take into account the inlet air flow (nodes placed "behind" the given node)
59		if(id - resId == 9 \|\| id - resId == -9){
60		try {
61		airThroughput = airThroughput + compResource.getAirThroughputInterface().getAirFlow(compResource.getAirThroughputInterface().getAirThroughputState())/2;
62		} catch (NoSuchFieldException e) {
63
64		}
65		}
66		}
67		}
	66	//if(resId >= OUT_START_ID && resId <= OUT_END_ID){
	67	// for(ComputingResource compResource: computingResource.getParent().getChildren()){
	68	// Integer id = Integer.parseInt(compResource.getName().split("_")[1]);
	69	// //we take into account the inlet air flow (nodes placed "behind" the given node)
	70	// if(id - resId == 9 \|\| id - resId == -9){
	71	// try {
	72	// airThroughput = airThroughput + compResource.getAirThroughputInterface().getAirFlow(compResource.getAirThroughputInterface().getAirThroughputState())/2;
	73	// } catch (NoSuchFieldException e) {
	74	//
	75	// }
	76	// }
	77	// }
	78	//}
68	79
69	80	return airThroughput;
70		}
	81	}*/
71	82
72		~~public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, Computing~~Resource resource) {
	83	/*public double estimateTemperature(EnergyEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
73	84	double tout = 0;
74	85	double tin = 21.3;
…	…
83	94	Integer resId = Integer.parseInt(resource.getName().split("_")[1]);
84	95
	96	ComputingResource computingResource = (ComputingResource) resource;
	97
85	98	//we estimate outlet temperature (related to the temperature of the nodes placed in outlet row)
86		for(ComputingResource compResource: resource.getParent().getChildren()){
	99	for(ComputingResource compResource: computingResource.getParent().getChildren()){
87	100	Integer id = Integer.parseInt(compResource.getName().split("_")[1]);
88	101	//we take into account the power of nodes placed "behind" the given nodes
…	…
98	111	tout = tin + delta1 * (power1/(Q * C * ro)) + delta2 * (power2/(Q * C * ro));;
99	112	return tout;
100		}
	113	}*/
101	114
102	115	}

DCWoRMS/branches/coolemall/src/example/energy/coolemall/NodeGroupEnergyEstimationPlugin.java

r913	r1207
1	1	package example.energy.coolemall;
2	2
3		import schedframe.~~Parameter~~;
4		import schedframe.resources.computing.~~ComputingResource~~;
	3	import schedframe.resources.computing.coolemall.Node;
	4	import schedframe.resources.computing.coolemall.NodeGroup;
5	5	import schedframe.resources.computing.profiles.energy.EnergyEvent;
6		import schedframe.resources.computing.recs.Node;
7		import schedframe.resources.computing.recs.NodeGroup;
	6	import schedframe.resources.devices.PhysicalResource;
8	7	import schedframe.scheduling.manager.tasks.JobRegistry;
9	8	import example.energy.BaseEnergyEstimationPlugin;
…	…
12	11
13	12	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
14		ComputingResource resource) {
	13	PhysicalResource resource) {
	14
15	15	double powerConsumption = 0;
16	16	NodeGroup nodeGroup = (NodeGroup)resource;
17		for(Node cn: nodeGroup.getNodes()){
	17	for(Node node: nodeGroup.getNodes()){
18	18	try{
19		powerConsumption = powerConsumption + cn.getPowerInterface().getRecentPowerUsage().getValue();
	19	powerConsumption = powerConsumption + node.getPowerInterface().getRecentPowerUsage().getValue();
20	20	} catch (Exception e){
21
22	21	}
23		}
24		~~try {~~
25		~~powerConsumption = powerConsumption + nodeGroup.getPowerInterface().getPowerConsumption(nodeGroup.getPowerInterface().getPowerState());~~
26		~~} catch (NoSuchFieldException e) {~~
27		~~Parameter param = nodeGroup.getResourceCharacteristic().getParameters().get("maxPower");~~
28		~~if(param != null)~~
29		~~powerConsumption = powerConsumption + Double.valueOf(param.get(0).getContent());~~
30	22	}
31	23

DCWoRMS/branches/coolemall/src/example/energy/coolemall/ProcessorEnergyEstimationPlugin.java

r913	r1207
1	1	package example.energy.coolemall;
2	2
3		import ~~schedframe.Parameter~~;
	3	import dcworms.schedframe.scheduling.ExecTask;
4	4	import schedframe.resources.ResourceStatus;
5		import schedframe.resources.computing.Co~~mputingResourc~~e;
	5	import schedframe.resources.computing.Core;
6	6	import schedframe.resources.computing.Processor;
7	7	import schedframe.resources.computing.profiles.energy.EnergyEvent;
8	8	import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
	9	import schedframe.resources.devices.PhysicalResource;
9	10	import schedframe.scheduling.manager.tasks.JobRegistry;
	11	import schedframe.scheduling.manager.tasks.JobRegistryImpl;
	12	import schedframe.scheduling.tasks.phases.PhaseBehaviour;
10	13	import example.energy.BaseEnergyEstimationPlugin;
11	14
…	…
13	16
14	17	public double estimatePowerConsumption(EnergyEvent event, JobRegistry jobRegistry,
15		ComputingResource resource) {
16		double powerConsumption = 0;
	18	PhysicalResource resource) {
	19
	20	/*double powerConsumption = 0;
17	21	Processor cpu = (Processor)resource;
18	22	if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
…	…
38	42	}
39	43	}
	44	return powerConsumption;*/
	45	double powerConsumption = 0;
	46	Processor proc = (Processor)resource;
	47	if(resource.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF))
	48	return 0;
	49	else {
	50	double processorLoad;
	51	double sumCoresLoad = 0;
	52
	53	int nrOfThreadsOnCpu = 1;
	54
	55	if(proc.getResourceCharacteristic().getParameters().get("product") != null){
	56	String productName = proc.getResourceCharacteristic().getParameters().get("product").get(0).getContent();
	57	if(productName.equals("Fusion G - T40N"))
	58	nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Fusion_G_T40N_NR_OF_THREADS;
	59	else if(productName.equals("Atom - D510"))
	60	nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Atom_D510_NR_OF_THREADS;
	61	else if(productName.equals("Atom - N2600"))
	62	nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Atom_N2600_NR_OF_THREADS;
	63	else if(productName.equals("Core i7 - 2715QE"))
	64	nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Core_i7_2715QE_NR_OF_THREADS;
	65	else if(productName.equals("Core i7 - 3615QE"))
	66	nrOfThreadsOnCpu = CoolEmAllTestbedMeasurements.Core_i7_3615QE_NR_OF_THREADS;
	67	}
	68
	69	for(Core core: proc.getCores()){
	70
	71	if(core.getStatus().equals(ResourceStatus.BUSY)){
	72	JobRegistry jr = new JobRegistryImpl(core.getFullName());
	73	for(ExecTask task: jr.getRunningTasks()){
	74	double cpuUsage = 100;
	75	double nrOfThreadsOfApplciation = 1;
	76	for(PhaseBehaviour pb: task.getCurrentResourceConsumption().getBehaviourList()){
	77	if(pb.getResouceName().equals("PM_CPU_Usage")){
	78	cpuUsage = pb.getUtilization();
	79	}
	80	if(pb.getResouceName().equals("PM_Threads")){
	81	nrOfThreadsOfApplciation = pb.getUtilization();
	82	break;
	83	}
	84	}
	85	sumCoresLoad = sumCoresLoad + cpuUsage * (nrOfThreadsOnCpu / nrOfThreadsOfApplciation);
	86	}
	87	}
	88	}
	89	processorLoad = 100 * sumCoresLoad/proc.getCores().size();
	90	double lowestLoadLevel = 100;
	91	double highestLoadLevel = 0;
	92	if(proc.getPowerInterface().getPState().getLoadPowerUsage().containsKey(new Double(processorLoad))){
	93	powerConsumption = proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(processorLoad));
	94	//System.out.println("power from profile: " + powerConsumption);
	95	} else {
	96	for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
	97	if(lowestLoadLevel > load){
	98	lowestLoadLevel = load;
	99	}
	100	if(highestLoadLevel < load){
	101	highestLoadLevel = load;
	102	}
	103	}
	104	if(processorLoad == 0){
	105	try{
	106	powerConsumption = proc.getPowerInterface().getSupportedPowerStates().get(0).getPowerUsage();
	107	//System.out.println("load = 0; power = idle power usage: " + powerConsumption);
	108	} catch (Exception e){
	109	powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));
	110	//System.out.println("error load = 0; power = 0.7 max power: " + powerConsumption);
	111	}
	112	} else {
	113
	114	double lowerLoadLevel = lowestLoadLevel;
	115	double higherLoadLevel = highestLoadLevel;
	116
	117	try{
	118
	119	for(Double load: proc.getPowerInterface().getPState().getLoadPowerUsage().keySet()){
	120	if(processorLoad > load){
	121	lowerLoadLevel = load;
	122	}
	123	else if(processorLoad < load){
	124	higherLoadLevel = load;
	125	break;
	126	}
	127	}
	128	double powerBelow;
	129	double powerAbove;
	130	double a;
	131	double b;
	132	if(lowerLoadLevel != higherLoadLevel)
	133	{
	134	powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowerLoadLevel);
	135	powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(higherLoadLevel);
	136	a = (powerAbove - powerBelow)/(higherLoadLevel - lowerLoadLevel);
	137	b = powerAbove - a * higherLoadLevel;
	138	} else {
	139	powerBelow = proc.getPowerInterface().getPState().getLoadPowerUsage().get(lowestLoadLevel);
	140	powerAbove = proc.getPowerInterface().getPState().getLoadPowerUsage().get(highestLoadLevel);
	141	a = (powerAbove - powerBelow)/(highestLoadLevel - lowestLoadLevel);
	142	b = powerAbove - a * highestLoadLevel;
	143	}
	144	powerConsumption = a * processorLoad + b;
	145	/*System.out.println("a" +lowestLoadLevel + ";" +highestLoadLevel);
	146	System.out.println("b" +lowerLoadLevel + ";" +higherLoadLevel);
	147	System.out.println("c" +powerBelow + ";" +powerAbove);
	148	System.out.println(resource.getFullName() + "load: " + processorLoad + "linear power estimation " + powerConsumption);*/
	149
	150	} catch (Exception e){
	151	powerConsumption = 0.7 * proc.getPowerInterface().getPState().getLoadPowerUsage().get(new Double(highestLoadLevel));
	152	//System.out.println("error; power = 0.7 max power: " + powerConsumption);
	153	}
	154	}
	155	}
	156	}
	157
	158
	159	powerConsumption = powerConsumption - CoolEmAllTestbedMeasurements.SINGLE_FAN_ON_POWER_CONSUMPTION;
	160	//System.out.println("estiamted power consumption: " + powerConsumption);
40	161	return powerConsumption;
41	162	}

DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_ClusterPlugin.java

r575	r1207
145	145	List<ComputingResource> nodes;
146	146	Properties properties = new Properties();
147		properties.setProperty("type", StandardResourceType.~~Computing~~Node.getName());
	147	properties.setProperty("type", StandardResourceType.Node.getName());
148	148	// properties.setProperty("status", ResourceStatus.FREE.toString());
149	149	nodes = (List<ComputingResource>) unitsManager.filterResources(properties);
150	150
151	151	//always return the same node from the list
152		return nodes.get(0).getName();
	152	return nodes.get(0).getFullName();
153	153	}
154	154

DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_ConsolidationClusterPlugin.java

r574	r1207
98	98	}
99	99	}
100		ProcessingElements result = new ProcessingElements(node.getName());
	100	ProcessingElements result = new ProcessingElements(node.getFullName());
101	101	result.addAll(choosenResources);
102	102	map.put(StandardResourceUnitName.PE, result);

DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_FanManagementClusterPlugin.java

r778	r1207
8	8
9	9	import schedframe.events.scheduling.SchedulingEvent;
	10	import schedframe.resources.StandardResourceType;
10	11	import schedframe.resources.computing.ComputingNode;
11	12	import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName;
12	13	import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName;
	14	import schedframe.resources.devices.Device;
13	15	import schedframe.scheduling.manager.resources.ClusterResourceManager;
14	16	import schedframe.scheduling.manager.resources.ResourceManager;
…	…
54	56	if (node != null) {
55	57	//if there are two or more tasks ( running on the given node then
56		if(new JobRegistryImpl(node.getName()).getRunningTasks().size() > 0)
57		node.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO"));
58		else
59		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON);
	58	if(new JobRegistryImpl(node.getFullName()).getRunningTasks().size() > 0){
	59	List<Device> devices = node.getResourceCharacteristic().getDevices();
	60	for(Device dev : devices){
	61	if(dev.getType().equals(StandardResourceType.Fan)){
	62	dev.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO"));
	63	}
	64	}
	65	}
	66	else {
	67	List<Device> devices = node.getResourceCharacteristic().getDevices();
	68	for(Device dev : devices){
	69	if(dev.getType().equals(StandardResourceType.Fan)){
	70	dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
	71	}
	72	}
	73	}
60	74	notSelectedNodes.remove(node);
61		addToSchedulingPlan(plan, task, node.getName());
	75	addToSchedulingPlan(plan, task, node.getFullName());
62	76	}
63	77	}
…	…
98	112	private void adjustOtherFans(List<ComputingNode> nodes){
99	113	for(ComputingNode node : nodes){
	114	List<Device> devices = node.getResourceCharacteristic().getDevices();
100	115	if(node.getFreeProcessorsNumber() == node.getProcessorsNumber()){
101		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
102		} else if(new JobRegistryImpl(node.getName()).getRunningTasks().size() > 1)
103		node.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO"));
104		else
105		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON);
	116	for(Device dev : devices){
	117	if(dev.getType().equals(StandardResourceType.Fan)){
	118	dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.OFF);
	119	}
	120	}
	121	} else if(new JobRegistryImpl(node.getFullName()).getRunningTasks().size() > 1){
	122	for(Device dev : devices){
	123	if(dev.getType().equals(StandardResourceType.Fan)){
	124	dev.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("FAN_ON_TURBO"));
	125	}
	126	}
	127	}
	128	else {
	129	for(Device dev : devices){
	130	if(dev.getType().equals(StandardResourceType.Fan)){
	131	dev.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.ON);
	132	}
	133	}
	134	}
106	135	}
107	136	}

DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_NodePowerManagementClusterPlugin.java

r531	r1207
90	90	}
91	91	}
92		ProcessingElements result = new ProcessingElements(nodes.get(0).getName());
	92	ProcessingElements result = new ProcessingElements(nodes.get(0).getFullName());
93	93	result.addAll(choosenResources);
94	94	map.put(StandardResourceUnitName.PE, result);

DCWoRMS/branches/coolemall/src/example/localplugin/FCFSBF_RandomClusterPlugin.java

r574	r1207
61	61	List<ComputingNode> nodes = resourceManager.getComputingNodes();
62	62	int nodeIdx = rand.nextInt(nodes.size());
63		return nodes.get(nodeIdx).getName();
	63	return nodes.get(nodeIdx).getFullName();
64	64	}
65	65

DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/FCFSBF_RECS_SP.java

r1100	r1207
6	6	import schedframe.events.scheduling.SchedulingEvent;
7	7	import schedframe.exceptions.ResourceException;
8		import schedframe.resources.~~CoolEmAll~~ResourceType;
	8	import schedframe.resources.StandardResourceType;
9	9	import schedframe.resources.computing.ComputingResource;
10	10	import schedframe.scheduling.manager.resources.ClusterResourceManager;
…	…
64	64	List<ComputingResource> nodes = null;
65	65	try {
66		nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(~~CoolEmAll~~ResourceType.Node);
	66	nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(StandardResourceType.Node);
67	67	} catch (ResourceException e) {
68	68	// TODO Auto-generated catch block
…	…
70	70	}
71	71	int nodeIdx = rand.nextInt(nodes.size());
72		return nodes.get(nodeIdx).getName();
	72	return nodes.get(nodeIdx).getFullName();
73	73	}
74	74

DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/computebox1/CB1_FCFS_Random_SP.java

r1099	r1207
1	1	package example.localplugin.coolemall.computebox1;
2	2
	3	import java.util.ArrayList;
	4	import java.util.HashMap;
3	5	import java.util.List;
	6	import java.util.Map;
4	7	import java.util.Random;
5	8
6	9	import schedframe.events.scheduling.SchedulingEvent;
7	10	import schedframe.exceptions.ResourceException;
8		import schedframe.resources.CoolEmAllResourceType;
	11	import schedframe.resources.ResourceStatus;
	12	import schedframe.resources.StandardResourceType;
9	13	import schedframe.resources.computing.ComputingResource;
	14	import schedframe.resources.computing.Core;
	15	import schedframe.resources.computing.coolemall.Node;
	16	import schedframe.resources.units.ProcessingElements;
	17	import schedframe.resources.units.ResourceUnit;
	18	import schedframe.resources.units.ResourceUnitName;
	19	import schedframe.resources.units.StandardResourceUnitName;
10	20	import schedframe.scheduling.manager.resources.ClusterResourceManager;
11	21	import schedframe.scheduling.manager.resources.ResourceManager;
…	…
17	27	import schedframe.scheduling.queue.TaskQueueList;
18	28	import schedframe.scheduling.tasks.TaskInterface;
	29	import testbed_hpc.Node_Fan_Mapping;
19	30	import example.localplugin.BaseLocalSchedulingPlugin;
20	31	import gridsim.dcworms.DCWormsTags;
…	…
26	37	public CB1_FCFS_Random_SP () {
27	38	rand = new Random(47);
	39	Node_Fan_Mapping.init();
28	40	}
29	41
…	…
49	61	if (task.getStatus() == DCWormsTags.READY) {
50	62
51		~~String nodeName = chooseRandomProvider(resourceManager~~);
52		if (~~nodeName~~ != null) {
53		addToSchedulingPlan(plan, task, ~~nodeName~~);
	63	Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task);
	64	if (choosenResources != null) {
	65	addToSchedulingPlan(plan, task, choosenResources);
54	66	}
55	67	}
…	…
61	73
62	74	@SuppressWarnings("unchecked")
63		private String chooseRandomProvider(ClusterResourceManager resourceManager) {
64		List<ComputingResource> nodes = null;
	75	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
	76	ClusterResourceManager resourceManager, TaskInterface<?> task) {
	77
	78	Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
	79
	80	List<Node> nodes = null;
65	81	try {
66		nodes = (List<~~ComputingResource>) resourceManager.getResourcesOfType(CoolEmAll~~ResourceType.Node);
	82	nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node);
67	83	} catch (ResourceException e) {
68	84	// TODO Auto-generated catch block
69	85	e.printStackTrace();
70	86	}
71		int nodeIdx = rand.nextInt(nodes.size());
72		return nodes.get(nodeIdx).getName();
	87	List<Node> avNodes = filterNodes(nodes, task);
	88	if(avNodes.size() == 0)
	89	return null;
	90	Node node = randomNode(avNodes);
	91	int cpuRequest;
	92	try {
	93	cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
	94	} catch (NoSuchFieldException e) {
	95	cpuRequest = 0;
	96	}
	97
	98	if (cpuRequest != 0) {
	99
	100	List<ComputingResource> choosenResources = new ArrayList<ComputingResource>();
	101
	102	List<Core> cores = node.getCores();
	103	for (int i = 0; i < cores.size() && cpuRequest > 0; i++) {
	104	if (cores.get(i).getStatus() == ResourceStatus.FREE) {
	105	choosenResources.add(cores.get(i));
	106	cpuRequest--;
	107	}
	108	}
	109	if (cpuRequest > 0) {
	110	return null;
	111	}
	112	//choosenResources.add(node.getProcessors().get(0));
	113	ProcessingElements pe = new ProcessingElements();
	114	pe.addAll(choosenResources);
	115	map.put(StandardResourceUnitName.PE, pe);
	116	return map;
	117	}
	118	return null;
	119	}
	120
	121	private List<Node> filterNodes(List<Node> nodes, TaskInterface<?> task){
	122	List<Node> filteredNodes = new ArrayList<Node>();
	123	int cpuRequest;
	124	try {
	125	cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
	126	} catch (NoSuchFieldException e) {
	127	cpuRequest = 0;
	128	}
	129	for (Node node : nodes) {
	130
	131	if (cpuRequest != 0) {
	132
	133	List<Core> cores = node.getCores();
	134	if (cores.size() < cpuRequest) {
	135	if(cores.size() == 0){
	136	if(node.getProcessors().size() < cpuRequest)
	137	continue;
	138	}
	139	}
	140
	141	int freeCores = 0;
	142	for(Core core: cores){
	143	if(core.getStatus() == ResourceStatus.FREE)
	144	freeCores++;
	145	}
	146
	147	if(freeCores < cpuRequest)
	148	continue;
	149
	150	filteredNodes.add(node);
	151	}
	152	}
	153
	154	return filteredNodes;
	155	}
	156
	157	private Node randomNode(List<Node> nodes){
	158	return nodes.get(rand.nextInt(nodes.size()));
73	159	}
74	160

DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_Consolidation_SP.java

r1102	r1207
10	10	import schedframe.events.scheduling.SchedulingEvent;
11	11	import schedframe.exceptions.ResourceException;
12		~~import schedframe.resources.CoolEmAllResourceType;~~
13	12	import schedframe.resources.ResourceStatus;
	13	import schedframe.resources.StandardResourceType;
14	14	import schedframe.resources.computing.ComputingResource;
15	15	import schedframe.resources.computing.Processor;
	16	import schedframe.resources.computing.coolemall.Node;
16	17	import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
17		~~import schedframe.resources.computing.recs.Node;~~
18	18	import schedframe.resources.units.Memory;
19	19	import schedframe.resources.units.ProcessingElements;
…	…
55	55	List<Node> nodes;
56	56	try {
57		nodes = (List<Node>) resourceManager.getResourcesOfType(~~CoolEmAll~~ResourceType.Node);
	57	nodes = (List<Node>) resourceManager.getResourcesOfType(StandardResourceType.Node);
58	58	} catch (ResourceException e) {
59	59	break;
…	…
140	140	}
141	141	}
142		ProcessingElements result = new ProcessingElements(node.getName());
	142	ProcessingElements result = new ProcessingElements(node.getFullName());
143	143	result.addAll(choosenResources);
144	144	map.put(StandardResourceUnitName.PE, result);
…	…
183	183	private void turnOffIdleNodes(List<Node> nodes){
184	184	for(Node node : nodes){
185		JobRegistry jr = new JobRegistryImpl(node.getName());
	185	JobRegistry jr = new JobRegistryImpl(node.getFullName());
186	186	if(jr.getRunningTasks().size() == 0)
187	187	node.getPowerInterface().setPowerState(StandardPowerStateName.OFF);

DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_LB_SP.java

r1102	r1207
5	5	import schedframe.events.scheduling.SchedulingEvent;
6	6	import schedframe.exceptions.ResourceException;
7		import schedframe.resources.~~CoolEmAll~~ResourceType;
	7	import schedframe.resources.StandardResourceType;
8	8	import schedframe.resources.computing.ComputingResource;
9		import schedframe.resources.computing.~~recs~~.Node;
	9	import schedframe.resources.computing.coolemall.Node;
10	10	import schedframe.scheduling.manager.resources.ClusterResourceManager;
11	11	import schedframe.scheduling.manager.resources.ResourceManager;
…	…
62	62	List<ComputingResource> nodes = null;
63	63	try {
64		nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(~~CoolEmAll~~ResourceType.Node);
	64	nodes = (List<ComputingResource>) resourceManager.getResourcesOfType(StandardResourceType.Node);
65	65	} catch (ResourceException e) {
66	66	// TODO Auto-generated catch block
…	…
68	68	}
69	69	int nodeIdx = findLeastLoadedResourceIdx(nodes);
70		return nodes.get(nodeIdx).getName();
	70	return nodes.get(nodeIdx).getFullName();
71	71	}
72	72
…	…
77	77	for(int i = 0; i < nodes.size(); i++){
78	78	Node node = (Node) nodes.get(i);
79		JobRegistry jr = new JobRegistryImpl(node.getName());
	79	JobRegistry jr = new JobRegistryImpl(node.getFullName());
80	80	int totalLoad = jr.getRunningTasks().size();
81	81	if(totalLoad < minLoad){

DCWoRMS/branches/coolemall/src/example/localplugin/coolemall/recs/RECS_FCFS_Random_SP.java

r1103	r1207
2	2
3	3	import java.util.ArrayList;
	4	import java.util.HashMap;
4	5	import java.util.List;
	6	import java.util.Map;
5	7	import java.util.Random;
6	8
7	9	import schedframe.events.scheduling.SchedulingEvent;
8	10	import schedframe.exceptions.ResourceException;
9		import schedframe.resources.CoolEmAllResourceType;
	11	import schedframe.resources.ResourceStatus;
	12	import schedframe.resources.StandardResourceType;
10	13	import schedframe.resources.computing.ComputingNode;
11		import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName;
	14	import schedframe.resources.computing.ComputingResource;
	15	import schedframe.resources.computing.Core;
	16	import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName;
	17	import schedframe.resources.devices.Device;
	18	import schedframe.resources.units.ProcessingElements;
	19	import schedframe.resources.units.ResourceUnit;
	20	import schedframe.resources.units.ResourceUnitName;
	21	import schedframe.resources.units.StandardResourceUnitName;
12	22	import schedframe.scheduling.manager.resources.ClusterResourceManager;
13	23	import schedframe.scheduling.manager.resources.ResourceManager;
…	…
19	29	import schedframe.scheduling.queue.TaskQueueList;
20	30	import schedframe.scheduling.tasks.TaskInterface;
	31	import testbed_hpc.Node_Fan_Mapping;
21	32	import example.localplugin.BaseLocalSchedulingPlugin;
22	33	import gridsim.dcworms.DCWormsTags;
…	…
28	39	public RECS_FCFS_Random_SP () {
29	40	rand = new Random(47);
	41	Node_Fan_Mapping.init();
30	42	}
31	43
…	…
47	59	List<ComputingNode> notSelectedNodes = null;
48	60	try {
49		notSelectedNodes = (List<ComputingNode>) resourceManager.getResourcesOfType(~~CoolEmAll~~ResourceType.Node);
	61	notSelectedNodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node);
50	62	} catch (ResourceException e) {
51	63	// TODO Auto-generated catch block
…	…
57	69	// if status of the tasks in READY
58	70	if (task.getStatus() == DCWormsTags.READY) {
59		ComputingNode node = chooseRandomProvider(resourceManager);
	71	Map<ResourceUnitName, ResourceUnit> choosenResources = chooseResourcesForExecution(resourceManager, task);
	72	if (choosenResources != null) {
	73	addToSchedulingPlan(plan, task, choosenResources);
	74	}
	75	/*ComputingNode node = chooseRandomProvider(resourceManager);
60	76	if (node != null) {
61		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON);
	77	//node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON);
62	78	notSelectedNodes.remove(node);
63	79	addToSchedulingPlan(plan, task, node.getName());
64		}
	80	}*/
65	81	}
66	82	}
…	…
75	91	List<ComputingNode> nodes = null;
76	92	try {
77		nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(~~CoolEmAll~~ResourceType.Node);
	93	nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node);
78	94	} catch (ResourceException e) {
79	95	// TODO Auto-generated catch block
…	…
94	110	return filteredNodes;
95	111	}
	112
	113	private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(
	114	ClusterResourceManager resourceManager, TaskInterface<?> task) {
	115
	116	Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
	117
	118	List<ComputingNode> nodes = null;
	119	try {
	120	nodes = (List<ComputingNode>) resourceManager.getResourcesOfType(StandardResourceType.Node);
	121	} catch (ResourceException e1) {
	122	// TODO Auto-generated catch block
	123	e1.printStackTrace();
	124	}
	125	List<ComputingNode> avNodes = filterNodes(nodes, task);
	126	if(avNodes.size() == 0)
	127	return null;
	128	ComputingNode node = randomNode(avNodes);
	129
	130	int cpuRequest;
	131	try {
	132	cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
	133	} catch (NoSuchFieldException e) {
	134	cpuRequest = 0;
	135	}
	136
	137	if (cpuRequest != 0) {
	138
	139	List<Core> cores = node.getProcessors().get(0).getCores();
	140
	141	List<ComputingResource> choosenResources = new ArrayList<ComputingResource>();
	142	for (int i = 0; i < cores.size(); i++) {
	143	if (cores.get(i).getStatus() == ResourceStatus.FREE) {
	144	//choosenResources.add(cores.get(i));
	145	cpuRequest--;
	146	}
	147	}
	148	if (cpuRequest > 0) {
	149	return null;
	150	}
	151	choosenResources.add(node.getProcessors().get(0));
	152	ProcessingElements pe = new ProcessingElements();
	153	pe.addAll(choosenResources);
	154	map.put(StandardResourceUnitName.PE, pe);
	155	return map;
	156	}
	157	return null;
	158	}
	159
	160	private List<ComputingNode> filterNodes(List<ComputingNode> nodes, TaskInterface<?> task){
	161	List<ComputingNode> filteredNodes = new ArrayList<ComputingNode>();
	162	for (ComputingNode node : nodes) {
	163	int cpuRequest;
	164	try {
	165	cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
	166	} catch (NoSuchFieldException e) {
	167	cpuRequest = 0;
	168	}
	169
	170	if (cpuRequest != 0) {
	171
	172	List<Core> cores = node.getProcessors().get(0).getCores();
	173	if (cores.size() < cpuRequest) {
	174	if(cores.size() == 0){
	175	if(node.getProcessors().size() < cpuRequest)
	176	continue;
	177	}
	178	}
	179
	180	int freeCores = 0;
	181	for(Core core: cores){
	182	if(core.getStatus() == ResourceStatus.FREE)
	183	freeCores++;
	184	}
	185
	186	if(freeCores != cores.size())
	187	continue;
	188
	189	filteredNodes.add(node);
	190	}
	191	}
	192
	193	return filteredNodes;
	194	}
	195
	196	private ComputingNode randomNode(List<ComputingNode> nodes){
	197	return nodes.get(rand.nextInt(nodes.size()));
	198	}
	199
96	200	private void adjustOtherFans(List<ComputingNode> nodes) {
97	201	for (ComputingNode node : nodes) {
	202
98	203	if (node.getProcessors().size() == node.getFreeProcessorsNumber()) {
99		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_OFF);
	204	for(Device device: node.getParent().getResourceCharacteristic().getDevices()){
	205	if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){
	206	device.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("Off"));
	207	break;
	208	}
	209	}
	210
100	211	} else {
101		node.getAirThroughputInterface().setAirThroughputState(StandardAirThroughputStateName.FAN_ON);
	212	for(Device device: node.getParent().getResourceCharacteristic().getDevices()){
	213	if(device.getFullName().equals(Node_Fan_Mapping.getNode_fan().get(node.getFullName()))){
	214	device.getAirThroughputInterface().setAirThroughputState(new UserAirThroughputStateName("On"));
	215	break;
	216	}
	217	}
102	218	}
103	219	}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 1207 for DCWoRMS/branches/coolemall/src/example

Legend:

Download in other formats: