scanner.java

this code is a parallel programming code . such code is esay but is very useful to understand how to

/**
 * <p>Title: Scanner
 * <p>Description: mulit reduction
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: </p>
 * @author :Tong Yuxin
 * @Student No. a1103993
 */

public class Scanner {

  CubbyHole [] storage;             // data parallel "machine" "pvar"
  CubbyHole [] temp;
  int inArrayLength;                // length of intput array
  public BarrierSynch waiting;      // object for barrier synchronisation.
  ScanThread nthread;               // temp var for starting threads
  ApplyObj applic;                  // the function passed in as a parameter

  int number_of_iters;              // total number of iterations
  int i,j;


  /* ==========================================================
     Main Method.. initialize; start up threads for DP step
     ==========================================================
  */

  public Object[] Scan(ApplyObj applic,Object[] inArray){

    inArrayLength = inArray.length;
    this.applic = applic;

    storage = new CubbyHole[inArrayLength];
    temp = new CubbyHole[inArrayLength];

    initializeStorage(inArray);

    number_of_iters = (int) Math.ceil(Math.log(
                                 (double)inArrayLength)/
                                      Math.log(2.0));


    // sample tracing code -- outputs "storage"

    for (j=0; j< inArrayLength; j++)
    {
      System.out.println( "^^ " +  storage[j].get());

      };

/*
   DATA PARALLEL STEPS -- make sure code for a step is complete
*/

      // this does only one DP step -- edit the loop control appropriately
   
              for (i=1; i <= number_of_iters; i++){

        waiting = new BarrierSynch(inArrayLength+1 ); // create barrier

        System.out.println("STEP " + i);   // trace: which DP step?

        for (j=0; j< inArrayLength; j++) {
            temp[j].put(storage[j].get());
        };
          System.out.println( "*********************************************");
        for (j=0; j< inArrayLength; j++) {

                        System.out.println( "temp " + temp[j].get()+" "+"storage " + storage[j].get());

                        }// display the differernt vaule of the array for each step
             System.out.println( "******************************************");

        startThreads();                    // start DP step



        waiting.iveArrived(999);          // Scan enters barrier




    };  // end for

    // sample tracing code -- outputs "storage"
   Object[] outArray = new Object[inArrayLength];

    for (i=0; i< inArrayLength; i++) {
      outArray[i] =  (Object) storage[i].get();
      //System.out.println( "^^" +  outArray[i]);
    }

          return outArray;
    //return storage[inArrayLength-1].get();

  }

  /* ==========================================================
     Fill up CubbyHoles with data from inArray
     ==========================================================
  */
  private void initializeStorage(Object[] inArray){
    int i;

    for (i=0;i<inArrayLength;i++){
      storage[i] = new CubbyHole();
      (storage[i]).put(inArray[i]);
      temp[i] = new CubbyHole();
      (temp[i]).put(inArray[i]);
    }

  }




  /* ==============================================================
     Start up threads with a pointer to this object plus a thread
     number.
     ==============================================================
  */
  private void startThreads(){
    int i = 0;
    for (i=0;i < inArrayLength; i++){
      nthread = new ScanThread(this,i);
      nthread.start();
    }
  }



class ScanThread extends Thread{

  int myId;
  BarrierSynch myBarrier;
  CubbyHole myCubby;
  Scanner myParent;
  ApplyObj myApplic;


  ScanThread(Scanner parent,int id){
    myId = id;
    myBarrier = parent.waiting;
    myCubby = parent.storage[id];
    myParent = parent;
    myApplic = parent.applic;
  }

  /* ==================================================================
     The run method is invoked by running start on each thread.
     Defining the code for this method is much of the work in your
     project. In this project run will implement the code for
     the part each thread plays in the partial multiplications process.
     This will generally involve using Myapplic and writing to
     myCubby  and other CubbyHoles.

     Barrier synchronizations is needed to provide end-of-step synch.
     Each thread will have a different role according
     to its thread number.
     ==================================================================
  */
  public void run(){


    // <insert code here>
      //create a interval step for reduce threads
    int step=(int)Math.pow((double)2,((double)myParent.i-1));// myParent.i is the number of step
    //decide whether or not the reduce threads have been already finished
    if(myId<myParent.inArrayLength-step){
           {

            myParent.storage[myId+step].put(myApplic.f(myParent.temp[myId].get(),myParent.temp[myId+step].get()));
            }

    }


    System.out.println("Hello there from thread: " + myId);



    System.out.println("Thread finished " + myId);

         myBarrier.iveArrived(myId);// Theads entry the barrier
   }


  }



}