source: DCWoRMS/branches/coolemall/src/schedframe/scheduling/manager/resources/LocalResourceManager.java @ 1415

Revision 1415, 11.4 KB checked in by wojtekp, 11 years ago (diff)
  • Property svn:mime-type set to text/plain
RevLine 
[477]1package schedframe.scheduling.manager.resources;
2
3import gridsim.GridSim;
4
5import java.util.ArrayDeque;
6import java.util.ArrayList;
7import java.util.Deque;
8import java.util.HashMap;
9import java.util.HashSet;
10import java.util.Iterator;
11import java.util.List;
12import java.util.Map;
13import java.util.Properties;
14import java.util.Set;
15
16import schedframe.exceptions.ResourceException;
17import schedframe.resources.ResourceStatus;
18import schedframe.resources.ResourceType;
19import schedframe.resources.StandardResourceType;
20import schedframe.resources.computing.ComputingResource;
[1207]21import schedframe.resources.computing.ComputingResourceCharacteristics;
[477]22import schedframe.resources.computing.validator.ResourcePropertiesValidator;
23import schedframe.resources.computing.validator.ResourceValidator;
24import schedframe.resources.units.PEUnit;
25import schedframe.resources.units.ProcessingElements;
26import schedframe.resources.units.ResourceUnit;
27import schedframe.resources.units.ResourceUnitName;
28import schedframe.resources.units.ResourceUnitState;
29import schedframe.resources.units.StandardResourceUnitName;
30import schedframe.scheduling.Scheduler;
31
32
[517]33public class LocalResourceManager implements ResourceAllocation, ResourceManager {
[477]34
35        //private Log log = LogFactory.getLog(ResourceManager.class);
36
37        protected List<ComputingResource> computingResources;
38        protected List<Scheduler> schedulers;
39        protected Map<ResourceUnitName, List<ResourceUnit>> resourceUnits;
40
41        public LocalResourceManager(List<ComputingResource> resources, List<Scheduler> schedulers, Map<ResourceUnitName, List<ResourceUnit>> resourceUnits) {
42                this.computingResources = resources;
43                this.schedulers = schedulers;
44                this.resourceUnits = resourceUnits;
45
46                //initSharedResourceUnits(computingResources);
47        }
48
49        public LocalResourceManager(ComputingResource compResource) {
50                this.computingResources = compResource.getChildren();
51
52                initSharedResourceUnits(compResource);
53        }
54
55        public void initSharedResourceUnits(ComputingResource compResource){
56                this.resourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
57                List<ResourceUnit> list;
58
59                ComputingResource parent = compResource.getParent();
60                while(parent != null){
61                        Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
62                        for(ResourceUnitName run : resUnits.keySet()){
63                                for(ResourceUnit resUnit : resUnits.get(run)){
64                                        if((resourceUnits.get(run) == null)){
65                                                list = new ArrayList<ResourceUnit>(1);
66                                                resourceUnits.put(resUnit.getName(), list);
67                                                list.add(resUnit);
68                                        } else if(!resourceUnits.get(run).contains(resUnit)){
69                                                list = resourceUnits.get(resUnit.getName());
70                                                list.add(resUnit);
71                                        }
72                                }
73                        }
74                        parent = parent.getParent();
75                }
76        }
77       
78        public List<ComputingResource> getResources() {
79                return computingResources;
80        }
81
82        public boolean areResourcesAchievable(ResourceType type) {
83                if (computingResources != null) {
84                        Deque<ComputingResource> toExamine = new ArrayDeque<ComputingResource>();
85                        for (ComputingResource resource : computingResources){
86                                toExamine.push(resource);       
87                        }
88                       
89                        while (!toExamine.isEmpty()) {
90                                ComputingResource resource = toExamine.pop();
[1054]91                                if(resource.getType().getName().equals(type.getName()))
[477]92                                        return true;
93                                List<ComputingResource> resources = resource.getChildren();
94                                /*if (resources == null)
95                                        continue;*/
96                                int numberOfResComp = resources.size();
97                                for (int i = 0; i < numberOfResComp; i++) {
98                                        ComputingResource resourceChild = resources.get(i);
[1054]99                                        if (resourceChild.getType().getName().equals(type.getName())) {
[477]100                                                return true;
101                                        } else
102                                                toExamine.push(resourceChild);
103                                }
104                        }
105                }
106                return false;
107        }
108
[1415]109        public List<? extends ComputingResource> getResourcesOfType(ResourceType type) {
[477]110                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
111                for (ComputingResource resource : computingResources) {
[779]112                        if (resource.getType().getName().equals(type.getName())) {
[477]113                                resourcesOfType.add(resource);
114                        } else
115                                resourcesOfType.addAll(resource.getDescendantsByType(type));
116                }
117                return resourcesOfType;
118        }
119
[1415]120        public List<? extends ComputingResource> getResourcesByTypeWithStatus(ResourceType type, ResourceStatus status){
[477]121
122                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
123                for (ComputingResource resource : computingResources) {
[779]124                        if (resource.getType().getName().equals(type.getName())) {
[477]125                                if (resource.getStatus() == status) {
126                                        resourcesOfType.add(resource);
127                                }
128                        } else
129                                resourcesOfType.addAll(resource.getDescendantsByTypeAndStatus(type, status));
130                }
131                return resourcesOfType;
132        }
133
[1374]134        public ComputingResource getResourceByName(String resourceName) {
[477]135                ComputingResource resourceWithName = null;
136                for (int i = 0; i < computingResources.size() && resourceWithName == null; i++) {
137                        ComputingResource resource = computingResources.get(i);
[1207]138                        if (resource.getFullName().equals(resourceName))
[477]139                                resourceWithName = resource;
140                        else
141                                resourceWithName = resource.getDescendantByName(resourceName);
142                }
143                return resourceWithName;
144        }
145
146        public List<ResourceUnit> getDistributedResourceUnits(ResourceUnitName unitName)  {
147                List<ResourceUnit> resourceUnit = new ArrayList<ResourceUnit>();
148                if (computingResources != null) {
149                        Deque<ComputingResource> toExamine = new ArrayDeque<ComputingResource>();
150                        for (ComputingResource resource : computingResources)
151                                toExamine.push(resource);
152                        while (!toExamine.isEmpty()) {
153                                ComputingResource resource = toExamine.pop();
[1207]154                                ComputingResourceCharacteristics resourceCharacteristic = (ComputingResourceCharacteristics)resource.getResourceCharacteristic();
[477]155                                List<ResourceUnit> units = null;
156                                units = resourceCharacteristic.getResourceUnits().get(unitName);
157                                if (units != null)
158                                        resourceUnit.addAll(units);
159                                // else {
160                                List<ComputingResource> resources = resource.getChildren();
161                                /*if (resources == null)
162                                        continue;*/
163                                int numberOfResComp = resources.size();
164                                for (int i = 0; i < numberOfResComp; i++) {
165                                        ComputingResource resourceChild = resources.get(i);
166                                        toExamine.push(resourceChild);
167                                }
168                                // }
169                        }
170                }
171                return resourceUnit;
172        }
173
174        public List<? extends ComputingResource> filterResources(Properties properties) {
175                List<ComputingResource> descendants = new ArrayList<ComputingResource>();
176                for (ComputingResource resource : computingResources) {
177                        ResourceValidator resourceValidator =  new ResourcePropertiesValidator(properties);
178                        if (resourceValidator.validate(resource))
179                                descendants.add(resource);
180                        else
181                                descendants.addAll(resource.filterDescendants(properties));
182                }
183                return descendants;
184        }
185
186        public Map<ResourceUnitName, List<ResourceUnit>> getSharedResourceUnits() {
187               
188                /*Map<ResourceUnitName, List<ResourceUnit>> sharedResourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
189                List<ResourceUnit> list;
190                for(ComputingResource resource : compResources){
191                        boolean resourceNotVisited = true;
192                        ComputingResource parent = resource.getParent();
193                        while(parent != null && resourceNotVisited){
194                                Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
195                                for(ResourceUnitName run : resUnits.keySet()){
196                                        for(ResourceUnit resUnit : resUnits.get(run)){
197                                                if((sharedResourceUnits.get(run) == null)){
198                                                        list = new ArrayList<ResourceUnit>(1);
199                                                        sharedResourceUnits.put(resUnit.getName(), list);
200                                                        list.add(resUnit);
201                                                } else if(!sharedResourceUnits.get(run).contains(resUnit)){
202                                                        list = sharedResourceUnits.get(resUnit.getName());
203                                                        list.add(resUnit);
204                                                } else {
205                                                        resourceNotVisited = false;
206                                                }
207                                        }
208                                }
209                                parent = parent.getParent();
210                        }
211                }
212                return sharedResourceUnits;*/
213                return resourceUnits;
214        }
215               
216        public List<Scheduler> getSchedulers() {
217                return schedulers;
218        }
219       
220        @SuppressWarnings("unchecked")
221        public List<ResourceUnit> getPE() throws ResourceException{
222               
223                List<ResourceUnit> peUnits = null;
224                List<ComputingResource> computingResources = null;
225                if(areResourcesAchievable(StandardResourceType.Core)){
[1415]226
227                        computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Core);
228
[477]229                        PEUnit peUnit = new ProcessingElements(computingResources);
230                        peUnits = new ArrayList<ResourceUnit>();
231                        peUnits.add(peUnit);                   
232                }
233
234                else if(areResourcesAchievable(StandardResourceType.Processor)){
[1415]235
236                        computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Processor);
237
[477]238                        PEUnit peUnit = new ProcessingElements(computingResources);
239                        peUnits = new ArrayList<ResourceUnit>();
240                        peUnits.add(peUnit);                   
241                }
242
243                else if (getDistributedResourceUnits(StandardResourceUnitName.PE).size() > 0){
244                        peUnits = getDistributedResourceUnits(StandardResourceUnitName.PE);
245                }
246               
247                else if(getSharedResourceUnits().get(StandardResourceUnitName.PE) != null){
248                                peUnits = getSharedResourceUnits().get(StandardResourceUnitName.PE);
249                }
250                if(peUnits == null)
251                        throw new ResourceException("Processing Elements are not defined");
252                return peUnits;
253        }
254       
255        public String getSchedulerName(String resName){
256                if(GridSim.getEntityId(resName) != -1){
257                        return resName;
258                }
259                ComputingResource resourceWithName = null;
260                for(int i = 0 ; i < computingResources.size() && resourceWithName == null; i++){
261                        ComputingResource resource = computingResources.get(i);
[1207]262                        if(resource.getFullName().equals(resName))
[477]263                                resourceWithName = resource;
264                        else
[1374]265                                resourceWithName = resource.getDescendantByName(resName);
266
[477]267                }
268                if(resourceWithName == null)
269                        return null;
270                List<ComputingResource> children = resourceWithName.getChildren();
271                Set<Scheduler> childrenSchedulers = new HashSet<Scheduler>();
272                if(children.isEmpty())
273                        return null;
274                for(ComputingResource child: children) {
275                        childrenSchedulers.add(child.getScheduler());
276                }       
277
278                Set<Scheduler> tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
279                while(childrenSchedulers.size() > 1){
280                        childrenSchedulers = new HashSet<Scheduler>();
281                        for(Scheduler s: tempChildrenSchedulers){
282                                childrenSchedulers.add(s.getParent());
283                        }
284                        tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
285                }
286                Iterator<Scheduler> it = childrenSchedulers.iterator();
287                Scheduler potentialScheduler = it.next();
288                if(potentialScheduler.getCompResources().containsAll(children))
289                        return potentialScheduler.get_name();
290                return null;
291        }
292       
[1377]293
294        public boolean allocateResources(Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) {
[477]295               
296                if (resources == null) {
297                        return false;
298                }
299               
[1377]300                if(exclusive){
301                        for(ResourceUnitName resUnitName: resources.keySet()){
302                                ResourceUnit resUnit = resources.get(resUnitName);
[1396]303                                if(resUnit.getName().getLabel().equals(StandardResourceUnitName.PE.getLabel())){
[1377]304                                        ProcessingElements pe = (ProcessingElements)resUnit;
305                                        for(ComputingResource cr: pe){
306                                                if(cr.getStatus().equals(ResourceStatus.BUSY)){
[1392]307                                                        freeResources(resources, true);
[1377]308                                                        return false;
309                                                }
310                                        }
311                                }
312                                resUnit.getProvisioner().setState(ResourceUnitState.BUSY);
313                        }
314                       
315                        return true;
316                } else {
317                        for(ResourceUnitName resUnitName: resources.keySet()){
318                                ResourceUnit resUnit = resources.get(resUnitName);
319                                resUnit.getProvisioner().setState(ResourceUnitState.BUSY);
320                        }
321                        return true;   
[477]322                }
323        }
324
[1377]325        public void freeResources(Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) {
[477]326               
327                for(ResourceUnitName resUnitName: resources.keySet()){
328                        ResourceUnit resUnit = resources.get(resUnitName);
329                        resUnit.getProvisioner().setState(ResourceUnitState.FREE);
330                }
331        }
332
333}
Note: See TracBrowser for help on using the repository browser.