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         /** Send the task asynchronously on the mailbox identified by the specified name,
 141          *  with no way to retrieve whether the communication succeeded or not
 142          *
 143          */
 144         public void dsend(String mailbox) {
 145                 MsgNative.taskDSend(mailbox, this);
 146         }
 147
 148         /**
 149          * Sends the task on the mailbox identified by the specified name
 150          *
 151      * @param mailbox
 152      * @throws TimeoutException
 153          * @throws HostFailureException
 154          * @throws TransferFailureException
 155          */
 156         public void send(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 157                 MsgNative.taskSend(mailbox, this, -1);
 158         }
 159
 160         /**
 161          * Sends the task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 162          *
 163      * @param mailbox
 164      * @param timeout
 165      * @exception  NativeException if the retrieval fails.
 166          * @throws TimeoutException
 167          * @throws HostFailureException
 168          * @throws TransferFailureException
 169          */
 170         public void send(String mailbox, double timeout) throws NativeException, TransferFailureException, HostFailureException, TimeoutException {
 171                 MsgNative.taskSend(mailbox, this, timeout);
 172         }
 173
 174         /**
 175          * Sends the task on the mailbox identified by the specified alias  (capping the sending rate to \a maxrate)
 176          *
 177      * @param alias
 178      * @param maxrate
 179      * @throws TransferFailureException
 180      * @throws HostFailureException
 181      * @throws TimeoutException
 182          */
 183         public void sendBounded(String alias, double maxrate) throws TransferFailureException, HostFailureException, TimeoutException {
 184                 MsgNative.taskSendBounded(alias, this, maxrate);
 185         }
 186
 187         /**
 188          * Retrieves next task from the mailbox identified by the specified name
 189          *
 190      * @param mailbox
 191      * @return
 192      * @throws TransferFailureException
 193      * @throws HostFailureException
 194      * @throws TimeoutException
 195          */
 196
 197         public static Task receive(String mailbox) throws TransferFailureException, HostFailureException, TimeoutException {
 198                 return MsgNative.taskReceive(mailbox, -1.0, null);
 199         }
 200
 201         /**
 202          * Retrieves next task on the mailbox identified by the specified name (wait at most \a timeout seconds)
 203          *
 204      * @param mailbox
 205      * @param timeout
 206      * @return
 207      * @throws TransferFailureException
 208      * @throws HostFailureException
 209      * @throws TimeoutException
 210          */
 211         public static Task receive(String mailbox, double timeout) throws  TransferFailureException, HostFailureException, TimeoutException {
 212                 return MsgNative.taskReceive(mailbox, timeout, null);
 213         }
 214
 215         /**
 216          * Retrieves next task sent by a given host on the mailbox identified by the specified alias
 217          *
 218      * @param mailbox
 219      * @param host
 220      * @return
 221      * @throws TransferFailureException
 222      * @throws TimeoutException
 223      * @throws HostFailureException
 224          */
 225
 226         public static Task receive(String mailbox, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 227                 return MsgNative.taskReceive(mailbox, -1.0, host);
 228         }
 229
 230         /**
 231          * Retrieves next task sent by a given host on the mailbox identified by the specified alias (wait at most \a timeout seconds)
 232          *
 233      * @param mailbox
 234      * @param timeout
 235      * @param host
 236      * @return
 237      * @throws TransferFailureException
 238      * @throws HostFailureException
 239      * @throws TimeoutException
 240          */
 241         public static Task receive(String mailbox, double timeout, Host host) throws TransferFailureException, HostFailureException, TimeoutException {
 242                 return MsgNative.taskReceive(mailbox, timeout, host);
 243         }
 244
 245         /**
 246          * Tests whether there is a pending communication on the mailbox identified by the specified alias, and who sent it
 247          *
 248      *
 249      * @param mailbox
 250      * @return
 251      */
 252         public static int listenFrom(String mailbox)  {
 253                 return MsgNative.taskListenFrom(mailbox);
 254         }
 255         /**
 256          * Listen whether there is a waiting task on the mailbox identified by the specified alias
 257          *
 258      *
 259      * @param mailbox
 260      * @return
 261      */
 262         public static boolean listen(String mailbox)   {
 263                 return MsgNative.taskListen(mailbox);
 264         }
 265
 266         /**
 267          * 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.
 268          *
 269      *
 270      * @param alias
 271      * @param host
 272      * @return
 273      */
 274         public static int listenFromHost(String alias, Host host)   {
 275                 return MsgNative.taskListenFromHost(alias, host);
 276         }
 277 }