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

## Uses of Class
lbg.common.exception.GridException

Packages that use GridException
lbg |
lbg.common |
lbg.common.exception |
lbg.common.io |
lbg.common.math |
lbg.common.net |
lbg.common.queueing.deque |
lbg.common.queueing.priority |
lbg.middleware |
lbg.middleware.execution |
lbg.middleware.util |
lbg.peer |
lbg.peer.config |
lbg.peer.core |
lbg.peer.core.negotiator |
lbg.peer.core.qms |
lbg.peer.core.qms.prequeue |
lbg.peer.core.qms.queue |
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.dummy |
lbg.peer.register.learning.db.meta |
lbg.peer.register.learning.supplying |
lbg.peer.register.negotiation |
lbg.peer.service |
lbg.peer.strategy |
lbg.peer.strategy.accounting |
lbg.peer.strategy.negotiation |
lbg.peer.strategy.negotiation.consumption |
lbg.peer.strategy.negotiation.supplying |
lbg.peer.strategy.ranking |
lbg.peer.strategy.scheduling |
lbg.peer.strategy.scheduling.consumption |
lbg.peer.strategy.scheduling.filtering |
lbg.peer.strategy.scheduling.local |
lbg.peer.strategy.scheduling.preemption |
lbg.peer.strategy.scheduling.supplying |
lbg.peer.web |
lbg.peer.workflow |
lbg.protocol.api |
lbg.protocol.data |
lbg.protocol.rpc |
lbg.resource |
lbg.resource.config |
lbg.resource.execution |
lbg.resource.service |
lbg.searchengine |
lbg.searchengine.service |
lbg.simulator |
lbg.simulator.config |
lbg.simulator.event |
lbg.simulator.tools |
lbg.simulator.tools.aggregator |
lbg.simulator.tools.generator |
lbg.simulator.tools.jdf |
lbg.simulator.tools.panorama |
lbg.simulator.tools.spreadsheet |
lbg.task |
lbg.user |
lbg.user.service |

Uses of GridException in lbg

Methods in lbg with parameters of type GridException
`static void` | `LightweightBarteringGrid.handleGridException(GridException e)`

Methods in lbg that throw GridException
`static Scenario` | `LightweightBarteringGrid.getScenario()` Returns current Scenario (legal in SIM mode only).
`static long` | `LightweightBarteringGrid.getTime()` Returns current time: SIM mode - in seconds since the beginning of the simulation LIVE mode - in seconds since the epoch
`static void` | `LightweightBarteringGrid.setMode(VirtualizationLevel mode)` Sets current operating mode (callable only once).
`static void` | `LightweightBarteringGrid.setSimulator(Simulator sim, Scenario sc)` Sets current Simulator and Scenario (legal in SIM mode only).
`static long` | `LightweightBarteringGrid.setTime(long time)` Sets current time to target time (legal in SIM mode only).
`static long` | `LightweightBarteringGrid.shiftTime(long timeshift)` Shifts current time forward by target amount (legal in SIM mode only).

Uses of GridException in lbg.common

Methods in lbg.common that throw GridException
`static void` | `ThreadPool.nap(long millis)`
`static void` | `ThreadPool.sleep(long seconds)`
`void` | `ThreadPool.startService()`

Constructors in lbg.common that throw GridException
`ThreadPool(java.lang.Runnable runnable, int thread_pool_size, boolean set_daemon, boolean hi_priority, java.lang.String thread_name)`

Uses of GridException in lbg.common.exception

Subclasses of GridException in lbg.common.exception
`class` | `GridNetworkException` Denotes a networking error in grid processes. As it's not due to grid inconsistency, retrying the action that led to this exception might be effective.

Uses of GridException in lbg.common.io

Methods in lbg.common.io that throw GridException
`static void` | `CommonFileHandling.closeBR(java.io.BufferedReader br, java.lang.String fn)` Closes target BufferedReader encapsulating target filename.
`static void` | `CommonFileHandling.copyFile(java.lang.String fn1, java.lang.String fn2)` Copies target source file to target destination file.
`static void` | `CommonFileHandling.createDirectory(java.lang.String target_dir)` Creates a new directory.
`static java.lang.String` | `CommonFileHandling.extractBaseFileNameFromFileName(java.lang.String fn, java.lang.String ext)` Extracts base file name (without extension) from target file name without complete path.
`static java.lang.String` | `CommonFileHandling.extractBaseFileNameFromPath(java.lang.String fn, java.lang.String ext)` Extracts base file name (without extension) from target file name with complete path.
`static java.lang.String` | `CommonFileHandling.extractFileNameFromPath(java.lang.String fn)` Extracts file name from target file name with complete path.
`static java.lang.String` | `CommonFileHandling.extractMainClass(java.lang.String jarfn)` Extracts the main class of the target jar file's embedded manifest.
`static java.lang.String` | `CommonStringHandling.fillWithHeadingCharacter(long i, int len, char c)` Generates a String representation of target int, filled with target heading character, if target int is smaller than target power of 10.
`static java.lang.String` | `CommonStringHandling.fillWithHeadingSpaces(long i, int len)` Generates a String representation of target int, filled with heading spaces, if target int is smaller than target power of 10.
`static java.lang.String` | `CommonStringHandling.fillWithHeadingZeros(long i, int len)` Generates a String representation of target int, filled with heading zeros, if target int is smaller than target power of 10.
`static java.lang.String` | `CommonStringHandling.fillWithHeadingZerosLimit(long i, long j)` Generates a String representation of target int, filled with heading zeros if target int if smaller than target limit.
`static org.jfree.chart.JFreeChart` | `CommonChartHandling.generateChart(java.lang.String title, java.lang.String x_label, java.lang.String y_label, double[] values)`
`static java.awt.image.BufferedImage` | `CommonChartHandling.generateChartImage(org.jfree.chart.JFreeChart chart)`
`static org.jfree.data.category.CategoryDataset` | `CommonChartHandling.generateDataset(double[] values)`
`static java.lang.String` | `CommonStringHandling.generateTimeStamp()` Generates a timestamp, i.e.
`static java.lang.String` | `CommonStringHandling.getStackTrace(java.lang.String msg)` Formats as a String the current stack trace using target message.
`static boolean` | `CommonStringHandling.loadBoolean(java.lang.String s)` Loads a boolean from target String.
`static boolean[]` | `CommonStringHandling.loadBooleanArray(java.lang.String s)` Loads a boolean array from target String.
`static double` | `CommonStringHandling.loadDouble(java.lang.String s)` Loads a double from target String.
`static double[]` | `CommonStringHandling.loadDoubleArray(java.lang.String s)` Loads a double array from target String.
`static float` | `CommonStringHandling.loadFloat(java.lang.String s)` Loads a float from target String.
`static float[]` | `CommonStringHandling.loadFloatArray(java.lang.String s)` Loads a float array from target String.
`static int` | `CommonStringHandling.loadInt(java.lang.String s)` Loads an integer from target String.
`static int[]` | `CommonStringHandling.loadIntArray(java.lang.String s)` Loads an integer array from target String.
`static long` | `CommonStringHandling.loadLong(java.lang.String s)` Loads a log from target String.
`static long[]` | `CommonStringHandling.loadLongArray(java.lang.String s)` Loads a long array from target String.
`static java.util.Properties` | `CommonFileHandling.loadProperties(java.lang.String fn)` Loads Properties from target text file.
`static java.lang.String` | `CommonStringHandling.loadProperty(java.lang.String key, java.util.Properties props)` Loads property from target Properties given target key.
`static java.lang.String[]` | `CommonStringHandling.loadStringArray(java.lang.String s)` Loads a String array from target String.
`static java.lang.String[]` | `CommonStringHandling.mergeStringArrays(java.lang.String[] a1, java.lang.String[] a2)` Deprecated. Use `CommonStringHandling.mergeArrays(T[], T[]...)` instead
`static java.io.BufferedReader` | `CommonFileHandling.openBR(java.lang.String fn)` Opens a BufferedReader encapsulating target filename.
`static java.lang.String` | `CommonFileHandling.readFile(java.lang.String fn)` Reads text file contents given target filename.
`static java.lang.String` | `CommonFileHandling.readFile(java.lang.String fn, boolean dont_complain)` Reads text file contents given target filename.
`static java.lang.String` | `CommonFileHandling.readLine(java.io.BufferedReader br, java.lang.String fn)` Reads one text line from target BufferedReader encapsulating target filename.
`static void` | `CommonFileHandling.removeDirectory(java.lang.String target_dir)` Recursively removes a directory and all its contents, including subdirectories.
`static void` | `CommonFileHandling.removeDirectory(java.lang.String target_dir, boolean fail_silently)` Recursively removes a directory and all its contents, including subdirectories.
`static org.jfree.chart.JFreeChart` | `CommonChartHandling.saveAsPDF(org.jfree.chart.JFreeChart chart, java.lang.String fn)` Saves target chart as a .pdf file.
`static org.jfree.chart.JFreeChart` | `CommonChartHandling.saveAsPDF(org.jfree.chart.JFreeChart chart, java.lang.String fn, int w, int h)` Saves target chart as a .pdf file.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, boolean[] values)` Sets target Properties with target (key, group values) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, double[] values)` Sets target Properties with target (key, group values) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, float[] values)` Sets target Properties with target (key, group values) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, int[] values)` Sets target Properties with target (key, group values) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, long[] values)` Sets target Properties with target (key, group values) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, java.lang.String value, int s)` Sets target Properties with target (key, group value) pair.
`static void` | `CommonStringHandling.setGroupProperty(java.util.Properties props, java.lang.String key, java.lang.String value_all_except_one, java.lang.String value_last, int s)` Sets target Properties with target (key, group value) pair.
`static void` | `CommonStringHandling.setProperty(java.util.Properties props, java.lang.String key, java.lang.String value)` Sets target Properties with target (key, value) pair.
`static void` | `CommonFileHandling.writeFile(java.io.File f, java.lang.String data)` Writes target data to target file.
`static boolean` | `CommonFileHandling.writeFile(java.lang.String fn, java.lang.String data)` Writes target data to target file.

Uses of GridException in lbg.common.math

Methods in lbg.common.math that throw GridException
`void` | `SummarizedMeasurement.addObservation(double x_i)`
`void` | `Measurement.addObservation(double x_i)`
`void` | `DescriptiveMeasurement.addObservation(double x_i)`
`void` | `SummarizedMeasurement.addObservation(double x_i, java.lang.String tag)`
`abstract void` | `Measurement.addObservation(double x_i, java.lang.String tag)`
`void` | `DescriptiveMeasurement.addObservation(double x_i, java.lang.String tag)`
`static Measurement` | `MeasurementFactory.createDescriptiveMeasurement(java.lang.String label)` Creates a new DescriptiveMeasurement.
`static Measurement` | `MeasurementFactory.createDescriptiveMeasurement(java.lang.String label, int ws)` Creates a new DescriptiveMeasurement.
`static Measurement` | `Measurement.createMetaMeasurement(java.lang.String list_of_measurements)`
`static Measurement` | `MeasurementFactory.createSummarizedMeasurement(java.lang.String label)` Creates a new SummarizedMeasurement.
`double` | `DescriptiveMeasurement.getMeanOfFirstKTerms(long k)`
`static double` | `CommonMath.normalizeCheckedValue(double base_val, double max_val)` Normalizes target base value with respect to target maximum value.
`static double` | `CommonMath.normalizeValue(double base_val, double max_val)` Normalizes target base value with respect to target maximum value.
`static int` | `CommonMath.sampleRandomFileSize(java.lang.String filename)` Samples a random file size sampled from a random distribution for target filename.
`static int` | `CommonMath.sampleUniformDist()` Samples a uniform distribution.
`static int` | `CommonMath.sampleUniformDist(int lo, int hi)` Samples a uniform distribution.
`static long` | `CommonMath.sampleUniformDist(long lo, long hi)` Samples a uniform distribution.
`static float` | `CommonMath.sampleUniformDistWithinUnity()` Samples a uniform distribution.
`static double` | `CommonMath.stddev(double sum_x, double sum_squared_x, long N)` Deprecated.

Constructors in lbg.common.math that throw GridException
`DescriptiveMeasurement(java.lang.String label)` Creates a new DescriptiveMeasurement.
`DescriptiveMeasurement(java.lang.String label, int ws)` Creates a new DescriptiveMeasurement.
`Measurement(java.lang.String label)`
`MeasurementSaver(Measurement measurement, java.lang.String stats_directory)`
`SummarizedMeasurement(java.lang.String label)` Creates a new SummarizedMeasurement.

Uses of GridException in lbg.common.net

Methods in lbg.common.net that throw GridException
`static java.lang.String` | `CommonNetHandling.getLocalHostName()`
`double` | `BitTorrentLeechersSetDownloadTime.myPredict(double s, int n)` Predicts the average download time of target file by the target leechers set using the BitTorrent protocol.
`double` | `BitTorrentLeechersSetDownloadTime.predict(double s, int n, double alpha, double beta)` Predicts the average download time of target file by the target leechers set using the BitTorrent protocol.

Constructors in lbg.common.net that throw GridException
`BitTorrentLeechersSetDownloadTime()`

Uses of GridException in lbg.common.queueing.deque

Methods in lbg.common.queueing.deque that throw GridException
`T` | `LinkedListDeque.firstElement()` Returns the object to the head of the Deque.
`T` | `Deque.firstElement()`
`void` | `LinkedListDeque.insertFirst(T o)` Inserts target Object at the head of the Deque.
`void` | `Deque.insertFirst(T O)`
`void` | `LinkedListDeque.insertLast(T o)` Inserts target Object at the tail of the Deque.
`void` | `Deque.insertLast(T O)`
`T` | `LinkedListDeque.lastElement()` Returns the object to the tail of the Deque.
`T` | `Deque.lastElement()`
`T` | `LinkedListDeque.removeFirst()` Returns the object to the head of the Deque, and removes that Object.
`T` | `Deque.removeFirst()`
`T` | `LinkedListDeque.removeLast()` Returns the object to the tail of the Deque, and removes that Object.
`T` | `Deque.removeLast()`

Uses of GridException in lbg.common.queueing.priority

Methods in lbg.common.queueing.priority that throw GridException
`boolean` | `PriorityQueue.add(E e)` Adds target element to the end of the PriorityQueue, if not already present.
`DoublyLinkedNode<E>` | `DoublyLinkedList.append(E e)` Appends target element to the tail of the doubly-linked list.
`DoublyLinkedNode<E>` | `DoublyLinkedList.appendAndTrim(E e, int limit)` Appends target element to the tail of the doubly-linked list, removing as many elements as required from the head of the list so that its size does not exceed the target limit, after appending the target element.
`E` | `PriorityQueue.extractHighestPriorityElement()` Removes then returns the element with the higest priority in the PriorityQueue.
`void` | `DoublyLinkedList.removeHead()` Removes the head element from the head of the doubly-linked list.

Uses of GridException in lbg.middleware

Methods in lbg.middleware that throw GridException
`void` | `AutomaticJobSubmitter.jobCompletion(JobDescriptor jd, int job_id)` LiveUserAgentListener implementation.
`static void` | `LaunchUserAgent.main(java.lang.String[] argv)`
`static void` | `LaunchSearchEngine.main(java.lang.String[] argv)`
`static void` | `LaunchResource.main(java.lang.String[] argv)`
`static void` | `LaunchPeer.main(java.lang.String[] argv)`
`void` | `AutomaticJobSubmitter.submitJobs()`

Constructors in lbg.middleware that throw GridException
`AutomaticJobSubmitter(LiveUserAgent ua, JobConfigurator jc, int jobs_to_submit, boolean block_before_resubmission, SubmissionTimesGenerator stg)` Constructs a new automatic Job submitter.

Uses of GridException in lbg.middleware.execution

Methods in lbg.middleware.execution that throw GridException
`void` | `GridClassLoader.load(JobDescriptor jd)` Tries to load all Tasks from the Job description
`GridApplication` | `GridClassLoader.load(Task t)` Loads all classes required to run the Task, and creates the Application.

Uses of GridException in lbg.middleware.util

Methods in lbg.middleware.util that throw GridException
`JobDescriptor` | `JobConfigurator.configureJobDescriptor()`
`static SubmissionUtils.MemoryJar` | `SubmissionUtils.loadJar(java.lang.String path)` Loads the bytecode of a jar in memory.
`JobDescriptor` | `PropertiesJobLoader.loadJobDescription(UserAgent user, java.util.Properties props)` Deprecated. Relying on the current working directory is dangerous and can yield confusing results for the user. The best is usually to specify the directory containing the JDF file using `PropertiesJobLoader.loadJobDescription(UserAgent, Properties, String)`
`JobDescriptor` | `PropertiesJobLoader.loadJobDescription(UserAgent user, java.util.Properties props, java.lang.String basedir)` Loads a JobDescriptor form a set of properties coming from a JDF file.
`static void` | `SubmissionTimesTrace.main(java.lang.String[] args)`
`void` | `SubmissionTimesTrace.skipWaitingBeforeFirstSubmission()`
`void` | `SubmissionTimesGenerator.skipWaitingBeforeFirstSubmission()`
`void` | `SubmissionTimesTrace.waitBeforeNextSubmission()`
`void` | `SubmissionTimesGenerator.waitBeforeNextSubmission()`
`void` | `SubmissionTimesDistribution.waitBeforeNextSubmission()`

Constructors in lbg.middleware.util that throw GridException
`JobConfigurator(int tpj, int dpt, int ddr, int data_size, boolean keep_datas, java.lang.String ftp_host, int ftp_port, java.lang.String data_source_directory, SubmissionUtils.MemoryJar mj, java.lang.String main_class)` Constructs an automatic submitter.
`SubmissionTimesDistribution(int inter_submission_lo, int inter_submission_hi)` Constructs a new submission times distribution-based generator.
`SubmissionTimesTrace(java.lang.String trace_fn, int expected_jobs)` Constructs a new submission times trace-based generator.

Uses of GridException in lbg.peer

Methods in lbg.peer that throw GridException
`void` | `Peer.processSelfEvents()`
`void` | `LivePeer.startService()`

Constructors in lbg.peer that throw GridException
`LivePeer(PeerBasicConfiguration peer_basic_config, PeerNetworkConfiguration peer_network_config, PeerDataConfiguration peer_data_config, PeerStrategyConfiguration peer_strategy_config, PeerServiceFactory peer_service_factory, ControllerFactory ctrlr_factory, SearchEngineHandle se_handle)` Creates a new Peer (LIVE mode).
`SimulatedPeer(PeerBasicConfiguration peer_basic_config, PeerNetworkConfiguration peer_network_config, PeerDataConfiguration peer_data_config, PeerStrategyConfiguration peer_strategy_config, PeerServiceFactory peer_service_factory, ControllerFactory ctrlr_factory, SearchEngineHandle se_handle, EnvironmentController env_ctrlr, int sim_idx)` Creates a new Peer (SIM mode).

Uses of GridException in lbg.peer.config

Methods in lbg.peer.config that throw GridException
`static int[]` | `PeerDataConfiguration.buildRcvPolicy(java.lang.String policy)` Deprecated. You shoudln't need to build any of these, the receiving policy is now enforced by the GridDataManager.
`static java.lang.String[]` | `PeerStrategyConfiguration.getPDPLabels(java.lang.String pdp)`

Constructors in lbg.peer.config that throw GridException
`PeerBasicConfiguration(java.util.Properties props)`
`PeerBasicConfiguration(java.lang.String peer_id, int timeout)`
`PeerDataConfiguration(GridConfiguration grid_config, int g)`
`PeerDataConfiguration(java.util.Properties props)`
`PeerNetworkConfiguration()`
`PeerNetworkConfiguration(java.util.Properties props)`
`PeerStrategyConfiguration(GridStrategyConfiguration grid_strategy_config, int g)`
`PeerStrategyConfiguration(java.util.Properties props)`
`RandomizerConfiguration(java.util.Properties props)`

Uses of GridException in lbg.peer.core

Methods in lbg.peer.core that throw GridException
`NegotiatorController` | `ControllerFactory.createNegotiatorController(Peer peer, Negotiator negotiator)`
`SchedulerController` | `ControllerFactory.createSchedulerController(Peer peer, Scheduler scheduler)`

Constructors in lbg.peer.core that throw GridException
`ControllerFactory()` Creates a ControllerFactory (legal in LIVE mode only).
`ControllerFactory(EnvironmentController env_ctrlr, java.lang.String PEER_BASE_NAME)` Creates a ControllerFactory (legal in SIM mode only).
`SelfEventProcessorThread(Peer managed_peer)`

Uses of GridException in lbg.peer.core.negotiator

Methods in lbg.peer.core.negotiator that throw GridException
`void` | `NegotiatorController.activateSupplyingRequestsEvaluation()`
`void` | `NegotiatorController.activateSupplyingRequestsGeneration()`
`void` | `SimulatedNegotiatorController.awakeNegotiator()`
`abstract void` | `NegotiatorController.awakeNegotiator()`
`void` | `LiveNegotiatorController.awakeNegotiator()`
`void` | `Negotiator.negotiate(NegotiatorControlFlags ctrl_flags)`
`void` | `LiveNegotiatorController.startService()`

Constructors in lbg.peer.core.negotiator that throw GridException
`LiveNegotiatorController(Peer managed_peer, Negotiator negotiator)`
`Negotiator(Peer managed_peer, java.lang.String target_negotiation_supplying_policy, java.lang.String target_negotiation_consumption_policy)`
`NegotiatorController(Peer managed_peer)`
`SimulatedNegotiatorController(Peer managed_peer, EnvironmentController env_ctrlr, java.lang.String PEER_BASE_NAME)`

Uses of GridException in lbg.peer.core.qms

Methods in lbg.peer.core.qms that throw GridException
`void` | `QueueManager.dequeueAllWaitingSupplyingTasks(boolean notify_consumers)` Dequeues all waiting Supplying Tasks.
`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.dequeueLocalJob(int job_id)` Dequeues a Local Job.
`void` | `QueueManager.dequeueMostRecentWaitingSupplyingTasks(boolean notify_consumers, int k)` Dequeues the k most recently queued waiting Supplying Tasks.
`void` | `QueueManager.dequeueOldestWaitingSupplyingTaskOfConsumer(boolean notify_consumer, java.lang.String consumer_id)` Dequeues the oldest waiting Supplying Task of target consumer.
`void` | `QueueManager.dequeueWaitingLocalTask(Task t)` Dequeues a waiting Local Task.
`void` | `QueueManager.dequeueWaitingSupplyingTask(boolean notify_consumer, Task t)` Dequeues target waiting Supplying Task.
`void` | `QueueManager.dequeueWorstRankedWaitingSupplyingTasks(boolean notify_consumers, int k)` Dequeues the k worst NoF-ranked queued waiting Supplying Tasks.
`JobConsumptionDataTracker` | `RequestContainer.getJobConsumptionDataTracker()`
`JobConsumptionOutcomeTracker` | `RequestContainer.getJobConsumptionOutcomeTracker()`
`double` | `QueueManager.getMeanJobCompletionTimeOfFirstKJobs(int k)`
`double` | `QueueManager.getMeanJobCompletionTimeOfNm5FirstKJobs()`
`TaskSchedulingContext` | `RequestContainer.getSchedulingContext()`
`boolean` | `QueueManager.isSupplyingTaskRunning(Task t)`
`void` | `QueueManager.preemptWaitingSupplyingTasks()`
`int` | `QueueManager.queryLocalJobStatus(int job_id)` Returns the number of completed Tasks of target Local Job.
`void` | `QueueManager.queueLocalJob(Job job)` Queues a Local Job.
`void` | `QueueManager.queueSupplyingJob(Job job, java.lang.String consumer_id)` Queues a Supplying Job.
`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.
`RequestContainer` | `QueueManager.scheduleBestRankedSupplyingTask()` Selects for Local execution the best Favors-ranked, queued, yet unscheduled Supplying Task
`RequestContainer` | `QueueManager.scheduleFirstConsumptionTask(boolean head_job_only)` Selects for Consumption execution the first queued, yet unscheduled Local Task.
`RequestContainer` | `QueueManager.scheduleFirstLocalTask(boolean head_job_only)` Selects for Local execution the first queued, yet unscheduled Local Task.
`RequestContainer` | `QueueManager.scheduleFirstSupplyingTask()` Selects for Local execution the first queued, yet unscheduled Supplying Task
`RequestContainer` | `QueueManager.scheduleNextConsumptionTask(LocalQueueCursor lqc)` Selects for Consumption execution the next queued, yet unscheduled Local Task
`void` | `RequestContainer.setJobConsumptionDataTracker(JobConsumptionDataTracker job_data_tracker)`
`void` | `RequestContainer.setJobConsumptionOutcomeTracker(JobConsumptionOutcomeTracker job_consumption_outcome_tracker)`
`void` | `RequestContainer.setSchedulingContext(TaskSchedulingContext tsc)`

Constructors in lbg.peer.core.qms that throw GridException
`QueueManager(Peer managed_peer, Scheduler scheduler, boolean enable_ttg)`
`RequestContainer(Task t, java.lang.Integer task_scheduling_id)`

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

Methods in lbg.peer.core.qms.prequeue that throw GridException
`protected void` | `JobPreQueue.actuallyTransferJob(JobPreQueue.RequestHolder req)`
`static JobPreQueue` | `JobPreQueueFactory.createJobPreQueue(Peer managed_peer, Scheduler scheduler, boolean enable_ttg)`
`int` | `SimulatedJobPreQueue.size()`
`abstract int` | `JobPreQueue.size()`
`void` | `LiveJobPreQueue.startService()`
`protected void` | `SimulatedJobPreQueue.transferJob(JobPreQueue.RequestHolder req)`
`protected void` | `LiveJobPreQueue.transferJob(JobPreQueue.RequestHolder req)`
`protected abstract void` | `JobPreQueue.transferJob(JobPreQueue.RequestHolder req)`
`int` | `JobPreQueue.transferLocalJobToQMS(UserHandle uh, JobDescriptor jd)`
`ConsumptionTaskID` | `JobPreQueue.transferSupplyingTaskToQMS(Task t)`

Constructors in lbg.peer.core.qms.prequeue that throw GridException
`ConsumptionTaskID(int job_id, int bot_id)` Constructs a legal new Consumption Task id.
`LiveJobPreQueue(Peer managed_peer, Scheduler scheduler, boolean enable_ttg)`
`SimulatedJobPreQueue(Peer managed_peer, Scheduler scheduler, boolean enable_ttg)`

Uses of GridException in lbg.peer.core.qms.queue

Methods in lbg.peer.core.qms.queue that throw GridException
`boolean` | `LocalQueueHistory.addJob(long submission_t, long completion_t)`
`boolean` | `LocalQueueHistory.addJobs(java.lang.String jobs_list)`
`void` | `LocalQueueCursor.update(RequestContainer rc)`

Constructors in lbg.peer.core.qms.queue that throw GridException
`LocalQueueHistory(java.lang.String peer_id, boolean store_data)` Constructs a new LocalQueueHistory.

Uses of GridException in lbg.peer.core.rms

Methods in lbg.peer.core.rms that throw GridException
`boolean` | `WorkingSet.addLocalData(MetaGridData data)` Note: the Resource-level DataTracker is updated by this operation
`boolean` | `WorkingSet.addLocalData(MetaGridData[] ds)` Note: the Resource-level DataTracker is updated by this operation
`void` | `ResourceManager.addResource(ResourceHandle rh, int power)`
`boolean` | `WorkingSet.addSupplyingData(MetaGridData data)` Note: the Resource-level DataTracker is updated by this operation
`boolean` | `WorkingSet.addSupplyingData(MetaGridData[] ds)` Note: the Resource-level DataTracker is updated by this operation
`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.
`void` | `WorkingSet.clearAllUnlockedData()` Note: the Resource-level DataTracker is updated by this operation
`void` | `WorkingSet.clearLocalUnlockedData()` Note: the Resource-level DataTracker is updated by this operation
`void` | `WorkingSet.clearSupplyingUnlockedData()` Note: the Resource-level DataTracker is updated by this operation
`boolean` | `WorkingSet.containsData(MetaGridData data)`
`boolean` | `WorkingSet.containsLocalData(MetaGridData data)`
`boolean` | `WorkingSet.containsSupplyingData(MetaGridData 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.
`GridData[][]` | `WorkingSet.getData()` Returns the GridData stored in the WorkingSet, so as to communicate them to the managed Resource.
`java.lang.String[]` | `WorkingSet.getDataId()`
`GridData[][]` | `WorkingSet.getLocalData()`
`java.lang.String[]` | `WorkingSet.getLocalDataId()`
`MetaGridData[]` | `WorkingSet.getLocalGridMetaData()`
`MetaGridData[]` | `WorkingSet.getMetaGridData()`
`ResourceHandle` | `ResourceTracker.getRandomBusyLocalResource()` Returns a random busy local Resource.
`ResourceHandle` | `ResourceTracker.getRandomBusySupplyingResource()` Returns a random busy supplying Resource.
`ResourceHandle` | `ResourceTracker.getRandomIdleResource()` Returns a random idle Resource.
`ResourceState` | `ResourceTracker.getResourceState(ResourceHandle rh)`
`ResourceUsageData` | `ResourceTracker.getResourceUsageData(ResourceHandle rh)`
`Task` | `ResourceManager.getRunningTask(ResourceHandle rh)` Returns the Task running on target Busy Resource.
`GridData[][]` | `WorkingSet.getSupplyingData()`
`java.lang.String[]` | `WorkingSet.getSupplyingDataId()`
`MetaGridData[]` | `WorkingSet.getSupplyingMetaGridData()`
`WorkingSet` | `ResourceTracker.getWorkingSetOfIdleResource(ResourceHandle rh)` Returns the WorkingSet of the target Resource, if target Resource is idle.
`WorkingSet` | `ResourceManager.getWorkingSetOfIdleResource(ResourceHandle rh)` Returns the WorkingSet of the target Resource, if target Resource is idle.
`boolean` | `ResourceManager.hasBusyLocalResource()`
`boolean` | `ResourceManager.hasBusySupplyingResource()`
`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.
`java.lang.String` | `ResourceDataTracker.locateLessLocallyReplicatedData(java.lang.String[] data_ids)` Locate data in target data set that is the less replicated on this Peer Resources.
`java.lang.String` | `ResourceDataTracker.locateMostLocallyReplicatedData(java.lang.String[] data_ids)` Locate data in target data set that is the most replicated on this Peer Resources.
`ResourceHandle` | `ResourceManager.locateResource(ResourceState state, Task t)` Locates a Resource currentlty in target state with maximum Storage Affinity with target Task.
`java.util.Set<ResourceHandle>` | `ResourceDataTracker.locateResourcesWithReplicatedData(java.lang.String data_id)` Locate Resources which have target data in their WorkingSet.
`java.util.Set<ResourceHandle>` | `ResourceDataTracker.locateResourcesWithReplicatedData(java.lang.String[] data_ids)` Locate Resources which have all target datas in their WorkingSet.
`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.
`void` | `ResourceManager.removeResource(ResourceHandle rh)` Removes a Resource from the Peer.
`void` | `ResourceManager.replicateSupplyingData()` Replicates Supplying data to Resources.
`boolean` | `ResourceManager.runLocalTask(ResourceHandle rh, Task t)` Runs target Task on target Resource.
`Task` | `ResourceUsageData.runningTask()`
`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)`
`boolean` | `ResourceDataTracker.trackData(java.lang.String data_id, ResourceHandle rh)`
`void` | `ResourceTracker.trackResource(ResourceHandle rh)` Starts the tracking of the target Resource.
`void` | `WorkingSet.unlockLocalInputData(Task t)`
`void` | `WorkingSet.unlockSupplyingInputData(Task t)`
`void` | `ResourceDataTracker.untrackAllData(java.lang.String[] data_ids, ResourceHandle rh)` Untrack all data for target Resource.
`void` | `ResourceLocator.untrackBusyLocalResource(Task t)`
`void` | `ResourceLocator.untrackBusySupplyingResource(Task t)`
`void` | `ResourceDataTracker.untrackData(java.lang.String[] data_ids, ResourceHandle rh)`
`void` | `ResourceDataTracker.untrackData(java.lang.String data_id, ResourceHandle rh)`
`ResourceUsageData` | `ResourceTracker.untrackResource(ResourceHandle rh)` Stops the tracking of the target Resource.
`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.
`WorkingSet` | `ResourceTracker.updateResourceStatusToIdle(ResourceHandle rh, ResourceState state)` Updates target Resource status from busy local or busy supplying, depending on the value of target state, to idle.
`void` | `ResourceUsageData.updateTotalBusyLocalTime()` Updates total busy Local time of the monitored Resource.
`void` | `ResourceUsageData.updateTotalBusySupplyingTime()` Updates total busy Supplying time of the monitored Resource.
`void` | `ResourceUsageData.updateTotalIdleTime(ResourceState state, Task t)` Updates total idle time of the monitored Resource.
`void` | `ResourceManager.updateUtilizationValue()`
`double` | `ResourceTracker.utilization()` Returns the Peer utilization, i.e.
`double` | `ResourceManager.utilization()` Returns the Peer utilization, i.e.

Constructors in lbg.peer.core.rms that throw GridException
`ResourceDataTracker.TransferCostData(ResourceHandle rh, long distance)` Constructs a new TransferCostData.
`ResourceDataTracker(Peer managed_peer)` Constructs a new ResourceDataTracker.
`ResourceLocator.ResourceLocatorKey(Task t, boolean is_local_task)`
`ResourceLocator(Peer managed_peer)`
`ResourceManager(Peer managed_peer, boolean data_present_enabled, boolean data_replication_enabled, float idle_replication_ratio, boolean psufferage_enabled)`
`ResourceTracker(Peer managed_peer, ResourceDataTracker data_tracker)`
`ResourceUsageData(Peer managed_peer, ResourceHandle rh, ResourceDataTracker data_tracker)`
`WorkingSet(Peer managed_peer, ResourceHandle rh, ResourceDataTracker data_tracker)` Constructs a new WorkingSet.

Uses of GridException in lbg.peer.core.scheduler

Methods in lbg.peer.core.scheduler that throw GridException
`void` | `Scheduler.accountSchedulerConsumptionDecision(long scheduled_tasks, double blacklisted_supplier_ratio)`
`void` | `SchedulerController.activateAllScheduling()`
`void` | `SchedulerController.activateConsumptionScheduling()`
`void` | `SchedulerController.activateLocalAndConsumptionScheduling()`
`void` | `SchedulerController.activateLocalAndSupplyingScheduling()`
`void` | `SchedulerController.activateLocalScheduling()`
`void` | `SchedulerController.activateSupplyingScheduling()`
`void` | `SimulatedSchedulerController.awakeScheduler()`
`abstract void` | `SchedulerController.awakeScheduler()`
`void` | `LiveSchedulerController.awakeScheduler()`
`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.
`void` | `Scheduler.preemptWaitingSupplyingTasks()` Preempts some waiting Supplying Tasks.
`void` | `Scheduler.schedule(SchedulerControlFlags ctrl_flags)` Activates scheduling of Local, Supplying and Consumption Tasks following target scheduling control flags.
`void` | `LiveSchedulerController.startService()`

Constructors in lbg.peer.core.scheduler that throw GridException
`LiveSchedulerController(Peer managed_peer, Scheduler scheduler)`
`Scheduler(Peer managed_peer, Negotiator negotiator, java.lang.String target_scheduling_local_policy, java.lang.String target_scheduling_running_preemption_policy, java.lang.String target_scheduling_waiting_preemption_policy, java.lang.String target_supplying_filtering_policy, java.lang.String target_scheduling_supplying_policy, java.lang.String target_scheduling_consumption_policy)` Creates a new Scheduler.
`SchedulerController(Peer managed_peer)`
`SimulatedSchedulerController(Peer managed_peer, EnvironmentController env_ctrlr, java.lang.String PEER_BASE_NAME)`

Uses of GridException in lbg.peer.core.xms

Methods in lbg.peer.core.xms that throw GridException
`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.
`boolean` | `RunningTaskManager.areSomeTasksRunning()`
`boolean` | `RunningTaskManager.areSomeTasksTimedOut()`
`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)`
`int` | `ExecutionManager.countRunningConsumptionTasks()`
`int` | `ExecutionManager.countRunningLocalTasks()`
`int` | `ExecutionManager.countRunningSupplyingTasks()`
`int` | `RunningTaskManager.countRunningTasks()`
`abstract TaskRuntimeData` | `TaskRuntimeDataFactory.createTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)`
`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).
`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.
`boolean` | `ExecutionManager.processTimedOutConsumptionTasks()` Cancels timed-out Consumption Tasks.
`boolean` | `ExecutionManager.processTimedOutLocalTasks()` Cancels timed-out Local Tasks.
`boolean` | `ExecutionManager.processTimedOutSupplyingTasks()` Cancels timed-out Supplying Tasks.
`abstract boolean` | `RunningTaskManager.processTimedOutTasks()` Processes timed-out Tasks.
`boolean` | `RunningSupplyingTaskManager.processTimedOutTasks()` Processes timed-out Tasks.
`boolean` | `RunningLocalTaskManager.processTimedOutTasks()` Processes timed-out Tasks.
`boolean` | `RunningConsumptionTaskManager.processTimedOutTasks()` Processes timed-out Tasks.
`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.
`abstract void` | `TaskRuntimeData.setTimeOut(long time_out)`
`void` | `SupplyingTaskRuntimeData.setTimeOut(long time_out)`
`void` | `LocalTaskRuntimeData.setTimeOut(long time_out)`
`void` | `ConsumptionTaskRuntimeData.setTimeOut(long time_out)`
`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 that throw GridException
`ConsumptionTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)`
`ExecutionManager(Peer managed_peer, long consumption_timeout)`
`LocalTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)`
`RunningConsumptionTaskManager(Peer managed_peer, TaskComparator task_cmp, java.lang.String task_runtime_data_type)`
`RunningLocalTaskManager(Peer managed_peer, TaskComparator task_cmp, java.lang.String task_runtime_data_type)`
`RunningSupplyingTaskManager(Peer managed_peer, TaskComparator task_cmp, java.lang.String task_runtime_data_type)`
`SupplyingTaskRuntimeData(Task t, long time_out, ExternalPeerHandle peer_handle, java.lang.String supplier_id, boolean do_cancel)`

Uses of GridException in lbg.peer.register

Methods in lbg.peer.register that throw GridException
`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` | `NeighborhoodNegotiationProfile.accountSentConsumptionGrants(java.lang.String peer_id, int tasks_count)`
`void` | `NeighborhoodNegotiationProfile.accountSentSupplyingRequests(java.lang.String peer_id, int tasks_count)`
`void` | `NeighborhoodBarteringProfile.accountSupplyingCancellation(Task t, long start_time)`
`void` | `NeighborhoodBarteringProfile.accountSupplyingCompletion(Task t, long xstart_time)`
`void` | `NeighborhoodNegotiationProfile.accountUsedConsumptionGrant(java.lang.String peer_id)`
`void` | `NeighborhoodNegotiationProfile.addReceivedConsumptionGrant(java.lang.String peer_id, int tasks_count)`
`void` | `NeighborhoodNegotiationProfile.addReceivedSupplyingRequest(java.lang.String peer_id, int tasks_count)`
`boolean` | `PeerRegister.checkProfile(java.lang.String peer_id)` Checks the Profile of the target Peer, and creates one if required.
`boolean` | `NeighborhoodNegotiationProfile.couldEvaluateConsumptionGrants()` Returns whether Consumption Grants can be evaluated, which is allowed when either the number of registered Consumption Grantors has reached the specified threshold, or when the time since a Consumption Grantor has been resgistered has reached the specified threshold, or both.
`boolean` | `NeighborhoodNegotiationProfile.couldEvaluateSupplyingRequests()` Returns whether Supplying Requests can be evaluated, which is allowed when either the number of registered Supplying Requestors has reached the specified threshold, or when the time since a Supplying Requestor has been resgistered has reached the specified threshold, or both.
`boolean` | `NeighborhoodNegotiationProfile.couldGenerateSupplyingRequests()` Returns whether Supplying can be Requested, which is allowed when the time since some Supplying has been Requested to other Peers has reached the specified threshold.
`int` | `NeighborhoodNegotiationProfile.countReceivedConsumptionGrants()`
`int` | `NeighborhoodNegotiationProfile.countReceivedSupplyingRequests()`
`TaskSchedulingContext` | `TestPeerProfile.createConsumptionTaskSchedulingContext(Task t)`
`TaskSchedulingContext` | `PeerProfile.createConsumptionTaskSchedulingContext(Task t)`
`void` | `PeerRegister.createProfile(ExternalPeerHandle peer_handle)` Creates a Profile in the PeerRegister for the target Peer.
`TaskSchedulingContext` | `TestPeerProfile.createSupplyingTaskSchedulingContext(Task t)`
`TaskSchedulingContext` | `PeerProfile.createSupplyingTaskSchedulingContext(Task t)`
`int` | `PeerProfile.decreaseRunningJobsCount()`
`int` | `TestPeerProfile.decreaseWaitingJobsCount()`
`int` | `PeerProfile.decreaseWaitingJobsCount()`
`ExternalPeerHandle` | `PeerRegister.getHandle(java.lang.String peer_id)` Returns the Handle of stored Peer.
`PeerInteractionsDataBase` | `TestPeerProfile.getInteractionsDataBase()`
`PeerInteractionsDataBase` | `PeerProfile.getInteractionsDataBase()`
`PeerProfile` | `PeerRegister.getProfile(java.lang.String peer_id)` Returns the Profile of the target Peer.
`ConsumptionGrantsContainer` | `NeighborhoodNegotiationProfile.getReceivedConsumptionGrants()` Returns received Consumption grants.
`SupplyingRequestsContainer` | `NeighborhoodNegotiationProfile.getReceivedSupplyingRequests()` Returns received Supplying Requests.
`int` | `PeerProfile.getRunningJobsCount()`
`int` | `TestPeerProfile.getWaitingJobsCount()`
`int` | `PeerProfile.getWaitingJobsCount()`
`int` | `PeerProfile.increaseRunningJobsCount()`
`int` | `TestPeerProfile.increaseWaitingJobsCount()`
`int` | `PeerProfile.increaseWaitingJobsCount()`
`void` | `PeerRegister.removeProfile(java.lang.String peer_id)` Removes a Profile from the PeerRegister for the target Peer.

Constructors in lbg.peer.register that throw GridException
`NeighborhoodBarteringProfile(Peer managed_peer, PeerRegister grid_register)`
`NeighborhoodNegotiationProfile(Peer managed_peer, PeerRegister grid_register, PeerStrategyConfiguration peer_strategy_config)`
`PeerProfile(Peer managed_peer, ExternalPeerHandle profiled_peer, BarteringAccountantPolicy accountant)`
`PeerRegister(Peer managed_peer, StrategyDescriptor strategy, PeerStrategyConfiguration peer_strategy_config)`
`TestPeerProfile(java.lang.String profiled_peer_id, java.lang.String managed_peer_id)`

Uses of GridException in lbg.peer.register.bartering

Methods in lbg.peer.register.bartering that throw GridException
`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)`
`BarteringAccountantPolicy` | `TestPeerBarteringProfile.getAccountant()`
`BarteringAccountantPolicy` | `PeerBarteringProfile.getAccountant()`
`void` | `TestPeerBarteringProfile.setAccountant(BarteringAccountantPolicy accountant)`
`void` | `PeerBarteringProfile.setAccountant(BarteringAccountantPolicy accountant)`
`void` | `IntervalStore.storeTimestamp(long t)`

Constructors in lbg.peer.register.bartering that throw GridException
`IntervalStore(int ivn, int ilen)`
`PeerBarteringProfile(Peer managed_peer, ExternalPeerHandle profiled_peer, BarteringAccountantPolicy accountant)`
`TestPeerBarteringProfile(java.lang.String profiled_peer_id, java.lang.String managed_peer_id)`

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

Methods in lbg.peer.register.learning.consumption that throw GridException
`java.util.ArrayList<java.lang.String>` | `JobConsumptionOutcomeTracker.rankPeers()` Return reliability ranking of Supplier Peers (i.e.
`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)`
`boolean` | `JobConsumptionOutcomeTracker.shouldBlackListPeer(java.lang.String supplier_id)` Indicates whether the target supplier should be blacklisted, i.e.
`boolean` | `JobConsumptionOutcomeTracker.shouldBlackListPeer(SupplierReliabilityHistory b)` Indicates whether a supplier with target reliability behavior should be blacklisted, i.e.
`boolean` | `JobConsumptionOutcomeTracker.shouldRestrictJobToLocalExecution()` Indicates whether the Tasks of the tracked Job can be executed as Consumption Tasks, or if it is preferable not to, because it comes that these are extremely difficult to execute by Supplier Peers (either intrinsically, or because the environment is totally unreliable).
`void` | `JobConsumptionOutcomeTracker.trackCancelledTask(java.lang.String supplier_peer, long runtime)`
`void` | `JobConsumptionOutcomeTracker.trackCompletedTask(java.lang.String supplier_peer, long runtime)`
`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)`
`java.util.Iterator<java.lang.String>` | `PeerConsumptionDataTracker.trackedSuppliers(java.lang.String data_id)` Returns an Iterator of the suppliers that presumably store target tracked data, i.e.
`java.util.Iterator<java.lang.String>` | `ConsumptionDataTracker.trackedSuppliers(java.lang.String data_id)`

Constructors in lbg.peer.register.learning.consumption that throw GridException
`JobConsumptionDataTracker(java.lang.String owner_peer_id, int job_id)`
`JobConsumptionOutcomeTracker(java.lang.String owner_peer_id, int job_id, int total_job_tasks)`
`PeerConsumptionDataTracker(int capacity)`
`SupplierReliabilityHistory(SupplierReliabilityHistory b)` Constructs a new SupplierReliabilityHistory, using target Supplier Reliability behavior to set initial Task completion/cancellation counts, i.e.

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

Methods in lbg.peer.register.learning.db that throw GridException
`void` | `PeerInteractionsDataBase.addConsumptionInteraction(TaskSchedulingContext tsc, boolean is_task_completed, boolean is_predict_correct)`
`void` | `PeerInteractionsDataBase.addSupplyingInteraction(TaskSchedulingContext tsc)`
`TaskSchedulingContext` | `TaskSchedulingContextFactory.createConsumptionTaskSchedulingContext(Task t)`
`PeerInteractionsDataBase` | `PeerInteractionsDataBaseFactory.createPeerInteractionsDataBase(Peer managed_peer, ExternalPeerHandle profiled_peer)` Creates a new PeerInteractionsDataBase.
`TaskSchedulingContext` | `TaskSchedulingContextFactory.createSupplyingTaskSchedulingContext(Task t)`
`TaskSchedulingContextFactory` | `PeerInteractionsDataBase.createTaskSchedulingContextFactory(PeerProfile profiled_peer_profile)` Does not create a new TaskSchedulingContextFactory.
`void` | `TaskSchedulingContext.setOutcome(Task t, long xstart_time, RequestType rt)`

Uses of GridException in lbg.peer.register.learning.db.dummy

Methods in lbg.peer.register.learning.db.dummy that throw GridException
`void` | `DummyPeerInteractionsDataBase.addConsumptionInteraction(TaskSchedulingContext tsc, boolean is_task_completed, boolean is_predict_correct)`
`void` | `DummyPeerInteractionsDataBase.addSupplyingInteraction(TaskSchedulingContext tsc)`
`TaskSchedulingContextFactory` | `DummyPeerInteractionsDataBase.createTaskSchedulingContextFactory(PeerProfile profiled_peer_profile)` Does not create a new TaskSchedulingContextFactory.

Constructors in lbg.peer.register.learning.db.dummy that throw GridException
`DummyPeerInteractionsDataBase()`

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

Methods in lbg.peer.register.learning.db.meta that throw GridException
`abstract double` | `InteractionAttributes.val(Task t, PeerBarteringProfile peer_bp)` Returns the value of interaction attribute for target Task and Peer.

Uses of GridException in lbg.peer.register.learning.supplying

Methods in lbg.peer.register.learning.supplying that throw GridException
`void` | `PeerSupplyingDataTracker.add(MetaGridData[] ds)` Add data (from a presumably Supplying Task) to be stored and analyzed.
`void` | `PeerSupplyingDataTracker.replicateData(java.util.Iterator<ResourceUsageData> it, int res_count)` Replicates data to target Resources, using prediction based on analysed trends.

Constructors in lbg.peer.register.learning.supplying that throw GridException
`PeerSupplyingDataTracker(Peer managed_peer, int capacity)` Constructs a new PeerSupplyingDataTracker.

Uses of GridException in lbg.peer.register.negotiation

Methods in lbg.peer.register.negotiation that throw GridException
`void` | `PeerNegotiationProfile.accountSentConsumptionGrants(int tasks)`
`void` | `PeerNegotiationProfile.accountSentSupplyingRequests(int tasks)`
`void` | `PeerNegotiationProfile.accountUsedConsumptionGrants(int tasks)`
`int` | `PeerNegotiationProfile.getAndResetReceivedConsumptionGrants()`
`int` | `PeerNegotiationProfile.getAndResetReceivedSupplyingRequests()`
`int` | `SupplyingRequestsContainer.grantedSupplyingRequests(int i)`
`ExternalPeerHandle` | `ConsumptionGrantsContainer.grantor(int i)`
`PeerProfile` | `ConsumptionGrantsContainer.grantorProfile(int i)`
`void` | `SupplyingRequestsContainer.grantSupplyingRequests(int i, int count)` If target requestor has no more remaining Supplying Requests, it is removed from the index of remaining requestors.
`int` | `ConsumptionGrantsContainer.initialConsumptionGrants(int i)`
`int` | `ConsumptionGrantsContainer.pendingConsumptionGrants(int i)`
`java.lang.Integer` | `ConsumptionGrantsContainer.pendingGrantorIndex(PeerProfile peer_profile)` Returns the index of target pending grantor.
`java.lang.Integer` | `ConsumptionGrantsContainer.pendingGrantorIndex(java.lang.String peer_id)` Returns the index of target pending grantor.
`int` | `SupplyingRequestsContainer.pendingSupplyingRequests(int i)`
`int` | `ConsumptionGrantsContainer.randomPendingGrantorIndex()`
`ExternalPeerHandle` | `SupplyingRequestsContainer.requestor(int i)`
`void` | `PeerNegotiationProfile.setConsumptionGrantsCount(int tasks)` Increases Consumption Grants count by specified amount.
`void` | `PeerNegotiationProfile.setReceivedSupplyingRequests(int tasks)` Increases Supplying Requests count by specified amount.
`void` | `ConsumptionGrantsContainer.spillAllConsumptionGrants(int i)` Spills, i.e.
`void` | `ConsumptionGrantsContainer.spillConsumptionGrants(int i, int count)` Spills, i.e.
`void` | `ConsumptionGrantsContainer.useAllConsumptionGrants(int i)` Uses all Consumption Grants from target grantor.
`void` | `ConsumptionGrantsContainer.useConsumptionGrants(int i, int count)` Uses some Consumption Grants from target grantor.
`int` | `ConsumptionGrantsContainer.usedConsumptionGrants(int i)`

Constructors in lbg.peer.register.negotiation that throw GridException
`ConsumptionGrantsContainer(java.util.Collection<PeerProfile> cgs, int s)`
`PeerNegotiationProfile(Peer managed_peer, ExternalPeerHandle profiled_peer)`
`SupplyingRequestsContainer(java.util.Collection<PeerProfile> srs, int s)`

Uses of GridException in lbg.peer.service

Methods in lbg.peer.service that throw GridException
`void` | `TestPeerHandle.addResource(ResourceHandle rh, int power)`
`void` | `SimulatedPeerService.addResource(ResourceHandle rh, int power)`
`void` | `SimulatedPeerHandle.addResource(ResourceHandle rh, int power)`
`void` | `LivePeerService.addResource(ResourceHandle rh, int power)`
`void` | `LivePeerHandle.addResource(ResourceHandle rh, int power)` Register a resource as part of this Peer
`void` | `AbstractInternalPeerHandle.addResource(ResourceHandle rh, int power)`
`void` | `TestPeerHandle.cancelJob(int job_id)`
`void` | `SimulatedPeerService.cancelJob(int job_id)`
`void` | `SimulatedPeerHandle.cancelJob(int job_id)`
`void` | `LivePeerService.cancelJob(int job_id)`
`void` | `LivePeerHandle.cancelJob(int job_id)` Cancels a Job from the Peer
`void` | `AbstractUserPeerHandle.cancelJob(int job_id)`
`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)`
`PeerHandle` | `SimulatedPeerService.createHandle()`
`PeerHandle` | `PeerService.createHandle()`
`PeerHandle` | `LivePeerService.createHandle()` Creates a LivePeerHandle
`PeerService` | `PeerServiceFactory.createPeerService(Peer owner_peer)`
`void` | `TestPeerHandle.grantConsumption(java.lang.String supplier_id, int granted_count)`
`void` | `SimulatedPeerService.grantConsumption(java.lang.String supplier_id, int granted_count)`
`void` | `SimulatedPeerHandle.grantConsumption(java.lang.String supplier_id, int granted_count)`
`void` | `LivePeerService.grantConsumption(java.lang.String supplier_id, int granted_count)`
`void` | `LivePeerHandle.grantConsumption(java.lang.String supplier_id, int granted_count)` Grant a consumption for a number of tasks
`void` | `AbstractExternalPeerHandle.grantConsumption(java.lang.String supplier_id, int granted_count)`
`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)`
`int` | `TestPeerHandle.queryJobStatus(int job_id)`
`int` | `SimulatedPeerService.queryJobStatus(int job_id)`
`int` | `SimulatedPeerHandle.queryJobStatus(int job_id)`
`int` | `LivePeerService.queryJobStatus(int job_id)`
`int` | `LivePeerHandle.queryJobStatus(int job_id)` Queries Job status from the Peer
`int` | `AbstractUserPeerHandle.queryJobStatus(int job_id)`
`void` | `TestPeerHandle.removeResource(ResourceHandle rh)`
`void` | `SimulatedPeerService.removeResource(ResourceHandle rh)`
`void` | `SimulatedPeerHandle.removeResource(ResourceHandle rh)`
`void` | `LivePeerService.removeResource(ResourceHandle rh)`
`void` | `LivePeerHandle.removeResource(ResourceHandle rh)` Remove a resource from this Peer
`void` | `AbstractInternalPeerHandle.removeResource(ResourceHandle rh)`
`void` | `TestPeerHandle.requestSupplying(java.lang.String consumer_id, int tasks_count)`
`void` | `SimulatedPeerService.requestSupplying(java.lang.String consumer_id, int tasks_count)`
`void` | `SimulatedPeerHandle.requestSupplying(java.lang.String consumer_id, int tasks_count)`
`void` | `LivePeerService.requestSupplying(java.lang.String consumer_id, int tasks_count)`
`void` | `LivePeerHandle.requestSupplying(java.lang.String consumer_id, int tasks_count)` Request this peer to supply power for a number of tasks
`void` | `AbstractExternalPeerHandle.requestSupplying(java.lang.String consumer_id, int tasks_count)`
`int` | `TestPeerHandle.submitJob(UserHandle uh, JobDescriptor jd)`
`int` | `SimulatedPeerService.submitJob(UserHandle uh, JobDescriptor jd)`
`int` | `SimulatedPeerHandle.submitJob(UserHandle uh, JobDescriptor jd)`
`int` | `LivePeerService.submitJob(UserHandle uh, JobDescriptor jd)`
`int` | `LivePeerHandle.submitJob(UserHandle uh, JobDescriptor jd)` Submit a job to peer
`int` | `AbstractUserPeerHandle.submitJob(UserHandle uh, JobDescriptor jd)`
`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)`

Constructors in lbg.peer.service that throw GridException
`LivePeerHandle(java.lang.String id, java.lang.String hostname, int peer_port, int resource_port, int user_port)` Create a handle to a peer
`LivePeerService(Peer owner_peer)`
`SimulatedPeerHandle(java.lang.String id, SimulatedPeerService peer_service)`
`SimulatedPeerService(Peer owner_peer)`
`SimulatedWithCloningPeerService(Peer owner_peer)`
`TestPeerHandle(java.lang.String id)`

Uses of GridException in lbg.peer.strategy

Methods in lbg.peer.strategy that throw GridException
`BarteringAccountantPolicy` | `StrategyDescriptor.createDefaultAccountant()`
`Negotiator` | `StrategyDescriptor.createNegotiator()`
`Scheduler` | `StrategyDescriptor.createScheduler(Negotiator negotiator)`

Constructors in lbg.peer.strategy that throw GridException
`StrategyDescriptor(Peer managed_peer, PeerStrategyConfiguration peer_strategy_config)`

Uses of GridException in lbg.peer.strategy.accounting

Methods in lbg.peer.strategy.accounting that throw GridException
`abstract BarteringAccountantPolicy` | `BarteringAccountantType.createAccountant(Peer peer)`
`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)`

Constructors in lbg.peer.strategy.accounting that throw GridException
`LBGRelativePowerAccountant(Peer managed_peer)`
`LBGTimeAccountant(Peer managed_peer)`
`NoEvalAccountant(Peer managed_peer)`
`OGPerfectAccountant(Peer managed_peer)` Constructs a new OGPerfectAccountant (SIM_MODE only).
`OGRelativePowerAccountant(Peer managed_peer)`
`OGTimeAccountant(Peer managed_peer)`

Uses of GridException in lbg.peer.strategy.negotiation

Methods in lbg.peer.strategy.negotiation that throw GridException
`abstract ConsumptionNegotiationPolicy` | `ConsumptionNegotiationType.createConsumptionNegotiationPolicy(Peer managed_peer)`
`abstract SupplyingNegotiationPolicy` | `SupplyingNegotiationType.createSupplyingNegotiationPolicy(Peer managed_peer)`
`void` | `SupplyingNegotiationPolicy.evaluateSupplyingRequests()`
`void` | `ConsumptionNegotiationPolicy.generateSupplyingRequests()`

Uses of GridException in lbg.peer.strategy.negotiation.consumption

Methods in lbg.peer.strategy.negotiation.consumption that throw GridException
`void` | `NoConsumptionNegotiation.generateSupplyingRequests()` ConsumptionNegotiationPolicy implementation.
`void` | `CommonConsumptionNegotiation.generateSupplyingRequests()` ConsumptionNegotiationPolicy implementation.

Constructors in lbg.peer.strategy.negotiation.consumption that throw GridException
`CommonConsumptionNegotiation(Peer managed_peer)`
`NoConsumptionNegotiation(Peer managed_peer)`
`RandomConsumptionNegotiation(Peer managed_peer)`

Uses of GridException in lbg.peer.strategy.negotiation.supplying

Methods in lbg.peer.strategy.negotiation.supplying that throw GridException
`void` | `UnlimitedSupplyingNegotiation.evaluateSupplyingRequests()` Implementation of Resource Supplying follows Andrade's initial Network of Favors paper (p.
`void` | `ReliableSupplyingNegotiation.evaluateSupplyingRequests()`
`void` | `RandomSupplyingNegotiation.evaluateSupplyingRequests()`
`void` | `NoSupplyingNegotiation.evaluateSupplyingRequests()`
`void` | `FavorsSupplyingNegotiation.evaluateSupplyingRequests()` Implementation of Resource Supplying follows Andrade's initial Network of Favors paper: available capacity is distributed first to Peers with highest Favors balance.

Constructors in lbg.peer.strategy.negotiation.supplying that throw GridException
`FavorsSupplyingNegotiation(Peer managed_peer)`
`NoSupplyingNegotiation(Peer managed_peer)`
`RandomSupplyingNegotiation(Peer managed_peer)`
`ReliableSupplyingNegotiation(Peer managed_peer)`
`UnlimitedSupplyingNegotiation(Peer managed_peer)`

Uses of GridException in lbg.peer.strategy.ranking

Methods in lbg.peer.strategy.ranking that throw GridException
`static Ranking` | `Rankings.merge(Ranking... rankings)` Merges the target rankings into one ranking.
`static double` | `MCoSConsumptionRanking.normalizedStrideDistance(PeerBarteringProfile peer_bp)` Computes the normalized difference between the mean and the most recent Consumption Completion Stride of target Supplier.

Constructors in lbg.peer.strategy.ranking that throw GridException
`AdaptiveMC4ConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist, float blacklist_proba)`
`AdaptiveTCoRConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`ConservativeTimeStrideConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`FavorsConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)` Constructs a new FavorsConsumptionRanking.
`FavorsSupplyingRanking(PeerProfile[] peers)`
`GrantsConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)` Constructs a new GrantsConsumptionRanking.
`MC4Ranking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`MCoSConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`MergedRanking(int[] peers_ranking)`
`MTBCConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`MTTCConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)`
`PerformanceConsumptionRanking(ConsumptionGrantsContainer c_g, double estimated_mean_self_runtime, JobConsumptionOutcomeTracker jcot, boolean do_blacklist)` Constructs a new PerformanceConsumptionRanking.
`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.
`TCaRConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist, float blacklist_proba)`
`TCoRConsumptionRanking(ConsumptionGrantsContainer c_g, JobConsumptionOutcomeTracker jcot, boolean do_blacklist, float blacklist_proba)`

Uses of GridException in lbg.peer.strategy.scheduling

Methods in lbg.peer.strategy.scheduling that throw GridException
`abstract ConsumptionSchedulingPolicy` | `ConsumptionSchedulingType.createConsumptionSchedulingPolicy(Peer managed_peer, Scheduler scheduler)`
`abstract LocalSchedulingPolicy` | `LocalSchedulingType.createLocalSchedulingPolicy(Peer managed_peer, Scheduler scheduler)`
`abstract SupplyingFilteringPolicy` | `SupplyingFilteringType.createSupplyingFilteringPolicy(Peer managed_peer)`
`abstract SupplyingRunningPreemptionPolicy` | `SupplyingRunningPreemptionType.createSupplyingRunningPreemptionPolicy(Peer managed_peer, Scheduler scheduler)`
`abstract SupplyingSchedulingPolicy` | `SupplyingSchedulingType.createSupplyingSchedulingPolicy(Peer managed_peer, Scheduler scheduler)`
`abstract SupplyingWaitingPreemptionPolicy` | `SupplyingWaitingPreemptionType.createSupplyingWaitingPreemptionPolicy(Peer managed_peer)`
`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.
`void` | `SupplyingWaitingPreemptionPolicy.preemptWaitingSupplyingTasks()` Preempts some waiting Supplying Tasks.
`int` | `ConsumptionSchedulingPolicy.scheduleConsumptionTasks()`
`void` | `LocalSchedulingPolicy.scheduleLocalTasks()`
`void` | `SupplyingSchedulingPolicy.scheduleSupplyingTasks()`

Uses of GridException in lbg.peer.strategy.scheduling.consumption

Methods in lbg.peer.strategy.scheduling.consumption that throw GridException
`protected static boolean` | `CommonConsumptionScheduling.assertConsumptionGrantsAvailability(ConsumptionGrantsContainer c_g, int peer_idx)`
`protected Ranking` | `TCoRConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `TCaRConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `ReliableMLConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `RandomConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `PerformanceConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `MTTCConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `MTBCConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `MCoSConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `MC4ConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `GrantsConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `FavorsConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `DataConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `ConservativeTimeStrideConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected abstract Ranking` | `CommonConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `AdaptiveTCoRConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`protected Ranking` | `AdaptiveMC4ConsumptionScheduling.rankSuppliers(ConsumptionGrantsContainer c_g, RequestContainer rc)` Rank Suppliers.
`int` | `ReliableMLConsumptionScheduling.scheduleConsumptionTasks()` ConsumptionSchedulingPolicy implementation.
`int` | `RandomConsumptionScheduling.scheduleConsumptionTasks()` ConsumptionSchedulingPolicy implementation.
`int` | `NoConsumptionScheduling.scheduleConsumptionTasks()` ConsumptionSchedulingPolicy implementation.
`int` | `CommonConsumptionScheduling.scheduleConsumptionTasks()` ConsumptionSchedulingPolicy implementation.
`protected RequestContainer` | `CommonConsumptionScheduling.scheduleFirstConsumptionTask()` Schedules first queued Local Task as a Consumption Task.
`protected RequestContainer` | `CommonConsumptionScheduling.scheduleNextConsumptionTask(LocalQueueCursor lqc)` Schedules next queued Local Task as a Consumption Task.

Constructors in lbg.peer.strategy.scheduling.consumption that throw GridException
`AdaptiveMC4ConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`AdaptiveTCoRConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`CommonConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`ConservativeTimeStrideConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`DataConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`FavorsConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`GrantsConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`MC4ConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`MCoSConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`MTBCConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`MTTCConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`NoConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`PerformanceConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`RandomConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`ReliableConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`ReliableMLConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`TCaRConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`
`TCoRConsumptionScheduling(Peer managed_peer, Scheduler scheduler)`

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

Methods in lbg.peer.strategy.scheduling.filtering that throw GridException
`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.

Constructors in lbg.peer.strategy.scheduling.filtering that throw GridException
`CommonSupplyingFiltering(Peer managed_peer)`
`FIFOSupplyingFiltering(Peer managed_peer)`
`NoSupplyingFiltering(Peer managed_peer)`
`RelaxedFavorsSupplyingFiltering(Peer managed_peer)`
`StrictFavorsSupplyingFiltering(Peer managed_peer)`
`UnlimitedSupplyingFiltering(Peer managed_peer)`

Uses of GridException in lbg.peer.strategy.scheduling.local

Methods in lbg.peer.strategy.scheduling.local that throw GridException
`void` | `PreemptiveLocalScheduling.scheduleLocalTasks()` LocalSchedulingPolicy implementation.
`void` | `NonpreemptiveLocalScheduling.scheduleLocalTasks()` LocalSchedulingPolicy implementation.

Constructors in lbg.peer.strategy.scheduling.local that throw GridException
`NonpreemptiveLocalScheduling(Peer managed_peer, Scheduler scheduler)`
`PreemptiveLocalScheduling(Peer managed_peer, Scheduler scheduler)`

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

Methods in lbg.peer.strategy.scheduling.preemption that throw GridException
`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.
`void` | `NoWaitingPreemption.preemptWaitingSupplyingTasks()` SupplyingWaitingPreemptionPolicy implementation.
`void` | `NoPreemption.preemptWaitingSupplyingTasks()` SupplyingWaitingPreemptionPolicy implementation.
`void` | `FullWaitingPreemption.preemptWaitingSupplyingTasks()` SupplyingWaitingPreemptionPolicy implementation.
`void` | `FIFOWaitingPreemption.preemptWaitingSupplyingTasks()` SupplyingWaitingPreemptionPolicy implementation.
`void` | `FavorsWaitingPreemption.preemptWaitingSupplyingTasks()` SupplyingWaitingPreemptionPolicy implementation.

Constructors in lbg.peer.strategy.scheduling.preemption that throw GridException
`AdaptivePreemption(Peer managed_peer, Scheduler scheduler)`
`AdaptivePreemptionGrace1(Peer managed_peer, Scheduler scheduler)`
`AdaptivePreemptionGrace10(Peer managed_peer, Scheduler scheduler)`
`AdaptivePreemptionGrace2(Peer managed_peer, Scheduler scheduler)`
`AdaptivePreemptionGrace5(Peer managed_peer, Scheduler scheduler)`
`FavorsWaitingPreemption(Peer managed_peer)`
`FIFOWaitingPreemption(Peer managed_peer)`
`FullCancellation(Peer managed_peer, Scheduler scheduler)`
`FullPreemption(Peer managed_peer, Scheduler scheduler)`
`FullWaitingPreemption(Peer managed_peer)`
`LimitedCancellation(Peer managed_peer, Scheduler scheduler)`
`LimitedPreemption(Peer managed_peer, Scheduler scheduler)`
`NoPreemption(Peer managed_peer)`
`NoPreemption(Peer managed_peer, Scheduler scheduler)`
`NoWaitingPreemption(Peer managed_peer)`

Uses of GridException in lbg.peer.strategy.scheduling.supplying

Methods in lbg.peer.strategy.scheduling.supplying that throw GridException
`void` | `QAwareFIFOSupplyingScheduling.scheduleSupplyingTasks()` SupplyingSchedulingPolicy implementation.
`void` | `QAwareFavorsSupplyingScheduling.scheduleSupplyingTasks()` SupplyingSchedulingPolicy implementation.
`void` | `NoSupplyingScheduling.scheduleSupplyingTasks()` SupplyingSchedulingPolicy implementation.
`void` | `FIFOSupplyingScheduling.scheduleSupplyingTasks()` SupplyingSchedulingPolicy implementation.
`void` | `FavorsSupplyingScheduling.scheduleSupplyingTasks()` SupplyingSchedulingPolicy implementation.

Constructors in lbg.peer.strategy.scheduling.supplying that throw GridException
`FavorsSupplyingScheduling(Peer managed_peer, Scheduler scheduler)`
`FIFOSupplyingScheduling(Peer managed_peer, Scheduler scheduler)`
`NoSupplyingScheduling(Peer managed_peer, Scheduler scheduler)`
`QAwareFavorsSupplyingScheduling(Peer managed_peer, Scheduler scheduler)`
`QAwareFIFOSupplyingScheduling(Peer managed_peer, Scheduler scheduler)`

Uses of GridException in lbg.peer.web

Methods in lbg.peer.web that throw GridException
`void` | `PeerWebStatusProvider.startService()`
`void` | `PeerWebServer.startService()`

Constructors in lbg.peer.web that throw GridException
`PeerWebServer(Peer p)`
`PeerWebStatusProvider(Peer p, java.util.concurrent.LinkedBlockingQueue<java.net.Socket> q)`

Uses of GridException in lbg.peer.workflow

Methods in lbg.peer.workflow that throw GridException
`void` | `JobDescriptor.add(java.lang.String[] classnames, byte[][] bytecodes)` Adds classes that will be required later.
`void` | `JobDescriptor.add(java.lang.String[] ids, GridData[][] datas)` Adds datas that will be required later.
`void` | `JobDescriptor.add(TaskDescriptor taskdesc)` Adds a TaskDescriptor to to this JobDescriptor.
`void` | `JobDescriptor.add(TaskDescriptor taskdesc, java.lang.String[] classnames, byte[][] bytecodes, java.lang.String[] ids, GridData[][] datas)` Convenience method to add everything needed for a TaskDescriptor at once
`static boolean` | `TemporalTasksGrouping.areDataEqual(MetaGridData[] ds1, MetaGridData[] ds2)` Data-Equality test between target Tasks data sets.
`JobConsumptionDataTracker` | `Job.consumptionDataTracker()`
`JobConsumptionOutcomeTracker` | `Job.consumptionOutcomeTracker()`
`void` | `JobDescriptor.convert(GridDataManager manager)` Convert all stored datas.
`BoT` | `BoTFactory.createBoT(java.lang.String consumer_peer_id, int job_id, JobDescriptor jd, boolean is_supplying_task)` Creates a Bag of Tasks from given JobDescriptor.
`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.createLocalJob(UserHandle uh, JobDescriptor jd)`
`Job` | `JobFactory.createSupplyingJob(Task t)`
`static long` | `TemporalTasksGrouping.distance(MetaGridData[] ds1, MetaGridData[] ds2)` Distance between target Tasks data sets, defined as the Storage Affinity of ds2 relative to ds1.
`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.
`Task` | `BoT.peekFirstSupplyingTask()` Peeks at the Supplying Task that would selected for scheduling.
`RequestContainer` | `BoT.selectFirstConsumptionTask()`
`RequestContainer` | `BoT.selectFirstLocalTask()`
`RequestContainer` | `BoT.selectFirstSupplyingTask()`
`RequestContainer` | `BoT.selectNextConsumptionTask(LocalQueueCursor lqc)` Selects next Consumption Task to schedule.
`void` | `JobDescriptor.setSubmissionTime()`
`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.
`UserHandle` | `Job.user()`

Constructors in lbg.peer.workflow that throw GridException
`BoT(int job_id, int bot_id, Task[] tasks, MetaGridData[] datas, boolean is_supplying_task)`
`BoTFactory(boolean enable_ttg)` Creates a new BoTFactory.
`Job(int id, java.lang.String owner_peer_id, long submission_time, BoT tasks_root)` Creates a new Supplying Job.
`Job(int id, java.lang.String owner_peer_id, UserHandle uh, long submission_time, BoT tasks_root)` Creates a new Local Job.
`JobFactory(java.lang.String owner_peer_id, boolean enable_ttg)` Creates a new JobFactory.
`TaskDescriptor(java.lang.String[] related_classes, java.lang.String main_class, java.lang.Object[] params, java.lang.String[] related_datas)` Create a task description
`TemporalTasksGrouping()`
`Workflow()`

Uses of GridException in lbg.protocol.api

Methods in lbg.protocol.api that throw GridException
`void` | `GridApplication.setInputData(GridData[] datas)` Sets the Grid application's input data files.
`void` | `GridApplication.setParameters(java.lang.Object[] parameters)` Sets the Grid application's input parameters.
`void` | `GridApplication.setPlaypen(java.lang.String playpen_dir)` Sets the playpen directory of the Resource where the Grid application can write and read temporary files.
`void` | `GridApplication.setSupplier(java.lang.String supplier_id)` Sets the id of the Supplier Peer that controls the Resource running the Grid application

Uses of GridException in lbg.protocol.data

Methods in lbg.protocol.data that throw GridException
`SimulatedGridData` | `SimulatedGridDataFactory.createSimulatedGridData(java.lang.String peer_id)`
`SimulatedGridData` | `SimulatedGridDataFactory.createSimulatedGridData(java.lang.String peer_id, java.lang.String suffix)`
`GridData[][]` | `SimulatedGridDataFactory.createSimulatedGridDataArray(java.lang.String consumer_peer_id)`
`void` | `EmbeddedFTPServer.forceNewUser()` Sets new user login and password for FTP Server. The server needs to be restarted for this change to take effect.
`byte[]` | `TorrentGridData.getChecksum()`
`byte[]` | `InlineGridData.getChecksum()`
`abstract byte[]` | `GridData.getChecksum()` Get checksum from data.
`byte[]` | `FTPGridData.getChecksum()`
`java.io.File` | `GridDataManager.getFile(GridData data)` Store data in cache and get the associated File. Data saved this way is never considered as local.
`java.io.File` | `GridDataManager.getFile(GridData[] data)` Convenience method to automate extraction of data when downloading
`java.io.InputStream` | `TorrentGridData.getInputStream()`
`abstract java.io.InputStream` | `GridData.getInputStream()` Get an input stream to read the data
`java.io.InputStream` | `FTPGridData.getInputStream()`
`static byte[]` | `GridDataManager.hash(java.io.File f)` Hashes a file using the default algorithm ("SHA-256").
`static byte[]` | `GridDataManager.hash(java.io.File f, java.lang.String algorithm)` Hashes a file using the supplied algorithm.
`GridData[]` | `GridDataManager.host(GridData data, boolean isLocal)` Hosts given GridData with default sharing policy.
`GridData[]` | `GridDataManager.host(GridData data, boolean isLocal, int prefs)` Hosts given GridData.
`void` | `EmbeddedBitTorrentServer.removeFromBitTorrent(Metadata<java.lang.String> meta)` Removes all mention of an entry in BitTorrent structures.
`void` | `GridDataManager.restartFTPServer()` Restart the FTP server, forcing reload of the configuration.
`void` | `GridDataManager.seed(GridData[][] datasOptions)` Ensures that all given data's are being seeded.
`void` | `EmbeddedFTPServer.setConfig(int port)` Sets the FTP server configuration. If a server is already running, it will need to be restarted for the changes to take effect.
`void` | `EmbeddedFTPServer.setConfig(int port, java.lang.String user, java.lang.String password)` Sets the FTP server configuration. If a server is already running, it will need to be restarted for the changes to take effect.
`GridDataManager` | `GridDataManager.setFTPConfig(int port)` Sets the FTP server configuration. If a server is already running, it will need to be restarted for the changes to take effect.
`GridDataManager` | `GridDataManager.setFTPConfig(int port, java.lang.String user, java.lang.String password)` Sets the FTP server configuration. If a server is already running, it will need to be restarted for the changes to take effect.
`void` | `FTPGridData.setLocalParameters(java.lang.String hostname, int port)`
`void` | `EmbeddedFTPServer.start()` Load an FTP Server and start it. If a server is already running, do nothing.
`void` | `TorrentGridData.toFile(java.io.File file)`
`void` | `InlineGridData.toFile(java.io.File file)`
`abstract void` | `GridData.toFile(java.io.File file)` Save data in a file.
`void` | `FTPGridData.toFile(java.io.File file)` Save data in a file.
`TorrentGridData` | `EmbeddedBitTorrentServer.track(Metadata<java.lang.String> meta)` Hosts the GridData and render it available for torrenting.
`void` | `GridDataManager.waitFor(GridData[] requirements)` Blockingly wait for all required data's to be present in cache.

Constructors in lbg.protocol.data that throw GridException
`EmbeddedBitTorrentServer(java.lang.String cacheDirectory, java.lang.String trackerHost, int trackerPort, int btDataPort)` Creates a BitTorrent server.
`FTPGridData(java.lang.String id, long size, java.lang.String host, int port, java.lang.String path, java.lang.String user, java.lang.String password, byte[] checksum)` Makes a new FTPGridData.
`GridData(java.lang.String id, long size)` Make a new GridData
`GridDataManager(java.lang.String hostname, java.lang.String cacheDir, int btDataPort, int ftpDataPort, java.lang.String trackerHost, int trackerPort, int capacity, int sharePreferences, java.lang.String statsDirectory)` Creates a GridDataManager.
`InlineGridData(java.lang.String id, byte[] data)` Create an InlineGridData with given id and data.
`MetaGridData(java.lang.String id, long size, GridData[] grid_data)`
`SimulatedGridData(java.lang.String id, long size)` Creates a dummy grid data.
`SimulatedGridDataFactory(boolean random_salt, int max_salt_value)` Creates a new SimulatedGridDataFactory.
`TorrentGridData(java.lang.String id, long size, java.util.Map az_serialized_map, byte[] checksum, org.gudy.azureus2.core3.download.DownloadManager manager)` Create a Torrent Grid Data from an id and a file

Uses of GridException in lbg.protocol.rpc

Methods in lbg.protocol.rpc that throw GridException
`java.lang.Object` | `RemoteCall.doCall(java.lang.Object obj)` Makes the `obj.methodName(params)` call.
`static LivePeerHandle` | `HandleDownloader.downloadPeerHandle(java.lang.String hostname, int port)` Downloads a LivePeerHandle from target Peer.
`static LiveSearchEngineHandle` | `HandleDownloader.downloadSearchEngineHandle(java.lang.String hostname, int port)` Downloads a LiveSearchEngineHandle from target Peer.
`protected static LivePeerHandle` | `RemoteCall.getPeerHandle(java.lang.String host, int port)` Gets a handle from a Peer just by knowing his host and port.
`protected static LiveSearchEngineHandle` | `RemoteCall.getSearchEngineHandle(java.lang.String host, int port)` Gets a handle from a search engine just by knowing his host and port.
`java.lang.Object` | `RemoteCall.send(java.lang.String host, int port, boolean do_return)` Opens a connection to host:port and send the call
`java.lang.Object` | `RemoteCall.send(java.lang.String host, int port, boolean do_return, boolean do_timeout)` Opens a connection to host:port and send the call
`java.lang.Object` | `RemoteCall.send(java.lang.String host, int port, boolean do_return, boolean do_timeout, boolean do_failfast)` Opens a connection to host:port and send the call

Constructors in lbg.protocol.rpc that throw GridException
`RemoteCall(RemoteCall.CallType destination, java.lang.String methodName, java.lang.Class[] paramtypes, java.lang.Object[] params)` Creates a remote call.
`RemoteCall(RemoteCall.CallType destination, java.lang.String methodName, java.lang.Object... params)` Creates a remote call. Warning: you could experience problem with runtime types (e.g.
`RemoteCallDaemon(RemoteCall.CallType target_type, int target_port, java.lang.Object callHandler, RemoteCallStatusListener l)` Create a daemon with the default number of handlers (does not start thread).
`RemoteCallDaemon(RemoteCall.CallType target_type, int target_port, java.lang.Object callHandler, RemoteCallStatusListener listener, int handlers)` Creates a daemon (does not start thread)

Uses of GridException in lbg.resource

Methods in lbg.resource that throw GridException
`void` | `SimulatedResource.cancelTask()`
`void` | `Resource.cancelTask()`
`void` | `LiveResource.cancelTask()` Cancel the currently running task
`void` | `Resource.completeTask(GridData data, byte[] logs)` Completes the execution of a Task by: flagging the Task as complete (thus, creating a TaskOutput) updating the Resource state
`void` | `LiveResource.completeTask(GridData data, byte[] logs)` Make final operations to register the running task as completed
`void` | `Resource.connect()` Connects the Resource to its owner Peer.
`void` | `LiveResource.connect()` Connects the Resource to its owner Peer.
`long` | `Resource.expectedTaskRuntime()`
`long` | `LiveResource.expectedTaskRuntime()` How much time should running this task take ?
`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.
`boolean` | `SimulatedResource.setWorkingSet(GridData[][] working_set)`
`abstract boolean` | `Resource.setWorkingSet(GridData[][] working_set)`
`boolean` | `LiveResource.setWorkingSet(GridData[][] working_set)`
`void` | `LiveResource.startService()`

Constructors in lbg.resource that throw GridException
`LiveResource(ResourceBasicConfiguration rbc, ResourceNetworkConfiguration rnc, ResourceDataConfiguration rdc, InternalPeerHandle owner_peer)` Creates a Live resource Resource is not yet connected to peer.
`SimulatedResource(ResourceBasicConfiguration res_basic_config, ResourceDataConfiguration res_data_config, ResourceReliabilityConfiguration res_rel_config, ResourceNetworkConfiguration res_net_config, InternalPeerHandle owner_peer, EventList el)`

Uses of GridException in lbg.resource.config

Constructors in lbg.resource.config that throw GridException
`ResourceBasicConfiguration(java.util.Properties props)` Creates a new ResourceBasicConfiguration.
`ResourceBasicConfiguration(java.lang.String resource_id, int resource_power)` Creates a new ResourceBasicConfiguration (legal in SIM_MODE only).
`ResourceDataConfiguration(int SUPPLYING_CACHE_CAPACITY)` Creates a new ResourceDataConfiguration (legal in SIM_MODE only).
`ResourceDataConfiguration(java.util.Properties props)` Creates a new ResourceDataConfiguration.
`ResourceNetworkConfiguration()` Creates a new ResourceNetworkConfiguration.
`ResourceNetworkConfiguration(java.util.Properties props)` Creates a new ResourceNetworkConfiguration.
`ResourceReliabilityConfiguration(int mtbf)` Creates a new ResourceReliabilityConfiguration (legal in SIM_MODE only).

Uses of GridException in lbg.resource.execution

Methods in lbg.resource.execution that throw GridException
`static java.lang.String` | `ContainerPolicyManager.getPlaypenDir(java.lang.String cache_dir)`
`java.lang.String` | `ContainerPolicyManager.getPolicy(java.lang.String... target_dirs)`
`void` | `ContainerPolicyManager.writePolicy(java.lang.String... target_dirs)`

Constructors in lbg.resource.execution that throw GridException
`ContainerPolicyManager(java.lang.String cache_dir)`
`LiveTaskExecutionHandler(LiveResource res, InternalPeerHandle iph, Task t, int mem_size)` Readies a handler to be started as a different Thread.

Uses of GridException in lbg.resource.service

Methods in lbg.resource.service that throw GridException
`void` | `SimulatedResourceService.cancelTask()`
`void` | `SimulatedResourceHandle.cancelTask()`
`void` | `LiveResourceService.cancelTask()` Cancel the currently running task
`void` | `LiveResourceHandle.cancelTask()` Ask a Resource to cancel running Task
`void` | `AbstractResourceHandle.cancelTask()`
`ResourceHandle` | `SimulatedResourceService.createHandle()`
`ResourceHandle` | `ResourceService.createHandle()`
`ResourceHandle` | `LiveResourceService.createHandle()` Get a handle to the owner resource
`static ResourceService` | `ResourceServiceFactory.createResourceService(Resource owner_resource)`
`void` | `LiveResourceService.delete_me_runTask(Task t)` Deprecated.
`void` | `LiveResourceHandle.delete_me_runTask(Task t)` Deprecated. Specify new Working Set when running a task.
`long` | `SimulatedResourceService.expectedTaskRuntime()`
`long` | `SimulatedResourceHandle.expectedTaskRuntime()`
`long` | `LiveResourceService.expectedTaskRuntime()` How much time should running this task take ?
`long` | `LiveResourceHandle.expectedTaskRuntime()` Ask a Resource to give expected Task runtime
`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)`
`boolean` | `SimulatedResourceService.setWorkingSet(GridData[][] working_set)`
`boolean` | `SimulatedResourceHandle.setWorkingSet(GridData[][] working_set)` Sets a resource's working set
`boolean` | `LiveResourceService.setWorkingSet(GridData[][] working_set)`
`boolean` | `LiveResourceHandle.setWorkingSet(GridData[][] working_set)` Sets a resource's working set This call is non-blocking (only verification of the validity of the WS is done before returning: data is not yet downloaded).
`boolean` | `AbstractResourceHandle.setWorkingSet(GridData[][] working_set)`

Constructors in lbg.resource.service that throw GridException
`LiveResourceHandle(java.lang.String id, int cache_capacity, java.lang.String res_host, int res_port)` Create a handle to contact a LiveResource
`LiveResourceService(LiveResource owner_resource)` Create a service for a resource.
`SimulatedResourceHandle(java.lang.String id, SimulatedResourceService resource_service)`
`SimulatedResourceService(SimulatedResource owner_resource)`

Uses of GridException in lbg.searchengine

Methods in lbg.searchengine that throw GridException
`boolean` | `SearchEngineServer.add(ExternalPeerHandle handle)` Adds a handle to this search engine.
`static SearchEngineClient` | `SearchEngineClientFactory.createSearchEnglineClient(SearchEngineHandle se_handle, ExternalPeerHandle owner_peer, int timeout)` Creates a new Search Engine client.
`SearchEngineResponse` | `SearchEngineServer.getHandles()`
`SearchEngineResponse` | `SearchEngineServer.getHandles(long since)`
`void` | `SearchEngineClient.refresh()` Refreshes the local database by recontacting the reference server.
`void` | `SearchEngineClient.remove(ExternalPeerHandle handle)` Removes a handle from the local database.
`SearchEngineHandle` | `SearchEngineClient.renewReferenceServer(SearchEngineHandle handle)` Changes this client's reference server.
`ExternalPeerHandle[]` | `SearchEngineClient.search()` Get 40 random handles from the cache.
`ExternalPeerHandle[]` | `SearchEngineClient.search(int k)` Get k random handles from the cache.
`ExternalPeerHandle` | `SearchEngineClient.search(java.lang.String id)` Searches for a handle in the local database.
`void` | `SearchEngineClient.setOwnerPeer(ExternalPeerHandle owner_peer)` Sets this client's owner peer.
`void` | `LiveSearchEngineServer.startService()`

Constructors in lbg.searchengine that throw GridException
`LiveSearchEngineClient(SearchEngineHandle reference, ExternalPeerHandle owner_peer, int timeout)` Creates a new Search Engine client.
`LiveSearchEngineServer(java.lang.String id, java.lang.String host, int port, int timeout)` Creates a Search Engine server.
`SearchEngineResponse(ExternalPeerHandle[] handles)` Creates a search engine response.
`SimulatedSearchEngineClient(SearchEngineHandle reference, ExternalPeerHandle owner_peer, int timeout)` Creates a new Search Engine client.
`SimulatedSearchEngineServer(java.lang.String id, java.lang.String host, int port, int timeout)` Creates a Search Engine server.

Uses of GridException in lbg.searchengine.service

Methods in lbg.searchengine.service that throw GridException
`void` | `SimulatedSearchEngineService.add(ExternalPeerHandle handle)`
`void` | `SimulatedSearchEngineHandle.add(ExternalPeerHandle handle)`
`void` | `SearchEngineHandle.add(ExternalPeerHandle handle)` Adds a handle to this SearchEngine.
`void` | `LiveSearchEngineService.add(ExternalPeerHandle handle)`
`void` | `LiveSearchEngineHandle.add(ExternalPeerHandle handle)`
`SearchEngineHandle` | `SimulatedSearchEngineService.createHandle()`
`SearchEngineHandle` | `SearchEngineService.createHandle()`
`SearchEngineHandle` | `LiveSearchEngineService.createHandle()`
`static SearchEngineService` | `SearchEngineServiceFactory.createSearchEngineService(SearchEngineServer owner_se)`
`SearchEngineResponse` | `SimulatedSearchEngineService.getHandles()`
`SearchEngineResponse` | `SimulatedSearchEngineHandle.getHandles()`
`SearchEngineResponse` | `SearchEngineHandle.getHandles()` Gets all handles that this engine currently knows.
`SearchEngineResponse` | `LiveSearchEngineService.getHandles()`
`SearchEngineResponse` | `LiveSearchEngineHandle.getHandles()`
`SearchEngineResponse` | `SimulatedSearchEngineService.getHandles(long since)`
`SearchEngineResponse` | `SimulatedSearchEngineHandle.getHandles(long since)`
`SearchEngineResponse` | `SearchEngineHandle.getHandles(long since)` Gets handles newer than a specified time.
`SearchEngineResponse` | `LiveSearchEngineService.getHandles(long since)`
`SearchEngineResponse` | `LiveSearchEngineHandle.getHandles(long since)`

Constructors in lbg.searchengine.service that throw GridException
`LiveSearchEngineHandle(java.lang.String id, java.lang.String host, int port)`
`LiveSearchEngineService(SearchEngineServer server)`
`SimulatedSearchEngineHandle(SimulatedSearchEngineService service)`
`SimulatedSearchEngineService(SearchEngineServer server)`

Uses of GridException in lbg.simulator

Methods in lbg.simulator that throw GridException
`void` | `SimulatorEnvironment.activateLocalScheduling()`
`void` | `SimulatorEnvironment.addJobSubmission(UserAgent user, java.lang.String peer_id)` ISimulator implementation.
`void` | `ISimulator.addJobSubmission(UserAgent user, java.lang.String peer_id)`
`static SimulatedResource[]` | `SimulatorEnvironment.createPeerResources(InternalPeerHandle owner_peer, int peer_power, int res_count, int lo_power, int hi_power, int cache_capacity, int mtbf, EventList event_list)` Creates Resources for target Peer.
`void` | `Scenario.loadGridConfiguration(java.util.Properties props)`
`void` | `Scenario.loadGridStrategyConfiguration(java.util.Properties props)`
`void` | `Scenario.loadRandomizerConfiguration(java.util.Properties props)`
`void` | `EnvironmentController.notifyEnvironmentController(int peer_id, NegotiatorController neg_ctrlr)`
`void` | `EnvironmentController.notifyEnvironmentController(int peer_id, SchedulerController sched_ctrlr)`
`void` | `EnvironmentController.processSelfEvents()`
`void` | `EnvironmentController.scheduleAndNegotiate()`
`void` | `Scenario.setGridConfiguration(GridConfiguration grid_config)`
`void` | `Scenario.setGridStrategyConfiguration(GridStrategyConfiguration grid_strategy_config)`
`void` | `SimTask.setInputData(GridData[] datas)` Sets the Grid application's input data files.
`void` | `EnvironmentController.setNegotiatorAndScheduler(int peer_id, Negotiator negotiator, Scheduler scheduler)`
`void` | `SimTask.setParameters(java.lang.Object[] parameters)`
`void` | `EnvironmentController.setPeers(Peer[] peers)`
`void` | `SimTask.setPlaypen(java.lang.String playpen_dir)`
`void` | `Scenario.setRandomizerConfiguration(RandomizerConfiguration randomizer_config)`
`void` | `SimTask.setSupplier(java.lang.String supplier_id)`
`void` | `Simulator.simulate()` Simulation loop.

Constructors in lbg.simulator that throw GridException
`EnvironmentController(int peer_count)`
`Scenario(java.util.Properties scenario_props, java.lang.String scenario_filename)`
`Scenario(java.util.Properties scenario_props, java.lang.String scenario_filename, boolean load_grid_config, boolean load_grid_strategy_config, boolean load_randomizer_config)`
`Simulator(java.util.Properties scenario_props)`
`Simulator(java.util.Properties scenario_props, java.lang.String scenario_filename)`
`SimulatorEnvironment(Simulator sim, java.util.Properties scenario_props, java.lang.String scenario_filename)`

Uses of GridException in lbg.simulator.config

Methods in lbg.simulator.config that throw GridException
`int` | `GridConfiguration.DATA_PER_TASK(java.lang.String peer_id)`
`int` | `GridConfiguration.JOB_INIT_SHIFT(java.lang.String peer_id)`
`int` | `GridConfiguration.JOBS_INTER_TIME_HI(java.lang.String peer_id)`
`int` | `GridConfiguration.JOBS_INTER_TIME_LO(java.lang.String peer_id)`
`int` | `GridConfiguration.JOBS_PER_PEER(java.lang.String peer_id)`
`int` | `GridConfiguration.resolvePeerID(java.lang.String peer_id)`
`int` | `GridConfiguration.TASK_LEN_HI(java.lang.String peer_id)`
`int` | `GridConfiguration.TASK_LEN_LO(java.lang.String peer_id)`
`int` | `GridConfiguration.TASKS_PER_JOB(java.lang.String peer_id)`

Constructors in lbg.simulator.config that throw GridException
`GridConfiguration(java.util.Properties props)`
`GridStrategyConfiguration(java.util.Properties props)`

Uses of GridException in lbg.simulator.event

Methods in lbg.simulator.event that throw GridException
`void` | `EventList.addEvent(Event evt)`
`boolean` | `EventList.containsEvent(Event evt)`
`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.
`Event` | `EventFactory.createJobEvent(UserAgent user, java.lang.String owner_id)` Creates a SubmittedJobEvent so that target UserAgent submits, at a legal random time from now, a Job to target Peer.
`Event` | `EventFactory.createJobEvent(UserAgent user, java.lang.String owner_id, long base_time)` Creates a SubmittedJobEvent so that target UserAgent submits, at a legal random time from target base time, a Job to target Peer.
`Event` | `EventFactory.createSelfEvent()` Creates a SelfEvent.
`EventContainer` | `EventList.extractFirstEvent()` side effect: time is updated to the timestamp of the extracted Event
`void` | `EventList.removeEvent(Event evt)`

Constructors in lbg.simulator.event that throw GridException
`CompletedTaskEvent(long id, long timestamp, java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)`
`EventContainer(Event evt, boolean is_last_event_at_current_timestamp)`
`EventFactory(Scenario sc)` Creates a new EventFactory.
`EventList(Scenario sc)`
`FailedTaskEvent(long id, long timestamp, java.lang.String consumer_id, java.lang.String supplier_id, Task t, Resource res)`
`SelfEvent(long id, long timestamp)`
`SubmittedJobEvent(long id, long timestamp, UserAgent user, java.lang.String owner_id)`

Uses of GridException in lbg.simulator.tools

Methods in lbg.simulator.tools that throw GridException
`static java.lang.String` | `LogAnalyzer.analyzeLog(java.lang.String log_name, GlobalPropertiesStore global_props_store, java.lang.StringBuffer sb_encountered_exceptions, java.util.concurrent.atomic.AtomicInteger encountered_exceptions)` Analyzes target log.
`static java.lang.String` | `LogAnalyzer.analyzeScenario(java.lang.String log_name)` Analyzes scenario of target log.
`Measurement` | `GlobalPropertiesStore.getMeasurement(java.lang.String key)` Returns stored Measurement.
`static boolean` | `LogAnalyzer.isStrategyProperty(java.lang.String prop)`
`void` | `GlobalPropertiesStore.storeProperty(java.lang.String log_name, java.lang.String key, java.lang.String value)`

Constructors in lbg.simulator.tools that throw GridException
`GlobalPropertiesStore()` Constructs a new GlobalPropertiesStore.

Uses of GridException in lbg.simulator.tools.aggregator

Methods in lbg.simulator.tools.aggregator that throw GridException
`void` | `LogPropertiesTrie.add(java.lang.String subkeys, java.lang.String value)`
`void` | `LogAggregator.aggregateLogs()`
`void` | `PolicyPerformanceGroupAnalyzer.analyze()`
`void` | `PolicyPerformanceAnalyzer.analyze()`
`void` | `LogAggregator.analyzeLogs()`
`void` | `StrategyPerformanceAnalyzer.analyzeStrategyPerformance()`
`java.lang.String` | `LogPropertiesTrie.enumerate()`
`java.lang.String` | `LogPropertiesTrie.get(java.lang.String subkeys)`
`Measurement` | `PolicyPerformanceAnalyzer.getPolicyMBRTAnalysisMeasurement(java.lang.String l)` Returns MBRT analysis measurement for target policy.
`Measurement` | `PolicyPerformanceAnalyzer.getPolicyRankAnalysisMeasurement(java.lang.String l)` Returns rank analysis measurement for target policy.
`java.lang.String` | `PolicyPerformanceGroupAnalyzer.outputAsCSV()`
`java.lang.String` | `PolicyPerformanceGroupAnalyzer.outputAsCSVSummary()`
`void` | `LogAggregatorReportManager.saveLogAnalysisSummary()`
`void` | `LogAggregatorReportManager.saveLogSpreadsheetReport()`
`void` | `StrategyPerformanceAnalyzer.saveStrategyPerformanceAnalysisReport()`

Constructors in lbg.simulator.tools.aggregator that throw GridException
`LogAggregator(java.lang.String list_of_logs, int thread_pool_size)` Constructs a new LogAggregator.
`LogAggregatorReportManager(java.lang.String timestamp, java.lang.String scenario_base_name, int logs_count, java.lang.String[] logs_csv_summary, GlobalPropertiesStore global_props_store, java.lang.String encountered_errors, java.lang.String encountered_exceptions)` Constructs a new LogAggregatorReportManager.
`LogPropertiesTrie()`
`PolicyPerformanceAnalyzer(java.lang.String pdp_label, java.lang.String[] ranked_policies, java.lang.Float[] ranked_mbrt)` Constructs a new PolicyPerformanceAnalyzer.
`PolicyPerformanceAnalyzer(java.lang.String pdp_label, java.lang.String[] ranked_policies, java.lang.Float[] ranked_mbrt, float best_row_analysis_ratio)` Constructs a new PolicyPerformanceAnalyzer.
`PolicyPerformanceGroupAnalyzer(java.lang.String pdp_label, java.lang.String[] ranked_policies, java.lang.Float[] ranked_mbrt)` Constructs a new PolicyPerformanceGroupAnalyzer.
`PolicyPerformanceGroupAnalyzer(java.lang.String pdp_label, java.lang.String[] ranked_policies, java.lang.Float[] ranked_mbrt, float... best_row_analysis_ratios)` Constructs a new PolicyPerformanceGroupAnalyzer.
`StrategyPerformanceAnalyzer(java.lang.String timestamp, java.lang.String spreadsheet_fn)` Constructs a new StrategyPerformanceAnalyzer.

Uses of GridException in lbg.simulator.tools.generator

Methods in lbg.simulator.tools.generator that throw GridException
`abstract void` | `ScenarioSetGenerator.checkArgs(java.lang.String[] args)`
`void` | `ScenarioRandomizer.checkArgs(java.lang.String[] args)`
`void` | `PolicyEnumerator.checkArgs(java.lang.String[] args)`
`protected void` | `ScenarioSetGenerator.generateBucketJDF(int b, java.util.ArrayList<java.util.Set<java.lang.String>> sc_buckets)`
`void` | `ScenarioSetGenerator.generateJDF()`
`protected static java.util.ArrayList<java.util.Set<java.lang.String>>` | `ScenarioSetGenerator.generateScenariiBuckets(java.util.Iterator<java.lang.String> it_sc_all, int generated_sc_count, int bucket_count)`
`protected void` | `ScenarioSetGenerator.generateScenario(int idx, ScenarioPayload sc_payload)`
`protected java.lang.String` | `ScenarioSetGenerator.generateScenarioFileName(int idx)`
`abstract void` | `ScenarioSetGenerator.generateScenarios()` Enumerates scenarios.
`void` | `ScenarioRandomizer.generateScenarios()`
`void` | `PolicyEnumerator.generateScenarios()`
`static void` | `ScenarioSetGenerator.run(ScenarioSetGenerator sse)`
`protected static void` | `ScenarioSetGenerator.storeScenario(Scenario sc, java.lang.String scenario_filename)`
`protected abstract void` | `ScenarioSetGenerator.updateScenario(Scenario sc, ScenarioPayload sc_payload)` Updates target scenario with target payload.
`protected void` | `ScenarioRandomizer.updateScenario(Scenario sc, ScenarioPayload sc_payload)`
`protected void` | `PolicyEnumerator.updateScenario(Scenario sc, ScenarioPayload sc_payload)`

Constructors in lbg.simulator.tools.generator that throw GridException
`PolicyEnumerator(java.lang.String[] args)`
`PolicyEnumeratorPayload(BarteringAccountantType ba, ConsumptionNegotiationType cn, SupplyingNegotiationType sn, LocalSchedulingType ls, SupplyingRunningPreemptionType rp, SupplyingWaitingPreemptionType wp, SupplyingFilteringType sf, ConsumptionSchedulingType cs, SupplyingSchedulingType ss)`
`ScenarioRandomizer(java.lang.String[] args)`
`ScenarioRandomizerPayload(java.lang.String sim_seed)`
`ScenarioSetGenerator(java.lang.String[] args)`

Uses of GridException in lbg.simulator.tools.jdf

Methods in lbg.simulator.tools.jdf that throw GridException
`JDFWriter` | `JDFWriterFactory.createJDFWriter(java.lang.String job_label, java.lang.String scenario_complete_filename, java.lang.String jar_complete_filename, java.util.Iterator<java.lang.String> scenarii, java.lang.String main_class)`
`java.lang.String` | `TaskDescription.format(java.lang.String task_name)`
`java.lang.String` | `OurGridTaskDescription.format(java.lang.String task_name)`
`java.lang.String` | `LBGridTaskDescription.format(java.lang.String task_name)`
`java.lang.String` | `OurGridJDFWriter.getJDFContent()`
`java.lang.String` | `LBGridJDFWriter.getJDFContent()`
`java.lang.String` | `JDFWriter.getJDFContent()`
`java.lang.String` | `OurGridJDFWriter.getJDFFileName()`
`java.lang.String` | `LBGridJDFWriter.getJDFFileName()`
`java.lang.String` | `JDFWriter.getJDFFileName()`
`void` | `TaskDescription.setInputs(java.lang.String[] inputs)`
`void` | `OurGridTaskDescription.setInputs(java.lang.String[] inputs)`
`void` | `LBGridTaskDescription.setInputs(java.lang.String[] inputs)`
`void` | `TaskDescription.setJar(java.lang.String jar)`
`void` | `OurGridTaskDescription.setJar(java.lang.String jar)`
`void` | `LBGridTaskDescription.setJar(java.lang.String jar)`
`void` | `TaskDescription.setMainClass(java.lang.String main_class)`
`void` | `OurGridTaskDescription.setMainClass(java.lang.String main_class)`
`void` | `LBGridTaskDescription.setMainClass(java.lang.String main_class)`
`void` | `TaskDescription.setOutputs(java.lang.String[] outputs)`
`void` | `OurGridTaskDescription.setOutputs(java.lang.String[] outputs)`
`void` | `LBGridTaskDescription.setOutputs(java.lang.String[] outputs)`
`void` | `TaskDescription.setParameters(java.lang.String[] parameters)`
`void` | `OurGridTaskDescription.setParameters(java.lang.String[] parameters)`
`void` | `LBGridTaskDescription.setParameters(java.lang.String[] parameters)`
`void` | `TaskDescription.setRemoteCmd(java.lang.String remote_cmd)`
`void` | `OurGridTaskDescription.setRemoteCmd(java.lang.String remote_cmd)`
`void` | `LBGridTaskDescription.setRemoteCmd(java.lang.String remote_cmd)`
`void` | `OurGridJDFWriter.writeJDF()`
`void` | `LBGridJDFWriter.writeJDF()`
`void` | `JDFWriter.writeJDF()`

Constructors in lbg.simulator.tools.jdf that throw GridException
`JDFWriterFactory(Middleware m, boolean upload_jar_dep)` Constructs a new JDF file writer factory.
`LBGridJDFWriter(java.lang.String job_label, java.lang.String scenario_complete_filename, java.lang.String jar_complete_filename, java.util.Iterator<java.lang.String> scenarii, java.lang.String main_class, boolean upload_jar_dep)`
`LBGridTaskDescription()`
`LBGridTaskDescription(java.lang.String[] inputs, java.lang.String[] parameters, java.lang.String jar, java.lang.String main_class, java.lang.String remote_cmd, java.lang.String[] outputs)`
`OurGridJDFWriter(java.lang.String job_label, java.lang.String scenario_complete_filename, java.lang.String jar_complete_filename, java.util.Iterator<java.lang.String> scenarii, java.lang.String main_class, boolean upload_jar_dep)`
`OurGridTaskDescription()`
`OurGridTaskDescription(java.lang.String[] inputs, java.lang.String[] parameters, java.lang.String jar, java.lang.String main_class, java.lang.String remote_cmd, java.lang.String[] outputs)`

Uses of GridException in lbg.simulator.tools.panorama

Methods in lbg.simulator.tools.panorama that throw GridException
`void` | `LogPanorama.chartDrawn(LogChartRequest log_chart_req)` LogChartDrawingListener implementation.
`void` | `LogChartDrawingListener.chartDrawn(LogChartRequest log_chart_req)`
`LogChartRequest` | `LogChartRequestFactory.createLogChartRequest(java.lang.String... col_titles)`
`void` | `LogPanorama.display()`
`void` | `LogChartFactory.requestLogChart(LogChartRequest log_chart_req)`
`void` | `LogChartRequest.setChartImage(java.awt.image.BufferedImage chart_img)`
`void` | `LogPanoramaFrame.setup(int expected_charts)`

Constructors in lbg.simulator.tools.panorama that throw GridException
`LogChartFactory(LogSpreadsheet spreadsheet, boolean do_generate_pdf)`
`LogChartRequest(LogChartDrawingListener listener, int chart_id, java.lang.String... col_titles)`
`LogChartRequestFactory(LogChartDrawingListener listener)`
`LogPanorama(java.lang.String[] args)`
`LogPanoramaFrame(java.lang.String spreadsheet_fn, java.util.concurrent.LinkedBlockingQueue<LogChartRequest> q)`

Uses of GridException in lbg.simulator.tools.spreadsheet

Methods in lbg.simulator.tools.spreadsheet that throw GridException
`java.lang.String` | `LogSpreadsheet.dump()`
`java.lang.Float[]` | `LogSpreadsheet.getDataColumn(java.lang.String col_title)`
`static java.lang.Float[]` | `LogSpreadsheetSorter.getSortedDataColumn(LogSpreadsheet spreadsheet, java.lang.String... col_titles)` Get last column of target columns sorted in function of the other target columns (first target column is first sort criterion and so on).
`static java.lang.String[]` | `LogSpreadsheetSorter.getSortedStrategyColumn(LogSpreadsheet spreadsheet, java.lang.String... col_titles)` Get last column of target columns sorted in function of the other target columns (first target column is first sort criterion and so on).
`java.lang.String[]` | `LogSpreadsheet.getStrategyColumn(java.lang.String col_title)`
`boolean` | `LogSpreadsheet.isStrategyColumn(java.lang.String col_title)`
`static java.util.ArrayList<java.lang.Integer>` | `LogSpreadsheetSorter.sortColumns(LogSpreadsheet spreadsheet, java.lang.String... col_titles)`

Constructors in lbg.simulator.tools.spreadsheet that throw GridException
`LogSpreadsheet(java.lang.String spreadsheet_fn)`

Uses of GridException in lbg.task

Methods in lbg.task that throw GridException
`void` | `Task.deleteMeatada()` Strips the Task from now-unuseful payload, such as metada, output, ...
`void` | `Task.flagAsCancelled(java.lang.String supplier_peer_id)`
`void` | `Task.flagAsCompleted(java.lang.String supplier_peer_id, long start_time, GridData data, byte[] logs, int power)`
`GridData[]` | `Task.getInputDataSet()` Returns readied data's.
`MetaGridData[]` | `Task.getInputMetaGridDataSet()`
`byte[]` | `TaskOutput.getLog()` Log.
`GridData` | `TaskOutput.getOutputData()` Output data.
`GridData[][]` | `Task.getRawInputDataSet()`
`TaskOutput` | `Task.output()`
`GridData[]` | `Task.readyInputDataSet(GridDataManager gdm)` Readies input data set for execution.
`void` | `Task.setStartTime()`
`void` | `Task.setSupplyingSpaceBoTID(int tmp_bot_id)`
`void` | `Task.setSupplyingSpaceJobID(int tmp_job_id)`
`void` | `Task.syncWith(Task returning_self)`

Constructors in lbg.task that throw GridException
`Task(java.lang.String consumer_peer_id, int job_id, int bot_id, int task_id, byte[][] jars, java.lang.String[] classnames, java.lang.String main_class, java.lang.Object[] parameters, GridData[][] datas, long nominal_runtime)` Constructs a new 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 GridException in lbg.user

Methods in lbg.user that throw GridException
`void` | `LiveUserAgentListener.jobCompletion(JobDescriptor jd, int jobID)` Called upon Job completion.
`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` | `LiveUserAgent.startService()`
`void` | `LiveUserAgent.startService(boolean set_daemon)`
`abstract int` | `UserAgent.submitJob(JobDescriptor jd)`
`int` | `SimulatedUserAgent.submitJob(JobDescriptor jd)`
`int` | `LiveUserAgent.submitJob(JobDescriptor jd)` Submits a Job.
`int` | `EmbeddedLiveUserAgent.submitJob(java.util.Properties jdf_props)` Submits a Job.
`void` | `LiveUserAgentListener.taskCompletion(Task t)` Called upon Task completion.

Constructors in lbg.user that throw GridException
`EmbeddedLiveUserAgent(java.lang.String id, java.lang.String user_hostname, int user_port, UserPeerHandle peer_handle, java.lang.String output_dir)` Creates an EmbeddedLiveUserAgent.
`LiveUserAgent(java.lang.String id, java.lang.String host, int port, UserPeerHandle peer, java.lang.String output_dir)` Creates a Live UserAgent.
`LiveUserAgent(java.lang.String id, java.lang.String host, int port, UserPeerHandle peer, java.lang.String output_dir, java.lang.String stats_dir)` Creates a Live UserAgent.
`LiveUserAgent(java.lang.String id, java.lang.String host, int port, UserPeerHandle peer, java.lang.String output_dir, java.lang.String stats_dir, boolean activate_measurement, boolean save_results)` Creates a Live UserAgent.
`SimulatedUserAgent(java.lang.String id, UserPeerHandle peer, ISimulator sim)`

Uses of GridException in lbg.user.service

Methods in lbg.user.service that throw GridException
`UserHandle` | `UserService.createHandle()`
`UserHandle` | `SimulatedUserService.createHandle()`
`UserHandle` | `LiveUserService.createHandle()` Creates a handle to parent user
`static UserService` | `UserServiceFactory.createUserService(UserAgent owner_user)`
`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

Constructors in lbg.user.service that throw GridException
`LiveUserHandle(java.lang.String id, java.lang.String user_host, int user_port)` Create a handle
`LiveUserService(UserAgent owner_user)` Creates a User service
`SimulatedUserHandle(java.lang.String id, SimulatedUserService user_service)`
`SimulatedUserService(UserAgent owner_user)`

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.