Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Lightweight Bartering Grid
PREV NEXT | FRAMES NO FRAMES

## 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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Lightweight Bartering Grid
PREV NEXT | FRAMES NO FRAMES

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