source: DCWoRMS/trunk/src/schedframe/scheduling/policy/local/LocalManagementSystem.java @ 555

Revision 555, 19.8 KB checked in by wojtekp, 12 years ago (diff)
  • Property svn:mime-type set to text/plain
Line 
1package schedframe.scheduling.policy.local;
2
3import dcworms.schedframe.scheduling.ExecTask;
4import dcworms.schedframe.scheduling.Executable;
5import eduni.simjava.Sim_event;
6import eduni.simjava.Sim_system;
7import gridsim.Accumulator;
8import gridsim.GridSimTags;
9import gridsim.ResourceCalendar;
10import gridsim.dcworms.DCWormsTags;
11import gridsim.dcworms.filter.ExecTaskFilter;
12
13import java.util.ArrayList;
14import java.util.HashMap;
15import java.util.Iterator;
16import java.util.List;
17import java.util.Map;
18
19import org.apache.commons.lang.ArrayUtils;
20import org.apache.commons.logging.Log;
21import org.apache.commons.logging.LogFactory;
22import org.joda.time.DateTime;
23import org.joda.time.DateTimeUtilsExt;
24import org.qcg.broker.schemas.schedulingplan.types.AllocationStatus;
25
26import qcg.shared.constants.BrokerConstants;
27import schedframe.ResourceController;
28import schedframe.events.scheduling.SchedulingEvent;
29import schedframe.events.scheduling.SchedulingEventType;
30import schedframe.events.scheduling.StartTaskExecutionEvent;
31import schedframe.events.scheduling.TaskFinishedEvent;
32import schedframe.events.scheduling.TaskRequestedTimeExpiredEvent;
33import schedframe.exceptions.ResourceException;
34import schedframe.resources.computing.ComputingResource;
35import schedframe.resources.computing.profiles.energy.EnergyEvent;
36import schedframe.resources.computing.profiles.energy.EnergyEventType;
37import schedframe.resources.units.PEUnit;
38import schedframe.resources.units.ProcessingElements;
39import schedframe.resources.units.ResourceUnit;
40import schedframe.resources.units.ResourceUnitName;
41import schedframe.resources.units.StandardResourceUnitName;
42import schedframe.scheduling.ResourceHistoryItem;
43import schedframe.scheduling.Scheduler;
44import schedframe.scheduling.TaskList;
45import schedframe.scheduling.TaskListImpl;
46import schedframe.scheduling.UsedResourcesList;
47import schedframe.scheduling.WorkloadUnitHandler;
48import schedframe.scheduling.manager.resources.LocalResourceManager;
49import schedframe.scheduling.manager.resources.ManagedResources;
50import schedframe.scheduling.manager.resources.ResourceManager;
51import schedframe.scheduling.plan.AllocationInterface;
52import schedframe.scheduling.plan.ScheduledTaskInterface;
53import schedframe.scheduling.plan.SchedulingPlanInterface;
54import schedframe.scheduling.plugin.SchedulingPlugin;
55import schedframe.scheduling.plugin.estimation.ExecutionTimeEstimationPlugin;
56import schedframe.scheduling.plugin.grid.ModuleListImpl;
57import schedframe.scheduling.plugin.grid.ModuleType;
58import schedframe.scheduling.policy.AbstractManagementSystem;
59import schedframe.scheduling.queue.TaskQueueList;
60import schedframe.scheduling.tasks.AbstractProcesses;
61import schedframe.scheduling.tasks.Job;
62import schedframe.scheduling.tasks.JobInterface;
63import schedframe.scheduling.tasks.Task;
64import schedframe.scheduling.tasks.TaskInterface;
65import schedframe.scheduling.tasks.WorkloadUnit;
66import simulator.DCWormsConstants;
67import simulator.utils.DoubleMath;
68
69public class LocalManagementSystem extends AbstractManagementSystem {
70
71        private Log log = LogFactory.getLog(LocalManagementSystem.class);
72
73        protected double lastUpdateTime;
74
75        protected Accumulator accTotalLoad;
76
77        public LocalManagementSystem(String providerId, String entityName, SchedulingPlugin schedPlugin,
78                        ExecutionTimeEstimationPlugin execTimeEstimationPlugin, TaskQueueList queues)
79                        throws Exception {
80
81                super(providerId, entityName, execTimeEstimationPlugin, queues);
82               
83                if (schedPlugin == null) {
84                        throw new Exception("Can not create local scheduling plugin instance.");
85                }
86                this.schedulingPlugin =  schedPlugin;
87                this.moduleList = new ModuleListImpl(1);
88               
89                this.accTotalLoad = new Accumulator();
90        }
91
92        public void init(Scheduler sched, ManagedResources managedResources) {
93                super.init(sched, managedResources);
94                double load = 0;
95                accTotalLoad.add(load);
96        }
97
98        public void processEvent(Sim_event ev) {
99
100                updateProcessingProgress();
101
102                int tag = ev.get_tag();
103                Object obj;
104
105                switch (tag) {
106
107                case DCWormsTags.TIMER:
108                        if (pluginSupportsEvent(tag)) {
109                                SchedulingEvent event = new SchedulingEvent(SchedulingEventType.TIMER);
110                                SchedulingPlanInterface<?> decision =  schedulingPlugin.schedule(event,
111                                                queues,  getJobRegistry(), getResourceManager(), moduleList);
112                                executeSchedulingPlan(decision);
113                        }
114                        sendTimerEvent();
115                        break;
116
117                case DCWormsTags.TASK_READY_FOR_EXECUTION:
118                        ExecTask execTask = (ExecTask) ev.get_data();
119                        try {
120                                execTask.setStatus(DCWormsTags.READY);
121                                if (pluginSupportsEvent(tag)) {
122                                        SchedulingEvent event = new StartTaskExecutionEvent(execTask.getJobId(), execTask.getId());
123                                        SchedulingPlanInterface<?> decision =  schedulingPlugin.schedule(event,
124                                                        queues,  getJobRegistry(), getResourceManager(), moduleList);
125                                        executeSchedulingPlan(decision);
126                                }
127                        } catch (Exception e) {
128                                e.printStackTrace();
129                        }
130                        break;
131
132                case DCWormsTags.TASK_EXECUTION_FINISHED:
133                        obj = ev.get_data();
134                        execTask = (ExecTask) obj;
135                        if (execTask.getStatus() == DCWormsTags.INEXEC) {
136                               
137                                finalizeExecutable(execTask);
138                                sendFinishedWorkloadUnit(execTask);
139                                log.debug(execTask.getJobId() + "_" + execTask.getId() + " finished execution on " + new DateTime());
140                                log.info(DCWormsConstants.USAGE_MEASURE_NAME + ": " + calculateTotalLoad(jobRegistry.getRunningTasks().size()));
141                                if (pluginSupportsEvent(tag)) {
142                                        SchedulingEvent event = new TaskFinishedEvent(execTask.getJobId(), execTask.getId());
143                                        SchedulingPlanInterface<?> decision = schedulingPlugin.schedule(event,
144                                                        queues, getJobRegistry(), getResourceManager(), moduleList);
145                                        executeSchedulingPlan(decision);
146                                }
147                        }
148
149                        Job job = jobRegistry.getJob(execTask.getJobId());
150                        if(!job.isFinished()){
151                                getWorkloadUnitHandler().handleJob(job);
152                        }
153                        break;
154                       
155                case DCWormsTags.TASK_REQUESTED_TIME_EXPIRED:
156                        obj = ev.get_data();
157                        execTask = (Executable) obj;
158                        if (pluginSupportsEvent(tag)) {
159                                SchedulingEvent event = new TaskRequestedTimeExpiredEvent(execTask.getJobId(), execTask.getId());
160                                SchedulingPlanInterface<?> decision = schedulingPlugin.schedule(event,
161                                                queues, getJobRegistry(), getResourceManager(), moduleList);
162                                executeSchedulingPlan(decision);
163                        }
164                        break;
165                       
166                case DCWormsTags.UPDATE:
167                        updateProcessingTimes(ev);
168                        break;
169                }
170        }
171
172        public void notifyReturnedWorkloadUnit(WorkloadUnit wu) {
173                if (pluginSupportsEvent(DCWormsTags.TASK_EXECUTION_FINISHED)) {
174                        SchedulingEvent event = new SchedulingEvent(SchedulingEventType.TASK_FINISHED);
175                        SchedulingPlanInterface<?> decision =  schedulingPlugin.schedule(event,
176                                        queues, getJobRegistry(), getResourceManager(), moduleList);
177                        executeSchedulingPlan(decision);
178                }
179                //if(scheduler.getParent() != null){
180                        sendFinishedWorkloadUnit(wu);
181                //}
182        }
183       
184        protected void executeSchedulingPlan(SchedulingPlanInterface<?> decision) {
185
186                ArrayList<ScheduledTaskInterface<?>> taskSchedulingDecisions = decision.getTasks();
187                for (int i = 0; i < taskSchedulingDecisions.size(); i++) {
188                        ScheduledTaskInterface<?> taskDecision = taskSchedulingDecisions.get(i);
189
190                        if (taskDecision.getStatus() == AllocationStatus.REJECTED) {
191                                continue;
192                        }
193
194                        ArrayList<AllocationInterface<?>> allocations = taskDecision.getAllocations();
195
196                        TaskInterface<?> task = taskDecision.getTask();
197                        for (int j = 0; j < allocations.size(); j++) {
198
199                                AllocationInterface<?> allocation = allocations.get(j);
200                                if (allocation.getRequestedResources() == null || allocation.getRequestedResources().size() > 0) {
201                                        ExecTask exec = (ExecTask) task;                                       
202                                        executeTask(exec, allocation.getRequestedResources());
203                                } else if(resourceManager.getSchedulerName(allocation.getProviderName()) != null){
204                                        allocation.setProviderName(resourceManager.getSchedulerName(allocation.getProviderName()));
205                                        submitTask(task, allocation);
206                                } else {
207                                        ExecTask exec = (ExecTask) task;
208                                        executeTask(exec, chooseResourcesForExecution(allocation.getProviderName(), exec));
209                                }
210                        }
211
212                }
213        }
214
215        protected void executeTask(ExecTask task, Map<ResourceUnitName, ResourceUnit> choosenResources) {
216
217                Executable exec = (Executable)task;
218                boolean allocationStatus = getAllocationManager().allocateResources(choosenResources);
219                if(allocationStatus == false){
220                        log.error("Task requires more resources than is availiable at this moment.");
221                        return;
222                }
223
224                removeFromQueue(task);
225
226                SchedulingEvent event = new SchedulingEvent(SchedulingEventType.START_TASK_EXECUTION);
227                int time = Double.valueOf(
228                                execTimeEstimationPlugin.execTimeEstimation(event, task, choosenResources, exec.getCompletionPercentage())).intValue();
229                log.debug(task.getJobId() + "_" + task.getId() + " starts executing on " + new DateTime()
230                                + " will finish after " + time);
231
232                if (time < 0.0)
233                        return;
234
235                exec.setEstimatedDuration(time);
236                DateTime currentTime = new DateTime();
237                ResourceHistoryItem resHistItem = new ResourceHistoryItem(choosenResources, currentTime);
238                exec.addUsedResources(resHistItem);
239                try {
240                        exec.setStatus(DCWormsTags.INEXEC);
241                } catch (Exception e) {
242                        // TODO Auto-generated catch block
243                        e.printStackTrace();
244                }
245                scheduler.sendInternal(time, DCWormsTags.TASK_EXECUTION_FINISHED, exec);
246
247                try {
248                        long expectedDuration = exec.getExpectedDuration().getMillis() / 1000;
249                        scheduler.sendInternal(expectedDuration, DCWormsTags.TASK_REQUESTED_TIME_EXPIRED, exec);
250                } catch (NoSuchFieldException e) {
251                        double t = exec.getEstimatedDuration();
252                        scheduler.sendInternal(t, DCWormsTags.TASK_REQUESTED_TIME_EXPIRED, exec);
253                }
254
255                log.info(DCWormsConstants.USAGE_MEASURE_NAME + ": " + calculateTotalLoad(jobRegistry.getRunningTasks().size()));
256               
257                PEUnit peUnit = (PEUnit)choosenResources.get(StandardResourceUnitName.PE);
258               
259                notifyComputingResources(peUnit, EnergyEventType.TASK_STARTED, exec);
260               
261                /*if(peUnit instanceof ProcessingElements){
262                        ProcessingElements pes = (ProcessingElements) peUnit;
263                        for (ComputingResource resource : pes) {
264                                resource.handleEvent(new EnergyEvent(EnergyEventType.TASK_STARTED, exec));
265                        }
266                } else {
267                        ComputingResource resource = null;
268                        try {
269                                resource = ResourceController.getComputingResourceByName(peUnit.getResourceId());
270                        } catch (ResourceException e) {
271                                return;
272                        }
273                        resource.handleEvent(new EnergyEvent(EnergyEventType.TASK_STARTED, exec));
274                }
275*/
276
277                /*for(ExecTaskInterface etask : jobRegistry.getRunningTasks()){
278                        System.out.println(etask.getJobId());
279                        for(String taskId: etask.getVisitedResources())
280                                System.out.println("====="+taskId);
281                }*/
282        }
283       
284        public void finalizeExecutable(ExecTask execTask){
285               
286                Executable exec = (Executable)execTask;
287                exec.finalizeExecutable();
288               
289                ExecTaskFilter filter = new ExecTaskFilter(exec.getUniqueId(), DCWormsTags.TASK_REQUESTED_TIME_EXPIRED);
290                scheduler.sim_cancel(filter, null);
291               
292                Task task;
293                Job job = jobRegistry.getJob(exec.getJobId());
294                try {
295                        task = job.getTask(exec.getTaskId());
296                } catch (NoSuchFieldException e) {
297                        return;
298                }
299                if(exec.getProcessesId() == null){
300                        try {
301                                task.setStatus(exec.getStatus());
302                        } catch (Exception e) {
303                                e.printStackTrace();
304                        }
305                } else {
306                        List<AbstractProcesses> processesList = task.getProcesses();
307                        for(int i = 0; i < processesList.size(); i++){
308                                AbstractProcesses processes = processesList.get(i);
309                                if(processes.getId().equals(exec.getProcessesId())){
310                                        processes.setStatus(exec.getStatus());
311                                        break;
312                                }
313                        }
314                }
315               
316                UsedResourcesList lastUsedList = exec.getUsedResources();
317                Map<ResourceUnitName, ResourceUnit> lastUsed = lastUsedList.getLast()
318                                .getResourceUnits();
319                getAllocationManager().freeResources(lastUsed);
320               
321                PEUnit peUnit = (PEUnit)lastUsed.get(StandardResourceUnitName.PE);
322                notifyComputingResources(peUnit, EnergyEventType.TASK_FINISHED, exec);
323                /*if(peUnit instanceof ProcessingElements){
324                        ProcessingElements pes = (ProcessingElements) peUnit;
325                        for (ComputingResource resource : pes) {
326                                resource.handleEvent(new EnergyEvent(EnergyEventType.TASK_FINISHED, exec));
327                        }
328                } else {
329                        ComputingResource resource = null;
330                        try {
331                                resource = ResourceController.getComputingResourceByName(peUnit.getResourceId());
332                        } catch (ResourceException e) {
333                                return;
334                        }
335                        resource.handleEvent(new EnergyEvent(EnergyEventType.TASK_FINISHED, exec));
336                }*/
337
338                //sendFinishedWorkloadUnit(executable);
339        }
340       
341        protected void updateProcessingProgress() {
342                double timeSpan = DoubleMath.subtract(Sim_system.clock(), lastUpdateTime);
343                if (timeSpan <= 0.0) {
344                        // don't update when nothing changed
345                        return;
346                }
347                lastUpdateTime = Sim_system.clock();
348                Iterator<ExecTask> iter = jobRegistry.getRunningTasks().iterator();
349                while (iter.hasNext()) {
350                        ExecTask task = iter.next();
351                        Executable exec = (Executable)task;
352                        exec.setCompletionPercentage(exec.getCompletionPercentage() + 100 * timeSpan/exec.getEstimatedDuration());
353                       
354                        UsedResourcesList usedResourcesList = exec.getUsedResources();
355                        PEUnit peUnit = (PEUnit)usedResourcesList.getLast().getResourceUnits()
356                                        .get(StandardResourceUnitName.PE);
357                        double load = getMIShare(timeSpan, peUnit);
358                        addTotalLoad(load);
359                }
360        }
361        private void notifyComputingResources(PEUnit peUnit, EnergyEventType eventType, Object obj){
362
363                if(peUnit instanceof ProcessingElements){
364                        ProcessingElements pes = (ProcessingElements) peUnit;
365                        for (ComputingResource resource : pes) {
366                                resource.handleEvent(new EnergyEvent(eventType, obj));
367                        }
368                } else {
369                        ComputingResource resource = null;
370                        try {
371                                resource = ResourceController.getComputingResourceByName(peUnit.getResourceId());
372                        } catch (ResourceException e) {
373                                return;
374                        }
375                        resource.handleEvent(new EnergyEvent(eventType, obj));
376                }
377        }
378       
379        private double getMIShare(double timeSpan, PEUnit pes) {
380                double localLoad;
381                ResourceCalendar resCalendar = (ResourceCalendar) moduleList.getModule(ModuleType.RESOURCE_CALENDAR);
382                if (resCalendar == null)
383                        localLoad = 0;
384                else
385                        // 1 - localLoad_ = available MI share percentage
386                        localLoad = resCalendar.getCurrentLoad();
387
388                int speed = pes.getSpeed();
389                int cnt = pes.getAmount();
390
391                double totalMI = speed * cnt * timeSpan * (1 - localLoad);
392                return totalMI;
393        }
394
395        protected void updateProcessingTimes(Sim_event ev) {
396                updateProcessingProgress();
397                for (ExecTask execTask : jobRegistry.getRunningTasks()) {
398                        Executable exec = (Executable)execTask;
399                        List<String> visitedResource = exec.getVisitedResources();
400                        String originResource = ev.get_data().toString();
401                        if(!ArrayUtils.contains(visitedResource.toArray(new String[visitedResource.size()]), originResource)){
402                                continue;
403                        }
404                       
405                        Map<ResourceUnitName, ResourceUnit> choosenResources = exec.getUsedResources().getLast().getResourceUnits();
406                        int time =  Double.valueOf(execTimeEstimationPlugin.execTimeEstimation(new SchedulingEvent(SchedulingEventType.RESOURCE_STATE_CHANGED),
407                                        execTask, choosenResources, exec.getCompletionPercentage())).intValue();
408
409                        //check if the new estimated end time is equal to the previous one; if yes the continue without update
410                        if( DoubleMath.subtract((exec.getExecStartTime() + exec.getEstimatedDuration()), (new DateTime().getMillis()/1000 + time)) == 0.0){
411                                continue;
412                        }
413                        exec.setEstimatedDuration(time);
414                        ExecTaskFilter filter = new ExecTaskFilter(exec.getUniqueId(), DCWormsTags.TASK_EXECUTION_FINISHED);
415                        scheduler.sim_cancel(filter, null);
416                        scheduler.sendInternal(time, DCWormsTags.TASK_EXECUTION_FINISHED, execTask);
417                }
418        }       
419
420        public double calculateTotalLoad(int size) {
421                // background load, defined during initialization
422                double load;
423                ResourceCalendar resCalendar = (ResourceCalendar) moduleList.getModule(ModuleType.RESOURCE_CALENDAR);
424                if (resCalendar == null)
425                        load = 0;
426                else
427                        load = resCalendar.getCurrentLoad();
428
429                int numberOfPE = 0;
430                try {
431                        for(ResourceUnit resUnit : getResourceManager().getPE()){
432                                numberOfPE = numberOfPE + resUnit.getAmount();
433                        }
434                } catch (Exception e) {
435                        numberOfPE = 1;
436                }
437                double tasksPerPE = (double) size / numberOfPE;
438                load += Math.min(1.0 - load, tasksPerPE);
439
440                return load;
441        }
442
443        public Accumulator getTotalLoad() {
444                return accTotalLoad;
445        }
446
447        protected void addTotalLoad(double load) {
448                accTotalLoad.add(load);
449        }
450       
451        private Map<ResourceUnitName, ResourceUnit> chooseResourcesForExecution(String resourceName,
452                        ExecTask task) {
453
454                Map<ResourceUnitName, ResourceUnit> map = new HashMap<ResourceUnitName, ResourceUnit>();
455                LocalResourceManager resourceManager = getResourceManager();
456                if(resourceName != null){
457                        ComputingResource resource = null;
458                        try {
459                                resource = resourceManager.getResourceByName(resourceName);
460                        } catch (ResourceException e) {
461                                return null;
462                        }
463                        resourceManager = new LocalResourceManager(resource);
464                }
465
466                int cpuRequest;
467                try {
468                        cpuRequest = Double.valueOf(task.getCpuCntRequest()).intValue();
469                } catch (NoSuchFieldException e) {
470                        cpuRequest = 1;
471                }
472
473                if (cpuRequest != 0) {
474                       
475                        List<ResourceUnit> availableUnits = null;
476                        try {
477                                availableUnits = resourceManager.getPE();
478                        } catch (ResourceException e) {
479                                return null;
480                        }
481                       
482                        List<ResourceUnit> choosenPEUnits = new ArrayList<ResourceUnit>();
483                        for (int i = 0; i < availableUnits.size() && cpuRequest > 0; i++) {
484                                PEUnit peUnit = (PEUnit) availableUnits .get(i);
485                                if(peUnit.getFreeAmount() > 0){
486                                        int  allocPE = Math.min(peUnit.getFreeAmount(), cpuRequest);
487                                        cpuRequest = cpuRequest - allocPE;
488                                        choosenPEUnits.add(peUnit.replicate(allocPE)); 
489                                }       
490                        }
491                       
492                        if(cpuRequest > 0){
493                                return null;
494                        }
495                        map.put(StandardResourceUnitName.PE, choosenPEUnits.get(0));
496                }
497
498                return  map;
499        }
500       
501        public void notifySubmittedWorkloadUnit(WorkloadUnit wu, boolean ack) {
502                updateProcessingProgress();
503                registerWorkloadUnit(wu);
504        }
505
506        private void registerWorkloadUnit(WorkloadUnit wu){
507                if(!wu.isRegistered()){
508                        wu.register(jobRegistry);
509                }
510                wu.accept(getWorkloadUnitHandler());
511        }
512       
513        class LocalWorkloadUnitHandler implements WorkloadUnitHandler{
514               
515                public void handleJob(JobInterface<?> job){
516
517                        if (log.isInfoEnabled())
518                                log.info("Received job " + job.getId() + " at " + new DateTime(DateTimeUtilsExt.currentTimeMillis()));
519
520                        List<JobInterface<?>> jobsList = new ArrayList<JobInterface<?>>();
521                        jobsList.add(job);
522                        TaskListImpl availableTasks = new TaskListImpl();
523                        for(Task task: jobRegistry.getAvailableTasks(jobsList)){
524                                task.setStatus((int)BrokerConstants.TASK_STATUS_QUEUED);
525                                availableTasks.add(task);
526                        }
527
528                        for(TaskInterface<?> task: availableTasks){     
529                                registerWorkloadUnit(task);
530                        }
531                }
532               
533                public void handleTask(TaskInterface<?> t){
534                        Task task = (Task)t;
535                        List<AbstractProcesses> processes = task.getProcesses();
536
537                        if(processes == null || processes.size() == 0){
538                                Executable exec = new Executable(task);
539                                registerWorkloadUnit(exec);
540                        } else {
541                                for(int j = 0; j < processes.size(); j++){
542                                        AbstractProcesses procesesSet = processes.get(j);
543                                        Executable exec = new Executable(task, procesesSet);
544                                        registerWorkloadUnit(exec);
545                                }
546                        }
547                }
548               
549                public void handleExecutable(ExecTask task){
550                       
551                        Executable exec = (Executable) task;
552                        jobRegistry.addExecTask(exec);
553                       
554                        exec.trackResource(scheduler.get_name());
555                        Scheduler parentScheduler = scheduler.getParent();
556                        List<String> visitedResource = exec.getVisitedResources();
557                        String [] visitedResourcesArray = visitedResource.toArray(new String[visitedResource.size()]);
558                        while (parentScheduler != null && !ArrayUtils.contains(visitedResourcesArray, parentScheduler.get_name())) {
559                                exec.trackResource(parentScheduler.get_name());
560                                parentScheduler = parentScheduler.getParent();
561                        }
562                        exec.setSchedulerName(scheduler.get_id());
563                       
564                        TaskList newTasks = new TaskListImpl();
565                        newTasks.add(exec);
566               
567                        schedulingPlugin.placeTasksInQueues(newTasks, queues, getResourceManager(), moduleList);
568
569                        if (exec.getStatus() == DCWormsTags.QUEUED) {
570                                sendExecutableReadyEvent(exec);
571                        }
572                }
573        }
574
575        public WorkloadUnitHandler getWorkloadUnitHandler() {
576                return new LocalWorkloadUnitHandler();
577        }
578       
579       
580        public LocalResourceManager getResourceManager() {
581                if (resourceManager instanceof ResourceManager)
582                        return (LocalResourceManager) resourceManager;
583                else
584                        return null;
585        }
586       
587}
Note: See TracBrowser for help on using the repository browser.