reduction.java.bak

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

/*

   Where there are no comments below, insert them

   Such comments should explain the purpose of important
   aspects of the code, and document classes, methods etc.

   They should communicate useful information, not merely
   state the obvious  (e.g." i:=i+1 // add 1 to i" will lose
   marks).

*/

public class Reduction{

  CubbyHole [] storage;             // data parallel "machine" "pvar"
  int inArrayLength;                // length of intput array
  public BarrierSynch waiting;      // object for barrier synchronisation.
  NodeThread 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 Reduce(ApplyObj applic,Object[] inArray){

    inArrayLength = inArray.length;  // get the length from input array
    this.applic = applic;

    storage = new CubbyHole[inArrayLength];

    initializeStorage(inArray);

    number_of_iters = (int) Math.ceil(Math.log(
                                 (double)inArrayLength)/
				      Math.log(2.0));// how many times the iterations . for example , 6 element shuold hace 3 iteration


    // 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++) {
                System.out.println( "reduction result " + storage[j].get());
                }// display the differernt vaule of the array for each step
      System.out.println("************************"+"STEP " + i);
        startThreads();                    // start DP step

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



    };  // end for

/*
  QUESTION 1:

   Reduce, and all the threads, participate in the barrier.

   The program may behave incorrectly if only the threads use the
   barrier. Explain why.

   Write your answer here:

ANSWER:

In this code, Reduce is a supervisor thread and the startThread () creates the threads.
In the first step, this method creates the old threads. These threads compute  and
update the data. After that the supervisor (Reduce) should make sure that all threads
already finished their work. Then, new threads can use the data that already updated
by old threads for next computation. Thus, we must ensure that both threads and
Reduce must participate the barrier. Just threats participating the barrier not supervisor
will cause problems.For instance, some old threads do not finished their work and the
new threads try to access the data that are still processing by the old threads. Thus,
the data are corrupted and the result may be wrong.

*/


    System.out.println("Finished -- what a relief");
    return storage[0].get();// display the finall result

  }

  /* ==========================================================
     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]);
    }

  }

/*
  QUESTION 2:

   What would be the effect on the behaviour of your data
   parallel emulation if the methods of class CubbyHole
   were not synchronized?

   Explain briefly in a few lines inserted here:

ANSWER:
Class CubbyHole must employ synchronized. Synchronized just like a
semaphore can avoid the race condition and protect the critical section.
For example, if a thread needs to "get" an object in CubbyHole, then the
object will be locked. No other thread can access this object until this
thread finish to use this object. If class CubbyHole does not invoke the
synchronized mechanism, then every thread can access the critical section
in same time, which is a problem just like writer and reader problem.
For example, one thread read a value of an object is 100, at the same time
another thread write this value to 0. So, to avoid this situation, the class CubbyHole
must employ the synchronized mechanism.

*/


  /* ==============================================================
     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 NodeThread(this,i);
      nthread.start();
    }
  }

}

class NodeThread extends Thread{

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


  NodeThread(Reduction 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 reduction 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>

    // this is the code executed by individual "processors" in a
    // data parallel step: remember to determine active/inactive threads

    // The code below this line needs to be modified...
    // at the moment it does almost nothing.


    int step;
       step=(int)Math.pow((double)2,((double)myParent.i-1));// myParent.i is the number of step
       //
       if(((myId%((int)Math.pow((double)2,(double)myParent.i))))==0){
               if((myId+step)<myParent.inArrayLength){
                       myCubby.put(myApplic.f(myCubby.get(),myParent.storage[myId+step].get()));
               }

       }

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

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

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


   }


  }