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

Revision 1377, 11.6 KB checked in by wojtekp, 11 years ago (diff)
  • Property svn:mime-type set to text/plain
Line 
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;
21import schedframe.resources.computing.ComputingResourceCharacteristics;
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
33public class LocalResourceManager implements ResourceAllocation, ResourceManager {
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();
91                                if(resource.getType().getName().equals(type.getName()))
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);
99                                        if (resourceChild.getType().getName().equals(type.getName())) {
100                                                return true;
101                                        } else
102                                                toExamine.push(resourceChild);
103                                }
104                        }
105                }
106                return false;
107        }
108
109        public List<? extends ComputingResource> getResourcesOfType(ResourceType type) throws ResourceException {
110                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
111                for (ComputingResource resource : computingResources) {
112                        if (resource.getType().getName().equals(type.getName())) {
113                                resourcesOfType.add(resource);
114                        } else
115                                resourcesOfType.addAll(resource.getDescendantsByType(type));
116                }
117                return resourcesOfType;
118        }
119
120        public List<? extends ComputingResource> getResourcesByTypeWithStatus(ResourceType type, ResourceStatus status)
121                        throws ResourceException {
122
123                List<ComputingResource> resourcesOfType = new ArrayList<ComputingResource>();
124                for (ComputingResource resource : computingResources) {
125                        if (resource.getType().getName().equals(type.getName())) {
126                                if (resource.getStatus() == status) {
127                                        resourcesOfType.add(resource);
128                                }
129                        } else
130                                resourcesOfType.addAll(resource.getDescendantsByTypeAndStatus(type, status));
131                }
132                return resourcesOfType;
133        }
134
135        public ComputingResource getResourceByName(String resourceName) {
136                ComputingResource resourceWithName = null;
137                for (int i = 0; i < computingResources.size() && resourceWithName == null; i++) {
138                        ComputingResource resource = computingResources.get(i);
139                        if (resource.getFullName().equals(resourceName))
140                                resourceWithName = resource;
141                        else
142                                resourceWithName = resource.getDescendantByName(resourceName);
143                }
144                return resourceWithName;
145        }
146
147        public List<ResourceUnit> getDistributedResourceUnits(ResourceUnitName unitName)  {
148                List<ResourceUnit> resourceUnit = new ArrayList<ResourceUnit>();
149                if (computingResources != null) {
150                        Deque<ComputingResource> toExamine = new ArrayDeque<ComputingResource>();
151                        for (ComputingResource resource : computingResources)
152                                toExamine.push(resource);
153                        while (!toExamine.isEmpty()) {
154                                ComputingResource resource = toExamine.pop();
155                                ComputingResourceCharacteristics resourceCharacteristic = (ComputingResourceCharacteristics)resource.getResourceCharacteristic();
156                                List<ResourceUnit> units = null;
157                                units = resourceCharacteristic.getResourceUnits().get(unitName);
158                                if (units != null)
159                                        resourceUnit.addAll(units);
160                                // else {
161                                List<ComputingResource> resources = resource.getChildren();
162                                /*if (resources == null)
163                                        continue;*/
164                                int numberOfResComp = resources.size();
165                                for (int i = 0; i < numberOfResComp; i++) {
166                                        ComputingResource resourceChild = resources.get(i);
167                                        toExamine.push(resourceChild);
168                                }
169                                // }
170                        }
171                }
172                return resourceUnit;
173        }
174
175        public List<? extends ComputingResource> filterResources(Properties properties) {
176                List<ComputingResource> descendants = new ArrayList<ComputingResource>();
177                for (ComputingResource resource : computingResources) {
178                        ResourceValidator resourceValidator =  new ResourcePropertiesValidator(properties);
179                        if (resourceValidator.validate(resource))
180                                descendants.add(resource);
181                        else
182                                descendants.addAll(resource.filterDescendants(properties));
183                }
184                return descendants;
185        }
186
187        public Map<ResourceUnitName, List<ResourceUnit>> getSharedResourceUnits() {
188               
189                /*Map<ResourceUnitName, List<ResourceUnit>> sharedResourceUnits = new HashMap<ResourceUnitName, List<ResourceUnit>>();
190                List<ResourceUnit> list;
191                for(ComputingResource resource : compResources){
192                        boolean resourceNotVisited = true;
193                        ComputingResource parent = resource.getParent();
194                        while(parent != null && resourceNotVisited){
195                                Map<ResourceUnitName, List<ResourceUnit>> resUnits = parent.getResourceCharacteristic().getResourceUnits();
196                                for(ResourceUnitName run : resUnits.keySet()){
197                                        for(ResourceUnit resUnit : resUnits.get(run)){
198                                                if((sharedResourceUnits.get(run) == null)){
199                                                        list = new ArrayList<ResourceUnit>(1);
200                                                        sharedResourceUnits.put(resUnit.getName(), list);
201                                                        list.add(resUnit);
202                                                } else if(!sharedResourceUnits.get(run).contains(resUnit)){
203                                                        list = sharedResourceUnits.get(resUnit.getName());
204                                                        list.add(resUnit);
205                                                } else {
206                                                        resourceNotVisited = false;
207                                                }
208                                        }
209                                }
210                                parent = parent.getParent();
211                        }
212                }
213                return sharedResourceUnits;*/
214                return resourceUnits;
215        }
216               
217        public List<Scheduler> getSchedulers() {
218                return schedulers;
219        }
220       
221        @SuppressWarnings("unchecked")
222        public List<ResourceUnit> getPE() throws ResourceException{
223               
224                List<ResourceUnit> peUnits = null;
225                List<ComputingResource> computingResources = null;
226                if(areResourcesAchievable(StandardResourceType.Core)){
227                        try {
228                                computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Core);
229                        } catch (ResourceException e) {
230                                throw new RuntimeException("DCWorms internal error");
231                        }
232                        PEUnit peUnit = new ProcessingElements(computingResources);
233                        peUnits = new ArrayList<ResourceUnit>();
234                        peUnits.add(peUnit);                   
235                }
236
237                else if(areResourcesAchievable(StandardResourceType.Processor)){
238                        try {
239                                computingResources = (List<ComputingResource>) getResourcesOfType(StandardResourceType.Processor);
240                        } catch (ResourceException e) {
241                                throw new RuntimeException("DCWorms internal error");
242                        }
243                        PEUnit peUnit = new ProcessingElements(computingResources);
244                        peUnits = new ArrayList<ResourceUnit>();
245                        peUnits.add(peUnit);                   
246                }
247
248                else if (getDistributedResourceUnits(StandardResourceUnitName.PE).size() > 0){
249                        peUnits = getDistributedResourceUnits(StandardResourceUnitName.PE);
250                }
251               
252                else if(getSharedResourceUnits().get(StandardResourceUnitName.PE) != null){
253                                peUnits = getSharedResourceUnits().get(StandardResourceUnitName.PE);
254                }
255                if(peUnits == null)
256                        throw new ResourceException("Processing Elements are not defined");
257                return peUnits;
258        }
259       
260        public String getSchedulerName(String resName){
261                if(GridSim.getEntityId(resName) != -1){
262                        return resName;
263                }
264                ComputingResource resourceWithName = null;
265                for(int i = 0 ; i < computingResources.size() && resourceWithName == null; i++){
266                        ComputingResource resource = computingResources.get(i);
267                        if(resource.getFullName().equals(resName))
268                                resourceWithName = resource;
269                        else
270                                resourceWithName = resource.getDescendantByName(resName);
271
272                }
273                if(resourceWithName == null)
274                        return null;
275                List<ComputingResource> children = resourceWithName.getChildren();
276                Set<Scheduler> childrenSchedulers = new HashSet<Scheduler>();
277                if(children.isEmpty())
278                        return null;
279                for(ComputingResource child: children) {
280                        childrenSchedulers.add(child.getScheduler());
281                }       
282
283                Set<Scheduler> tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
284                while(childrenSchedulers.size() > 1){
285                        childrenSchedulers = new HashSet<Scheduler>();
286                        for(Scheduler s: tempChildrenSchedulers){
287                                childrenSchedulers.add(s.getParent());
288                        }
289                        tempChildrenSchedulers = new HashSet<Scheduler>(childrenSchedulers);
290                }
291                Iterator<Scheduler> it = childrenSchedulers.iterator();
292                Scheduler potentialScheduler = it.next();
293                if(potentialScheduler.getCompResources().containsAll(children))
294                        return potentialScheduler.get_name();
295                return null;
296        }
297       
298
299        public boolean allocateResources(Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) {
300               
301                if (resources == null) {
302                        return false;
303                }
304               
305                if(exclusive){
306                        for(ResourceUnitName resUnitName: resources.keySet()){
307                                ResourceUnit resUnit = resources.get(resUnitName);
308                                if(resUnit.getName().getName().equals(StandardResourceUnitName.PE.getName())){
309                                        ProcessingElements pe = (ProcessingElements)resUnit;
310                                        for(ComputingResource cr: pe){
311                                                if(cr.getStatus().equals(ResourceStatus.BUSY)){
312                                                        return false;
313                                                }
314                                        }
315                                }
316                                resUnit.getProvisioner().setState(ResourceUnitState.BUSY);
317                        }
318                       
319                        return true;
320                } else {
321                        for(ResourceUnitName resUnitName: resources.keySet()){
322                                ResourceUnit resUnit = resources.get(resUnitName);
323                                resUnit.getProvisioner().setState(ResourceUnitState.BUSY);
324                        }
325                        return true;   
326                }
327        }
328
329        public void freeResources(Map<ResourceUnitName, ResourceUnit> resources, boolean exclusive) {
330               
331                for(ResourceUnitName resUnitName: resources.keySet()){
332                        ResourceUnit resUnit = resources.get(resUnitName);
333                        resUnit.getProvisioner().setState(ResourceUnitState.FREE);
334                }
335        }
336
337}
Note: See TracBrowser for help on using the repository browser.