source: DCWoRMS/trunk/build/classes/schedframe/scheduling/manager/resources/LocalResourceManager.java @ 477

package schedframe.scheduling.manager.resources;

import gridsim.GridSim;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Stack;

import schedframe.exceptions.ResourceException;
import schedframe.resources.ResourceStatus;
import schedframe.resources.ResourceType;
import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.ResourceCharacteristics;
import schedframe.resources.computing.validator.ResourcePropertiesValidator;
import schedframe.resources.computing.validator.ResourceValidator;
import schedframe.resources.units.PEUnit;
import schedframe.resources.units.ProcessingElements;
import schedframe.resources.units.ResourceUnit;
import schedframe.resources.units.ResourceUnitName;
import schedframe.resources.units.ResourceUnitState;
import schedframe.resources.units.StandardResourceUnitName;
import schedframe.scheduling.Scheduler;
import schedframe.scheduling.plugin.local.ResourceAllocationInterface;


public class LocalResourceManager implements ResourceAllocationInterface, ResourceManager {

        //private Log log = LogFactory.getLog(ResourceManager.class);

        protected List<ComputingResource> computingResources;
        protected List<Scheduler> schedulers;
        //protected ResourceCharacteristics resourceCharacteristic;
        protected Map<ResourceUnitName, List<ResourceUnit>> resourceUnits;

        public LocalResourceManager(List<ComputingResource> resources, List<Scheduler> schedulers, Map<ResourceUnitName, List<ResourceUnit>> resourceUnits) {
                this.computingResources = resources;
                this.schedulers = schedulers;
                this.resourceUnits = resourceUnits;

                //initSharedResourceUnits(computingResources);
        }

        public LocalResourceManager(ComputingResource compResource) {
                this.computingResources = compResource.getChildren();

                initSharedResourceUnits(compResource);
        }

        public void initSharedResourceUnits(ComputingResource compResource){
                this.resourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
                List<ResourceUnit> list;

                ComputingResource parent = compResource.getParent();
                while(parent != null){
                        Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
                        for(ResourceUnitName run : resUnits.keySet()){
                                for(ResourceUnit resUnit : resUnits.get(run)){
                                        if((resourceUnits.get(run) == null)){
                                                list = new ArrayList<ResourceUnit>(1);
                                                resourceUnits.put(resUnit.getName(), list);
                                                list.add(resUnit);
                                        } else if(!resourceUnits.get(run).contains(resUnit)){
                                                list = resourceUnits.get(resUnit.getName());
                                                list.add(resUnit);
                                        } 
                                }
                        }
                        parent = parent.getParent();
                }
        }
        
        public List<ComputingResource> getResources() {
                return computingResources;
        }

        public boolean areResourcesAchievable(ResourceType type) {
                if (computingResources != null) {
                        Deque<ComputingResource> toExamine = new ArrayDeque<ComputingResource>();
                        for (ComputingResource resource : computingResources){
                                toExamine.push(resource);       
                        }
                        
                        while (!toExamine.isEmpty()) {
                                ComputingResource resource = toExamine.pop();
                                if(resource.getType() == type)
                                        return true;
                                List<ComputingResource> resources = resource.getChildren();
                                /*if (resources == null)
                                        continue;*/
                                int numberOfResComp = resources.size();
                                for (int i = 0; i < numberOfResComp; i++) {
                                        ComputingResource resourceChild = resources.get(i);
                                        if (resourceChild.getType() == type) {
                                                return true;
                                        } else
                                                toExamine.push(resourceChild);
                                }
                        }
                }
                return false;
        }

        public List<? extends ComputingResource> getResourcesOfType(ResourceType type) throws ResourceException {
                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
                for (ComputingResource resource : computingResources) {
                        if (resource.getType() == type) {
                                resourcesOfType.add(resource);
                        } else
                                resourcesOfType.addAll(resource.getDescendantsByType(type));
                }
                return resourcesOfType;
        }

        public List<? extends ComputingResource> getResourcesByTypeWithStatus(ResourceType type, ResourceStatus status)
                        throws ResourceException {

                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
                for (ComputingResource resource : computingResources) {
                        if (resource.getType() == type) {
                                if (resource.getStatus() == status) {
                                        resourcesOfType.add(resource);
                                }
                        } else
                                resourcesOfType.addAll(resource.getDescendantsByTypeAndStatus(type, status));
                }
                return resourcesOfType;
        }

        public ComputingResource getResourceByName(String resourceName) throws ResourceException {
                ComputingResource resourceWithName = null;
                for (int i = 0; i < computingResources.size() && resourceWithName == null; i++) {
                        ComputingResource resource = computingResources.get(i);
                        if (resource.getName().equals(resourceName))
                                resourceWithName = resource;
                        else
                                resourceWithName = resource.getDescendantByName(resourceName);
                }
                return resourceWithName;
        }

        public List<ResourceUnit> getDistributedResourceUnits(ResourceUnitName unitName)  {
                List<ResourceUnit> resourceUnit = new ArrayList<ResourceUnit>();
                if (computingResources != null) {
                        Deque<ComputingResource> toExamine = new ArrayDeque<ComputingResource>();
                        for (ComputingResource resource : computingResources)
                                toExamine.push(resource);
                        while (!toExamine.isEmpty()) {
                                ComputingResource resource = toExamine.pop();
                                ResourceCharacteristics resourceCharacteristic = resource.getResourceCharacteristic();
                                List<ResourceUnit> units = null;
                                units = resourceCharacteristic.getResourceUnits().get(unitName);
                                if (units != null)
                                        resourceUnit.addAll(units);
                                // else {
                                List<ComputingResource> resources = resource.getChildren();
                                /*if (resources == null)
                                        continue;*/
                                int numberOfResComp = resources.size();
                                for (int i = 0; i < numberOfResComp; i++) {
                                        ComputingResource resourceChild = resources.get(i);
                                        toExamine.push(resourceChild);
                                }
                                // }
                        }
                }
                return resourceUnit;
        }
        /*public List<AbstractResourceUnit> getAvailableResourceUnits(String resourceName) throws Exception {
                ComputingResource resource = getResourceByName(resourceName);
                List<AbstractResourceUnit> resourceUnits = new ArrayList<AbstractResourceUnit>();
                while(resource != null){
                        for(List<AbstractResourceUnit> resUnits: resource.getResourceCharacteristic().getResourceUnits().values())
                                resUnits.addAll(resourceUnits);
                        resource = resource.getParent();
                }
                
                return resourceUnits;
        }*/

        public List<? extends ComputingResource> filterResources(Properties properties) {
                List<ComputingResource> descendants = new ArrayList<ComputingResource>();
                for (ComputingResource resource : computingResources) {
                        ResourceValidator resourceValidator =  new ResourcePropertiesValidator(properties);
                        if (resourceValidator.validate(resource))
                                descendants.add(resource);
                        else
                                descendants.addAll(resource.filterDescendants(properties));
                }
                return descendants;
        }

        public Map<ResourceUnitName, List<ResourceUnit>> getSharedResourceUnits() {
                
                /*Map<ResourceUnitName, List<ResourceUnit>> sharedResourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
                List<ResourceUnit> list;
                for(ComputingResource resource : compResources){
                        boolean resourceNotVisited = true;
                        ComputingResource parent = resource.getParent();
                        while(parent != null && resourceNotVisited){
                                Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
                                for(ResourceUnitName run : resUnits.keySet()){
                                        for(ResourceUnit resUnit : resUnits.get(run)){
                                                if((sharedResourceUnits.get(run) == null)){
                                                        list = new ArrayList<ResourceUnit>(1);
                                                        sharedResourceUnits.put(resUnit.getName(), list);
                                                        list.add(resUnit);
                                                } else if(!sharedResourceUnits.get(run).contains(resUnit)){
                                                        list = sharedResourceUnits.get(resUnit.getName());
                                                        list.add(resUnit);
                                                } else {
                                                        resourceNotVisited = false;
                                                }
                                        }
                                }
                                parent = parent.getParent();
                        }
                }
                return sharedResourceUnits;*/
                return resourceUnits;
        }
                
        public List<Scheduler> getSchedulers() {
                return schedulers;
        }
        
        @SuppressWarnings("unchecked")
        public List<ResourceUnit> getPE() throws ResourceException{
                
                List<ResourceUnit> peUnits = null;
                List<ComputingResource> computingResources = null;
                if(areResourcesAchievable(StandardResourceType.Core)){
                        try {
                                computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Core);
                        } catch (ResourceException e) {
                                throw new RuntimeException("GSSIM internal error");
                        }
                        PEUnit peUnit = new ProcessingElements(computingResources);
                        peUnits = new ArrayList<ResourceUnit>();
                        peUnits.add(peUnit);                    
                }

                else if(areResourcesAchievable(StandardResourceType.Processor)){
                        try {
                                computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Processor);
                        } catch (ResourceException e) {
                                throw new RuntimeException("GSSIM internal error");
                        }
                        PEUnit peUnit = new ProcessingElements(computingResources);
                        peUnits = new ArrayList<ResourceUnit>();
                        peUnits.add(peUnit);                    
                }

                else if (getDistributedResourceUnits(StandardResourceUnitName.PE).size() > 0){
                        peUnits = getDistributedResourceUnits(StandardResourceUnitName.PE);
                } 
                
                else if(getSharedResourceUnits().get(StandardResourceUnitName.PE) != null){
                                peUnits = getSharedResourceUnits().get(StandardResourceUnitName.PE);
                }
                if(peUnits == null)
                        throw new ResourceException("Processing Elements are not defined");
                return peUnits;
        }
        
        public String getSchedulerName(String resName){
                if(GridSim.getEntityId(resName) != -1){
                        return resName;
                }
                ComputingResource resourceWithName = null;
                for(int i = 0 ; i < computingResources.size() && resourceWithName == null; i++){
                        ComputingResource resource = computingResources.get(i);
                        if(resource.getName().equals(resName))
                                resourceWithName = resource;
                        else
                                try {
                                        resourceWithName = resource.getDescendantByName(resName);
                                } catch (ResourceException e) {
                                        return null;
                                }
                }
                if(resourceWithName == null)
                        return null;
                List<ComputingResource> children = resourceWithName.getChildren();
                Set<Scheduler> childrenSchedulers = new HashSet<Scheduler>();
                if(children.isEmpty())
                        return null;
                for(ComputingResource child: children) {
                        childrenSchedulers.add(child.getScheduler());
                }       

                Set<Scheduler> tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
                while(childrenSchedulers.size() > 1){
                        childrenSchedulers = new HashSet<Scheduler>();
                        for(Scheduler s: tempChildrenSchedulers){
                                childrenSchedulers.add(s.getParent());
                        }
                        tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
                }
                Iterator<Scheduler> it = childrenSchedulers.iterator();
                Scheduler potentialScheduler = it.next();
                if(potentialScheduler.getCompResources().containsAll(children))
                        return potentialScheduler.get_name();
                return null;
        }
        
        public boolean allocateResources(Map<ResourceUnitName, ResourceUnit> resources) {
                
                if (resources == null) {
                        return false;
                }
                /*ResourceUnit peUnit = resources.get(StandardResourceUnitName.PE);

                if (peUnit != null) {
                        if (peUnit instanceof ProcessingElements) {
                                ProcessingElements choosenProcessors = (ProcessingElements) peUnit;

                                for (int i = 0; i < choosenProcessors.size(); i++) {
                                        choosenProcessors.get(i).setStatus(ResourceStatus.BUSY);
                                }
                        }
                }*/

                /*Memory m = (Memory) resources.get(StandardResourceUnitName.MEMORY);
                if (m != null) {
                        m.getProvisioner().setState(ResourceUnitState.BUSY);
                }*/
                
                for(ResourceUnitName resUnitName: resources.keySet()){
                        ResourceUnit resUnit = resources.get(resUnitName);
                        resUnit.getProvisioner().setState(ResourceUnitState.BUSY);
                }
                return true;
        }


        public void freeResources(Map<ResourceUnitName, ResourceUnit> resources) {
                
                /*ResourceUnit peUnit = resources.get(StandardResourceUnitName.PE);
                
                if (peUnit instanceof ProcessingElements) {
                        ProcessingElements processingElements = (ProcessingElements) peUnit;

                        for (int i = 0; i < processingElements.size(); i++) {
                                processingElements.get(i).setStatus(ResourceStatus.FREE);
                        }
                }*/

                /*Memory m = (Memory) resources.get(StandardResourceUnitName.MEMORY);
                if (m != null) {
                        m.getProvisioner().setState(ResourceUnitState.FREE);
                }*/
                
                for(ResourceUnitName resUnitName: resources.keySet()){
                        ResourceUnit resUnit = resources.get(resUnitName);
                        resUnit.getProvisioner().setState(ResourceUnitState.FREE);
                }
        }


}