Lightweight Bartering Grid

Uses of Class
lbg.task.Task

Packages that use Task
lbg.middleware   
lbg.middleware.execution   
lbg.peer.core.qms   
lbg.peer.core.qms.prequeue   
lbg.peer.core.rms   
lbg.peer.core.scheduler   
lbg.peer.core.xms   
lbg.peer.register   
lbg.peer.register.bartering   
lbg.peer.register.learning.consumption   
lbg.peer.register.learning.db   
lbg.peer.register.learning.db.meta   
lbg.peer.service   
lbg.peer.strategy.accounting   
lbg.peer.strategy.ranking   
lbg.peer.strategy.scheduling   
lbg.peer.strategy.scheduling.filtering   
lbg.peer.strategy.scheduling.preemption   
lbg.peer.workflow   
lbg.resource   
lbg.resource.execution   
lbg.resource.service   
lbg.simulator.event   
lbg.task   
lbg.user   
lbg.user.service   
 

Uses of Task in lbg.middleware
 

Methods in lbg.middleware with parameters of type Task
 void AutomaticJobSubmitter.taskCompletion(Task t)
          LiveUserAgentListener implementation.
 

Uses of Task in lbg.middleware.execution
 

Methods in lbg.middleware.execution with parameters of type Task
 GridApplication GridClassLoader.load(Task t)
          Loads all classes required to run the Task, and creates the Application.
 

Uses of Task in lbg.peer.core.qms
 

Methods in lbg.peer.core.qms that return Task
 Task RequestContainer.getTask()
           
 

Methods in lbg.peer.core.qms with parameters of type Task
 void QueueManager.dequeueCancelledLocalTask(Task t, long xstart_time, long runtime, java.lang.String supplier_id)
          Dequeues a Local Task after its execution has been cancelled.
 void QueueManager.dequeueCancelledSupplyingTask(Task t, long xstart_time)
          Dequeues a Supplying Task after its execution has been cancelled.
 RequestStatus QueueManager.dequeueCompletedConsumptionTask(Task t, long xstart_time, long runtime)
          Dequeues a Consumption Task after its execution has been completed
 RequestStatus QueueManager.dequeueCompletedLocalTask(Task t, long xstart_time, long runtime)
          Dequeues a Local Task after its execution has been completed
 RequestStatus QueueManager.dequeueCompletedSupplyingTask(Task t, long xstart_time, long runtime)
          Dequeues a Supplying Task after its execution has been completed
 void QueueManager.dequeueWaitingLocalTask(Task t)
          Dequeues a waiting Local Task.
 void QueueManager.dequeueWaitingSupplyingTask(boolean notify_consumer, Task t)
          Dequeues target waiting Supplying Task.
 boolean QueueManager.isSupplyingTaskRunning(Task t)
           
 void QueueManager.requeuePreemptedConsumptionTask(Task t, long xstart_time, long runtime, java.lang.String supplier_id)
          Requeues a Consumption Task after its execution has been cancelled.
 void QueueManager.requeuePreemptedLocalTask(Task t, long xstart_time, long runtime, java.lang.String supplier_id)
          Requeues a Local Task after its execution has been cancelled.
 void QueueManager.requeuePreemptedSupplyingTask(Task t, long xstart_time)
          Requeues a Supplying Task after its execution has been cancelled.
 void QueueManager.requeueUnqueuedConsumptionTask(Task t)
          Requeues a Consumption Task that has been unqueued, but not executed, i.e.
 void QueueManager.requeueUnqueuedLocalTask(Task t)
          Requeues a Local Task that has been unqueued, but not executed, i.e.
 void QueueManager.requeueUnqueuedSupplyingTask(Task t)
          Requeues a Supplying Task that has been unqueued, but not executed, i.e.
 

Constructors in lbg.peer.core.qms with parameters of type Task
RequestContainer(Task t, java.lang.Integer task_scheduling_id)
           
 

Uses of Task in lbg.peer.core.qms.prequeue
 

Methods in lbg.peer.core.qms.prequeue with parameters of type Task
 ConsumptionTaskID JobPreQueue.transferSupplyingTaskToQMS(Task t)
           
 

Uses of Task in lbg.peer.core.rms
 

Methods in lbg.peer.core.rms that return Task
 Task ResourceManager.getRunningTask(ResourceHandle rh)
          Returns the Task running on target Busy Resource.
 Task ResourceUsageData.runningTask()
           
 

Methods in lbg.peer.core.rms with parameters of type Task
 void WorkingSet.clearAddAndLockLocalInputData(Task t)
          Clears WorkingSet, then add-and-lock target Local data.
 void WorkingSet.clearAddAndLockSupplyingInputData(Task t)
          Clears WorkingSet, then add-and-lock target Supplying data.
 long ResourceManager.freeBusyLocalResource(Task t)
          Clears the state of the target Resource.
 long ResourceManager.freeBusySupplyingResource(Task t)
          Clears the state of the target Resource.
 ResourceHandle ResourceLocator.locateAndCheckBusyLocalResource(Task t)
          Locates a Busy Local Resource running target Task (guaranteed to be non-null).
 ResourceHandle ResourceLocator.locateAndCheckBusySupplyingResource(Task t)
          Locates a Busy Supplying Resource running target Task (guaranteed to be non-null).
 ResourceHandle ResourceLocator.locateBusyLocalResource(Task t)
          Locates a Busy Local Resource running target Task (may be null).
 ResourceHandle ResourceLocator.locateBusySupplyingResource(Task t)
          Locates a Busy Supplying Resource running target Task (may be null).
 java.util.Set<ResourceDataTracker.TransferCostData> ResourceDataTracker.locateIdleResourcesWithStorageAffinity(Task t)
          Deprecated.  
 ResourceHandle ResourceDataTracker.locateIdleResourceWithBestStorageAffinity(Task t)
          Locate best (Storage Affinity-wise) Resource which has a mximum of data required by target Task in her WorkingSet.
 ResourceHandle ResourceManager.locateResource(ResourceState state, Task t)
          Locates a Resource currentlty in target state with maximum Storage Affinity with target Task.
 long ResourceManager.preemptBusyLocalResource(Task t)
          Clears the state of the target Resource.
 long ResourceManager.preemptBusySupplyingResource(Task t)
          Clears the state of the target Resource.
 long ResourceManager.preemptBusySupplyingResource(Task t, ResourceHandle rh)
          Clears the state of the target Resource.
 boolean ResourceManager.runLocalTask(ResourceHandle rh, Task t)
          Runs target Task on target Resource.
 boolean ResourceManager.runSupplyingTask(ResourceHandle rh, Task t)
          Runs target Task on target Resource.
 void ResourceLocator.trackBusyLocalResource(Task t, ResourceHandle rh)
           
 void ResourceLocator.trackBusySupplyingResource(Task t, ResourceHandle rh)
           
 void WorkingSet.unlockLocalInputData(Task t)
           
 void WorkingSet.unlockSupplyingInputData(Task t)
           
 void ResourceLocator.untrackBusyLocalResource(Task t)
           
 void ResourceLocator.untrackBusySupplyingResource(Task t)
           
 WorkingSet ResourceTracker.updateResourceStatusToBusy(ResourceHandle rh, ResourceState state, Task t)
          Updates target Resource status from idle to busy local or busy supplying, depending on the value of target state.
 void ResourceUsageData.updateTotalIdleTime(ResourceState state, Task t)
          Updates total idle time of the monitored Resource.
 

Constructors in lbg.peer.core.rms with parameters of type Task
ResourceLocator.ResourceLocatorKey(Task t, boolean is_local_task)
           
 

Uses of Task in lbg.peer.core.scheduler
 

Methods in lbg.peer.core.scheduler with parameters of type Task
 boolean Scheduler.filterOutSupplyingTask(Task t)
          Indicates whether target Supplying Task should be filtered out, or may be safely queued.
 void Scheduler.preemptLocalResources(Task prioritary_task)
          Preempts some Supplying Tasks on Local Resources so as to enable the Local scheduling of target prioritary Local Task.
 

Uses of Task in lbg.peer.core.xms
 

Methods in lbg.peer.core.xms that return Task
 Task ExecutionManager.getMostRecentlyRunningAndUngracedSupplyingTask()
          Returns the most recently running Supplying Task that has not been graced (useful for PSufferage Resource selection to preempt a running Supplying Task).
 Task RunningTaskManager.getMostRecentlyRunningAndUngracedTask()
          Returns the most recently running Task that has not been graced (useful for PSufferage Resource selection to preempt a running Supplying Task).
abstract  Task TaskRuntimeData.getTask()
           
 Task SupplyingTaskRuntimeData.getTask()
           
 Task LocalTaskRuntimeData.getTask()
           
 Task ConsumptionTaskRuntimeData.getTask()
           
 Task[] ExecutionManager.listRunningConsumptionTasks()
          Lists running Consumption Tasks, in decreasing order of execution time (longest-running first).
 Task[] ExecutionManager.listRunningLocalTasks()
          Lists running Local Tasks, in decreasing order of execution time (longest-running first).
 Task[] ExecutionManager.listRunningSupplyingTasks()
          Lists running Supplying Tasks, in decreasing order of execution time (longest-running first).
 Task[] RunningTaskManager.listRunningTasks()
          Lists running Tasks, in decreasing order of execution time (longest-running first).
 

Methods in lbg.peer.core.xms with parameters of type Task
 void RunningTaskManager.addRunningTask(Task t, long timeout, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)
          Adds target Task to this running Tasks Manager.
 void ExecutionManager.cancelLocalTaskOnLocalResource(Task t, byte[] logs)
          The managed Peer instructs itself to cancel a Local Task running locally.
 void ExecutionManager.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
          Notifies Consumer Peer of the cancellation of target Task on the Supplier Peer.
 void ExecutionManager.cancelLocalTaskOnSupplyingResource(Task t)
          Notifies Consumer Peer of the cancellation of target Task on the Supplier Peer.
 void ExecutionManager.cancelSupplyingTaskOnLocalResource(Task t)
          Asks this (Supplier) Peer to cancel target Supplying Task.
 RequestStatus ExecutionManager.completeLocalTaskOnLocalResource(Task t)
           
 RequestStatus ExecutionManager.completeLocalTaskOnSupplyingResource(Task t)
           
 RequestStatus ExecutionManager.completeSupplyingTaskOnLocalResource(Task t)
           
abstract  TaskRuntimeData TaskRuntimeDataFactory.createTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)
           
 long RunningTaskManager.getStartTime(Task t)
          Returns the start time of target Task's execution.
 long ExecutionManager.getStartTime(Task t, RequestType rt)
          Returns the start time of target Task's execution.
 RequestType ExecutionManager.identifyRunningTaskType(Task t)
          Identity running Task type.
 java.lang.String RunningTaskManager.identifySupplier(Task t)
          Identifies which Peer is running the target Task.
 boolean ExecutionManager.isSupplyingTaskGraced(Task t)
          Identifies if target Supplying Task has been graced
 boolean RunningTaskManager.isTaskGraced(Task t)
          Identifies if target Task has been graced
 void ExecutionManager.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
          The managed Peer instructs itself to preempt a Local Task running locally.
 void ExecutionManager.preemptSupplyingTaskOnLocalResource(Task t, byte[] logs)
          The managed Peer instructs itself to preempt a Supplying Task running locally.
 long RunningTaskManager.removeRunningTask(Task t)
          Removes target Task from this running Tasks Manager.
 boolean ExecutionManager.runLocalTaskOnLocalResource(Task t, ResourceHandle rh)
          Runs target Task on target Resource.
 boolean ExecutionManager.runLocalTaskOnSupplyingResource(Task t, ExternalPeerHandle peer_handle)
          Returns the target Task on target Supplier Peer.
 boolean ExecutionManager.runSupplyingTaskOnLocalResource(Task t, ResourceHandle rh)
          Runs target Task on target Resource.
 boolean ExecutionManager.updateSupplyingTaskTimeOutAction(Task t, boolean do_cancel, long time_out)
          Updates the time-out and action tag associated with the target Supplying Task.
 boolean RunningTaskManager.updateTimeOutActionTag(Task t, boolean do_cancel)
          Updates the time-out action tag associated with the target Task.
 boolean RunningTaskManager.updateTimeOutActionTagAndValue(Task t, boolean do_cancel, long time_out)
          Updates the time-out and action tag associated with the target Task.
 void RunningTaskManager.updateTimeOutValue(Task t, long time_out)
          Updates the time-out associated with the target Task.
 

Constructors in lbg.peer.core.xms with parameters of type Task
ConsumptionTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)
           
LocalTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)
           
SupplyingTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)
           
 

Uses of Task in lbg.peer.register
 

Methods in lbg.peer.register with parameters of type Task
 void NeighborhoodBarteringProfile.accountConsumptionCancellation(java.lang.String supplier_id, Task t, long start_time)
           
 void NeighborhoodBarteringProfile.accountConsumptionCompletion(Task t, long xstart_time)
           
 void NeighborhoodBarteringProfile.accountLocalActivityCancellation(Task t)
           
 void NeighborhoodBarteringProfile.accountLocalActivityCompletion(Task t)
           
 void NeighborhoodBarteringProfile.accountSupplyingCancellation(Task t, long start_time)
           
 void NeighborhoodBarteringProfile.accountSupplyingCompletion(Task t, long xstart_time)
           
 TaskSchedulingContext TestPeerProfile.createConsumptionTaskSchedulingContext(Task t)
           
 TaskSchedulingContext PeerProfile.createConsumptionTaskSchedulingContext(Task t)
           
 TaskSchedulingContext TestPeerProfile.createSupplyingTaskSchedulingContext(Task t)
           
 TaskSchedulingContext PeerProfile.createSupplyingTaskSchedulingContext(Task t)
           
 

Uses of Task in lbg.peer.register.bartering
 

Methods in lbg.peer.register.bartering with parameters of type Task
 void TestPeerBarteringProfile.accountConsumptionCancellation(Task t, long xstart_time)
           
 void PeerBarteringProfile.accountConsumptionCancellation(Task t, long xstart_time)
           
 double TestPeerBarteringProfile.accountConsumptionCompletion(Task t, long xstart_time, long consumed_external_power)
           
 double PeerBarteringProfile.accountConsumptionCompletion(Task t, long xstart_time, long consumed_external_power)
           
 void TestPeerBarteringProfile.accountSupplyingCancellation(Task t, long xstart_time)
           
 void PeerBarteringProfile.accountSupplyingCancellation(Task t, long xstart_time)
           
 double TestPeerBarteringProfile.accountSupplyingCompletion(Task t, long xstart_time, long supplied_local_power)
           
 double PeerBarteringProfile.accountSupplyingCompletion(Task t, long xstart_time, long supplied_local_power)
           
 

Uses of Task in lbg.peer.register.learning.consumption
 

Methods in lbg.peer.register.learning.consumption with parameters of type Task
 java.util.Map<java.lang.Long,java.util.Set<java.lang.String>> PeerConsumptionDataTracker.rankPeers(Task t)
          Return data-aware ranking of Supplier Peers, sorted by decreasing Storage Affinity, where input data of target Task may be present.
 java.util.Map<java.lang.Long,java.util.Set<java.lang.String>> ConsumptionDataTracker.rankPeers(Task t)
           
 void PeerConsumptionDataTracker.trackData(java.lang.String supplier_peer, Task t)
          Tracks target data, i.e.
 void ConsumptionDataTracker.trackData(java.lang.String supplier_peer, Task t)
           
 

Uses of Task in lbg.peer.register.learning.db
 

Methods in lbg.peer.register.learning.db with parameters of type Task
 TaskSchedulingContext TaskSchedulingContextFactory.createConsumptionTaskSchedulingContext(Task t)
           
 TaskSchedulingContext TaskSchedulingContextFactory.createSupplyingTaskSchedulingContext(Task t)
           
 void TaskSchedulingContext.setOutcome(Task t, long xstart_time, RequestType rt)
           
 

Uses of Task in lbg.peer.register.learning.db.meta
 

Methods in lbg.peer.register.learning.db.meta with parameters of type Task
abstract  double InteractionAttributes.val(Task t, PeerBarteringProfile peer_bp)
          Returns the value of interaction attribute for target Task and Peer.
 

Uses of Task in lbg.peer.service
 

Methods in lbg.peer.service with parameters of type Task
 void TestPeerHandle.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void SimulatedWithCloningPeerService.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void SimulatedPeerService.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void SimulatedPeerHandle.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void LivePeerService.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void LivePeerHandle.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
          Cancel a task from this Peer running on another Peer
 void AbstractExternalPeerHandle.cancelLocalTaskOnSupplyingResource(java.lang.String supplier_id, Task t)
           
 void TestPeerHandle.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 void SimulatedWithCloningPeerService.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 void SimulatedPeerService.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 void SimulatedPeerHandle.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 void LivePeerService.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 void LivePeerHandle.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
          Cancel a task from another Peer running on this Peer
 void AbstractExternalPeerHandle.cancelSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID TestPeerHandle.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID SimulatedWithCloningPeerService.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID SimulatedPeerService.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID SimulatedPeerHandle.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID LivePeerService.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 ConsumptionTaskID LivePeerHandle.computeSupplyingTask(java.lang.String consumer_id, Task t)
          Compute a task.
 ConsumptionTaskID AbstractExternalPeerHandle.computeSupplyingTask(java.lang.String consumer_id, Task t)
           
 void TestPeerHandle.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void SimulatedWithCloningPeerService.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void SimulatedPeerService.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void SimulatedPeerHandle.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void LivePeerService.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void LivePeerHandle.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
          Cancels a task from this Peer running on this Resource
 void AbstractInternalPeerHandle.preemptLocalTaskOnLocalResource(Task t, byte[] logs)
           
 void TestPeerHandle.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void SimulatedWithCloningPeerService.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void SimulatedPeerService.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void SimulatedPeerHandle.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void LivePeerService.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void LivePeerHandle.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
          Preempts a task from another Peer running on this Peer
 void AbstractInternalPeerHandle.preemptSupplyingTaskOnLocalResource(java.lang.String consumer_id, Task t, byte[] logs)
           
 void TestPeerHandle.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void SimulatedWithCloningPeerService.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void SimulatedPeerService.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void SimulatedPeerHandle.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void LivePeerService.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void LivePeerHandle.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void AbstractExternalPeerHandle.uploadBySupplyingCompletedTask(java.lang.String supplier_id, Task t)
           
 void TestPeerHandle.uploadLocallyCompletedTask(Task t)
           
 void SimulatedWithCloningPeerService.uploadLocallyCompletedTask(Task t)
           
 void SimulatedPeerService.uploadLocallyCompletedTask(Task t)
           
 void SimulatedPeerHandle.uploadLocallyCompletedTask(Task t)
           
 void LivePeerService.uploadLocallyCompletedTask(Task t)
           
 void LivePeerHandle.uploadLocallyCompletedTask(Task t)
          Upload a task completed by a resource to this Peer
 void AbstractInternalPeerHandle.uploadLocallyCompletedTask(Task t)
           
 

Uses of Task in lbg.peer.strategy.accounting
 

Methods in lbg.peer.strategy.accounting with parameters of type Task
 double OGTimeAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double OGRelativePowerAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double OGPerfectAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double NoEvalAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double LBGTimeAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double LBGRelativePowerAccountant.evaluateConsumption(Task t, long xstart_time)
          BarteringAccountant implementation.
 double BarteringAccountantPolicy.evaluateConsumption(Task t, long start_time)
           
 double OGTimeAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double OGRelativePowerAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double OGPerfectAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double NoEvalAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double LBGTimeAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double LBGRelativePowerAccountant.evaluateSupplying(Task t, long xstart_time)
          BarteringAccountant implementation.
 double BarteringAccountantPolicy.evaluateSupplying(Task t, long start_time)
           
 

Uses of Task in lbg.peer.strategy.ranking
 

Constructors in lbg.peer.strategy.ranking with parameters of type Task
ReliableMLConsumptionRanking(ConsumptionGrantsContainer c_g, Task t)
           
ReliableMLConsumptionRanking(ConsumptionGrantsContainer c_g, Task t, boolean keep_only_best_tsc)
           
StorageAffinityConsumptionRanking(ConsumptionGrantsContainer c_g, ConsumptionDataTracker data_tracker, Task t, JobConsumptionOutcomeTracker jcot, boolean do_blacklist, float blacklist_proba)
          Constructs a new StorageAffinityConsumptionRanking.
StorageAffinityConsumptionRanking(ConsumptionGrantsContainer c_g, ConsumptionDataTracker data_tracker, Task t, JobConsumptionOutcomeTracker jcot, boolean do_blacklist, float blacklist_proba, boolean apply_tcor)
          Constructs a new StorageAffinityConsumptionRanking.
 

Uses of Task in lbg.peer.strategy.scheduling
 

Methods in lbg.peer.strategy.scheduling with parameters of type Task
 boolean SupplyingFilteringPolicy.filterOutSupplyingTask(Task t)
          Indicates whether target Supplying Task should be filtered out, or may be safely queued.
 void SupplyingRunningPreemptionPolicy.preemptLocalResources(Task t)
          Preempts some running Supplying Tasks, in order to reclaim some Local Resources for target Task.
 

Uses of Task in lbg.peer.strategy.scheduling.filtering
 

Methods in lbg.peer.strategy.scheduling.filtering with parameters of type Task
 boolean UnlimitedSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
 boolean StrictFavorsSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
 boolean RelaxedFavorsSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
 boolean NoSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
 boolean FIFOSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
abstract  boolean CommonSupplyingFiltering.filterOutSupplyingTask(Task t)
          SupplyingFilteringPolicy implementation.
 

Uses of Task in lbg.peer.strategy.scheduling.preemption
 

Methods in lbg.peer.strategy.scheduling.preemption with parameters of type Task
 void NoPreemption.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 void LimitedPreemption.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 void LimitedCancellation.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 void FullPreemption.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 void FullCancellation.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 void AdaptivePreemption.preemptLocalResources(Task prioritary_task)
          SupplyingRunningPreemptionPolicy implementation.
 

Uses of Task in lbg.peer.workflow
 

Methods in lbg.peer.workflow that return Task
 Task[] TemporalTasksGrouping.groupTasks(Task[] tasks)
          Reorders a given set of Tasks with the TemporalTasksGrouping heuristic.
 Task[] TemporalTasksGrouping.groupTasksWithSingleData(Task[] tasks)
          Deprecated.  
 Task BoT.peekFirstSupplyingTask()
          Peeks at the Supplying Task that would selected for scheduling.
 Task[] JobDescriptor.toTasks(java.lang.String consumer_peer_id, int job_id, int bot_id)
          Makes Tasks from the current description.
Calls to this method are always run completely (i.e.
 

Methods in lbg.peer.workflow that return types with arguments of type Task
 java.util.Iterator<Task> BoT.completedTasks()
           
 java.util.Iterator<Task> BoT.scheduledTasks()
           
 java.util.Iterator<Task> BoT.unscheduledTasks()
           
 

Methods in lbg.peer.workflow with parameters of type Task
 BoT BoTFactory.createBoT(java.lang.String consumer_peer_id, int job_id, Task[] tasks, boolean is_supplying_task)
          Creates a Bag of Tasks from given Tasks array.
 Job JobFactory.createSupplyingJob(Task t)
           
 RequestContainer BoT.flagTaskAsCompleted(Task returning_t)
           
 RequestContainer BoT.flagTaskAsUnscheduled(Task returning_t, boolean resync)
           
 Task[] TemporalTasksGrouping.groupTasks(Task[] tasks)
          Reorders a given set of Tasks with the TemporalTasksGrouping heuristic.
 Task[] TemporalTasksGrouping.groupTasksWithSingleData(Task[] tasks)
          Deprecated.  
 

Constructors in lbg.peer.workflow with parameters of type Task
BoT(int job_id, int bot_id, Task[] tasks, MetaGridData[] datas, boolean is_supplying_task)
           
 

Uses of Task in lbg.resource
 

Methods in lbg.resource that return Task
 Task Resource.runningTask()
           
 

Methods in lbg.resource with parameters of type Task
 void SimulatedResource.runTask(Task t)
           
 void Resource.runTask(Task t)
           
 void LiveResource.runTask(Task t)
          Runs a given Task by getting and loading all required information, then running the methods as specified by GridApplication.
The method returns immediately, starting the Task in another Thread.
 

Uses of Task in lbg.resource.execution
 

Constructors in lbg.resource.execution with parameters of type Task
LiveTaskExecutionHandler(LiveResource res, InternalPeerHandle iph, Task t, int mem_size)
          Readies a handler to be started as a different Thread.
 

Uses of Task in lbg.resource.service
 

Methods in lbg.resource.service that return Task
 Task SimulatedResourceService.runningTask()
          Deprecated.  
 Task SimulatedResourceHandle.runningTask()
          Deprecated.  
 Task LiveResourceService.runningTask()
          Deprecated.  
 Task LiveResourceHandle.runningTask()
          Deprecated.  
 Task AbstractResourceHandle.runningTask()
          Deprecated.  
 

Methods in lbg.resource.service with parameters of type Task
 void LiveResourceService.delete_me_runTask(Task t)
          Deprecated.  
 void LiveResourceHandle.delete_me_runTask(Task t)
          Deprecated. Specify new Working Set when running a task.
 boolean SimulatedResourceService.runTask(Task t, GridData[][] working_set)
           
 boolean SimulatedResourceHandle.runTask(Task t, GridData[][] working_set)
           
 boolean LiveResourceService.runTask(Task t, GridData[][] working_set)
           
 boolean LiveResourceHandle.runTask(Task t, GridData[][] working_set)
          Sets a resource's working set then runs a task.
 boolean AbstractResourceHandle.runTask(Task t, GridData[][] working_set)
           
 

Uses of Task in lbg.simulator.event
 

Methods in lbg.simulator.event that return Task
 Task TaskEvent.task()
           
 

Methods in lbg.simulator.event with parameters of type Task
 Event EventFactory.createCompletedTaskEvent(java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)
          Creates a CompletedTaskEvent so that target Task, submitted by target Consumer Peer, is completed by target Resource of target Supplier Peer, after the expected Task runtime from now.
 Event EventFactory.createFailedTaskEvent(java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)
          Creates a FailedTaskEvent so that target Task, submitted by target Consumer Peer, is cancelled by target Resource of target Supplier Peer, between now and the expected Task runtime from now.
 

Constructors in lbg.simulator.event with parameters of type Task
CompletedTaskEvent(long id, long timestamp, java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)
           
FailedTaskEvent(long id, long timestamp, java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)
           
 

Uses of Task in lbg.task
 

Methods in lbg.task with parameters of type Task
abstract  int TaskComparator.compare(Task t1, Task t2)
           
 int SupplyingTaskComparator.compare(Task t1, Task t2)
           
 int LocalTaskComparator.compare(Task t1, Task t2)
           
 int Task.compareTo(Task other)
          Note: this class has a natural ordering that is inconsistent with equals (see comment here below).
 void Task.syncWith(Task returning_self)
           
 

Constructors in lbg.task with parameters of type Task
TaskOutput(Task t, java.lang.String supplier_peer_id, long start_time, GridData data, byte[] logs, int power)
          Constructs a new TaskOutput.
 

Uses of Task in lbg.user
 

Methods in lbg.user with parameters of type Task
abstract  void UserAgent.notifyCompletedJob(Task t)
           
 void SimulatedUserAgent.notifyCompletedJob(Task t)
           
 void LiveUserAgent.notifyCompletedJob(Task t)
          Notifies a User that the last Task of a Job has been completed.
abstract  void UserAgent.notifyCompletedTask(Task t)
           
 void SimulatedUserAgent.notifyCompletedTask(Task t)
           
 void LiveUserAgent.notifyCompletedTask(Task t)
          Notifies a User that a Task has been completed.
 void LiveUserAgentListener.taskCompletion(Task t)
          Called upon Task completion.
 

Uses of Task in lbg.user.service
 

Methods in lbg.user.service with parameters of type Task
 void UserHandle.notifyCompletedJob(Task t)
           
 void SimulatedUserService.notifyCompletedJob(Task t)
           
 void SimulatedUserHandle.notifyCompletedJob(Task t)
           
 void LiveUserService.notifyCompletedJob(Task t)
          Notify a user of a completed job
 void LiveUserHandle.notifyCompletedJob(Task t)
          Notify a user of a completed job
 void UserHandle.notifyCompletedTask(Task t)
           
 void SimulatedUserService.notifyCompletedTask(Task t)
           
 void SimulatedUserHandle.notifyCompletedTask(Task t)
           
 void LiveUserService.notifyCompletedTask(Task t)
          Notify a user of a completed task
 void LiveUserHandle.notifyCompletedTask(Task t)
          Notify a user of a completed task
 


Lightweight Bartering Grid

Copyright (c) 2005-2008, Cyril Briquet, parts Xavier Dalem.