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