org/simgrid/msg/Task.java

   1 /*
   2  * simgrid.msg.Task.java        1.00 07/05/01
   3  *
   4  * Copyright 2006,2007 Martin Quinson, Malek Cherier
   5  * All right reserved.
   6  *
   7  * This program is free software; you can redistribute
   8  * it and/or modify it under the terms of the license
   9  *(GNU LGPL) which comes with this package.
  10  */
  11
  12 package simgrid.msg;
  13
  14 /**
  15  * A task is either something to compute somewhere, or something to exchange between two hosts (or both).
  16  * It is defined by a computing amount and a message size.
  17  *
  18  */
  19 public class Task {
  20         /**
  21          * This attribute represents a bind between a java task object and
  22          * a native task. Even if this attribute is public you must never
  23          * access to it. It is set automatically during the build of the object.
  24          */
  25         public long bind = 0;
  26
  27
  28         /** Default constructor (all fields to 0 or null) */
  29         public Task() {
  30                 MsgNative.taskCreate(this, null, 0, 0);
  31         }
  32         /* *              * *
  33          * * Constructors * *
  34          * *              * */
  35         /**
  36          * Construct an new task with the specified processing amount and amount
  37          * of data needed.
  38          *
  39          * @param name  Task's name
  40          *
  41          * @param computeDuration       A value of the processing amount (in flop) needed to process the task.
  42          *                              If 0, then it cannot be executed with the execute() method.
  43          *                              This value has to be >= 0.
  44          *
  45          * @param messageSize           A value of amount of data (in bytes) needed to transfert this task.
  46          *                              If 0, then it cannot be transfered with the get() and put() methods.
  47          *                              This value has to be >= 0.
  48          */
  49         public Task(String name, double computeDuration, double messageSize) {
  50                 MsgNative.taskCreate(this, name, computeDuration, messageSize);
  51         }
  52         /**
  53          * Construct an new parallel task with the specified processing amount and amount for each host
  54          * implied.
  55          *
  56          * @param name          The name of the parallel task.
  57          * @param hosts         The list of hosts implied by the parallel task.
  58          * @param computeDurations      The amount of operations to be performed by each host of \a hosts.
  59          * @param messageSizes  A matrix describing the amount of data to exchange between hosts.
  60          */
  61         public Task(String name, Host[]hosts, double[]computeDurations, double[]messageSizes) {
  62                 MsgNative.parallelTaskCreate(this, name, hosts, computeDurations, messageSizes);
  63         }
  64         /* *                   * *
  65          * * Getters / Setters * *
  66          * *                   * */
  67         /** Gets the name of a task */
  68         public String getName() {
  69                 return MsgNative.taskGetName(this);
  70         }
  71         /** Gets the sender of the task */
  72         Process getSender() {
  73                 return MsgNative.taskGetSender(this);
  74         }
  75         /** Gets the source of the task */
  76         public Host getSource()  {
  77                 return MsgNative.taskGetSource(this);
  78         }
  79         /** Gets the computing amount of the task */
  80         public double getComputeDuration() {
  81                 return MsgNative.taskGetComputeDuration(this);
  82         }
  83         /** Gets the remaining computation of the task */
  84         public double getRemainingDuration() {
  85                 return MsgNative.taskGetRemainingDuration(this);
  86         }
  87         /**
  88          * This method sets the priority of the computation of the task.
  89          * The priority doesn't affect the transfert rate. For example a
  90          * priority of 2 will make the task receive two times more cpu than
  91          * the other ones.
  92          *
  93          * @param priority      The new priority of the task.
  94          */
  95         public void setPriority(double priority) {
  96                 MsgNative.taskSetPriority(this, priority);
  97         }
  98         /* *                       * *
  99          * * Communication-related * *
 100          * *                       * */
 101
 102
 103         /* *                     * *
 104          * * Computation-related * *
 105          * *                     * */
 106         /**
 107          * Executes a task on the location on which the process is running.
 108          *
 109          * @exception HostFailureException,TaskCancelledException
 110          */
 111         public void execute() throws HostFailureException,TaskCancelledException {
 112                 MsgNative.taskExecute(this);
 113         }
 114         /**
 115          * Cancels a task.
 116          *
 117          * @exception NativeException if the cancellation failed.
 118          */
 119         public void cancel()  {
 120                 MsgNative.taskCancel(this);
 121         }
 122         /** Deletes a task.
 123          *
 124          * @exception                   NativeException if the destruction failed.
 125          */
 126         protected void finalize() throws NativeException {
 127                 if (this.bind != 0)
 128                         MsgNative.taskDestroy(this);
 129         }
 130
 131         /**
 132          * Sends the task on the mailbox identified by the specified name
 133          *
 134          * @throws TimeoutException
 135          * @throws HostFailureException
 136          * @throws TransferFailureException
 137          */
 138         public void send(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 139                 MsgNative.taskSend(mailbox, this, -1);
 140         }
 141
 142         /**
 143          * Sends the task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 144          *
 145          * @exception  NativeException if the retrieval fails.
 146          * @throws TimeoutException
 147          * @throws HostFailureException
 148          * @throws TransferFailureException
 149          */
 150         public void send(String mailbox, double timeout) throws NativeException, TransferFailureException, HostFailureException, TimeoutException {
 151                 MsgNative.taskSend(mailbox, this, timeout);
 152         }
 153
 154         /**
 155          * Sends the task on the mailbox identified by the specified alias  (capping the sending rate to \a maxrate)
 156          *
 157          * @exception  TransferFailureException, HostFailureException, TimeoutException.
 158          */
 159         public void sendBounded(String alias, double maxrate) throws TransferFailureException, HostFailureException, TimeoutException {
 160                 MsgNative.taskSendBounded(alias, this, maxrate);
 161         }
 162
 163         /**
 164          * Retrieves next task from the mailbox identified by the specified name
 165          *
 166          * @exception  TransferFailureException, HostFailureException, TimeoutException if the retrieval fails.
 167          */
 168
 169         public static Task receive(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 170                 return MsgNative.taskReceive(mailbox, -1.0, null);
 171         }
 172
 173         /**
 174          * Retrieves next task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 175          *
 176          * @exception  TransferFailureException, HostFailureException, TimeoutException if the retrieval fails.
 177          */
 178         public static Task receive(String mailbox, double timeout) throws  TransferFailureException, HostFailureException, TimeoutException {
 179                 return MsgNative.taskReceive(mailbox, timeout, null);
 180         }
 181
 182         /**
 183          * Retrieves next task sent by a given host on the mailbox identified by the specified alias
 184          *
 185          * @exception  TransferFailureException, HostFailureException, TimeoutException if the retrieval fails.
 186          */
 187
 188         public static Task receive(String mailbox, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 189                 return MsgNative.taskReceive(mailbox, -1.0, host);
 190         }
 191
 192         /**
 193          * Retrieves next task sent by a given host on the mailbox identified by the specified alias (wait at most \a timeout seconds)
 194          *
 195          * @exception  TransferFailureException, HostFailureException, TimeoutException if the retrieval fails.
 196          */
 197         public static Task receive(String mailbox, double timeout, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 198                 return MsgNative.taskReceive(mailbox, timeout, host);
 199         }
 200
 201         /**
 202          * Tests whether there is a pending communication on the mailbox identified by the specified alias, and who sent it
 203          *
 204          */
 205         public static int listenFrom(String mailbox)  {
 206                 return MsgNative.taskListenFrom(mailbox);
 207         }
 208         /**
 209          * Listen whether there is a waiting task on the mailbox identified by the specified alias
 210          *
 211          */
 212         public static boolean listen(String mailbox)   {
 213                 return MsgNative.taskListen(mailbox);
 214         }
 215
 216         /**
 217          * Counts the number of tasks waiting to be received on the \a mailbox identified by the specified alia and sended by the specified \a host.
 218          *
 219          */
 220         public static int listenFromHost(String alias, Host host)   {
 221                 return MsgNative.taskListenFromHost(alias, host);
 222         }
 223 }