Data Propogation to different thread via Shared Variable

1. Design has three modules in UT level, Transmit sends data from the array in 
   an autonmous thread, interface receives data and passes it on to the display
   block.
         ___________          ___________          ___________
        |           |        |           |        |           |
        | Transmit  |--------| Interface |--------|  Display  | 
        |___________|        |___________|        |___________|
  
2. Interface block has three threads, one a slave thread sensitive to input and 
   two clock sensitive thread. Input sensitive thread notify an events ( event
   scheduling ) for every input, the clock sensitve thread wait to receive event
   notification , in this case the variable is shared between two threads inter_f1
   & inter_f2 to transfer data to the display block. 
   
3. Waits are inserted in different threads. The transmit block has a thread
   transmit_f, which writes data from an array to the master port, resulting in
   invocation of all slave processes (inter_f0 in this case). This slave process
   determines if the data changed, if so, it generates an event. 

   The sc_thread inter_f1, is sensitive to the clock, in which it monitors the 
   input-events to occur, with two MS wait. inter_f2, is sensitive to the clock, 
   in which it monitors the input-events to occur, with one MS wait. Subsequent 
   clock edges are ignored. Event-scheduling and monitoring must not be separated 
   by more than a delta cycle. On input-event trigger, data is written to the 
   outmaster port of interface instance. which results in writing value to the 
   in-slave port of display instance.
   
   Also, the time is represented in the new notaion of sc_time. The data is 
   transmitted at each clock edge, which has a period of 5 time units, and a 
   duty cycle of 0.5, and start-offset of zero. Each clock-edge generates a 
   new data. 

This tests for a data propagation to different threads via shared 
variable temp1 with global scope within interface.h . Data is
stored in one thread, and retrieved from the same variable in another
thread - both threads are in the same block. In inter_f1() which is
sensitive to the positive edge of the clock, data is stored in the shared
variable when event trigger is seen within the delta cycle. The
inter_f2() is sensitive to the negative edge of the clock, retrieves 
the data from the shared variable and sends it to the display.

A result of this test case is also available in result.log file, which illustrates
the sequence of operation such as Interface block waiting for an event notification,
when the transmit block sends data at every clock edge, the event is notified & the
Interface block passes the same to dispaly block & we see that sucessful receiving of
data in the display block.
