Robust/src/Benchmarks/SingleTM/LeeRouting/LeeThread.java

   1 /*
   2  * BSD License
   3  *
   4  * Copyright (c) 2007, The University of Manchester (UK)
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  *     - Redistributions of source code must retain the above copyright
  13  *       notice, this list of conditions and the following disclaimer.
  14  *     - Redistributions in binary form must reproduce the above
  15  *       copyright notice, this list of conditions and the following
  16  *       disclaimer in the documentation and/or other materials provided
  17  *       with the distribution.
  18  *     - Neither the name of the University of Manchester nor the names
  19  *       of its contributors may be used to endorse or promote products
  20  *       derived from this software without specific prior written
  21  *       permission.
  22
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /********************************************************************
  37  *  Ported for our STM implementation
  38  *  This version copyright(c) University of California, Irvine 2009
  39  *  @author:  Alokika Dash, adash@uci.edu
  40  *  @date:    04/05/2009
  41  ********************************************************************/
  42 public class LeeThread extends Thread {
  43   public boolean stop;
  44   boolean finished;
  45   public boolean sampleNow;
  46   public boolean doneSample;
  47   public long totalLaidTracks;
  48   public long myLaidTracks;
  49   LeeRouter lt;
  50   WorkQueue t;
  51   boolean done;
  52   //  int[][][] tempg;
  53
  54   /*
  55   protected static ThreadLocal<ThreadState> _threadState = new ThreadLocal<ThreadState>() {
  56     protected synchronized ThreadState initialValue() {
  57       return new ThreadState();
  58     }
  59   };
  60   static ThreadLocal<Thread> _thread = new ThreadLocal<Thread>() {
  61     protected synchronized Thread initialValue() {
  62       return null;
  63     }
  64   };
  65   */
  66
  67   LeeThread(LeeRouter lt) {
  68     stop = false;
  69     finished = false;
  70     sampleNow = false;
  71     doneSample = true;
  72     totalLaidTracks=0;
  73     myLaidTracks=0;
  74     done = true;
  75     this.lt = lt;
  76   }
  77
  78   public void run() {
  79     int [][][] tempg = scratch new int[lt.GRID_SIZE][lt.GRID_SIZE][2]; // Lee 2D Grid copy
  80     while (!finished && !stop) {
  81       if(sampleNow) {
  82         //collectMyStatistics();
  83         doneSample = true;
  84         sampleNow = false;
  85       }
  86       if(done) {
  87         atomic {
  88           t = lt.getNextTrack();
  89           done = false;
  90         }
  91       }
  92       if(t==null) {
  93         finished = true;
  94         System.out.println("Finished");
  95         //collectMyStatistics();
  96         //collectStatistics(_threadState.get());
  97         break;
  98       } else {
  99           atomic {
 100           //System.out.println("Laying track "+t.nn);
 101               lt.layNextTrack(t, tempg);
 102           done = true;
 103         }
 104         //updateStatistics();
 105       }
 106     }
 107   }
 108
 109
 110   /*
 111   protected static void collectStatistics(ThreadState threadState) {
 112     // collect statistics
 113     //synchronized (lock){
 114     totalLaidTracks+=threadState.myLaidTracks;
 115     threadState.reset();  // set up for next iteration
 116     //}
 117   }
 118
 119   public void updateStatistics(){
 120     _threadState.get().myLaidTracks++;
 121   }
 122
 123   public void collectMyStatistics() {
 124     myLaidTracks=_threadState.get().myLaidTracks-myLaidTracks;
 125   }
 126   */
 127
 128   public void resetMyStatistics() {
 129     myLaidTracks=0;
 130   }
 131
 132 }
 133
 134 /**
 135  * Class that holds thread's actual state
 136  */
 137 public class ThreadState {
 138   private long myLaidTracks;        // number of laid tracks
 139
 140   /**
 141    * Creates new ThreadState
 142    */
 143   public ThreadState() {
 144     myLaidTracks = 0;
 145   }
 146
 147   /**
 148    * Resets any metering information (commits/aborts, etc).
 149    */
 150   public void reset() {
 151     myLaidTracks = 0;            // total number of transactions
 152   }
 153
 154   /**
 155    * used for debugging
 156    * @return string representation of thread state
 157    */
 158   public String toString() {
 159     return
 160       "Thread" + hashCode() + "["+
 161       "total: " +  myLaidTracks + "," +
 162       "]";
 163   }
 164
 165 }
 166