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 org.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      * @return
  69      */
  70         public String getName() {
  71                 return MsgNative.taskGetName(this);
  72         }
  73         /** Gets the sender of the task */
  74         Process getSender() {
  75                 return MsgNative.taskGetSender(this);
  76         }
  77     /** Gets the source of the task
  78      * @return
  79      */
  80         public Host getSource()  {
  81                 return MsgNative.taskGetSource(this);
  82         }
  83     /** Gets the computing amount of the task
  84      * @return
  85      */
  86         public double getComputeDuration() {
  87                 return MsgNative.taskGetComputeDuration(this);
  88         }
  89     /** Gets the remaining computation of the task
  90      * @return
  91      */
  92         public double getRemainingDuration() {
  93                 return MsgNative.taskGetRemainingDuration(this);
  94         }
  95         /**
  96          * This method sets the priority of the computation of the task.
  97          * The priority doesn't affect the transfer rate. For example a
  98          * priority of 2 will make the task receive two times more cpu than
  99          * the other ones.
 100          *
 101          * @param priority      The new priority of the task.
 102          */
 103         public void setPriority(double priority) {
 104                 MsgNative.taskSetPriority(this, priority);
 105         }
 106         /* *                       * *
 107          * * Communication-related * *
 108          * *                       * */
 109
 110
 111         /* *                     * *
 112          * * Computation-related * *
 113          * *                     * */
 114         /**
 115          * Executes a task on the location on which the process is running.
 116          *
 117      *
 118      * @throws HostFailureException
 119      * @throws TaskCancelledException
 120      */
 121         public void execute() throws HostFailureException,TaskCancelledException {
 122                 MsgNative.taskExecute(this);
 123         }
 124         /**
 125          * Cancels a task.
 126          *
 127          */
 128         public void cancel()  {
 129                 MsgNative.taskCancel(this);
 130         }
 131         /** Deletes a task.
 132          *
 133          * @exception                   NativeException if the destruction failed.
 134          */
 135         protected void finalize() throws NativeException {
 136                 if (this.bind != 0)
 137                         MsgNative.taskDestroy(this);
 138         }
 139
 140
 141         /** Send the task asynchronously on the mailbox identified by the specified name,
 142          *  with no way to retrieve whether the communication succeeded or not
 143          *
 144          */
 145         public void dsend(String mailbox) {
 146                 MsgNative.taskDSend(mailbox, this);
 147         }
 148
 149         /**
 150          * Sends the task on the mailbox identified by the specified name
 151          *
 152      * @param mailbox
 153      * @throws TimeoutException
 154          * @throws HostFailureException
 155          * @throws TransferFailureException
 156          */
 157         public void send(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 158                 MsgNative.taskSend(mailbox, this, -1);
 159         }
 160
 161         /**
 162          * Sends the task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 163          *
 164      * @param mailbox
 165      * @param timeout
 166      * @exception  NativeException if the retrieval fails.
 167          * @throws TimeoutException
 168          * @throws HostFailureException
 169          * @throws TransferFailureException
 170          */
 171         public void send(String mailbox, double timeout) throws NativeException, TransferFailureException, HostFailureException, TimeoutException {
 172                 MsgNative.taskSend(mailbox, this, timeout);
 173         }
 174
 175         /**
 176          * Sends the task on the mailbox identified by the specified alias  (capping the sending rate to \a maxrate)
 177          *
 178      * @param alias
 179      * @param maxrate
 180      * @throws TransferFailureException
 181      * @throws HostFailureException
 182      * @throws TimeoutException
 183          */
 184         public void sendBounded(String alias, double maxrate) throws TransferFailureException, HostFailureException, TimeoutException {
 185                 MsgNative.taskSendBounded(alias, this, maxrate);
 186         }
 187         /**
 188          * Starts listening for receiving a task from an asynchronous communication
 189          * @param mailbox
 190          * @return
 191          */
 192         public static Comm irecv(String mailbox) {
 193                 Comm comm = new Comm();
 194                 irecvBind(comm,mailbox);
 195                 return comm;
 196         }
 197         public static native void irecvBind(Comm comm, String mailbox);
 198         /**
 199          * Retrieves next task from the mailbox identified by the specified name
 200          *
 201      * @param mailbox
 202      * @return
 203      * @throws TransferFailureException
 204      * @throws HostFailureException
 205      * @throws TimeoutException
 206          */
 207
 208         public static Task receive(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 209                 return MsgNative.taskReceive(mailbox, -1.0, null);
 210         }
 211
 212         /**
 213          * Retrieves next task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 214          *
 215      * @param mailbox
 216      * @param timeout
 217      * @return
 218      * @throws TransferFailureException
 219      * @throws HostFailureException
 220      * @throws TimeoutException
 221          */
 222         public static Task receive(String mailbox, double timeout) throws  TransferFailureException, HostFailureException, TimeoutException {
 223                 return MsgNative.taskReceive(mailbox, timeout, null);
 224         }
 225
 226         /**
 227          * Retrieves next task sent by a given host on the mailbox identified by the specified alias
 228          *
 229      * @param mailbox
 230      * @param host
 231      * @return
 232      * @throws TransferFailureException
 233      * @throws TimeoutException
 234      * @throws HostFailureException
 235          */
 236
 237         public static Task receive(String mailbox, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 238                 return MsgNative.taskReceive(mailbox, -1.0, host);
 239         }
 240
 241         /**
 242          * Retrieves next task sent by a given host on the mailbox identified by the specified alias (wait at most \a timeout seconds)
 243          *
 244      * @param mailbox
 245      * @param timeout
 246      * @param host
 247      * @return
 248      * @throws TransferFailureException
 249      * @throws HostFailureException
 250      * @throws TimeoutException
 251          */
 252         public static Task receive(String mailbox, double timeout, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 253                 return MsgNative.taskReceive(mailbox, timeout, host);
 254         }
 255
 256         /**
 257          * Tests whether there is a pending communication on the mailbox identified by the specified alias, and who sent it
 258          *
 259      *
 260      * @param mailbox
 261      * @return
 262      */
 263         public static int listenFrom(String mailbox)  {
 264                 return MsgNative.taskListenFrom(mailbox);
 265         }
 266         /**
 267          * Listen whether there is a waiting task on the mailbox identified by the specified alias
 268          *
 269      *
 270      * @param mailbox
 271      * @return
 272      */
 273         public static boolean listen(String mailbox)   {
 274                 return MsgNative.taskListen(mailbox);
 275         }
 276
 277         /**
 278          * 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.
 279          *
 280      *
 281      * @param alias
 282      * @param host
 283      * @return
 284      */
 285         public static int listenFromHost(String alias, Host host)   {
 286                 return MsgNative.taskListenFromHost(alias, host);
 287         }
 288 }