SAM Example 4

From SoOS

[edit] Description

This example shows how to execute a worker thread that writes to memory speculatively.

[edit] Code

#include <stdio.h>
#include <stdlib.h>
#include <sam.h>
 
#define N 1
#define ARRAY_SIZE 64
 
struct datast
{
  int *A;
};
 
void * worker_routine(void *args)
{
  SAM_t sam_context; /* Declare a SAM context variable */
  void *myargs; /* Pointer to where the arguments are stored */
  int *myArray; /* Pointer to the Array of the data */
  struct datast *data_arg; /* Pointer to the arguments of the function */
  int total; /* Store the variable of the calculation */
  int *result; /* Pointer to the result (total) of the calculation */
  SAM_pdif_t dif; /* The differential for the __SAM_ADDR__() macro*/
  int i;
 
 
  /* Start the execution of this worker thread */
  /* Extract the SAM context and the arguments */
  SAM_Execution_start(args, &sam_context, &myargs);
 
  /* Print the SAM worker ID of this worker thread  */
  printf("SAM worker id: %d\n", (int)SAM_My_workid(sam_context));
 
  /* Extract the arguments of the function */
  data_arg = (struct datast *) myargs;
  myArray = data_arg->A;
 
  total = 0;
 
  /* Declare the region as read by the worker thread */
  SAM_Memory_speculative_read(sam_context, SAM_My_workid(sam_context), myArray);
 
  /* Prepare the memory region for speculative write and obtain the differential parameter */
  dif = SAM_Memory_speculative_write_prepare(sam_context, myArray);
 
 
  /* Make some calculations... */
  for(i=0; i<ARRAY_SIZE; i++)
    {
      /* Example on how to use the __SAM_ADDR__() for reading */
      total += __SAM_ADDR__(myArray[i], dif);
      /* Example on how to use the __SAM_ADDR__() for writing */
      __SAM_ADDR__(myArray[i], dif) = __SAM_ADDR__(myArray[i], dif) *2;
    }
 
  total = total * (int)SAM_My_workid(sam_context);
 
  /* Print the total, but this value might not be valid */
  printf("Calculated %d: %d\n", (int)SAM_My_workid(sam_context), total);
 
  /* Finish the execution of this worker trhead */
  SAM_Execution_finish(sam_context);
 
  /* Reserve memory for the result and return it */
  result = (int *) malloc(sizeof(int));
  *result = total;
 
  return result;
}
 
int main(void)
{
  SAM_t sam_context; /* Declare a SAM context variable */
  SAM_Workerid_t th[N]; /* For storing the worker threads ID's  */
  int *result; /* Gets the result of the worker thread */
  int *myArray; /* Pointer to the array of the data */
  struct datast *data_arg; /* Pointer to the worker threads arguments */
  int i;
 
 
  myArray = (int *) malloc(ARRAY_SIZE *sizeof(int));
  data_arg = (struct datast *) malloc(sizeof(struct datast));
 
 
  /* Set some data into the Array */
  for(i=0; i<ARRAY_SIZE; i++)
    {
      myArray[i] = i + 1000;
    }
 
 
  /* Initialize the SAM context */
  SAM_Init(&sam_context);
 
  /* Setup the arguments we are going to send to the worker threads */
  data_arg->A = myArray;
 
 
  /* Register a region and protect it */
  SAM_Memory_region_register(sam_context, myArray, ARRAY_SIZE * sizeof(int));
  SAM_Memory_region_protect(sam_context, myArray);
 
 
  for(i=0;i<N;i++)
    {
      /* Create the worker threads running worker_routine  */
      th[i] = SAM_Execution_create(sam_context, *worker_routine, (void *)data_arg);
    }
 
  /* ---------------------------------------- */
  /* Prepare the region to write, this flashes back all the worker threads */
  /* that already accesed to this region of memory */
  SAM_Memory_write_prepare(sam_context, myArray);
  for(i=0; i<ARRAY_SIZE; i++)
    {
      /* Create a delay to allow some context switches */
      usleep(20*1000);
      /* Set a new value in the array elements*/
      myArray[i] = i;
    }
  /* Declare the region as written */
  SAM_Memory_write(sam_context, myArray);
  /* ---------------------------------------- */
 
 
  for(i=0;i<N;i++)
    {
      /* Join the worker threads and get the result */
      result = (int *)SAM_Execution_join(sam_context, th[i]);
 
      /* Print the result */
      printf("RES %d: %d\n", i, *result);
 
      /* Do not forget to free the memory reserved to store the result */
      free(result);
    }
 
  /* Release and unregister the memory region*/
  SAM_Memory_region_release(sam_context, myArray);
  SAM_Memory_region_unregister(sam_context, myArray);
 
 
  /* Destroy the SAM context */
  SAM_Destroy(&sam_context);
 
  /* Show the array after memory speculative writing */
  for(i=0; i<ARRAY_SIZE; i++)
    {
      printf("%d - %d\n", i, myArray[i]);
    }
 
  /* Free the memory */
  free(myArray);
  free(data_arg);
 
  return 0;
}

[edit] Explanation

This example shows how to execute a worker thread that writes to memory speculatively and flashes back when dependencies are detected.

To write speculatively first we have to declare a SAM_pdif_t variable (line 21) that stores the result of the call to the function SAM_Memory_write_prepare(), in the line 42, that will create a copy of the memory region into which the reads and writes are carried out using the macro __SAM_ADDR__(), which translates the memory addresses, as shown in the lines 49 and 51.

In the for loop in the line 145, the data array is printed on the screen, after the commits from the speculative writing is accepted as correct and merged into the memory of the main thread.

[edit] Compile Command

gcc example4.c -lsam -lpthread -o example4

[edit] Download

example4.c