Changeset 1396 for DCWoRMS/branches/coolemall/src/schedframe/resources/devices

Timestamp:

06/26/14 14:18:01 (11 years ago)

Author:

wojtekp

Message:

 

Location:

DCWoRMS/branches/coolemall/src/schedframe/resources/devices

Files:

• Device.java (modified) (1 diff)
• DeviceAirflowInterface.java (moved) (moved from DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DeviceAirThroughputInterface.java) (4 diffs)
• DeviceEnergyExtension.java (deleted)
• PhysicalResource.java (modified) (2 diffs)
• coolemall/FanAirflowInterface.java (moved) (moved from DCWoRMS/branches/coolemall/src/schedframe/resources/devices/coolemall/FanAirThroughputInterface.java) (1 diff)
• description/PhysicalResourceDescription.java (modified) (5 diffs)

DCWoRMS/branches/coolemall/src/schedframe/resources/devices/Device.java

@@ -25 +25 @@
                 this.extensionList = new ExtensionListImpl(1);
                 initCharacteristics(devDesc);
-                accept(new EnergyExtension.Builder().resource(this).powerProfile(devDesc.getPowerProfile()).airFlowProfile(devDesc.getAirThroughputProfile()).thermalProfile(devDesc.getThermalProfile()).build());     
+                accept(new EnergyExtension.Builder().resource(this).powerProfile(devDesc.getPowerProfile()).airflowProfile(devDesc.getAirflowProfile()).thermalProfile(devDesc.getThermalProfile()).build());   
         }
 

DCWoRMS/branches/coolemall/src/schedframe/resources/devices/DeviceAirflowInterface.java

@@ -9 +9 @@
 import schedframe.resources.computing.profiles.energy.EnergyEvent;
 import schedframe.resources.computing.profiles.energy.EnergyEventType;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirFlowValue;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputState;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputStateName;
-import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirThroughputStateName;
-import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowValue;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowState;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowStateName;
+import schedframe.resources.computing.profiles.energy.airthroughput.StandardAirflowStateName;
+import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirflowInterface;
 
-public class DeviceAirThroughputInterface implements AirThroughputInterface{
+public class DeviceAirflowInterface implements AirflowInterface{
 
-        protected AirThroughputStateName currentAirThroughputState;
-        protected AirThroughputProfile airThroughputProfile;
+        protected AirflowStateName currentAirflowState;
+        protected AirflowProfile airflowProfile;
         protected PhysicalResource resource;
         
-        public DeviceAirThroughputInterface(PhysicalResource resource, AirThroughputProfile airThroughputProfile){
+        public DeviceAirflowInterface(PhysicalResource resource, AirflowProfile airflowProfile){
                 this.resource = resource;
-                this.airThroughputProfile = airThroughputProfile;
-                this.currentAirThroughputState = StandardAirThroughputStateName.ON;
+                this.airflowProfile = airflowProfile;
+                this.currentAirflowState = StandardAirflowStateName.ON;
         }
         
-        public AirThroughputStateName getAirThroughputState() {
-                return currentAirThroughputState;
+        public AirflowStateName getAirflowState() {
+                return currentAirflowState;
         }
 
-        public boolean setAirThroughputState(AirThroughputStateName state) {
-                if(supportAirThroughputState(state)){
-                        currentAirThroughputState = state;
+        public boolean setAirflowState(AirflowStateName state) {
+                if(supportAirflowState(state)){
+                        currentAirflowState = state;
                         
                         //TO DO - notifications should be called for all resources starting form the lowest layer
@@ -44 +44 @@
         }
 
-        public boolean supportAirThroughputState(AirThroughputStateName state) {
-                for(AirThroughputState airFlowState: airThroughputProfile.getAirThroughputStates()){
-                        if(airFlowState.getName().equals(state.getName())){
+        public boolean supportAirflowState(AirflowStateName state) {
+                for(AirflowState airflowState: airflowProfile.getAirflowStates()){
+                        if(airflowState.getName().getLabel().equals(state.getLabel())){
                                 return true;
                         }
@@ -53 +53 @@
         }
 
-        public List<AirThroughputState> getSupportedAirThroughputStates(){
-                List<AirThroughputState> airThroughputStates = new ArrayList<AirThroughputState>();
-                for(AirThroughputState airFlowState: airThroughputProfile.getAirThroughputStates()){
-                        airThroughputStates.add(airFlowState);
+        public List<AirflowState> getSupportedAirflowStates(){
+                List<AirflowState> airflowStates = new ArrayList<AirflowState>();
+                for(AirflowState airFlowState: airflowProfile.getAirflowStates()){
+                        airflowStates.add(airFlowState);
                 }
-                return airThroughputStates;
+                return airflowStates;
         }
 
-        public double getAirFlow(AirThroughputStateName state) throws NoSuchFieldException {
-                double airThroughput = 0;
-                if(supportAirThroughputState(state)){
-                        for(AirThroughputState airFlowState: airThroughputProfile.getAirThroughputStates()){
-                                if(airFlowState.getName().equals(state.getName())){
-                                        airThroughput = airFlowState.getValue();
+        public double getAirflow(AirflowStateName state) throws NoSuchFieldException {
+                double airflow = 0;
+                if(supportAirflowState(state)){
+                        for(AirflowState airflowState: airflowProfile.getAirflowStates()){
+                                if(airflowState.getName().getLabel().equals(state.getLabel())){
+                                        airflow = airflowState.getValue();
                                         break;
                                 }
                         }
                 }
-                return airThroughput;
+                return airflow;
         }
 
-        public double getPowerConsumption(AirThroughputStateName state) throws NoSuchFieldException {
+        public double getPowerConsumption(AirflowStateName state) throws NoSuchFieldException {
                 double powerConsumption = 0;
-                if(supportAirThroughputState(state)){
-                        for(AirThroughputState airFlowState: airThroughputProfile.getAirThroughputStates()){
-                                if(airFlowState.getName().equals(state.getName())){
-                                        powerConsumption = airFlowState.getPowerUsage();
+                if(supportAirflowState(state)){
+                        for(AirflowState airflowState: airflowProfile.getAirflowStates()){
+                                if(airflowState.getName().getLabel().equals(state.getLabel())){
+                                        powerConsumption = airflowState.getPowerUsage();
                                         break;
                                 }
@@ -87 +87 @@
         }
         
-        public AirFlowValue getRecentAirFlow() {
-                AirFlowValue airFlow = null;
-                int lastIdx = getAirFlowHistory().size() - 1;
+        public AirflowValue getRecentAirflow() {
+                AirflowValue airflow = null;
+                int lastIdx = getAirflowHistory().size() - 1;
                 if(lastIdx >= 0)
-                        airFlow = getAirFlowHistory().get(lastIdx);
+                        airflow = getAirflowHistory().get(lastIdx);
                 else {  
                         try {
-                                airFlow = new AirFlowValue(DateTimeUtils.currentTimeMillis(), getAirFlow(currentAirThroughputState));
+                                airflow = new AirflowValue(DateTimeUtils.currentTimeMillis(), getAirflow(currentAirflowState));
                         } catch (NoSuchFieldException e) {
                         }
                 }
-                return airFlow;
+                return airflow;
         }
         
-        public List<AirFlowValue> getAirFlowHistory(){
-                return airThroughputProfile.getAirThroughputHistory();
+        public List<AirflowValue> getAirflowHistory(){
+                return airflowProfile.getAirflowHistory();
         }
         
         public Parameters getParameters() {
-                return airThroughputProfile.getParameters();
+                return airflowProfile.getParameters();
         }
 

DCWoRMS/branches/coolemall/src/schedframe/resources/devices/PhysicalResource.java

@@ -12 +12 @@
 import schedframe.resources.computing.extensions.ExtensionType;
 import schedframe.resources.computing.profiles.energy.EnergyExtension;
-import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirThroughputInterface;
+import schedframe.resources.computing.profiles.energy.airthroughput.ui.AirflowInterface;
 import schedframe.resources.computing.profiles.energy.power.ui.PowerInterface;
 import schedframe.resources.computing.profiles.energy.thermal.ui.ThermalInterface;
@@ -70 +70 @@
         }
         
-        public AirThroughputInterface getAirThroughputInterface(){
+        public AirflowInterface getAirflowInterface(){
                 Extension extension = getExtension(ExtensionType.ENERGY_EXTENSION);
                 if(extension != null){
                         EnergyExtension ee = (EnergyExtension)extension;
-                        return ee.getAirThroughputInterface();
+                        return ee.getAirflowInterface();
                 }
                 return null;

DCWoRMS/branches/coolemall/src/schedframe/resources/devices/coolemall/FanAirflowInterface.java

@@ -1 +1 @@
 package schedframe.resources.devices.coolemall;
 
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
-import schedframe.resources.computing.profiles.energy.airthroughput.UserAirThroughputStateName;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile;
+import schedframe.resources.computing.profiles.energy.airthroughput.CustomAirflowStateName;
 import schedframe.resources.devices.PhysicalResource;
-import schedframe.resources.devices.DeviceAirThroughputInterface;
+import schedframe.resources.devices.DeviceAirflowInterface;
 
-public class FanAirThroughputInterface extends DeviceAirThroughputInterface {
+public class FanAirflowInterface extends DeviceAirflowInterface {
 
-        public FanAirThroughputInterface(PhysicalResource resource, AirThroughputProfile airThroughputProfile) {
-                super(resource, airThroughputProfile);
-                this.currentAirThroughputState = new UserAirThroughputStateName("2");
+        public FanAirflowInterface(PhysicalResource resource, AirflowProfile airflowProfile) {
+                super(resource, airflowProfile);
+                this.currentAirflowState = new CustomAirflowStateName("2");
         }
         
         public boolean turnOn(){
-                return setAirThroughputState(new UserAirThroughputStateName("2"));
+                return setAirflowState(new CustomAirflowStateName("2"));
         }
 
         public boolean turnOff(){
-                return setAirThroughputState(new UserAirThroughputStateName("1"));
+                return setAirflowState(new CustomAirflowStateName("1"));
         }
 }

DCWoRMS/branches/coolemall/src/schedframe/resources/devices/description/PhysicalResourceDescription.java

@@ -10 +10 @@
 import schedframe.resources.computing.description.ResourceDescription;
 import schedframe.resources.computing.location.Location;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputProfile;
-import schedframe.resources.computing.profiles.energy.airthroughput.AirThroughputState;
-import schedframe.resources.computing.profiles.energy.airthroughput.plugin.AirThroughputEstimationPlugin;
-import schedframe.resources.computing.profiles.energy.airthroughput.plugin.DefaultAirThroughputEstimationPlugin;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowStateNameFactory;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowProfile;
+import schedframe.resources.computing.profiles.energy.airthroughput.AirflowState;
+import schedframe.resources.computing.profiles.energy.airthroughput.plugin.AirflowEstimationPlugin;
+import schedframe.resources.computing.profiles.energy.airthroughput.plugin.DefaultAirflowEstimationPlugin;
 import schedframe.resources.computing.profiles.energy.power.PState;
 import schedframe.resources.computing.profiles.energy.power.PowerProfile;
@@ -36 +37 @@
 
         protected PowerProfile powerProfile;
-        protected AirThroughputProfile airThroughputProfile;
+        protected AirflowProfile airflowProfile;
         protected ThermalProfile thermalProfile;
         protected LoadProfile loadProfile;
@@ -58 +59 @@
                 if (profile != null) {
                         initPowerProfile(profile.getPowerProfile());
-                        initAirThroughputProfile(profile.getAirThroughputProfile());
+                        initAirflowProfile(profile.getAirThroughputProfile());
                         initThermalProfile(profile.getThermalProfile());
                         initLoadProfile(profile.getLoadProfile());
@@ -151 +152 @@
         }
 
-        protected void initAirThroughputProfile(schemas.AirThroughputProfile airThroughputProfile) {
-                if (airThroughputProfile != null) {
-                        
-                        AirThroughputEstimationPlugin airThroughputEstimationPlugin = null;
-                        List<AirThroughputState> airThroughputStates = null;
-                        if(airThroughputProfile.getAirThroughputEstimationPlugin() != null){
-                                String airThroughputEstimationPluginName = airThroughputProfile.getAirThroughputEstimationPlugin().getName();
-                                if(airThroughputEstimationPluginName != null) {
-                                        airThroughputEstimationPlugin = (AirThroughputEstimationPlugin) InstanceFactory.createInstance(
-                                                        airThroughputEstimationPluginName, AirThroughputEstimationPlugin.class);                        
+        protected void initAirflowProfile(schemas.AirThroughputProfile airflowProfile) {
+                if (airflowProfile != null) {
+                        
+                        AirflowEstimationPlugin airflowEstimationPlugin = null;
+                        List<AirflowState> airflowStates = null;
+                        if(airflowProfile.getAirThroughputEstimationPlugin() != null){
+                                String airflowEstimationPluginName = airflowProfile.getAirThroughputEstimationPlugin().getName();
+                                if(airflowEstimationPluginName != null) {
+                                        airflowEstimationPlugin = (AirflowEstimationPlugin) InstanceFactory.createInstance(
+                                                        airflowEstimationPluginName, AirflowEstimationPlugin.class);                    
                                 } else {
-                                        airThroughputEstimationPlugin = new DefaultAirThroughputEstimationPlugin();
-                                }
-                                Parameters params = extractParameters(airThroughputProfile.getAirThroughputEstimationPlugin().getParameter());
-                                airThroughputEstimationPlugin.init(params);
-                        }
-                        if(airThroughputProfile.getAirThroughputStates() != null){
-                                airThroughputStates = new ArrayList<AirThroughputState>();
-                                int airThrouhputStateCount = airThroughputProfile.getAirThroughputStates().getAirThroughputStateCount();
-                                for (int i = 0; i < airThrouhputStateCount; i++) {
-                                        schemas.AirThroughputState ats = airThroughputProfile.getAirThroughputStates().getAirThroughputState(i);
-                                        AirThroughputState airThroughputState = new AirThroughputState(ats.getName(), ats.getValue()
+                                        airflowEstimationPlugin = new DefaultAirflowEstimationPlugin();
+                                }
+                                Parameters params = extractParameters(airflowProfile.getAirThroughputEstimationPlugin().getParameter());
+                                airflowEstimationPlugin.init(params);
+                        }
+                        if(airflowProfile.getAirThroughputStates() != null){
+                                airflowStates = new ArrayList<AirflowState>();
+                                int airflowStateCount = airflowProfile.getAirThroughputStates().getAirThroughputStateCount();
+                                for (int i = 0; i < airflowStateCount; i++) {
+                                        schemas.AirThroughputState ats = airflowProfile.getAirThroughputStates().getAirThroughputState(i);
+                                        AirflowState airflowState = new AirflowState(AirflowStateNameFactory.createAirflowStateName(ats.getName()), ats.getValue()
                                                         .getContent(), ats.getPowerUsage().getContent());
                                         Parameters params = extractParameters(ats.getParameter());
-                                        airThroughputState.init(params);
-                                        airThroughputStates.add(airThroughputState);
-                                }
-                        }
-                        this.airThroughputProfile = new AirThroughputProfile(airThroughputEstimationPlugin, airThroughputStates);
-                        Parameters params = extractParameters(airThroughputProfile.getParameter());
-                        this.airThroughputProfile.init(params);
+                                        airflowState.init(params);
+                                        airflowStates.add(airflowState);
+                                }
+                        }
+                        this.airflowProfile = new AirflowProfile(airflowEstimationPlugin, airflowStates);
+                        Parameters params = extractParameters(airflowProfile.getParameter());
+                        this.airflowProfile.init(params);
                 }
         }
@@ -281 +282 @@
         }
 
-        public AirThroughputProfile getAirThroughputProfile() {
-                return airThroughputProfile;
+        public AirflowProfile getAirflowProfile() {
+                return airflowProfile;
         }