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