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
  76     this.lt = lt;
  77     tempg = new int[lt.GRID_SIZE][lt.GRID_SIZE][2]; // Lee 2D Grid copy
  78   }
  79
  80   public void run() {
  81     while (!finished && !stop) {
  82       if(sampleNow) {
  83         //collectMyStatistics();
  84         doneSample = true;
  85         sampleNow = false;
  86       }
  87       if(done) {
  88         atomic {
  89           t = lt.getNextTrack();
  90           done = false;
  91         }
  92       }
  93       if(t==null) {
  94         finished = true;
  95         System.out.println("Finished");
  96         //collectMyStatistics();
  97         //collectStatistics(_threadState.get());
  98         break;
  99       } else {
 100         atomic {
 101           //System.out.println("Laying track "+t.nn);
 102           lt.layNextTrack(t, tempg);
 103           done = true;
 104         }
 105         //updateStatistics();
 106       }
 107     }
 108   }
 109
 110
 111   /*
 112   protected static void collectStatistics(ThreadState threadState) {
 113     // collect statistics
 114     //synchronized (lock){
 115     totalLaidTracks+=threadState.myLaidTracks;
 116     threadState.reset();  // set up for next iteration
 117     //}
 118   }
 119
 120   public void updateStatistics(){
 121     _threadState.get().myLaidTracks++;
 122   }
 123
 124   public void collectMyStatistics() {
 125     myLaidTracks=_threadState.get().myLaidTracks-myLaidTracks;
 126   }
 127   */
 128
 129   public void resetMyStatistics() {
 130     myLaidTracks=0;
 131   }
 132
 133 }
 134
 135 /**
 136  * Class that holds thread's actual state
 137  */
 138 public class ThreadState {
 139   private long myLaidTracks;        // number of laid tracks
 140
 141   /**
 142    * Creates new ThreadState
 143    */
 144   public ThreadState() {
 145     myLaidTracks = 0;
 146   }
 147
 148   /**
 149    * Resets any metering information (commits/aborts, etc).
 150    */
 151   public void reset() {
 152     myLaidTracks = 0;            // total number of transactions
 153   }
 154
 155   /**
 156    * used for debugging
 157    * @return string representation of thread state
 158    */
 159   public String toString() {
 160     return
 161       "Thread" + hashCode() + "["+
 162       "total: " +  myLaidTracks + "," +
 163       "]";
 164   }
 165
 166 }
 167