public class Task

A task is either something to compute somewhere, or something to exchange between two hosts (or both). It is defined by a computing amount and a message size.

## Fields¶

### name¶

protected String name

## Constructors¶

public Task()

Default constructor (all fields to 0 or null)

public Task(String name, double flopsAmount, double bytesAmount)

Construct a new task with the specified processing amount and amount of data needed.

Parameters: name – Task’s name flopsAmount – A value of the processing amount (in flop) needed to process the task. If 0, then it cannot be executed with the execute() method. This value has to be ≥ 0. bytesAmount – A value of amount of data (in bytes) needed to transfert this task. If 0, then it cannot be transfered with the get() and put() methods. This value has to be ≥ 0.

public Task(String name, Host[] hosts, double[] flopsAmount, double[] bytesAmount)

Construct a new parallel task with the specified processing amount and amount for each host implied.

Parameters: name – The name of the parallel task. hosts – The list of hosts implied by the parallel task. flopsAmount – The amount of operations to be performed by each host of hosts. flopsAmount[i] is the total number of operations that have to be performed on hosts[i]. bytesAmount – A matrix describing the amount of data to exchange between hosts. The length of this array must be hosts.length * hosts.length. It is actually used as a matrix with the lines being the source and the columns being the destination of the communications.

## Methods¶

### cancel¶

public native void cancel()

### dsend¶

public native void dsend(String mailbox)

Send the task asynchronously on the specified mailbox, with no way to retrieve whether the communication succeeded or not

### dsendBounded¶

public native void dsendBounded(String mailbox, double maxrate)

Send the task asynchronously on the specified mailbox, with no way to retrieve whether the communication succeeded or not

### execute¶

public native void execute()

Executes a task on the location on which the current process is running.

### finalize¶

protected void finalize()

Deletes a task once the garbage collector reclaims it

### getFlopsAmount¶

public native double getFlopsAmount()

Gets the remaining amount of flops to execute in this task If it’s ongoing, you get the exact amount at the present time. If it’s already done, it’s 0.

### getMessageSize¶

public double getMessageSize()

### getName¶

public String getName()

Gets the name of the task

### getSender¶

public native Process getSender()

Gets the sender of the task (or null if not sent yet)

### getSource¶

public native Host getSource()

Gets the source of the task (or null if not sent yet).

### irecv¶

public static native Comm irecv(String mailbox)

Starts listening for receiving a task from an asynchronous communication

Parameters: mailbox – a Comm handler

### irecvBounded¶

public static native Comm irecvBounded(String mailbox, double rate)

Starts listening for receiving a task from an asynchronous communication with a capped rate

Parameters: mailbox – a Comm handler

### isend¶

public native Comm isend(String mailbox)

Sends the task on the mailbox asynchronously

### isendBounded¶

public native Comm isendBounded(String mailbox, double maxrate)

Sends the task on the mailbox asynchronously (capping the sending rate to a maxrate)

### listen¶

public static native boolean listen(String mailbox)

Listen whether there is a task waiting (either for a send or a recv) on the mailbox identified by the specified alias

### listenFrom¶

public static native int listenFrom(String mailbox)

Tests whether there is a pending communication on the mailbox identified by the specified alias, and who sent it

### nativeFinalize¶

protected native void nativeFinalize()

### nativeInit¶

public static native void nativeInit()

Class initializer, to initialize various JNI stuff

public static Task receive(String mailbox)

Retrieves next task on the mailbox identified by the specified alias

public static native Task receive(String mailbox, double timeout)

Retrieves next task on the mailbox identified by the specified alias (wait at most a timeout seconds)

Parameters: mailbox – timeout – a Task

public static Task receiveBounded(String mailbox, double rate)

Retrieves next task from the mailbox identified by the specified name with a capped rate

public static native Task receiveBounded(String mailbox, double timeout, double rate)

Retrieves next task on the mailbox identified by the specified name (wait at most a timeout seconds) with a capped rate

Parameters: mailbox – timeout – a Task

### send¶

public void send(String mailbox)

Sends the task on the specified mailbox

Parameters: mailbox – where to send the message

### send¶

public void send(String mailbox, double timeout)

Sends the task on the specified mailbox (wait at most a timeout seconds)

Parameters: mailbox – where to send the message timeout –

### sendBounded¶

public void sendBounded(String mailbox, double maxrate)

Sends the task on the specified mailbox (capping the sending rate to a maxrate)

Parameters: mailbox – where to send the message maxrate –

### sendBounded¶

public native void sendBounded(String mailbox, double timeout, double maxrate)

Sends the task on the specified mailbox (capping the sending rate to a maxrate) with a timeout

Parameters: mailbox – where to send the message timeout – maxrate –

### setBound¶

public native void setBound(double bound)

Changes the maximum CPU utilization of a computation task. Unit is flops/s.

### setBytesAmount¶

public native void setBytesAmount(double bytesAmount)

Set the amount of bytes to exchange the task Warning if the communication is already started and ongoing, this call does nothing.

Parameters: bytesAmount – the size of the task

### setFlopsAmount¶

public native void setFlopsAmount(double flopsAmount)

Set the computation amount needed to process the task Warning if the execution is already started and ongoing, this call does nothing.

Parameters: flopsAmount – the amount of computation needed to process the task

### setName¶

public native void setName(String name)

Sets the name of the task

Parameters: name – the new task name

### setPriority¶

public native void setPriority(double priority)

This method sets the priority of the computation of the task. The priority doesn’t affect the transfer rate. For example a priority of 2 will make the task receive two times more cpu than the other ones.

Parameters: priority – The new priority of the task.