|
Lightweight Bartering Grid | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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 | |||||||||
PREV NEXT | FRAMES NO FRAMES |
Copyright (c) 2005-2008, Cyril Briquet, parts Xavier Dalem.