Updated mt tests

diff --git a/mt/Makefile b/mt/Makefile
index 455f066fcc66ccec027ee3ccb372d7594ba2a1b2..1d85ed3cd97d55b3af625bdacfae5d00ef414f8e 100755 (executable)
--- a/mt/Makefile
+++ b/mt/Makefile
@@ -89,11 +89,9 @@ bt_vvadd\
 #--------------------------------------------------------------------
 
 RISCV_GCC = riscv-gcc
-RISCV_GCC_OPTS = -std=gnu99 -T common/test.ld -O3 -nostdlib -nostartfiles -funroll-all-loops
-RISCV_LINK = riscv-gcc -T $(common)/test.ld
-RISCV_LINK_MT = riscv-gcc -T $(common)/test-mt.ld
-RISCV_LINK_OPTS = -lc
-RISCV_LINK_SYSCALL = -I$(bmarkdir)/../env $(common)/syscalls.c -lc
+RISCV_GCC_OPTS = -Wa,-march=RVIMAFDXhwacha -std=gnu99 -O2 -ffast-math
+RISCV_LINK = riscv-gcc -T $(common)/test.ld $(incs) 
+RISCV_LINK_OPTS = -nostdlib -nostartfiles -ffast-math -lc
 RISCV_OBJDUMP = riscv-objdump --disassemble-all --disassemble-zeroes --section=.text --section=.text.startup --section=.data
 RISCV_SIM = spike -p2
 
@@ -121,8 +119,8 @@ bmarks_cycles = 80000
 %.hex: %
        elf2hex 16 32768 $< > $@
 
-$(bmarks_riscv_bin): %.riscv: %.o crt-mt.o
-       $(RISCV_LINK_MT) crt-mt.o $< $(RISCV_LINK_SYSCALL) -o $@
+$(bmarks_riscv_bin): %.riscv: %.o syscalls.o crt.o
+       $(RISCV_LINK) $< syscalls.o crt.o $(RISCV_LINK_OPTS) -o $@
 
 $(bmarks_riscv_dump): %.riscv.dump: %.riscv
        $(RISCV_OBJDUMP) $< > $@
@@ -131,7 +129,7 @@ $(bmarks_riscv_out): %.riscv.out: %.riscv
        $(RISCV_SIM) $< > $@
 
 %.o: %.c
-       $(RISCV_GCC) $(RISCV_GCC_OPTS) $(bmarks_defs) \
+       $(RISCV_GCC) $(RISCV_GCC_OPTS) $(bmarks_defs)  -D__ASSEMBLY__=1 \
                     -c $(incs) $< -o $@
 
 %.o: %.S

diff --git a/mt/ab_matmul/ab_matmul.c b/mt/ab_matmul/ab_matmul.c
index 0cd1bf52335311ac0ddadd28fd925a82fb161631..6530a5d105261a2eb73d108096db060b8f6a6ad5 100755 (executable)
--- a/mt/ab_matmul/ab_matmul.c
+++ b/mt/ab_matmul/ab_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -213,33 +213,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ab_matmul/matmul_mi.c b/mt/ab_matmul/matmul_mi.c
index 0cd1bf52335311ac0ddadd28fd925a82fb161631..6530a5d105261a2eb73d108096db060b8f6a6ad5 100755 (executable)
--- a/mt/ab_matmul/matmul_mi.c
+++ b/mt/ab_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -213,33 +213,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ab_vvadd/ab_vvadd.c b/mt/ab_vvadd/ab_vvadd.c
index 47f5e18790c068e58b749ae652d1cab47d5d016e..f2c8a6505773552d78d2592339119d4f4a8444fa 100755 (executable)
--- a/mt/ab_vvadd/ab_vvadd.c
+++ b/mt/ab_vvadd/ab_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -138,12 +138,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -151,21 +151,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ad_matmul/ad_matmul.c b/mt/ad_matmul/ad_matmul.c
index 04dd7efc5c1c924be52d9ccbecb2829a6243378e..da9aaecd71656d60d1262fac0c2a2aa644ef7b21 100755 (executable)
--- a/mt/ad_matmul/ad_matmul.c
+++ b/mt/ad_matmul/ad_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -163,33 +163,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ad_matmul/matmul_mi.c b/mt/ad_matmul/matmul_mi.c
index 04dd7efc5c1c924be52d9ccbecb2829a6243378e..da9aaecd71656d60d1262fac0c2a2aa644ef7b21 100755 (executable)
--- a/mt/ad_matmul/matmul_mi.c
+++ b/mt/ad_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -163,33 +163,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ad_vvadd/ad_vvadd.c b/mt/ad_vvadd/ad_vvadd.c
index 2dfd2bd840f18278e4f5954fe94e5c48028e0ea2..4b77dc5b1daef8b10b2d9f9624f7c0f6706542be 100755 (executable)
--- a/mt/ad_vvadd/ad_vvadd.c
+++ b/mt/ad_vvadd/ad_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -142,12 +142,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -155,21 +155,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ae_matmul/ae_matmul.c b/mt/ae_matmul/ae_matmul.c
index 7d4ad801aa2424f23cee4d6462e70173142b3c19..7a2e79d656baebc139dba68e973285ff7be44de8 100755 (executable)
--- a/mt/ae_matmul/ae_matmul.c
+++ b/mt/ae_matmul/ae_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -146,7 +146,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                        }
                }
        }
-       barrier();
+       barrier(ncores);
 
        for ( i = 0; i < lda; i+=4 ) {
                for ( j = coreid*(lda/ncores); j < (coreid+1)*(lda/ncores); j++ )  {
@@ -229,34 +229,34 @@ void thread_entry(int cid, int nc)
 
 /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 */
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ae_matmul/matmul_mi.c b/mt/ae_matmul/matmul_mi.c
index 5062141a784eef66d1387b25cab6c48068a142e4..cf464f410930b04b78c83cef609ae495da988954 100755 (executable)
--- a/mt/ae_matmul/matmul_mi.c
+++ b/mt/ae_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -146,7 +146,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                         }
                 }
         }
-        barrier();
+        barrier(nc);
 
        for ( int x = 0; x < ncores; x++) {
                //split the i values into two chunks so the threads don't interfere on the B loads
@@ -277,34 +277,34 @@ void thread_entry(int cid, int nc)
 
 /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 */
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ae_vvadd/ae_vvadd.c b/mt/ae_vvadd/ae_vvadd.c
index 0e6541b7a30543a5467ad3bce46a065a91e91c17..b1d336b01db48263cbecbe4464098ec24fbad07c 100755 (executable)
--- a/mt/ae_vvadd/ae_vvadd.c
+++ b/mt/ae_vvadd/ae_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -144,12 +144,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -157,21 +157,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/Ronald.c b/mt/af_matmul/Ronald.c
index 31ea15d52e314d1fad1c22713e6aac8211738cc3..796dbeb34cc95a030e919e9b984d697595499c24 100644 (file)
--- a/mt/af_matmul/Ronald.c
+++ b/mt/af_matmul/Ronald.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -214,33 +214,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/af_matmul.c b/mt/af_matmul/af_matmul.c
index c2d72ab8a11db1b0a0b4258020ebf39419247b05..4de06dd569165099f435acbcaf49ae841c447e26 100755 (executable)
--- a/mt/af_matmul/af_matmul.c
+++ b/mt/af_matmul/af_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -205,33 +205,33 @@ void thread_entry(int cid, int nc)
 
        
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/bestattemptthusfar.c b/mt/af_matmul/bestattemptthusfar.c
index ab8e7c18438f9e5d0084a90f5b9712019be410d7..8ca604d34cfd0cbd91bc6004cb0c2e1a2011f801 100644 (file)
--- a/mt/af_matmul/bestattemptthusfar.c
+++ b/mt/af_matmul/bestattemptthusfar.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -180,33 +180,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/bestattemptthusfar2.c b/mt/af_matmul/bestattemptthusfar2.c
index a35d30215eb896b9a40d63b4d3a41a6dae2b7093..3264360e1c1a0c1674ad20803c503e419ef60c09 100644 (file)
--- a/mt/af_matmul/bestattemptthusfar2.c
+++ b/mt/af_matmul/bestattemptthusfar2.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -206,33 +206,33 @@ void thread_entry(int cid, int nc)
 
        
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/failedattempt.c b/mt/af_matmul/failedattempt.c
index acd4a12c8eac2de6f9a84486bd8282e5edd30e33..f56168e29448528729c9d8c4421064c423ed2ce1 100644 (file)
--- a/mt/af_matmul/failedattempt.c
+++ b/mt/af_matmul/failedattempt.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -266,33 +266,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/failedattempt2.c b/mt/af_matmul/failedattempt2.c
index 049399874bc3b57d6277baff4c1dfbb8ac85a7d6..657c23d9422b03d2aceb647c569830b37286e475 100644 (file)
--- a/mt/af_matmul/failedattempt2.c
+++ b/mt/af_matmul/failedattempt2.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -197,33 +197,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/keeptrying.c b/mt/af_matmul/keeptrying.c
index ebfce6cc2bd5dc596a68552dbf63b48fac7a0e9b..501e7fcef21f854fec92f4f8c6512c1dba3fbac8 100644 (file)
--- a/mt/af_matmul/keeptrying.c
+++ b/mt/af_matmul/keeptrying.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -219,33 +219,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/keeptrying2.c b/mt/af_matmul/keeptrying2.c
index ad2ff41f8155804a46553b66e324bf889e6d277b..5251cf0628b3ab97d582938b63dc36dda754d67c 100644 (file)
--- a/mt/af_matmul/keeptrying2.c
+++ b/mt/af_matmul/keeptrying2.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -222,33 +222,33 @@ void thread_entry(int cid, int nc)
 
        /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/keeptrying3.c b/mt/af_matmul/keeptrying3.c
index 9c28faa149b75de91f60a2f91d40b9ce49bd1b8c..627a2d6d30bdd3c3366a53f12d9f1f527fc99412 100644 (file)
--- a/mt/af_matmul/keeptrying3.c
+++ b/mt/af_matmul/keeptrying3.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -221,33 +221,33 @@ void thread_entry(int cid, int nc)
 
        
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_matmul/matmul_mi.c b/mt/af_matmul/matmul_mi.c
index 74a43f354e9a4e67309b82ea45ce8477d900dbfe..3190c8e2cb9d4805246b8cddec92b25bd46bfcc4 100644 (file)
--- a/mt/af_matmul/matmul_mi.c
+++ b/mt/af_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -218,33 +218,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/af_vvadd/af_vvadd.c b/mt/af_vvadd/af_vvadd.c
index 7f7bc7ae4c30d5f9ca710b47d68a6bf63140685f..5c6b1e9d7c8d89749d9af508a08fa1b325f06461 100755 (executable)
--- a/mt/af_vvadd/af_vvadd.c
+++ b/mt/af_vvadd/af_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -144,12 +144,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -157,21 +157,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ag_matmul/ag_matmul.c b/mt/ag_matmul/ag_matmul.c
index 9782d781e2ce859f4ce97527a7b64a1be21c37dd..bd470eb33eb189cfc3065e1cb97de6746d0bd7fa 100755 (executable)
--- a/mt/ag_matmul/ag_matmul.c
+++ b/mt/ag_matmul/ag_matmul.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------
 // Helper functions
 
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
     int i;
     if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
     printf( "\n" );
 }
 
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
     if (coreid != 0)
         return;
@@ -176,7 +176,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                 C[(j+3)*lda + i + 1] += sum;
                 
             }
-            barrier();
+            barrier(ncores);
         }
     }
 }
@@ -197,33 +197,33 @@ void thread_entry(int cid, int nc)
     
     
 //    // Execute the provided, naive matmul
-//    barrier();
-//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//    barrier(nc);
+//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 //    
 //    
 //    // verify
-//    verify(ARRAY_SIZE, results_data, verify_data);
+//    verifyMT(ARRAY_SIZE, results_data, verify_data);
 //    
 //    // clear results from the first trial
 //    size_t i;
 //    if (coreid == 0) 
 //        for (i=0; i < ARRAY_SIZE; i++)
 //            results_data[i] = 0;
-//    barrier();
+//    barrier(nc);
     
     
     // Execute your faster matmul
-    barrier();
-    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+    barrier(nc);
+    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
     
 #ifdef DEBUG
-    printArray("results:", ARRAY_SIZE, results_data);
-    printArray("verify :", ARRAY_SIZE, verify_data);
+    printArrayMT("results:", ARRAY_SIZE, results_data);
+    printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
     
     // verify
-    verify(ARRAY_SIZE, results_data, verify_data);
-    barrier();
+    verifyMT(ARRAY_SIZE, results_data, verify_data);
+    barrier(nc);
     
     exit(0);
 }

diff --git a/mt/ag_matmul/matmul_mi.c b/mt/ag_matmul/matmul_mi.c
index 9782d781e2ce859f4ce97527a7b64a1be21c37dd..3352c56fd9c1fa57370262e88e7421cdc3b338c3 100755 (executable)
--- a/mt/ag_matmul/matmul_mi.c
+++ b/mt/ag_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------
 // Helper functions
 
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
     int i;
     if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
     printf( "\n" );
 }
 
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
     if (coreid != 0)
         return;
@@ -176,7 +176,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                 C[(j+3)*lda + i + 1] += sum;
                 
             }
-            barrier();
+            barrier(nc);
         }
     }
 }
@@ -197,33 +197,33 @@ void thread_entry(int cid, int nc)
     
     
 //    // Execute the provided, naive matmul
-//    barrier();
-//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//    barrier(nc);
+//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 //    
 //    
 //    // verify
-//    verify(ARRAY_SIZE, results_data, verify_data);
+//    verifyMT(ARRAY_SIZE, results_data, verify_data);
 //    
 //    // clear results from the first trial
 //    size_t i;
 //    if (coreid == 0) 
 //        for (i=0; i < ARRAY_SIZE; i++)
 //            results_data[i] = 0;
-//    barrier();
+//    barrier(nc);
     
     
     // Execute your faster matmul
-    barrier();
-    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+    barrier(nc);
+    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
     
 #ifdef DEBUG
-    printArray("results:", ARRAY_SIZE, results_data);
-    printArray("verify :", ARRAY_SIZE, verify_data);
+    printArrayMT("results:", ARRAY_SIZE, results_data);
+    printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
     
     // verify
-    verify(ARRAY_SIZE, results_data, verify_data);
-    barrier();
+    verifyMT(ARRAY_SIZE, results_data, verify_data);
+    barrier(nc);
     
     exit(0);
 }

diff --git a/mt/ag_vvadd/ag_vvadd.c b/mt/ag_vvadd/ag_vvadd.c
index 8594c5fee90fb8af078c3c7e86666a1fe3e4f693..51aa3846c39b58e6763d828d98e5190e9b528f20 100755 (executable)
--- a/mt/ag_vvadd/ag_vvadd.c
+++ b/mt/ag_vvadd/ag_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -137,12 +137,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -150,21 +150,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ai_matmul/ai_matmul.c b/mt/ai_matmul/ai_matmul.c
index e74a5d30ed3ccef943cab6ef216355c3e32f465d..f9640f4f15c5bbe74e6746a34c76101b4c84a3be 100755 (executable)
--- a/mt/ai_matmul/ai_matmul.c
+++ b/mt/ai_matmul/ai_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -118,7 +118,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
 //----------MSI--------------
 ///*
    int i,j,k;
-   barrier();
+   barrier(ncores);
    for(j = coreid*lda/ncores; j < coreid*lda/ncores + lda/ncores; j++) {
        for(i = 0; i < lda; i+=4) {
                data_t Cval0 = 0;
@@ -142,7 +142,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
 //------------------MI-------------------
 /*
    int i,j,k;
-   barrier();
+   barrier(nc);
    for(j = coreid*lda/ncores; j < coreid*lda/ncores + lda/ncores; j++) {
         for(i = 0; i < lda; i+=4) {
                data_t Cval0 = 0;
@@ -189,33 +189,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ai_matmul/matmul_mi.c b/mt/ai_matmul/matmul_mi.c
index bacfbfc10a64671e042ca8a3141129cfbebb4ebc..154569c43e6afea8f784bfd3d786fc5af36f8a41 100755 (executable)
--- a/mt/ai_matmul/matmul_mi.c
+++ b/mt/ai_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -118,7 +118,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
 //----------MSI--------------
 /*
    int i,j,k;
-   barrier();
+   barrier(nc);
    for(j = coreid*lda/ncores; j < coreid*lda/ncores + lda/ncores; j++) {
        for(i = 0; i < lda; i+=4) {
                data_t Cval0 = 0;
@@ -142,7 +142,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
 //------------------MI-------------------
 
    int i,j,k;
-   barrier();
+   barrier(nc);
    for(j = coreid*lda/ncores; j < coreid*lda/ncores + lda/ncores; j++) {
         for(i = 0; i < lda; i+=4) {
                data_t Cval0 = 0;
@@ -188,33 +188,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ai_vvadd/ai_vvadd.c b/mt/ai_vvadd/ai_vvadd.c
index 03191261a41493f4febec607767a518c63732ea4..64d1774a9ed45f3697dc7c7e3abdeca44f085629 100755 (executable)
--- a/mt/ai_vvadd/ai_vvadd.c
+++ b/mt/ai_vvadd/ai_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -136,12 +136,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -149,21 +149,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aj_matmul/aj_matmul.c b/mt/aj_matmul/aj_matmul.c
index 228077140e954b75e7cdf92fd347bf3b675b6fe9..445f924fe965a36d57803cab72404b213d0c535b 100755 (executable)
--- a/mt/aj_matmul/aj_matmul.c
+++ b/mt/aj_matmul/aj_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -347,33 +347,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aj_matmul/matmul_mi.c b/mt/aj_matmul/matmul_mi.c
index 228077140e954b75e7cdf92fd347bf3b675b6fe9..445f924fe965a36d57803cab72404b213d0c535b 100644 (file)
--- a/mt/aj_matmul/matmul_mi.c
+++ b/mt/aj_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -347,33 +347,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aj_vvadd/aj_vvadd.c b/mt/aj_vvadd/aj_vvadd.c
index 55d1dbcb464bfc7406d3d50a9bd9501af9e9bad9..009620997195979144f60946a79440574be0addc 100755 (executable)
--- a/mt/aj_vvadd/aj_vvadd.c
+++ b/mt/aj_vvadd/aj_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -134,12 +134,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -147,21 +147,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ak_matmul/ak_matmul.c b/mt/ak_matmul/ak_matmul.c
index 614a81f06b67775b384da8133f03aa3a7675bf04..4d803eed9ad65047a7fa15e1e5597bb58aed0253 100755 (executable)
--- a/mt/ak_matmul/ak_matmul.c
+++ b/mt/ak_matmul/ak_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -180,33 +180,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ak_matmul/matmulMI.c b/mt/ak_matmul/matmulMI.c
index a9068f8ee12ab8aefc7a84e5755a8ded2fc5cfa5..e73150124a058e00667e4543e82ed6fb936f8e56 100755 (executable)
--- a/mt/ak_matmul/matmulMI.c
+++ b/mt/ak_matmul/matmulMI.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -179,33 +179,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ak_matmul/matmul_mi.c b/mt/ak_matmul/matmul_mi.c
index 992194d765dbded7fd02c6cd767e141e683decf4..aa41e329e861390bf1be4eed41d84edbf557f9aa 100755 (executable)
--- a/mt/ak_matmul/matmul_mi.c
+++ b/mt/ak_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -179,33 +179,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ak_vvadd/ak_vvadd.c b/mt/ak_vvadd/ak_vvadd.c
index a63bbe78f34ce352451808792d1fa727ba195127..ee82f19167c69201dd43310a4f62ff36b06c218d 100755 (executable)
--- a/mt/ak_vvadd/ak_vvadd.c
+++ b/mt/ak_vvadd/ak_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -137,12 +137,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -150,21 +150,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/al_matmul/al_matmul.c b/mt/al_matmul/al_matmul.c
index b4d2663de6f6288a1e1111b400c27245dadbe13c..13bc501fb525e6466e8fa2ac75a32174c2da3b78 100644 (file)
--- a/mt/al_matmul/al_matmul.c
+++ b/mt/al_matmul/al_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -240,33 +240,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/al_matmul/matmul_mi.c b/mt/al_matmul/matmul_mi.c
index 47b0992ab6b458ee8fb3c6eb4c4185fd59459a72..c8016dba7362bf8fadd48c7ae3ceb8eb0d70928b 100644 (file)
--- a/mt/al_matmul/matmul_mi.c
+++ b/mt/al_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -294,33 +294,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/al_vvadd/al_vvadd.c b/mt/al_vvadd/al_vvadd.c
index 2319f5bad1c23ef433f571de37b723df1533b0f0..fd89916650176fe9be8b27e7440aa6804344ec9e 100755 (executable)
--- a/mt/al_vvadd/al_vvadd.c
+++ b/mt/al_vvadd/al_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -139,12 +139,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -152,21 +152,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_matmul/am_matmul.c b/mt/am_matmul/am_matmul.c
index 7fe737b10794bdc99dc36a567c7a6796f7b13fe8..b00d573cc15e85e0727cc1f68e5bb14b0e79a43b 100755 (executable)
--- a/mt/am_matmul/am_matmul.c
+++ b/mt/am_matmul/am_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -183,33 +183,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_matmul/matmul3.c b/mt/am_matmul/matmul3.c
index 9a79baac54978931dc61fa71445bbc20cb7f3ae3..429be469ee6c21e5236141f2bb5b93ce57356a1d 100755 (executable)
--- a/mt/am_matmul/matmul3.c
+++ b/mt/am_matmul/matmul3.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -188,33 +188,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_matmul/matmul4.c b/mt/am_matmul/matmul4.c
index 05a1aa47246cf964506d146e706eb331a8edd4f8..7953d59a3ab6579421eaaa8431fc338cf5155f31 100755 (executable)
--- a/mt/am_matmul/matmul4.c
+++ b/mt/am_matmul/matmul4.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -249,33 +249,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_matmul/matmul_mi.c b/mt/am_matmul/matmul_mi.c
index 841a4b5a236cdf0b0e2d5ca24f91d5fe7e2d6099..0a93ce250ba8efdf463ee43cc853865c9c4c6143 100755 (executable)
--- a/mt/am_matmul/matmul_mi.c
+++ b/mt/am_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -216,33 +216,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_matmul/matmul_msi.c b/mt/am_matmul/matmul_msi.c
index 0b59f8c15d951c10f1a4b013a956e04dfb9c2c03..b4e5ad8eff7ca89f9dae3757a730bbfc47029772 100755 (executable)
--- a/mt/am_matmul/matmul_msi.c
+++ b/mt/am_matmul/matmul_msi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -183,33 +183,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/am_vvadd/am_vvadd.c b/mt/am_vvadd/am_vvadd.c
index a4681d0c1adb907177811370464532748e80be74..af10ea9de436d2e54c36500fcf181fdbca633a50 100755 (executable)
--- a/mt/am_vvadd/am_vvadd.c
+++ b/mt/am_vvadd/am_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -135,12 +135,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -148,21 +148,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/an_matmul/an_matmul.c b/mt/an_matmul/an_matmul.c
index e7608fee9793da64a147616deee1751a45c514cc..2150277b04492918b97df40345a71056f7a2e3e2 100755 (executable)
--- a/mt/an_matmul/an_matmul.c
+++ b/mt/an_matmul/an_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -163,33 +163,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/an_matmul/matmul_mi.c b/mt/an_matmul/matmul_mi.c
index e7608fee9793da64a147616deee1751a45c514cc..2150277b04492918b97df40345a71056f7a2e3e2 100644 (file)
--- a/mt/an_matmul/matmul_mi.c
+++ b/mt/an_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -163,33 +163,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/an_vvadd/an_vvadd.c b/mt/an_vvadd/an_vvadd.c
index 497b9bb38df48c3b50ebad341599cff512c756ae..d5868e4df002eb8596ca841e64788640a82cea6f 100755 (executable)
--- a/mt/an_vvadd/an_vvadd.c
+++ b/mt/an_vvadd/an_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -131,12 +131,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -144,21 +144,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ap_matmul/ap_matmul.c b/mt/ap_matmul/ap_matmul.c
index ae1c84c7426057278c017d60c9df94e64115211f..1b31d86a0b23d7c6da0d471c2ab366b642b233bc 100755 (executable)
--- a/mt/ap_matmul/ap_matmul.c
+++ b/mt/ap_matmul/ap_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -205,33 +205,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ap_matmul/matmul_mi.c b/mt/ap_matmul/matmul_mi.c
index ae1c84c7426057278c017d60c9df94e64115211f..1b31d86a0b23d7c6da0d471c2ab366b642b233bc 100755 (executable)
--- a/mt/ap_matmul/matmul_mi.c
+++ b/mt/ap_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -205,33 +205,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ap_vvadd/ap_vvadd.c b/mt/ap_vvadd/ap_vvadd.c
index fe1440b5d2e784c54d576bd231511631580a5584..aa3b3ad7a41bc8e6adf696ceb147263ee4a193c6 100755 (executable)
--- a/mt/ap_vvadd/ap_vvadd.c
+++ b/mt/ap_vvadd/ap_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -148,12 +148,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -161,21 +161,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aq_matmul/aq_matmul.c b/mt/aq_matmul/aq_matmul.c
index e7a3c6584508010654942d746f03089c10be159c..a2037662ce8c633f0697a2276c336f584e6f99f9 100644 (file)
--- a/mt/aq_matmul/aq_matmul.c
+++ b/mt/aq_matmul/aq_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -150,33 +150,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aq_matmul/matmul_mi.c b/mt/aq_matmul/matmul_mi.c
index 524b13dd3f6c7ccfd5ba884586b1479430aa271f..932e6bc3b81e742fa7e642f60082de372648a285 100755 (executable)
--- a/mt/aq_matmul/matmul_mi.c
+++ b/mt/aq_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -150,33 +150,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/aq_vvadd/aq_vvadd.c b/mt/aq_vvadd/aq_vvadd.c
index af88a0ba1a3793822bfc35e6dc94a4cf6e18f687..375569b81646bbc2f28d0d250f65f010fdf4db61 100755 (executable)
--- a/mt/aq_vvadd/aq_vvadd.c
+++ b/mt/aq_vvadd/aq_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -157,12 +157,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -170,21 +170,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ar_matmul/ar_matmul.c b/mt/ar_matmul/ar_matmul.c
index 22ca10b892cd8d6a5da6a77c9fd8f1388a2e06e6..9286adc11941e5c236d7c80be89c72be6388988c 100755 (executable)
--- a/mt/ar_matmul/ar_matmul.c
+++ b/mt/ar_matmul/ar_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -160,33 +160,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ar_matmul/matmul_mi.c b/mt/ar_matmul/matmul_mi.c
deleted file mode 120000 (symlink)
index bd5f2b1..0000000
--- a/mt/ar_matmul/matmul_mi.c
+++ /dev/null
@@ -1 +0,0 @@
-matmul.c
\ No newline at end of file

diff --git a/mt/ar_vvadd/ar_vvadd.c b/mt/ar_vvadd/ar_vvadd.c
index eeb578c4bce12ba578008df09d292934364ee957..18ad0334626f90ca7a50486275ef1b2aa1fef235 100755 (executable)
--- a/mt/ar_vvadd/ar_vvadd.c
+++ b/mt/ar_vvadd/ar_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -136,12 +136,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -149,21 +149,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/as_matmul/as_matmul.c b/mt/as_matmul/as_matmul.c
index d98da8ef9f2791c1165d36b05ae5a98c9d075fc5..15855e0c1c7dd9f925ed0a32350a4dd1e15be486 100755 (executable)
--- a/mt/as_matmul/as_matmul.c
+++ b/mt/as_matmul/as_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -119,8 +119,8 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
    int i, j, k, n, m;
 
 
-   //matmul_naive(32, input1_data, input2_data, results_data); barrier(): 957424 cycles, 29.2 cycles/iter, 3.6 CPI
-   //matmul(32, input1_data, input2_data, results_data); barrier(): 340408 cycles, 10.3 cycles/iter, 1.8 CPI
+   //matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 957424 cycles, 29.2 cycles/iter, 3.6 CPI
+   //matmul(32, input1_data, input2_data, results_data); barrier(nc): 340408 cycles, 10.3 cycles/iter, 1.8 CPI
 
    for (n = 0; n < lda; n += 1) {
       for (m = 0; m < lda; m += 1) {
@@ -128,7 +128,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
          bTranspose[lda*n + m] = B[lda*m + n];
       }
    }
-   barrier();
+   barrier(ncores);
 
    for ( j = coreid; j < lda; j += 2*ncores ) {
       for ( i = 0; i < lda; i += 1 ){
@@ -138,21 +138,21 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
             c1 += A[j * lda + k] * bTranspose[i*lda + k];
             c2 += A[(j+2) * lda + k] * bTranspose[i*lda + k];
             
-            //barrier();
+            //barrier(nc);
          }
 
          C[i + j * lda] = c1;
          C[i + (j+2) * lda] = c2;
-         barrier();
+         barrier(ncores);
       }
-   //barrier();
+   //barrier(nc);
    }
 
 
 
 
-   //matmul_naive(32, input1_data, input2_data, results_data); barrier(): 983609 cycles, 30.0 cycles/iter, 3.7 CPI
-   //matmul(32, input1_data, input2_data, results_data); barrier(): 389942 cycles, 11.9 cycles/iter, 2.5 CPI
+   //matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 983609 cycles, 30.0 cycles/iter, 3.7 CPI
+   //matmul(32, input1_data, input2_data, results_data); barrier(nc): 389942 cycles, 11.9 cycles/iter, 2.5 CPI
 
    /*
    for ( j = coreid; j < lda; j += 2*ncores ) {
@@ -163,34 +163,34 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
             c1 += A[j * lda + k] * B[k*lda + i];
             c2 += A[(j+2) * lda + k] * B[k*lda + i];
             
-            //barrier();
+            //barrier(nc);
          }
 
          C[i + j * lda] = c1;
          C[i + (j+2) * lda] = c2;
-         barrier();
+         barrier(nc);
       }
-   //barrier();
+   //barrier(nc);
    }
    */
 
-   // matmul_naive(32, input1_data, input2_data, results_data); barrier(): 973781 cycles, 29.7 cycles/iter, 3.7 CPI
-   // matmul(32, input1_data, input2_data, results_data); barrier(): 461066 cycles, 14.0 cycles/iter, 3.5 CPI
+   // matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 973781 cycles, 29.7 cycles/iter, 3.7 CPI
+   // matmul(32, input1_data, input2_data, results_data); barrier(nc): 461066 cycles, 14.0 cycles/iter, 3.5 CPI
    // for ( k = 0; k < lda; k += 1 ) {
    //    for ( j = coreid; j < lda; j += 2*ncores ) {      
    //       for ( i = 0; i < lda; i += 1 ){
    //          C[i + j * lda] += A[j * lda + k] * B[k*lda + i];
    //          C[i + (j+2) * lda] += A[(j+2) * lda + k] * B[k*lda + i];      
-   //          //barrier();
+   //          //barrier(nc);
    //       }
-   //       barrier();
+   //       barrier(nc);
    //    }
-   // //barrier();
+   // //barrier(nc);
    // }
    
 
-   // matmul_naive(32, input1_data, input2_data, results_data); barrier(): 965136 cycles, 29.4 cycles/iter, 3.7 CPI
-   // matmul(32, input1_data, input2_data, results_data); barrier(): 513779 cycles, 15.6 cycles/iter, 3.2 CPI
+   // matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 965136 cycles, 29.4 cycles/iter, 3.7 CPI
+   // matmul(32, input1_data, input2_data, results_data); barrier(nc): 513779 cycles, 15.6 cycles/iter, 3.2 CPI
 
    // for ( j = coreid; j < lda; j += 2*ncores ) {
    //    for ( i = 0; i < lda; i += 1 ){
@@ -198,16 +198,16 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
    //          C[i + j * lda] += A[j * lda + k] * B[k*lda + i];
    //          C[i + (j+2) * lda] += A[(j+2) * lda + k] * B[k*lda + i];
             
-   //          //barrier();
+   //          //barrier(nc);
    //       }
-   //       barrier();
+   //       barrier(nc);
    //    }
-   // //barrier();
+   // //barrier(nc);
    //}
 
 
-   // matmul_naive(32, input1_data, input2_data, results_data); barrier(): 937892 cycles, 28.6 cycles/iter, 3.6 CPI
-   // matmul(32, input1_data, input2_data, results_data); barrier(): 576478 cycles, 17.5 cycles/iter, 3.5 CPI
+   // matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 937892 cycles, 28.6 cycles/iter, 3.6 CPI
+   // matmul(32, input1_data, input2_data, results_data); barrier(nc): 576478 cycles, 17.5 cycles/iter, 3.5 CPI
 
    // for ( i = 0; i < lda; i += 1 ){
    //    for ( j = coreid; j < lda; j += 2*ncores ) {
@@ -215,11 +215,11 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
    //          C[i + j * lda] += A[j * lda + k] * B[k*lda + i];
    //          C[i + (j+2) * lda] += A[(j+2) * lda + k] * B[k*lda + i];
             
-   //          //barrier();
+   //          //barrier(nc);
    //       }
-   //       barrier();
+   //       barrier(nc);
    //    }
-   //    //barrier();
+   //    //barrier(nc);
    // }
 
    //for ( i = coreid; i < lda; i += ncores ){
@@ -227,7 +227,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
    //      for ( k = coreid; k < lda; k += ncores ) {
    //         C[i + j*lda] += A[j*lda + k] * B[k*lda + i];
    //      }
-         //barrier();
+         //barrier(nc);
    //   }
    //}
 }
@@ -248,33 +248,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/as_matmul/matmul_mi.c b/mt/as_matmul/matmul_mi.c
index 130fdb7232489de0d4eea7afdb2d42def4510000..88534b8803e3c50f34331cf2b82ece06ed07cc30 100644 (file)
--- a/mt/as_matmul/matmul_mi.c
+++ b/mt/as_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -118,8 +118,8 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
 
    int i, j, k, n, m, c1, c2;
 
-   //matmul_naive(32, input1_data, input2_data, results_data); barrier(): 952596 cycles, 29.0 cycles/iter, 3.6 CPI
-   //matmul(32, input1_data, input2_data, results_data); barrier(): 570135 cycles, 17.3 cycles/iter, 3.4 CPI
+   //matmul_naive(32, input1_data, input2_data, results_data); barrier(nc): 952596 cycles, 29.0 cycles/iter, 3.6 CPI
+   //matmul(32, input1_data, input2_data, results_data); barrier(nc): 570135 cycles, 17.3 cycles/iter, 3.4 CPI
    
    for ( j = coreid; j < lda; j += 2*ncores ) {
       for ( i = 0; i < lda; i += 1 ){
@@ -129,14 +129,14 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
             c1 += A[j * lda + k] * B[k*lda + i];
             c2 += A[(j+2) * lda + k] * B[k*lda + i];
             
-            //barrier();
+            //barrier(nc);
          }
 
          C[i + j * lda] = c1;
          C[i + (j+2) * lda] = c2;
-         barrier();
+         barrier(nc);
       }
-   //barrier();
+   //barrier(nc);
    }
    
 }
@@ -157,33 +157,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/as_vvadd/as_vvadd.c b/mt/as_vvadd/as_vvadd.c
index dd1f94bd53b92a440bdb66740bb6de30b1b6150f..3034ae34e123e435d64a352804f0ba692872cb9a 100755 (executable)
--- a/mt/as_vvadd/as_vvadd.c
+++ b/mt/as_vvadd/as_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -107,9 +107,9 @@ void __attribute__((noinline)) vvadd_opt(size_t n, data_t* __restrict__ x, const
   for (i = coreid; i < n; i += 2*ncores) {
     x[i] = x[i] + y[i];
     x[i+2] = x[i+2] + y[i+2];
-    //barrier();
+    //barrier(nc);
   }
-    barrier();    //adding a barrier so there aren't any OOB errors due to faster threads
+    barrier(ncores);    //adding a barrier so there aren't any OOB errors due to faster threads
   
 }
 
@@ -140,12 +140,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -153,21 +153,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/at_matmul/at_matmul.c b/mt/at_matmul/at_matmul.c
index d69f8fe65dc17837cbc636cfa3c53ffdd43be75a..ccda17a40a783e9c49722d8deedbe0c64a1a4fa2 100755 (executable)
--- a/mt/at_matmul/at_matmul.c
+++ b/mt/at_matmul/at_matmul.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------
 // Helper functions
 
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
        int i;
        if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
        printf( "\n" );
 }
 
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
        if (coreid != 0)
                return;
@@ -284,33 +284,33 @@ void thread_entry(int cid, int nc)
        
        
 //     // Execute the provided, naive matmul
-//     barrier();
-//     stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//     barrier(nc);
+//     stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 //     
 //     
 //     // verify
-//     verify(ARRAY_SIZE, results_data, verify_data);
+//     verifyMT(ARRAY_SIZE, results_data, verify_data);
 //     
 //     // clear results from the first trial
 //     size_t i;
 //     if (coreid == 0) 
 //             for (i=0; i < ARRAY_SIZE; i++)
 //                     results_data[i] = 0;
-//     barrier();
+//     barrier(nc);
        
        
        // Execute your faster matmul
-       barrier();
-       stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+       barrier(nc);
+       stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
        
 #ifdef DEBUG
-       printArray("results:", ARRAY_SIZE, results_data);
-       printArray("verify :", ARRAY_SIZE, verify_data);
+       printArrayMT("results:", ARRAY_SIZE, results_data);
+       printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
        
        // verify
-       verify(ARRAY_SIZE, results_data, verify_data);
-       barrier();
+       verifyMT(ARRAY_SIZE, results_data, verify_data);
+       barrier(nc);
        
        exit(0);
 }

diff --git a/mt/at_matmul/matmul_mi.c b/mt/at_matmul/matmul_mi.c
index 0c5115fcdedb518ff5d251f54bef308cbcbdf46a..640c32de4cd9bfadc8af31c2423a7f30ccb2bf3f 100644 (file)
--- a/mt/at_matmul/matmul_mi.c
+++ b/mt/at_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------
 // Helper functions
 
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
        int i;
        if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
        printf( "\n" );
 }
 
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
        if (coreid != 0)
                return;
@@ -284,33 +284,33 @@ void thread_entry(int cid, int nc)
        
        
 //     // Execute the provided, naive matmul
-//     barrier();
-//     stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//     barrier(nc);
+//     stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 //     
 //     
 //     // verify
-//     verify(ARRAY_SIZE, results_data, verify_data);
+//     verifyMT(ARRAY_SIZE, results_data, verify_data);
 //     
 //     // clear results from the first trial
 //     size_t i;
 //     if (coreid == 0) 
 //             for (i=0; i < ARRAY_SIZE; i++)
 //                     results_data[i] = 0;
-//     barrier();
+//     barrier(nc);
        
        
        // Execute your faster matmul
-       barrier();
-       stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+       barrier(nc);
+       stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
        
 #ifdef DEBUG
-       printArray("results:", ARRAY_SIZE, results_data);
-       printArray("verify :", ARRAY_SIZE, verify_data);
+       printArrayMT("results:", ARRAY_SIZE, results_data);
+       printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
        
        // verify
-       verify(ARRAY_SIZE, results_data, verify_data);
-       barrier();
+       verifyMT(ARRAY_SIZE, results_data, verify_data);
+       barrier(nc);
        
        exit(0);
 }

diff --git a/mt/at_vvadd/at_vvadd.c b/mt/at_vvadd/at_vvadd.c
index 55fb8dee136b9a793a222a306543f5eb648376cb..b271d67dda3a913aca95599a031ecf05dd5a8e90 100755 (executable)
--- a/mt/at_vvadd/at_vvadd.c
+++ b/mt/at_vvadd/at_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -145,12 +145,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -158,21 +158,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/av_matmul/av_matmul.c b/mt/av_matmul/av_matmul.c
index 8a289491984df5a5ca858ef5fdc2dd0c04085cea..ad5ccdb62a07e51d071588054b63474ba4ced3dc 100644 (file)
--- a/mt/av_matmul/av_matmul.c
+++ b/mt/av_matmul/av_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -2869,33 +2869,33 @@ void thread_entry(int cid, int nc)
    
        
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/av_matmul/matmul_mi.c b/mt/av_matmul/matmul_mi.c
index 4cdac762f017445c0f33686d7b82d98f41088a94..b0ce08ae22a77b6151a328facc330ab02879b911 100644 (file)
--- a/mt/av_matmul/matmul_mi.c
+++ b/mt/av_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -2176,33 +2176,33 @@ void thread_entry(int cid, int nc)
    /*
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/av_vvadd/av_vvadd.c b/mt/av_vvadd/av_vvadd.c
index 2f213d87a03626152b74a5ba0d48383916e258c7..11202c75cf28a68cfd60a1bcbc98e7734905d24f 100644 (file)
--- a/mt/av_vvadd/av_vvadd.c
+++ b/mt/av_vvadd/av_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -162,12 +162,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -175,21 +175,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ay_matmul/ay_matmul.c b/mt/ay_matmul/ay_matmul.c
index 2a1e04c6bbba5865a7a9844738e3d6a1f88edde7..857a78fab6d2d10e6e79b939579ecf2d83e7e068 100644 (file)
--- a/mt/ay_matmul/ay_matmul.c
+++ b/mt/ay_matmul/ay_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------\r
 // Helper functions\r
     \r
-void printArray( char name[], int n, data_t arr[] )\r
+void printArrayMT( char name[], int n, data_t arr[] )\r
 {\r
    int i;\r
    if (coreid != 0)\r
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );\r
 }\r
       \r
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)\r
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)\r
 {\r
    if (coreid != 0)\r
       return;\r
@@ -176,33 +176,33 @@ void thread_entry(int cid, int nc)
 \r
 \r
    //// Execute the provided, naive matmul\r
-   //barrier();\r
-   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+   //barrier(nc);\r
+   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
  \r
    //\r
    //// verify\r
-   //verify(ARRAY_SIZE, results_data, verify_data);\r
+   //verifyMT(ARRAY_SIZE, results_data, verify_data);\r
    //\r
    //// clear results from the first trial\r
    //size_t i;\r
    //if (coreid == 0) \r
    //   for (i=0; i < ARRAY_SIZE; i++)\r
    //      results_data[i] = 0;\r
-   //barrier();\r
+   //barrier(nc);\r
 \r
    \r
    // Execute your faster matmul\r
-   barrier();\r
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+   barrier(nc);\r
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
  \r
 #ifdef DEBUG\r
-   printArray("results:", ARRAY_SIZE, results_data);\r
-   printArray("verify :", ARRAY_SIZE, verify_data);\r
+   printArrayMT("results:", ARRAY_SIZE, results_data);\r
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);\r
 #endif\r
    \r
    // verify\r
-   verify(ARRAY_SIZE, results_data, verify_data);\r
-   barrier();\r
+   verifyMT(ARRAY_SIZE, results_data, verify_data);\r
+   barrier(nc);\r
 \r
    exit(0);\r
 }\r

diff --git a/mt/ay_matmul/matmul_mi.c b/mt/ay_matmul/matmul_mi.c
index d58c5b87b94ea0d57285930e8e092d0cab86f183..1a42e8397189ac77304b0987e72eeed7ad098f30 100644 (file)
--- a/mt/ay_matmul/matmul_mi.c
+++ b/mt/ay_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------\r
 // Helper functions\r
     \r
-void printArray( char name[], int n, data_t arr[] )\r
+void printArrayMT( char name[], int n, data_t arr[] )\r
 {\r
    int i;\r
    if (coreid != 0)\r
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );\r
 }\r
       \r
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)\r
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)\r
 {\r
    if (coreid != 0)\r
       return;\r
@@ -224,33 +224,33 @@ void thread_entry(int cid, int nc)
 \r
 \r
    //// Execute the provided, naive matmul\r
-   //barrier();\r
-   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+   //barrier(nc);\r
+   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
  \r
    //\r
    //// verify\r
-   //verify(ARRAY_SIZE, results_data, verify_data);\r
+   //verifyMT(ARRAY_SIZE, results_data, verify_data);\r
    //\r
    //// clear results from the first trial\r
    //size_t i;\r
    //if (coreid == 0) \r
    //   for (i=0; i < ARRAY_SIZE; i++)\r
    //      results_data[i] = 0;\r
-   //barrier();\r
+   //barrier(nc);\r
 \r
    \r
    // Execute your faster matmul\r
-   barrier();\r
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+   barrier(nc);\r
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
  \r
 #ifdef DEBUG\r
-   printArray("results:", ARRAY_SIZE, results_data);\r
-   printArray("verify :", ARRAY_SIZE, verify_data);\r
+   printArrayMT("results:", ARRAY_SIZE, results_data);\r
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);\r
 #endif\r
    \r
    // verify\r
-   verify(ARRAY_SIZE, results_data, verify_data);\r
-   barrier();\r
+   verifyMT(ARRAY_SIZE, results_data, verify_data);\r
+   barrier(nc);\r
 \r
    exit(0);\r
 }\r

diff --git a/mt/ay_vvadd/ay_vvadd.c b/mt/ay_vvadd/ay_vvadd.c
index 0455a41fd8bd4895a175cc72d0781d49502bc949..2bf8da9041e0474a7df034438bd6292c04c90ca0 100755 (executable)
--- a/mt/ay_vvadd/ay_vvadd.c
+++ b/mt/ay_vvadd/ay_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -141,12 +141,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -154,21 +154,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/az_matmul/az_matmul.c b/mt/az_matmul/az_matmul.c
index 56f02d3bd801bfa8061df124bd2dd592e769b85a..5bfd15ff2eb7eb3faa70fe34be1783ad4b8283bf 100755 (executable)
--- a/mt/az_matmul/az_matmul.c
+++ b/mt/az_matmul/az_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -383,33 +383,33 @@ void thread_entry(int cid, int nc)
 
 
    //// Execute the provided, naive matmul
-   //barrier();
-   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   //barrier(nc);
+   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    //
    //// verify
-   //verify(ARRAY_SIZE, results_data, verify_data);
+   //verifyMT(ARRAY_SIZE, results_data, verify_data);
    //
    //// clear results from the first trial
    //size_t i;
    //if (coreid == 0) 
    //   for (i=0; i < ARRAY_SIZE; i++)
    //      results_data[i] = 0;
-   //barrier();
+   //barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/az_matmul/matmul_mi.c b/mt/az_matmul/matmul_mi.c
index 56f02d3bd801bfa8061df124bd2dd592e769b85a..5bfd15ff2eb7eb3faa70fe34be1783ad4b8283bf 100755 (executable)
--- a/mt/az_matmul/matmul_mi.c
+++ b/mt/az_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -383,33 +383,33 @@ void thread_entry(int cid, int nc)
 
 
    //// Execute the provided, naive matmul
-   //barrier();
-   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   //barrier(nc);
+   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    //
    //// verify
-   //verify(ARRAY_SIZE, results_data, verify_data);
+   //verifyMT(ARRAY_SIZE, results_data, verify_data);
    //
    //// clear results from the first trial
    //size_t i;
    //if (coreid == 0) 
    //   for (i=0; i < ARRAY_SIZE; i++)
    //      results_data[i] = 0;
-   //barrier();
+   //barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/az_vvadd/az_vvadd.c b/mt/az_vvadd/az_vvadd.c
index 7b40fb1a4cc78b84f13023f794b68ce58ec4d8f6..cf32ac78381bfcc25caff1837860db5658ae7109 100755 (executable)
--- a/mt/az_vvadd/az_vvadd.c
+++ b/mt/az_vvadd/az_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -140,12 +140,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -153,21 +153,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ba_matmul/ba_matmul.c b/mt/ba_matmul/ba_matmul.c
index da9a764cf099bc3cb3a43843823fb85bd41fb6a9..3f712c1a25cbd7c3a0e5da928e1f1215f3fe825d 100755 (executable)
--- a/mt/ba_matmul/ba_matmul.c
+++ b/mt/ba_matmul/ba_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -238,33 +238,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ba_matmul/matmul_mi.c b/mt/ba_matmul/matmul_mi.c
index da9a764cf099bc3cb3a43843823fb85bd41fb6a9..3f712c1a25cbd7c3a0e5da928e1f1215f3fe825d 100755 (executable)
--- a/mt/ba_matmul/matmul_mi.c
+++ b/mt/ba_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -238,33 +238,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/ba_vvadd/ba_vvadd.c b/mt/ba_vvadd/ba_vvadd.c
index 30703df8f4b07600cf46f560fae385fc971df0e9..90aec9d1037fe0cc9c26524dbbdeb968ad005a31 100755 (executable)
--- a/mt/ba_vvadd/ba_vvadd.c
+++ b/mt/ba_vvadd/ba_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -134,12 +134,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -147,21 +147,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bb_matmul/bb_matmul.c b/mt/bb_matmul/bb_matmul.c
index 067e3e38c650790c8320318499e64498ce2f985f..d9b2add350bfaf8bb47f09042c7ea43e40e46db3 100755 (executable)
--- a/mt/bb_matmul/bb_matmul.c
+++ b/mt/bb_matmul/bb_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -184,7 +184,7 @@ void __attribute__((noinline)) matmul_mi(const int lda,  const data_t A[], const
     }
   }
 
-  barrier();
+  barrier(ncores);
   curhalf++;
   curhalf %= ncores;
 
@@ -240,33 +240,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bb_matmul/matmul_mi.c b/mt/bb_matmul/matmul_mi.c
index 919e2ce6ec1c1c9a084d9cdddd798d7b0d25e2ff..346f178aca972059fce3e95071d836d0fe97a74a 100755 (executable)
--- a/mt/bb_matmul/matmul_mi.c
+++ b/mt/bb_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -184,7 +184,7 @@ void __attribute__((noinline)) matmul_mi(const int lda,  const data_t A[], const
     }
   }
 
-  barrier();
+  barrier(nc);
   curhalf++;
   curhalf %= ncores;
 
@@ -240,33 +240,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bb_vvadd/bb_vvadd.c b/mt/bb_vvadd/bb_vvadd.c
index 327da105d5e82c3f6952e2a0a2be767d2d45eeab..664ce35d278bc27659cd7f0f9bbc6b945e5ab04a 100755 (executable)
--- a/mt/bb_vvadd/bb_vvadd.c
+++ b/mt/bb_vvadd/bb_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -133,12 +133,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -146,21 +146,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bc_matmul/bc_matmul.c b/mt/bc_matmul/bc_matmul.c
index 088f38f8ad2182c7cda90c2d7f660f757efbc831..bac98cb1f194019937da2d0f6f0356e96525f488 100755 (executable)
--- a/mt/bc_matmul/bc_matmul.c
+++ b/mt/bc_matmul/bc_matmul.c
@@ -60,7 +60,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -72,7 +72,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -254,33 +254,33 @@ void thread_entry(int cid, int nc)
 
 
 //   /* // Execute the provided, naive matmul */
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bc_matmul/matmul_mi.c b/mt/bc_matmul/matmul_mi.c
index 86bd562c48c6fb91be83a8fa76def6231a78485d..35abdc8ed7cda9a5e28ab41b3a29eb44a365f193 100755 (executable)
--- a/mt/bc_matmul/matmul_mi.c
+++ b/mt/bc_matmul/matmul_mi.c
@@ -60,7 +60,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -72,7 +72,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -172,7 +172,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
            }
          }
        }
-       /* barrier(); */
+       /* barrier(nc); */
 
        /* kk_start= (coreid == 1 ? 0 : LDA/2); */
        /* kk_end = (coreid == 1 ? LDA/2 : LDA); */
@@ -216,7 +216,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
     }
   
     
-    //barrier();
+    //barrier(nc);
     for (jj = start; jj < end; jj += BLOCK_J) {
       int kk_start= (coreid != 0 ? 0 : LDA/2), kk_end = (coreid != 0 ? LDA/2 : LDA);
       for (kk = kk_start; kk < kk_end; kk += BLOCK_K) {
@@ -285,33 +285,33 @@ void thread_entry(int cid, int nc)
 
 
 //   /* // Execute the provided, naive matmul */
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bc_vvadd/bc_vvadd.c b/mt/bc_vvadd/bc_vvadd.c
index 50673ed5bb92e7903606c262deb2b0fbbb0ce4b3..c7af6b807915995404f99abaafa5f690acd72f70 100755 (executable)
--- a/mt/bc_vvadd/bc_vvadd.c
+++ b/mt/bc_vvadd/bc_vvadd.c
@@ -53,7 +53,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -65,7 +65,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -138,12 +138,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -151,21 +151,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/be_matmul/be_matmul.c b/mt/be_matmul/be_matmul.c
index da4b531e9b8374f7d03556e77e7831add7b3727b..e8bff41b58879dabe0c6684e0c7c082f0691d351 100755 (executable)
--- a/mt/be_matmul/be_matmul.c
+++ b/mt/be_matmul/be_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -227,7 +227,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                        pos_B += (lda*step_k) ;
                                                        pos_A += step_k;
                                                }
-                                               //barrier();
+                                               //barrier(nc);
 
                                                C[(pos_C + 0)] = temp10;
                                                C[(pos_C + 1)] = temp11;
@@ -237,7 +237,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp15;
                                                C[(pos_C + 6)] = temp16;
                                                C[(pos_C + 7)] = temp17;
-                                               //barrier();
+                                               //barrier(nc);
                                
                                                pos_C = i + j*lda;
                                                //pos_C -= lda;
@@ -249,15 +249,15 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp05;
                                                C[(pos_C + 6)] = temp06;
                                                C[(pos_C + 7)] = temp07;
-                                               //barrier();
+                                               //barrier(nc);
                                                //pos_C += step_j * lda;
                                        }
-                                       //barrier();
+                                       //barrier(nc);
                                }
-                               //barrier();
+                               //barrier(nc);
 
                        }
-                       //barrier();
+                       //barrier(nc);
                }       
 }
 
@@ -277,35 +277,35 @@ void thread_entry(int cid, int nc)
 
        /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
           
 
 
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    
        //printf("input1_data");

diff --git a/mt/be_matmul/matmul_mi.c b/mt/be_matmul/matmul_mi.c
index da4b531e9b8374f7d03556e77e7831add7b3727b..e8bff41b58879dabe0c6684e0c7c082f0691d351 100755 (executable)
--- a/mt/be_matmul/matmul_mi.c
+++ b/mt/be_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -227,7 +227,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                        pos_B += (lda*step_k) ;
                                                        pos_A += step_k;
                                                }
-                                               //barrier();
+                                               //barrier(nc);
 
                                                C[(pos_C + 0)] = temp10;
                                                C[(pos_C + 1)] = temp11;
@@ -237,7 +237,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp15;
                                                C[(pos_C + 6)] = temp16;
                                                C[(pos_C + 7)] = temp17;
-                                               //barrier();
+                                               //barrier(nc);
                                
                                                pos_C = i + j*lda;
                                                //pos_C -= lda;
@@ -249,15 +249,15 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp05;
                                                C[(pos_C + 6)] = temp06;
                                                C[(pos_C + 7)] = temp07;
-                                               //barrier();
+                                               //barrier(nc);
                                                //pos_C += step_j * lda;
                                        }
-                                       //barrier();
+                                       //barrier(nc);
                                }
-                               //barrier();
+                               //barrier(nc);
 
                        }
-                       //barrier();
+                       //barrier(nc);
                }       
 }
 
@@ -277,35 +277,35 @@ void thread_entry(int cid, int nc)
 
        /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
           
 
 
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    
        //printf("input1_data");

diff --git a/mt/be_vvadd/be_vvadd.c b/mt/be_vvadd/be_vvadd.c
index 1090c5a83a08eec6ad62def798113207bcee83e3..b1bf72b69487bf7bcfe3c962e3b4460f9d9e657d 100755 (executable)
--- a/mt/be_vvadd/be_vvadd.c
+++ b/mt/be_vvadd/be_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -137,12 +137,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -150,21 +150,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bf_matmul/bf_matmul.c b/mt/bf_matmul/bf_matmul.c
index 0bab50c98b6b5d4c87978af52179bf4633f864e5..24fa7e6f4390ae6c21cdc73d9949037f6802718e 100644 (file)
--- a/mt/bf_matmul/bf_matmul.c
+++ b/mt/bf_matmul/bf_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -246,33 +246,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bf_matmul/matmul_mi.c b/mt/bf_matmul/matmul_mi.c
index 1eb414551854b48086f45f42b0fcebd03e91410b..a063df024c4ec7b8fecf9cb13fa5c604bd143ff2 100755 (executable)
--- a/mt/bf_matmul/matmul_mi.c
+++ b/mt/bf_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -359,33 +359,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bf_vvadd/bf_vvadd.c b/mt/bf_vvadd/bf_vvadd.c
index 1c64793acca86623d103fe9e7e0e04f7128fb267..f783ee1369360c12353ccd7afe9880e7e3a3be68 100755 (executable)
--- a/mt/bf_vvadd/bf_vvadd.c
+++ b/mt/bf_vvadd/bf_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -146,12 +146,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -159,21 +159,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bh_matmul/bh_matmul.c b/mt/bh_matmul/bh_matmul.c
index 990c9352fae548b95b500e75fdfbf50e1f658a71..a496bbadb9d62859f75d408298c3a1970629a9ee 100755 (executable)
--- a/mt/bh_matmul/bh_matmul.c
+++ b/mt/bh_matmul/bh_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -215,33 +215,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bh_matmul/matmul_mi.c b/mt/bh_matmul/matmul_mi.c
index 990c9352fae548b95b500e75fdfbf50e1f658a71..a496bbadb9d62859f75d408298c3a1970629a9ee 100755 (executable)
--- a/mt/bh_matmul/matmul_mi.c
+++ b/mt/bh_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -215,33 +215,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bh_vvadd/bh_vvadd.c b/mt/bh_vvadd/bh_vvadd.c
index 216f9ad6653645fcdfce3072274ccef73d579b37..c4d06d3d7ac286373e72ccd673094ccfeddcbc8c 100755 (executable)
--- a/mt/bh_vvadd/bh_vvadd.c
+++ b/mt/bh_vvadd/bh_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -153,12 +153,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -166,21 +166,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bj_matmul/bj_matmul.c b/mt/bj_matmul/bj_matmul.c
index 5766e9186129d3ff09e9b777761a96e9967039bd..1642d109b50cf76e36aea80afbd75a37a18335b4 100644 (file)
--- a/mt/bj_matmul/bj_matmul.c
+++ b/mt/bj_matmul/bj_matmul.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------\r
 // Helper functions\r
 \r
-void printArray( char name[], int n, data_t arr[] )\r
+void printArrayMT( char name[], int n, data_t arr[] )\r
 {\r
     int i;\r
     if (coreid != 0)\r
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
     printf( "\n" );\r
 }\r
 \r
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)\r
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)\r
 {\r
     if (coreid != 0)\r
         return;\r
@@ -215,33 +215,33 @@ void thread_entry(int cid, int nc)
     \r
     \r
 //    // Execute the provided, naive matmul\r
-//    barrier();\r
-//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+//    barrier(nc);\r
+//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
 //    \r
 //    \r
 //    // verify\r
-//    verify(ARRAY_SIZE, results_data, verify_data);\r
+//    verifyMT(ARRAY_SIZE, results_data, verify_data);\r
 //    \r
 //    // clear results from the first trial\r
 //    size_t i;\r
 //    if (coreid == 0)\r
 //        for (i=0; i < ARRAY_SIZE; i++)\r
 //            results_data[i] = 0;\r
-//    barrier();\r
+//    barrier(nc);\r
     \r
     \r
     // Execute your faster matmul\r
-    barrier();\r
-    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+    barrier(nc);\r
+    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
     \r
 #ifdef DEBUG\r
-    printArray("results:", ARRAY_SIZE, results_data);\r
-    printArray("verify :", ARRAY_SIZE, verify_data);\r
+    printArrayMT("results:", ARRAY_SIZE, results_data);\r
+    printArrayMT("verify :", ARRAY_SIZE, verify_data);\r
 #endif\r
     \r
     // verify\r
-    verify(ARRAY_SIZE, results_data, verify_data);\r
-    barrier();\r
+    verifyMT(ARRAY_SIZE, results_data, verify_data);\r
+    barrier(nc);\r
     \r
     exit(0);\r
 }\r

diff --git a/mt/bj_matmul/matmul_mi.c b/mt/bj_matmul/matmul_mi.c
index 5766e9186129d3ff09e9b777761a96e9967039bd..1642d109b50cf76e36aea80afbd75a37a18335b4 100644 (file)
--- a/mt/bj_matmul/matmul_mi.c
+++ b/mt/bj_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ stringify(code), _c, _c/DIM_SIZE/DIM_SIZE/DIM_SIZE, 10*_c/DIM_SIZE/DIM_SIZE/DIM_
 //--------------------------------------------------------------------------\r
 // Helper functions\r
 \r
-void printArray( char name[], int n, data_t arr[] )\r
+void printArrayMT( char name[], int n, data_t arr[] )\r
 {\r
     int i;\r
     if (coreid != 0)\r
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
     printf( "\n" );\r
 }\r
 \r
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)\r
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)\r
 {\r
     if (coreid != 0)\r
         return;\r
@@ -215,33 +215,33 @@ void thread_entry(int cid, int nc)
     \r
     \r
 //    // Execute the provided, naive matmul\r
-//    barrier();\r
-//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+//    barrier(nc);\r
+//    stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
 //    \r
 //    \r
 //    // verify\r
-//    verify(ARRAY_SIZE, results_data, verify_data);\r
+//    verifyMT(ARRAY_SIZE, results_data, verify_data);\r
 //    \r
 //    // clear results from the first trial\r
 //    size_t i;\r
 //    if (coreid == 0)\r
 //        for (i=0; i < ARRAY_SIZE; i++)\r
 //            results_data[i] = 0;\r
-//    barrier();\r
+//    barrier(nc);\r
     \r
     \r
     // Execute your faster matmul\r
-    barrier();\r
-    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());\r
+    barrier(nc);\r
+    stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));\r
     \r
 #ifdef DEBUG\r
-    printArray("results:", ARRAY_SIZE, results_data);\r
-    printArray("verify :", ARRAY_SIZE, verify_data);\r
+    printArrayMT("results:", ARRAY_SIZE, results_data);\r
+    printArrayMT("verify :", ARRAY_SIZE, verify_data);\r
 #endif\r
     \r
     // verify\r
-    verify(ARRAY_SIZE, results_data, verify_data);\r
-    barrier();\r
+    verifyMT(ARRAY_SIZE, results_data, verify_data);\r
+    barrier(nc);\r
     \r
     exit(0);\r
 }\r

diff --git a/mt/bj_vvadd/bj_vvadd.c b/mt/bj_vvadd/bj_vvadd.c
index 3e2ed6ef9021212e9fea5b808d48fca5b154e3c4..4f69c35e71fe7f581893be104b5073ab7b27aa14 100755 (executable)
--- a/mt/bj_vvadd/bj_vvadd.c
+++ b/mt/bj_vvadd/bj_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -135,12 +135,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -148,21 +148,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bk_matmul/bk_matmul.c b/mt/bk_matmul/bk_matmul.c
index eddbcfb2f5191abc5c965f1da503990b468c1bb2..9fa22b1325f11e760b175eaa15226b61c74b040f 100755 (executable)
--- a/mt/bk_matmul/bk_matmul.c
+++ b/mt/bk_matmul/bk_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -293,33 +293,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bk_matmul/matmul_mi.c b/mt/bk_matmul/matmul_mi.c
index b1c0a39b07200b6ab75b65ad2add4cacc02304f5..b45071b1229fa8044d672772a69d151f04160c35 100755 (executable)
--- a/mt/bk_matmul/matmul_mi.c
+++ b/mt/bk_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -337,33 +337,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bk_matmul/matmul_msi.c b/mt/bk_matmul/matmul_msi.c
index 5890d2f3706ea5e5b35dbba73621d431658dbb28..253ea120b9c7bb727617b5050dad2ec7837902d1 100755 (executable)
--- a/mt/bk_matmul/matmul_msi.c
+++ b/mt/bk_matmul/matmul_msi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -293,33 +293,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bk_vvadd/bk_vvadd.c b/mt/bk_vvadd/bk_vvadd.c
index cf95374ce51cbc91cf7abe668f82ad45ff0144a4..20fe4af56c422f9d935fd1ff414bf0003fc75a19 100755 (executable)
--- a/mt/bk_vvadd/bk_vvadd.c
+++ b/mt/bk_vvadd/bk_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -144,12 +144,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -157,21 +157,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bm_matmul/bm_matmul.c b/mt/bm_matmul/bm_matmul.c
index 3f267dc49ad7c43a917dd1f83f2b6c2f516b013e..9897d9909152f0ffe7a0217001a335a7ba91c085 100644 (file)
--- a/mt/bm_matmul/bm_matmul.c
+++ b/mt/bm_matmul/bm_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -324,33 +324,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bm_matmul/matmul_mi.c b/mt/bm_matmul/matmul_mi.c
index 2471a4a3f7fcf596a2bd8c05bb6ea571bc00922c..3bdd09651c592db723a01ea5356e9be349dd0ea5 100644 (file)
--- a/mt/bm_matmul/matmul_mi.c
+++ b/mt/bm_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -152,7 +152,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
        data_t temp2_3=0;
        data_t temp3_3=0;
        data_t tempB_3=0;
-       barrier();
+       barrier(nc);
        if (coreid!=ncores-1){
                for (i=space*coreid;i<max/4*4;i+=4)
                {
@@ -315,33 +315,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bm_vvadd/bm_vvadd.c b/mt/bm_vvadd/bm_vvadd.c
index d60f4ec4a3f277bebc5e7cf28e055cb7264f8dd1..914c71170cc828d6a51aa66b186dd073d2689d25 100755 (executable)
--- a/mt/bm_vvadd/bm_vvadd.c
+++ b/mt/bm_vvadd/bm_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -160,12 +160,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -173,21 +173,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bn_matmul/bn_matmul.c b/mt/bn_matmul/bn_matmul.c
index eddbcfb2f5191abc5c965f1da503990b468c1bb2..9fa22b1325f11e760b175eaa15226b61c74b040f 100755 (executable)
--- a/mt/bn_matmul/bn_matmul.c
+++ b/mt/bn_matmul/bn_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -293,33 +293,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bn_matmul/matmul_mi.c b/mt/bn_matmul/matmul_mi.c
index b1c0a39b07200b6ab75b65ad2add4cacc02304f5..b45071b1229fa8044d672772a69d151f04160c35 100644 (file)
--- a/mt/bn_matmul/matmul_mi.c
+++ b/mt/bn_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -337,33 +337,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bn_vvadd/bn_vvadd.c b/mt/bn_vvadd/bn_vvadd.c
index 143d437a9829f65fd118e39b7f0d030146bb530a..6c1459e1aa35018169dfe484ff35a73fb49528cb 100755 (executable)
--- a/mt/bn_vvadd/bn_vvadd.c
+++ b/mt/bn_vvadd/bn_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------\r
 // Helper functions\r
  \r
-void printArray( char name[], int n, data_t arr[] )\r
+void printArrayMT( char name[], int n, data_t arr[] )\r
 {\r
   int i;\r
   if (coreid != 0)\r
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );\r
 }\r
       \r
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)\r
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)\r
 {\r
    if (coreid != 0)\r
       return;\r
@@ -137,12 +137,12 @@ void thread_entry(int cid, int nc)
 \r
 \r
    // Execute the provided, terrible vvadd\r
-   barrier();\r
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());\r
+   barrier(nc);\r
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));\r
  \r
    \r
    // verify\r
-   verify(DATA_SIZE, results_data, verify_data);\r
+   verifyMT(DATA_SIZE, results_data, verify_data);\r
    \r
    // reset results from the first trial\r
    if (coreid == 0) \r
@@ -150,21 +150,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)\r
          results_data[i] = input1_data[i];\r
    }\r
-   barrier();\r
+   barrier(nc);\r
                                             \r
    \r
    // Execute your faster vvadd\r
-   barrier();\r
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());\r
+   barrier(nc);\r
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));\r
 \r
 #ifdef DEBUG\r
-   printArray("results: ", DATA_SIZE, results_data);\r
-   printArray("verify : ", DATA_SIZE, verify_data);\r
+   printArrayMT("results: ", DATA_SIZE, results_data);\r
+   printArrayMT("verify : ", DATA_SIZE, verify_data);\r
 #endif\r
    \r
    // verify\r
-   verify(DATA_SIZE, results_data, verify_data);\r
-   barrier();\r
+   verifyMT(DATA_SIZE, results_data, verify_data);\r
+   barrier(nc);\r
 \r
    exit(0);\r
 }\r

diff --git a/mt/bo_matmul/bo_matmul.c b/mt/bo_matmul/bo_matmul.c
index de964db65bd787decd0347880d7ae67e8af19d15..dd061103031230dfb4ed8526ff0a8f25da94d823 100644 (file)
--- a/mt/bo_matmul/bo_matmul.c
+++ b/mt/bo_matmul/bo_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -308,33 +308,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   //verify(ARRAY_SIZE, results_data, verify_data);
+//   //verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bo_matmul/matmul_mi.c b/mt/bo_matmul/matmul_mi.c
index ccd39875e2085f4fd8857d5f840128dbd313f0f8..3ccdb6244a4515c1159457f6001848c144284251 100644 (file)
--- a/mt/bo_matmul/matmul_mi.c
+++ b/mt/bo_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -308,33 +308,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   //verify(ARRAY_SIZE, results_data, verify_data);
+//   //verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 //
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bo_vvadd/bo_vvadd.c b/mt/bo_vvadd/bo_vvadd.c
index 74b0351a8535b97a28ab370b45ded6678cab5657..efdee6c1c4773441a5dce56bf24881e43364e917 100755 (executable)
--- a/mt/bo_vvadd/bo_vvadd.c
+++ b/mt/bo_vvadd/bo_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -138,12 +138,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -151,21 +151,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bp_matmul/bp_matmul.c b/mt/bp_matmul/bp_matmul.c
index de964db65bd787decd0347880d7ae67e8af19d15..dd061103031230dfb4ed8526ff0a8f25da94d823 100755 (executable)
--- a/mt/bp_matmul/bp_matmul.c
+++ b/mt/bp_matmul/bp_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -308,33 +308,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   //verify(ARRAY_SIZE, results_data, verify_data);
+//   //verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bp_matmul/matmul_mi.c b/mt/bp_matmul/matmul_mi.c
index de964db65bd787decd0347880d7ae67e8af19d15..dd061103031230dfb4ed8526ff0a8f25da94d823 100755 (executable)
--- a/mt/bp_matmul/matmul_mi.c
+++ b/mt/bp_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -308,33 +308,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   //stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   //verify(ARRAY_SIZE, results_data, verify_data);
+//   //verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bp_vvadd/bp_vvadd.c b/mt/bp_vvadd/bp_vvadd.c
index 5d073cf10cbd3945a64ef6aaa0fdb523ad44a739..41d56ab6c357754e887298d0a35f6e1e0f48f176 100755 (executable)
--- a/mt/bp_vvadd/bp_vvadd.c
+++ b/mt/bp_vvadd/bp_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -144,12 +144,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -157,21 +157,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/br_matmul/br_matmul.c b/mt/br_matmul/br_matmul.c
index 5ca1dbe427c11ec7ec99df9057d5fa865be504f9..f831ac2d364ea08e0299acc5905048ae50e0f769 100755 (executable)
--- a/mt/br_matmul/br_matmul.c
+++ b/mt/br_matmul/br_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
   if (coreid != 0)
     return;
@@ -138,7 +138,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
       tB[(j + 1)*lda + i + 1] = B[(i + 1)*lda + j + 1];
     }
   }
-  barrier();
+  barrier(ncores);
 
   // compute C[j*n + i] += A[j*n + k] + Btranspose[i*n + k]
   for ( j2 = 0; j2 < lda; j2 += jBLOCK )
@@ -250,33 +250,33 @@ void thread_entry(int cid, int nc)
 
 
 //  // Execute the provided, naive matmul
-//  barrier();
-//  stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//  barrier(nc);
+//  stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //  // verify
-//  verify(ARRAY_SIZE, results_data, verify_data);
+//  verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //  // clear results from the first trial
 //  size_t i;
 //  if (coreid == 0) 
 //    for (i=0; i < ARRAY_SIZE; i++)
 //      results_data[i] = 0;
-//  barrier();
+//  barrier(nc);
 
    
   // Execute your faster matmul
-  barrier();
-  stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+  barrier(nc);
+  stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-  printArray("results:", ARRAY_SIZE, results_data);
-  printArray("verify :", ARRAY_SIZE, verify_data);
+  printArrayMT("results:", ARRAY_SIZE, results_data);
+  printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
   // verify
-  verify(ARRAY_SIZE, results_data, verify_data);
-  barrier();
+  verifyMT(ARRAY_SIZE, results_data, verify_data);
+  barrier(nc);
 
   exit(0);
 }

diff --git a/mt/br_matmul/matmul_mi.c b/mt/br_matmul/matmul_mi.c
index 5ca1dbe427c11ec7ec99df9057d5fa865be504f9..14a0705bfbe0b8f3b5c56985e4b488b65ef22184 100755 (executable)
--- a/mt/br_matmul/matmul_mi.c
+++ b/mt/br_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
   if (coreid != 0)
     return;
@@ -138,7 +138,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
       tB[(j + 1)*lda + i + 1] = B[(i + 1)*lda + j + 1];
     }
   }
-  barrier();
+  barrier(nc);
 
   // compute C[j*n + i] += A[j*n + k] + Btranspose[i*n + k]
   for ( j2 = 0; j2 < lda; j2 += jBLOCK )
@@ -250,33 +250,33 @@ void thread_entry(int cid, int nc)
 
 
 //  // Execute the provided, naive matmul
-//  barrier();
-//  stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//  barrier(nc);
+//  stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //  // verify
-//  verify(ARRAY_SIZE, results_data, verify_data);
+//  verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //  // clear results from the first trial
 //  size_t i;
 //  if (coreid == 0) 
 //    for (i=0; i < ARRAY_SIZE; i++)
 //      results_data[i] = 0;
-//  barrier();
+//  barrier(nc);
 
    
   // Execute your faster matmul
-  barrier();
-  stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+  barrier(nc);
+  stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-  printArray("results:", ARRAY_SIZE, results_data);
-  printArray("verify :", ARRAY_SIZE, verify_data);
+  printArrayMT("results:", ARRAY_SIZE, results_data);
+  printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
   // verify
-  verify(ARRAY_SIZE, results_data, verify_data);
-  barrier();
+  verifyMT(ARRAY_SIZE, results_data, verify_data);
+  barrier(nc);
 
   exit(0);
 }

diff --git a/mt/br_vvadd/br_vvadd.c b/mt/br_vvadd/br_vvadd.c
index b27ed647cdb36c908565379c274d948d03acf251..ce0d6bb8d41672203013db2ac545c7c969d50597 100755 (executable)
--- a/mt/br_vvadd/br_vvadd.c
+++ b/mt/br_vvadd/br_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -140,12 +140,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -153,21 +153,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bs_matmul/bs_matmul.c b/mt/bs_matmul/bs_matmul.c
index f382a4268dba4908af3acd67f6c5d4a56e3e8f65..336c0838f472553892081fe5de56512116d30cd5 100755 (executable)
--- a/mt/bs_matmul/bs_matmul.c
+++ b/mt/bs_matmul/bs_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -151,33 +151,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bs_matmul/matmul_mi.c b/mt/bs_matmul/matmul_mi.c
index d1500d2c85dedbb8532a3509b5fe3e79b97a3ff4..ec0d89be4229a0474a0f8947889be0b43e95364b 100644 (file)
--- a/mt/bs_matmul/matmul_mi.c
+++ b/mt/bs_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -157,33 +157,33 @@ void thread_entry(int cid, int nc)
 
 
 //   // Execute the provided, naive matmul
-//   barrier();
-//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+//   barrier(nc);
+//   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
 // 
 //   
 //   // verify
-//   verify(ARRAY_SIZE, results_data, verify_data);
+//   verifyMT(ARRAY_SIZE, results_data, verify_data);
 //   
 //   // clear results from the first trial
 //   size_t i;
 //   if (coreid == 0) 
 //      for (i=0; i < ARRAY_SIZE; i++)
 //         results_data[i] = 0;
-//   barrier();
+//   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bs_vvadd/bs_vvadd.c b/mt/bs_vvadd/bs_vvadd.c
index 01d708b3d84f8d1757a0d393c2ca824dd479644e..af126f035c9473933a2f6d8ec1f5fba8d438f071 100755 (executable)
--- a/mt/bs_vvadd/bs_vvadd.c
+++ b/mt/bs_vvadd/bs_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -145,12 +145,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -158,21 +158,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/bt_matmul/bt_matmul.c b/mt/bt_matmul/bt_matmul.c
index 021549144391b2360ddead0323838041209b954f..4cf652d0c7d8a1be96f7f71d0d3cb0bce2a060ab 100755 (executable)
--- a/mt/bt_matmul/bt_matmul.c
+++ b/mt/bt_matmul/bt_matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -209,7 +209,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                        pos_B += (lda*step_k) ;
                                                        pos_A += step_k;
                                                }
-                                               //barrier();
+                                               //barrier(nc);
 
                                                C[(pos_C + 0)] = temp10;
                                                C[(pos_C + 1)] = temp11;
@@ -219,7 +219,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp15;
                                                C[(pos_C + 6)] = temp16;
                                                C[(pos_C + 7)] = temp17;
-                                               //barrier();
+                                               //barrier(nc);
                                
                                                pos_C = i + j*lda;
                                                //pos_C -= lda;
@@ -231,15 +231,15 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp05;
                                                C[(pos_C + 6)] = temp06;
                                                C[(pos_C + 7)] = temp07;
-                                               //barrier();
+                                               //barrier(nc);
                                                //pos_C += step_j * lda;
                                        }
-                                       //barrier();
+                                       //barrier(nc);
                                }
-                               //barrier();
+                               //barrier(nc);
 
                        }
-                       //barrier();
+                       //barrier(nc);
                }       
 }
 
@@ -259,35 +259,35 @@ void thread_entry(int cid, int nc)
 
        /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
           
 
 
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    
        //printf("input1_data");

diff --git a/mt/bt_matmul/matmul_mi.c b/mt/bt_matmul/matmul_mi.c
index dc9ae1bd6ae7d5bf714695f3276f086726bdf795..181314ec5eec2c7885471d66d0bf7ffc538208a8 100755 (executable)
--- a/mt/bt_matmul/matmul_mi.c
+++ b/mt/bt_matmul/matmul_mi.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -210,7 +210,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                        pos_B += (lda*step_k) ;
                                                        pos_A += step_k;
                                                }
-                                               //barrier();
+                                               //barrier(nc);
 
                                                C[(pos_C + 0)] = temp10;
                                                C[(pos_C + 1)] = temp11;
@@ -220,7 +220,7 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp15;
                                                C[(pos_C + 6)] = temp16;
                                                C[(pos_C + 7)] = temp17;
-                                               //barrier();
+                                               //barrier(nc);
                                
                                                pos_C = i + j*lda;
                                                //pos_C -= lda;
@@ -232,15 +232,15 @@ void __attribute__((noinline)) matmul(const int lda,  const data_t A[], const da
                                                C[(pos_C + 5)] = temp05;
                                                C[(pos_C + 6)] = temp06;
                                                C[(pos_C + 7)] = temp07;
-                                               //barrier();
+                                               //barrier(nc);
                                                //pos_C += step_j * lda;
                                        }
-                                       //barrier();
+                                       //barrier(nc);
                                }
-                               //barrier();
+                               //barrier(nc);
 
                        }
-                       //barrier();
+                       //barrier(nc);
                }       
 }
 
@@ -260,35 +260,35 @@ void thread_entry(int cid, int nc)
 
        /*
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    */
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
           
 
 
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    
        //printf("input1_data");

diff --git a/mt/bt_vvadd/bt_vvadd.c b/mt/bt_vvadd/bt_vvadd.c
index d2a01c45163719bfae3e683b95758ca3c08884e1..7af3562b18a7df99deafcfdc1940847af1e97349 100755 (executable)
--- a/mt/bt_vvadd/bt_vvadd.c
+++ b/mt/bt_vvadd/bt_vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -139,12 +139,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -152,21 +152,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/matmul/matmul.c b/mt/matmul/matmul.c
index 93f8ea9c41887c69ff2c66e21cef98a0534c071e..b009d26d16b6a867e17a0864c12a32e450cc3806 100755 (executable)
--- a/mt/matmul/matmul.c
+++ b/mt/matmul/matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -134,33 +134,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/mt-matmul/mt-matmul.c b/mt/mt-matmul/mt-matmul.c
index 93f8ea9c41887c69ff2c66e21cef98a0534c071e..b009d26d16b6a867e17a0864c12a32e450cc3806 100644 (file)
--- a/mt/mt-matmul/mt-matmul.c
+++ b/mt/mt-matmul/mt-matmul.c
@@ -52,7 +52,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
     
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
    int i;
    if (coreid != 0)
@@ -64,7 +64,7 @@ void printArray( char name[], int n, data_t arr[] )
    printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -134,33 +134,33 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, naive matmul
-   barrier();
-   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul_naive(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
    
    // clear results from the first trial
    size_t i;
    if (coreid == 0) 
       for (i=0; i < ARRAY_SIZE; i++)
          results_data[i] = 0;
-   barrier();
+   barrier(nc);
 
    
    // Execute your faster matmul
-   barrier();
-   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier());
+   barrier(nc);
+   stats(matmul(DIM_SIZE, input1_data, input2_data, results_data); barrier(nc));
  
 #ifdef DEBUG
-   printArray("results:", ARRAY_SIZE, results_data);
-   printArray("verify :", ARRAY_SIZE, verify_data);
+   printArrayMT("results:", ARRAY_SIZE, results_data);
+   printArrayMT("verify :", ARRAY_SIZE, verify_data);
 #endif
    
    // verify
-   verify(ARRAY_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(ARRAY_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }

diff --git a/mt/mt-vvadd/mt-vvadd.c b/mt/mt-vvadd/mt-vvadd.c
index 497b9bb38df48c3b50ebad341599cff512c756ae..d5868e4df002eb8596ca841e64788640a82cea6f 100644 (file)
--- a/mt/mt-vvadd/mt-vvadd.c
+++ b/mt/mt-vvadd/mt-vvadd.c
@@ -51,7 +51,7 @@ unsigned long ncores;
 //--------------------------------------------------------------------------
 // Helper functions
  
-void printArray( char name[], int n, data_t arr[] )
+void printArrayMT( char name[], int n, data_t arr[] )
 {
   int i;
   if (coreid != 0)
@@ -63,7 +63,7 @@ void printArray( char name[], int n, data_t arr[] )
   printf( "\n" );
 }
       
-void __attribute__((noinline)) verify(size_t n, const data_t* test, const data_t* correct)
+void __attribute__((noinline)) verifyMT(size_t n, const data_t* test, const data_t* correct)
 {
    if (coreid != 0)
       return;
@@ -131,12 +131,12 @@ void thread_entry(int cid, int nc)
 
 
    // Execute the provided, terrible vvadd
-   barrier();
-   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd(DATA_SIZE, results_data, input2_data); barrier(nc));
  
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
+   verifyMT(DATA_SIZE, results_data, verify_data);
    
    // reset results from the first trial
    if (coreid == 0) 
@@ -144,21 +144,21 @@ void thread_entry(int cid, int nc)
       for (i=0; i < DATA_SIZE; i++)
          results_data[i] = input1_data[i];
    }
-   barrier();
+   barrier(nc);
                                             
    
    // Execute your faster vvadd
-   barrier();
-   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier());
+   barrier(nc);
+   stats(vvadd_opt(DATA_SIZE, results_data, input2_data); barrier(nc));
 
 #ifdef DEBUG
-   printArray("results: ", DATA_SIZE, results_data);
-   printArray("verify : ", DATA_SIZE, verify_data);
+   printArrayMT("results: ", DATA_SIZE, results_data);
+   printArrayMT("verify : ", DATA_SIZE, verify_data);
 #endif
    
    // verify
-   verify(DATA_SIZE, results_data, verify_data);
-   barrier();
+   verifyMT(DATA_SIZE, results_data, verify_data);
+   barrier(nc);
 
    exit(0);
 }