src/java/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  * Since most scheduling algorithms rely on a concept of
  16  * task that can be either computed locally or transferred
  17  * on another processor, it seems to be the right level of
  18  * abstraction for our purposes. A task may then be defined
  19  * by a computing amount, a message size and some private
  20  * data. To transfer a task you use an instance of the class
  21  * Channel identified by an number.
  22  *
  23  * @author  Abdelmalek Cherier
  24  * @author  Martin Quinson
  25  * @since SimGrid 3.3
  26  */
  27 public class Task {
  28
  29         /**
  30          * This attribute represents a bind between a java task object and
  31          * a native task. Even if this attribute is public you must never
  32          * access to it. It is set automaticatly during the build of the object.
  33          */
  34   public long bind = 0;
  35
  36
  37   /* Default constructor (disabled) */
  38   protected Task() {
  39   }
  40   /* *              * *
  41    * * Constructors * *
  42          * *              * *//**
  43          * Construct an new task with the specified processing amount and amount
  44          * of data needed.
  45          *
  46          * @param name  Task's name
  47          *
  48          * @param computeDuration       A value of the processing amount (in flop) needed to process the task.
  49          *                              If 0, then it cannot be executed with the execute() method.
  50          *                              This value has to be >= 0.
  51          *
  52          * @param messageSize           A value of amount of data (in bytes) needed to transfert this task.
  53          *                              If 0, then it cannot be transfered with the get() and put() methods.
  54          *                              This value has to be >= 0.
  55          *
  56          * @exception                   JniException if the binding mecanism fails.
  57          */ public Task(String name, double computeDuration,
  58                  double messageSize) throws JniException {
  59     MsgNative.taskCreate(this, name, computeDuration, messageSize);
  60   }
  61     /**
  62      * Construct an new parallel task with the specified processing amount and amount for each host
  63      * implied.
  64      *
  65      * @param name              The name of the parallel task.
  66      * @param hosts             The list of hosts implied by the parallel task.
  67      * @param computeDurations  The amount of operations to be performed by each host of @hosts.
  68      * @param messageSizes      A matrix describing the amount of data to exchange between hosts.
  69      *
  70      * @exception               JniException if the binding mecanism fails.
  71      */ public Task(String name, Host[]hosts, double[]computeDurations,
  72                     double[]messageSizes) throws JniException {
  73     MsgNative.parallelTaskCreate(this, name, hosts, computeDurations,
  74                                  messageSizes);
  75   }
  76   /* *                   * *
  77    * * Getters / Setters * *
  78          * *                   * *//**
  79          * This method gets the name of a task.
  80          *
  81          * @return                              The name of the task.
  82          *
  83          * @exception                   JniException if the binding mecanism fails.
  84          * @exception                   InvalidTaskException is the specified task is not valid. A task
  85          *                                              is invalid if it is not binded with a native task.
  86          */ public String getName() throws JniException {
  87     return MsgNative.taskGetName(this);
  88   }
  89         /**
  90          * This method gets the sender of the task.
  91          *
  92          * @return                              The sender of the task.
  93          *
  94          * @exception                   JniException if the binding mecanism fails.
  95          *
  96          */ Process getSender() throws JniException {
  97     return MsgNative.taskGetSender(this);
  98   }
  99          /**
 100           * This method gets the source of the task.
 101           *
 102           * @return                             The source of the task.
 103           *
 104           * @exception                  JniException if the binding mecanism fails.
 105           */ public Host getSource() throws JniException, NativeException {
 106     return MsgNative.taskGetSource(this);
 107   }
 108         /**
 109          * This method gets the computing amount of the task.
 110          *
 111          * @return                              The computing amount of the task.
 112          *
 113          * @exception                   JniException if the binding mecanism fails.
 114          */ public double getComputeDuration() throws JniException {
 115     return MsgNative.taskGetComputeDuration(this);
 116   }
 117         /**
 118          * This method gets the remaining computation.
 119          *
 120          * @return                              The remaining duration.
 121          *
 122          * @exception                   JniException if the binding mecanism fails.
 123          */ public double getRemainingDuration() throws JniException {
 124     return MsgNative.taskGetRemainingDuration(this);
 125   }
 126         /**
 127          * This method sets the priority of the computation of the task.
 128          * The priority doesn't affect the transfert rate. For example a
 129          * priority of 2 will make the task receive two times more cpu than
 130          * the other ones.
 131          *
 132          * @param                               The new priority of the task.
 133          *
 134          * @exception                   InvalidTaskException is the specified task is not valid. A task
 135          *                                              is invalid if it is not binded with a native task.
 136          */ public void setPrirority(double priority) throws JniException {
 137     MsgNative.taskSetPriority(this, priority);
 138   }
 139   /* *                       * *
 140    * * Communication-related * *
 141     * *                       * *//**
 142     * Retrieves next task on given channel of local host
 143     *
 144     * @exception  JniException if the binding mecanism fails.
 145     * @exception  NativeException if the retrival fails.
 146     */
 147     public static Task get(int channel) throws JniException, NativeException {
 148     return MsgNative.taskGet(channel, -1.0, null);
 149   }
 150    /**
 151     * Retrieves next task on given channel of local host (wait at most #timeout seconds)
 152     *
 153     * @exception  JniException if the binding mecanism fails.
 154     * @exception  NativeException if the retrival fails.
 155     */
 156     public static Task get(int channel, double timeout) throws JniException,
 157     NativeException {
 158     return MsgNative.taskGet(channel, timeout, null);
 159   }
 160    /**
 161     * Retrieves next task from given host on given channel of local host
 162     *
 163     * @exception  JniException if the binding mecanism fails.
 164     * @exception  NativeException if the retrival fails.
 165     */
 166     public static Task get(int channel, Host host) throws JniException,
 167     NativeException {
 168     return MsgNative.taskGet(channel, -1, host);
 169   }
 170    /**
 171     * Retrieves next task from given host on given channel of local host (wait at most #timeout seconds)
 172     *
 173     * @exception  JniException if the binding mecanism fails.
 174     * @exception  NativeException if the retrival fails.
 175     */ public static Task get(int channel, double timeout,
 176                               Host host) throws JniException, NativeException {
 177     return MsgNative.taskGet(channel, timeout, host);
 178   }
 179    /**
 180     * Probes whether there is a waiting task on the given channel of local host
 181     *
 182     * @exception  JniException if the binding mecanism fails.
 183     * @exception  NativeException if the retrival fails.
 184     */ public static boolean probe(int channel) throws JniException {
 185     return MsgNative.taskProbe(channel);
 186   }
 187    /**
 188     * Counts tasks waiting on the given #channel of local host and sent by given #host
 189     *
 190     * @exception  JniException if the binding mecanism fails.
 191     */ public static int probe(int channel, Host host) throws JniException {
 192     return MsgNative.taskProbeHost(channel, host);
 193   }
 194   /* *                     * *
 195    * * Computation-related * *
 196          * *                     * *//**
 197          * This method execute a task on the location on which the
 198          * process is running.
 199          *
 200          * @exception JniException if the binding mecanism fails.
 201          * @exception NativeException if the cancelation failed.
 202          */ public void execute() throws JniException, NativeException {
 203     MsgNative.taskExecute(this);
 204   }
 205         /**
 206          * This method cancels a task.
 207          *
 208          * @exception JniException if the binding mecanism fails.
 209          * @exception NativeException if the cancelation failed.
 210          */ public void cancel() throws JniException, NativeException {
 211     MsgNative.taskCancel(this);
 212   }
 213         /**
 214          * This method deletes a task.
 215          *
 216          * @exception                   InvalidTaskException is the specified task is not valid. A task
 217          *                                              is invalid if it is not binded with a native task.
 218          *                                              MsgException if the destruction failed.
 219          */ protected void finalize() throws JniException, NativeException {
 220     if (this.bind != 0)
 221       MsgNative.taskDestroy(this);
 222 }}