From f1120f06a7ea7fb6cf897df0a71329b3e54c3030 Mon Sep 17 00:00:00 2001
From: Anthony <adanalis@icl.utk.edu>
Date: Tue, 29 Oct 2024 20:23:51 -0400
Subject: [PATCH 1/2] CAT: New instruction benchmarks for FMA and Int.

---
 src/counter_analysis_toolkit/Makefile       |   2 +-
 src/counter_analysis_toolkit/instructions.c | 343 ++++++++++++++++++++
 2 files changed, 344 insertions(+), 1 deletion(-)

diff --git a/src/counter_analysis_toolkit/Makefile b/src/counter_analysis_toolkit/Makefile
index 608c33a03..ed65548af 100644
--- a/src/counter_analysis_toolkit/Makefile
+++ b/src/counter_analysis_toolkit/Makefile
@@ -103,7 +103,7 @@ icache_seq_kernel_0.o: icache_seq.c icache_seq.h
 	rm icache_seq_kernel_0.o
 
 instr: instructions.c instr.h
-	-$(CC) -c $(CFLAGS) $(OPT2) -ftree-vectorize $(INSTR) $(INCFLAGS) instructions.c -o instructions.o
+	-$(CC) -c $(CFLAGS) $(OPT2) -ftree-vectorize $(FLOP) $(INSTR) $(INCFLAGS) instructions.c -o instructions.o
 
 weak_symbols.o: weak_symbols.c vec.h
 	-$(CC) -c $(CFLAGS) weak_symbols.c
diff --git a/src/counter_analysis_toolkit/instructions.c b/src/counter_analysis_toolkit/instructions.c
index 80edf0df8..7a021b198 100644
--- a/src/counter_analysis_toolkit/instructions.c
+++ b/src/counter_analysis_toolkit/instructions.c
@@ -115,6 +115,234 @@ void test_int_add(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 
+void test_int_add_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    int i32_00, i32_01, i32_02, i32_03, i32_04, i32_05, i32_06, i32_07;
+    int i32_08, i32_09, i32_10, i32_11;
+    int i32_100, i32_101, i32_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    i32_00 =  2*p;
+    i32_01 = -p/3;
+    i32_02 =  p/4;
+    i32_03 = -p/5;
+    i32_04 =  p/6;
+    i32_05 = -p/7;
+    i32_06 =  p/8;
+    i32_07 = -p/9;
+    i32_08 =  1+p/2;
+    i32_09 =  1-p/2;
+    i32_10 =  1+p/3;
+    i32_11 =  1-p/3;
+
+    i32_100 =  17;
+    i32_101 = -18;
+    i32_102 =  12;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 12345678 ){
+        p /= 2;
+        i32_100 *= 13;
+        i32_101 *= 12;
+        i32_102 *= 11;
+    }else{
+        // Almost certainly this is what will execute and all variables will
+        // end up with the value zero, but the compiler doesn't know that.
+        i32_100 /= i32_00+16;
+        i32_101 /= i32_00+17;
+        i32_102 /= i32_00+11;
+    }
+
+#define I32_ADDS(_X) {i32_00 += _X; i32_01 += _X; i32_02 += _X; i32_03 += _X; i32_04 += _X; i32_05 += _X; i32_06 += _X; i32_07 += _X; i32_08 += _X; i32_09 += _X; i32_10 += _X; i32_11 += _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            I32_ADDS(i32_100);
+            I32_ADDS(i32_101);
+            I32_ADDS(i32_102);
+            if( i32_100 > 100 ){
+                I32_ADDS(i32_07);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld # INT_ADD_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
+    sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
+
+clean_up:
+
+    return;
+}
+
+
+void test_int_mul_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    int i32_00, i32_01, i32_02, i32_03, i32_04, i32_05, i32_06, i32_07;
+    int i32_08, i32_09, i32_10, i32_11;
+    int i32_100, i32_101, i32_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    i32_00 =  2*p;
+    i32_01 = -p/3;
+    i32_02 =  p/4;
+    i32_03 = -p/5;
+    i32_04 =  p/6;
+    i32_05 = -p/7;
+    i32_06 =  p/8;
+    i32_07 =  1/p;
+    i32_08 =  1+p/2;
+    i32_09 =  1-p/2;
+    i32_10 =  1+p/3;
+    i32_11 =  1-p/3;
+
+    i32_100 =  17;
+    i32_101 = -18;
+    i32_102 =  12;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 12345678 ){
+        p /= 2;
+        i32_100 *= 13;
+        i32_101 *= 12;
+        i32_102 *= 11;
+    }else{
+        // Almost certainly this is what will execute and all variables will
+        // end up with the value one, but the compiler doesn't know that.
+        i32_100 = 1 + i32_100 / (i32_00+16);
+        i32_101 = 1 + i32_101 / (i32_00+17);
+        i32_102 = 1 + i32_102 / (i32_00+11);
+    }
+
+#define I32_MULS(_X) {i32_00 *= _X; i32_01 *= _X; i32_02 *= _X; i32_03 *= _X; i32_04 *= _X; i32_05 *= _X; i32_06 *= _X; i32_07 *= _X; i32_08 *= _X; i32_09 *= _X; i32_10 *= _X; i32_11 *= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            I32_MULS(i32_100);
+            I32_MULS(i32_101);
+            I32_MULS(i32_102);
+            if( i32_100 > 100 ){
+                I32_MULS(i32_07);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld # INT_MUL_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
+    sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
+
+clean_up:
+
+    return;
+}
+
+
+void test_int_div_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    int i32_00, i32_01, i32_02, i32_03, i32_04, i32_05, i32_06, i32_07;
+    int i32_08, i32_09, i32_10, i32_11;
+    int i32_100, i32_101, i32_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    i32_00 =  2*p;
+    i32_01 = -p/3;
+    i32_02 =  p/4;
+    i32_03 = -p/5;
+    i32_04 =  p/6;
+    i32_05 = -p/7;
+    i32_06 =  p/8;
+    i32_07 =  1+1/p;
+    i32_08 =  1+p/2;
+    i32_09 =  1-p/2;
+    i32_10 =  1+p/3;
+    i32_11 =  1-p/3;
+
+    i32_100 =  17;
+    i32_101 = -18;
+    i32_102 =  12;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 12345678 ){
+        p /= 2;
+        i32_100 *= 13;
+        i32_101 *= 12;
+        i32_102 *= 11;
+    }else{
+        // Almost certainly this is what will execute and all variables will
+        // end up with the value one, but the compiler doesn't know that.
+        i32_100 = 1 + i32_100 / (i32_00+16);
+        i32_101 = 1 + i32_101 / (i32_00+17);
+        i32_102 = 1 + i32_102 / (i32_00+11);
+    }
+
+#define I32_DIVS(_X) {i32_00 /= _X; i32_01 /= _X; i32_02 /= _X; i32_03 /= _X; i32_04 /= _X; i32_05 /= _X; i32_06 /= _X; i32_07 /= _X; i32_08 /= _X; i32_09 /= _X; i32_10 /= _X; i32_11 /= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            I32_DIVS(i32_100);
+            I32_DIVS(i32_101);
+            I32_DIVS(i32_102);
+            if( i32_100 > 100 ){
+                I32_DIVS(i32_07);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld # INT_DIV_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
+    sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
+
+clean_up:
+
+    return;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // f64 ADDITION
 
@@ -889,6 +1117,77 @@ void test_f64_div_max(int p, int M, int N, int EventSet, FILE *fp){
     return;
 }
 
+
+void test_f64_fma_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
+    double f64_08, f64_09, f64_10, f64_11;
+    double f64_100, f64_101, f64_102;
+    double f64_B;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  p/431.2;
+    f64_01 = -p/431.3;
+    f64_02 =  p/431.4;
+    f64_03 = -p/431.5;
+    f64_04 =  p/431.6;
+    f64_05 = -p/431.7;
+    f64_06 =  p/431.8;
+    f64_07 = -p/431.9;
+    f64_08 =  p/432.0;
+    f64_09 = -p/432.1;
+    f64_10 =  p/432.2;
+    f64_11 = -p/432.3;
+
+    f64_100 =  1.00001;
+    f64_101 = -1.00002;
+    f64_102 =  1.00003;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p != 12345678 ){
+        f64_100 /= 1.000045;
+        f64_101 /= 1.000054;
+        f64_102 /= 1.000067;
+    }
+    f64_B = f64_100/34567.8;
+
+#define F64_FMAS(_A,_B) {f64_00 = _A*f64_00+_B; f64_01 = _A*f64_01+_B; f64_02 = _A*f64_02+_B; f64_03 = _A*f64_03+_B; f64_04 = _A*f64_04+_B; f64_05 = _A*f64_05+_B; f64_06 = _A*f64_06+_B; f64_07 = _A*f64_07+_B; f64_08 = _A*f64_08+_B; f64_09 = _A*f64_09+_B; f64_10 = _A*f64_10+_B; f64_11 = _A*f64_11+_B;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64_FMAS(f64_100, f64_B);
+            F64_FMAS(f64_101, f64_B);
+            F64_FMAS(f64_102, f64_B);
+            if( p < 2 ){
+                F64_FMAS(f64_00, f64_B);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld # FP_FMA_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
+    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+
+clean_up:
+
+    return;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // MEM ops
 
@@ -1144,6 +1443,39 @@ void instr_test(int EventSet, FILE *fp) {
     }
     fprintf(fp, "\n");
 
+    ////////////////////////////////////////
+    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_int_add_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_int_mul_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_int_div_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
     ////////////////////////////////////////
     fprintf(fp, "# (((40+3)*N)+3)*M\n");
     for(i=16; i<50; i*=2){
@@ -1232,6 +1564,17 @@ void instr_test(int EventSet, FILE *fp) {
     }
     fprintf(fp, "\n");
 
+    ////////////////////////////////////////
+    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM/4);
+            N = (int)(i*f[j]*minN/4);
+            test_f64_fma_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
     ////////////////////////////////////////
     fprintf(fp, "# (((2+3)*N)+3)*M\n");
     for(i=16; i<50; i*=2){

From 1af70642acf57796795aab759bdbc2f21df0747d Mon Sep 17 00:00:00 2001
From: Anthony <adanalis@icl.utk.edu>
Date: Wed, 30 Oct 2024 17:28:42 -0400
Subject: [PATCH 2/2] CAT: More instruction tests and cleaner output.

---
 src/counter_analysis_toolkit/Makefile       |    2 +-
 src/counter_analysis_toolkit/instructions.c | 1419 ++++++++++++++-----
 2 files changed, 1052 insertions(+), 369 deletions(-)

diff --git a/src/counter_analysis_toolkit/Makefile b/src/counter_analysis_toolkit/Makefile
index ed65548af..45ec4ae58 100644
--- a/src/counter_analysis_toolkit/Makefile
+++ b/src/counter_analysis_toolkit/Makefile
@@ -162,7 +162,7 @@ vec_nonfma_dp: vec_nonfma_dp.c vec_scalar_verify.h
 	-$(CC) -c $(CFLAGS) $(INCFLAGS) $(VEC256) vec_nonfma_dp.c -o vec_nonfma_dp-256B.o
 	-$(CC) -c $(CFLAGS) $(INCFLAGS) $(VEC512) vec_nonfma_dp.c -o vec_nonfma_dp-512B.o
 
-cat_collect: main.c
+cat_collect:
 	$(CC) $(CFLAGS) -fopenmp $(INCFLAGS) main.c $(wildcard *.o) -o cat_collect $(LDFLAGS)
 
 clean:
diff --git a/src/counter_analysis_toolkit/instructions.c b/src/counter_analysis_toolkit/instructions.c
index 7a021b198..9fd28c167 100644
--- a/src/counter_analysis_toolkit/instructions.c
+++ b/src/counter_analysis_toolkit/instructions.c
@@ -105,7 +105,7 @@ void test_int_add(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # INT_ADD_count: %lld (%.3lf)\n", N, ev_values[0], 50LL*N*M, ev_values[0]/(50.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 50LL*N*M, (double)ev_values[0]/(50.0*N*M));
 
     sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07 + i32_08 + i32_09;
 
@@ -180,7 +180,7 @@ void test_int_add_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # INT_ADD_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
     sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
     sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
@@ -256,7 +256,7 @@ void test_int_mul_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # INT_MUL_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 50LL*N*M, (double)ev_values[0]/(50.0*N*M));
 
     sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
     sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
@@ -332,7 +332,7 @@ void test_int_div_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # INT_DIV_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 50LL*N*M, (double)ev_values[0]/(50.0*N*M));
 
     sum_i32 += i32_00 + i32_01 + i32_02 + i32_03 + i32_04 + i32_05 + i32_06 + i32_07;
     sum_i32 += i32_08 + i32_09 + i32_10 + i32_11;
@@ -344,18 +344,18 @@ void test_int_div_max(int p, int M, int N, int EventSet, FILE *fp){
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// f64 ADDITION
+// f32 ADD
 
-void test_f64_add(int p, int M, int N, int EventSet, FILE *fp){
+void test_f32_add(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-    double f64_00, f64_01, f64_02, f64_03;
+    float f32_00, f32_01, f32_02, f32_03;
 
     /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  (double)p/1.02;
-    f64_01 = -(double)p/1.03;
-    f64_02 =  (double)p/1.04;
-    f64_03 = -(double)p/1.05;
+    f32_00 =  (float)p/1.02;
+    f32_01 = -(float)p/1.03;
+    f32_02 =  (float)p/1.04;
+    f32_03 = -(float)p/1.05;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -365,20 +365,20 @@ void test_f64_add(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-#define FADD_BLOCK() {f64_01 += f64_00; f64_02 += f64_01; f64_03 += f64_02; f64_00 += f64_03;}
+#define F32ADD_BLOCK() {f32_01 += f32_00; f32_02 += f32_01; f32_03 += f32_02; f32_00 += f32_03;}
 
     for(int i=0; i<M; i++){
         for(int j=0; j<N; j++){
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
-            FADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
+            F32ADD_BLOCK();
         }
     }
 
@@ -389,9 +389,9 @@ void test_f64_add(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
     long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
-    fprintf(fp, "%d %lld # FP_ADD_count: %lld (%.3lf)\n", N, ev_values[0], fp_op_count, (double)ev_values[0]/fp_op_count);
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03;
 
 clean_up:
 
@@ -399,30 +399,30 @@ void test_f64_add(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 
-void test_f64_add_max(int p, int M, int N, int EventSet, FILE *fp){
+void test_f32_add_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
-    double f64_08, f64_09, f64_10, f64_11;
-    double f64_100, f64_101, f64_102;
+    float f32_00, f32_01, f32_02, f32_03, f32_04, f32_05, f32_06, f32_07;
+    float f32_08, f32_09, f32_10, f32_11;
+    float f32_100, f32_101, f32_102;
 
     /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  p/1.2;
-    f64_01 = -p/1.3;
-    f64_02 =  p/1.4;
-    f64_03 = -p/1.5;
-    f64_04 =  p/1.6;
-    f64_05 = -p/1.7;
-    f64_06 =  p/1.8;
-    f64_07 = -p/1.9;
-    f64_08 =  p/2.0;
-    f64_09 = -p/2.1;
-    f64_10 =  p/2.2;
-    f64_11 = -p/2.3;
-
-    f64_100 =  0.00100;
-    f64_101 = -0.00101;
-    f64_102 =  0.00102;
+    f32_00 =  p/1.2;
+    f32_01 = -p/1.3;
+    f32_02 =  p/1.4;
+    f32_03 = -p/1.5;
+    f32_04 =  p/1.6;
+    f32_05 = -p/1.7;
+    f32_06 =  p/1.8;
+    f32_07 = -p/1.9;
+    f32_08 =  p/2.0;
+    f32_09 = -p/2.1;
+    f32_10 =  p/2.2;
+    f32_11 = -p/2.3;
+
+    f32_100 =  0.00100;
+    f32_101 = -0.00101;
+    f32_102 =  0.00102;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -434,18 +434,20 @@ void test_f64_add_max(int p, int M, int N, int EventSet, FILE *fp){
 
     if( p == 123456 ){
         p /= 2;
-        f64_100 *= 1.045;
-        f64_101 *= 1.054;
-        f64_102 *= 1.067;
+        f32_100 *= 1.045;
+        f32_101 *= 1.054;
+        f32_102 *= 1.067;
     }
 
-#define F64_ADDS(_X) {f64_00 += _X; f64_01 += _X; f64_02 += _X; f64_03 += _X; f64_04 += _X; f64_05 += _X; f64_06 += _X; f64_07 += _X; f64_08 += _X; f64_09 += _X; f64_10 += _X; f64_11 += _X;}
+#define F32_ADDS(_X) {f32_00 += _X; f32_01 += _X; f32_02 += _X; f32_03 += _X; f32_04 += _X; f32_05 += _X; f32_06 += _X; f32_07 += _X; f32_08 += _X; f32_09 += _X; f32_10 += _X; f32_11 += _X;}
 
     for(int i=0; i<M; i++){
         for(int j=0; j<N; j++){
-            F64_ADDS(f64_100); F64_ADDS(f64_101); F64_ADDS(f64_102);
-            if( p < 4 ){
-                F64_ADDS(f64_00); F64_ADDS(f64_01); F64_ADDS(f64_02);
+            F32_ADDS(f32_100);
+            F32_ADDS(f32_101);
+            F32_ADDS(f32_102);
+            if( p < 2 ){
+                F32_ADDS(f32_00);
             }
         }
     }
@@ -456,32 +458,30 @@ void test_f64_add_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
-    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03 + f32_04 + f32_05 + f32_06 + f32_07;
+    sum_f32 += f32_08 + f32_09 + f32_10 + f32_11;
 
 clean_up:
 
     return;
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
-// Vector double precision ADD
+// f32 SUB
 
-void test_f64_add_DVEC128(int p, int M, int N, int EventSet, FILE *fp){
+void test_f32_sub(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+2
-    double a[BUFFER_SIZE];
-    double b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  (float)p/1.02;
+    f32_01 = -(float)p/1.03;
+    f32_02 =  (float)p/1.04;
+    f32_03 = -(float)p/1.05;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -491,10 +491,20 @@ void test_f64_add_DVEC128(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-2);
-    for(int i=0; i<UB; i++){
-        for(int j=2; j<BUFFER_SIZE; j++){
-            a[j] = a[j-2] + b[j];
+#define F32SUB_BLOCK() {f32_01 -= f32_00; f32_02 -= f32_01; f32_03 -= f32_02; f32_00 -= f32_03;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
+            F32SUB_BLOCK();
         }
     }
 
@@ -504,30 +514,41 @@ void test_f64_add_DVEC128(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_DVEC128_count: %lld (%.3lf)\n", N, ev_values[0], N*M/2LL, (double)ev_values[0]/(N*M/2.0));
+    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += a[j];
-    }
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03;
 
 clean_up:
 
     return;
 }
 
-void test_f64_add_DVEC256(int p, int M, int N, int EventSet, FILE *fp){
+
+void test_f32_sub_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+4
-    double a[BUFFER_SIZE];
-    double b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03, f32_04, f32_05, f32_06, f32_07;
+    float f32_08, f32_09, f32_10, f32_11;
+    float f32_100, f32_101, f32_102;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  p/1.2;
+    f32_01 = -p/1.3;
+    f32_02 =  p/1.4;
+    f32_03 = -p/1.5;
+    f32_04 =  p/1.6;
+    f32_05 = -p/1.7;
+    f32_06 =  p/1.8;
+    f32_07 = -p/1.9;
+    f32_08 =  p/2.0;
+    f32_09 = -p/2.1;
+    f32_10 =  p/2.2;
+    f32_11 = -p/2.3;
+
+    f32_100 =  0.00100;
+    f32_101 = -0.00101;
+    f32_102 =  0.00102;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -537,10 +558,23 @@ void test_f64_add_DVEC256(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-4);
-    for(int i=0; i<UB; i++){
-        for(int j=4; j<BUFFER_SIZE; j++){
-            a[j] = a[j-4] + b[j];
+    if( p == 123456 ){
+        p /= 2;
+        f32_100 *= 1.045;
+        f32_101 *= 1.054;
+        f32_102 *= 1.067;
+    }
+
+#define F32_SUBS(_X) {f32_00 -= _X; f32_01 -= _X; f32_02 -= _X; f32_03 -= _X; f32_04 -= _X; f32_05 -= _X; f32_06 -= _X; f32_07 -= _X; f32_08 -= _X; f32_09 -= _X; f32_10 -= _X; f32_11 -= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32_SUBS(f32_100);
+            F32_SUBS(f32_101);
+            F32_SUBS(f32_102);
+            if( p < 2 ){
+                F32_SUBS(f32_00);
+            }
         }
     }
 
@@ -550,30 +584,29 @@ void test_f64_add_DVEC256(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_DVEC256_count: %lld (%.3lf)\n", N, ev_values[0], N*M/4LL, (double)ev_values[0]/(N*M/4.0));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += a[j];
-    }
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03 + f32_04 + f32_05 + f32_06 + f32_07;
+    sum_f32 += f32_08 + f32_09 + f32_10 + f32_11;
 
 clean_up:
 
     return;
 }
 
-void test_f64_add_DVEC512(int p, int M, int N, int EventSet, FILE *fp){
+////////////////////////////////////////////////////////////////////////////////
+// f32 MULTIPLICATION
+
+void test_f32_mul(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+8
-    double a[BUFFER_SIZE];
-    double b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  (float)p/1.02;
+    f32_01 =  1.03/(float)p;
+    f32_02 =  (float)p/1.04;
+    f32_03 =  1.05/(float)p;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -583,10 +616,20 @@ void test_f64_add_DVEC512(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-8);
-    for(int i=0; i<UB; i++){
-        for(int j=8; j<BUFFER_SIZE; j++){
-            a[j] = a[j-8] + b[j];
+#define F32MUL_BLOCK() {f32_01 *= f32_00; f32_02 *= f32_01; f32_03 *= f32_02; f32_00 *= f32_03;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
+            F32MUL_BLOCK();
         }
     }
 
@@ -596,11 +639,80 @@ void test_f64_add_DVEC512(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_DVEC512_count: %lld (%.3lf)\n", N, ev_values[0], N*M/8LL, (double)ev_values[0]/(N*M/8.0));
+    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += a[j];
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03;
+
+clean_up:
+
+    return;
+}
+
+
+void test_f32_mul_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    float f32_00, f32_01, f32_02, f32_03, f32_04, f32_05, f32_06, f32_07;
+    float f32_08, f32_09, f32_10, f32_11;
+    float f32_100, f32_101, f32_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  p/431.2;
+    f32_01 = -p/431.3;
+    f32_02 =  p/431.4;
+    f32_03 = -p/431.5;
+    f32_04 =  p/431.6;
+    f32_05 = -p/431.7;
+    f32_06 =  p/431.8;
+    f32_07 = -p/431.9;
+    f32_08 =  p/432.0;
+    f32_09 = -p/432.1;
+    f32_10 =  p/432.2;
+    f32_11 = -p/432.3;
+
+    f32_100 =  1.00001;
+    f32_101 = -1.00002;
+    f32_102 =  1.00003;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 123456 ){
+        p /= 2;
+        f32_100 *= 1.0045;
+        f32_101 *= 1.0054;
+        f32_102 *= 1.0067;
+    }
+
+#define F32_MULS(_X) {f32_00 *= _X; f32_01 *= _X; f32_02 *= _X; f32_03 *= _X; f32_04 *= _X; f32_05 *= _X; f32_06 *= _X; f32_07 *= _X; f32_08 *= _X; f32_09 *= _X; f32_10 *= _X; f32_11 *= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32_MULS(f32_100);
+            F32_MULS(f32_101);
+            F32_MULS(f32_102);
+            if( p < 2 ){
+                F32_MULS(f32_00);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
     }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03 + f32_04 + f32_05 + f32_06 + f32_07;
+    sum_f32 += f32_08 + f32_09 + f32_10 + f32_11;
 
 clean_up:
 
@@ -608,21 +720,18 @@ void test_f64_add_DVEC512(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Vector single precision ADD
+// f32 DIVISION
 
-void test_f64_add_SVEC128(int p, int M, int N, int EventSet, FILE *fp){
+void test_f32_div(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+2
-    float a[BUFFER_SIZE];
-    float b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  1.0 + 1.0/(1000.1*(float)p);
+    f32_01 =  1.0 + 1.0/(1000.2*(float)p);
+    f32_02 =  1.0 + 1.0/(1000.3*(float)p);
+    f32_03 =  1.0 + 1.0/(1000.4*(float)p);
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -632,10 +741,20 @@ void test_f64_add_SVEC128(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-2);
-    for(int i=0; i<UB; i++){
-        for(int j=2; j<BUFFER_SIZE; j++){
-            a[j] = a[j-2] + b[j];
+#define F32DIV_BLOCK() {f32_01 /= f32_00; f32_02 /= f32_01; f32_03 /= f32_02; f32_00 /= f32_03;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
+            F32DIV_BLOCK();
         }
     }
 
@@ -645,30 +764,41 @@ void test_f64_add_SVEC128(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_SVEC128_count: %lld (%.3lf)\n", N, ev_values[0], N*M/2LL, (double)ev_values[0]/(N*M/2.0));
+    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += (float)a[j];
-    }
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03;
 
 clean_up:
 
     return;
 }
 
-void test_f64_add_SVEC256(int p, int M, int N, int EventSet, FILE *fp){
+
+void test_f32_div_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+4
-    float a[BUFFER_SIZE];
-    float b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03, f32_04, f32_05, f32_06, f32_07;
+    float f32_08, f32_09, f32_10, f32_11;
+    float f32_100, f32_101, f32_102;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  p/431.2;
+    f32_01 = -p/431.3;
+    f32_02 =  p/431.4;
+    f32_03 = -p/431.5;
+    f32_04 =  p/431.6;
+    f32_05 = -p/431.7;
+    f32_06 =  p/431.8;
+    f32_07 = -p/431.9;
+    f32_08 =  p/432.0;
+    f32_09 = -p/432.1;
+    f32_10 =  p/432.2;
+    f32_11 = -p/432.3;
+
+    f32_100 =  1.00001;
+    f32_101 = -1.00002;
+    f32_102 =  1.00003;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -678,10 +808,23 @@ void test_f64_add_SVEC256(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-4);
-    for(int i=0; i<UB; i++){
-        for(int j=4; j<BUFFER_SIZE; j++){
-            a[j] = a[j-4] + b[j];
+    if( p == 123456 ){
+        p /= 2;
+        f32_100 *= 1.0045;
+        f32_101 *= 1.0054;
+        f32_102 *= 1.0067;
+    }
+
+#define F32_DIVS(_X) {f32_00 /= _X; f32_01 /= _X; f32_02 /= _X; f32_03 /= _X; f32_04 /= _X; f32_05 /= _X; f32_06 /= _X; f32_07 /= _X; f32_08 /= _X; f32_09 /= _X; f32_10 /= _X; f32_11 /= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32_DIVS(f32_100);
+            F32_DIVS(f32_101);
+            F32_DIVS(f32_102);
+            if( p < 2 ){
+                F32_DIVS(f32_00);
+            }
         }
     }
 
@@ -691,30 +834,42 @@ void test_f64_add_SVEC256(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_SVEC256_count: %lld (%.3lf)\n", N, ev_values[0], N*M/4LL, (double)ev_values[0]/(N*M/4.0));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += (float)a[j];
-    }
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03 + f32_04 + f32_05 + f32_06 + f32_07;
+    sum_f32 += f32_08 + f32_09 + f32_10 + f32_11;
 
 clean_up:
 
     return;
 }
 
-void test_f64_add_SVEC512(int p, int M, int N, int EventSet, FILE *fp){
+
+void test_f32_fma_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-#undef BUFFER_SIZE
-#define BUFFER_SIZE 512+8
-    float a[BUFFER_SIZE];
-    float b[BUFFER_SIZE];
+    float f32_00, f32_01, f32_02, f32_03, f32_04, f32_05, f32_06, f32_07;
+    float f32_08, f32_09, f32_10, f32_11;
+    float f32_100, f32_101, f32_102;
+    float f32_B;
 
-    /* Initialize the arrays with values that the compiler cannot guess. */
-    for(int i=0; i<BUFFER_SIZE; i++){
-        a[i] =  p/(i+1.2);
-        b[i] = -p/(i+1.3);
-    }
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f32_00 =  p/431.2;
+    f32_01 = -p/431.3;
+    f32_02 =  p/431.4;
+    f32_03 = -p/431.5;
+    f32_04 =  p/431.6;
+    f32_05 = -p/431.7;
+    f32_06 =  p/431.8;
+    f32_07 = -p/431.9;
+    f32_08 =  p/432.0;
+    f32_09 = -p/432.1;
+    f32_10 =  p/432.2;
+    f32_11 = -p/432.3;
+
+    f32_100 =  1.00001;
+    f32_101 = -1.00002;
+    f32_102 =  1.00003;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -724,10 +879,23 @@ void test_f64_add_SVEC512(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    long long int UB=1LL*M*N/(BUFFER_SIZE-8);
-    for(int i=0; i<UB; i++){
-        for(int j=8; j<BUFFER_SIZE; j++){
-            a[j] = a[j-8] + b[j];
+    if( p != 12345678 ){
+        f32_100 /= 1.000045;
+        f32_101 /= 1.000054;
+        f32_102 /= 1.000067;
+    }
+    f32_B = f32_100/34567.8;
+
+#define F32_FMAS(_A,_B) {f32_00 = _A*f32_00+_B; f32_01 = _A*f32_01+_B; f32_02 = _A*f32_02+_B; f32_03 = _A*f32_03+_B; f32_04 = _A*f32_04+_B; f32_05 = _A*f32_05+_B; f32_06 = _A*f32_06+_B; f32_07 = _A*f32_07+_B; f32_08 = _A*f32_08+_B; f32_09 = _A*f32_09+_B; f32_10 = _A*f32_10+_B; f32_11 = _A*f32_11+_B;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F32_FMAS(f32_100, f32_B);
+            F32_FMAS(f32_101, f32_B);
+            F32_FMAS(f32_102, f32_B);
+            if( p < 2 ){
+                F32_FMAS(f32_00, f32_B);
+            }
         }
     }
 
@@ -737,21 +905,21 @@ void test_f64_add_SVEC512(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_ADD_SVEC512_count: %lld (%.3lf)\n", N, ev_values[0], N*M/8LL, (double)ev_values[0]/(N*M/8.0));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
-    for(int j=0; j<BUFFER_SIZE; j++){
-        sum_f64 += (float)a[j];
-    }
+    sum_f32 += f32_00 + f32_01 + f32_02 + f32_03 + f32_04 + f32_05 + f32_06 + f32_07;
+    sum_f32 += f32_08 + f32_09 + f32_10 + f32_11;
 
 clean_up:
 
     return;
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
-// f64 SUB
+// f64 ADD
 
-void test_f64_sub(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_add(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
     double f64_00, f64_01, f64_02, f64_03;
@@ -770,20 +938,20 @@ void test_f64_sub(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-#define FSUB_BLOCK() {f64_01 -= f64_00; f64_02 -= f64_01; f64_03 -= f64_02; f64_00 -= f64_03;}
+#define F64ADD_BLOCK() {f64_01 += f64_00; f64_02 += f64_01; f64_03 += f64_02; f64_00 += f64_03;}
 
     for(int i=0; i<M; i++){
         for(int j=0; j<N; j++){
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
-            FSUB_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
+            F64ADD_BLOCK();
         }
     }
 
@@ -794,7 +962,7 @@ void test_f64_sub(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
     long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
-    fprintf(fp, "%d %lld # FP_SUB_count: %lld (%.3lf)\n", N, ev_values[0], fp_op_count, (double)ev_values[0]/fp_op_count);
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
     sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
 
@@ -804,7 +972,7 @@ void test_f64_sub(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 
-void test_f64_sub_max(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_add_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
     double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
@@ -844,13 +1012,15 @@ void test_f64_sub_max(int p, int M, int N, int EventSet, FILE *fp){
         f64_102 *= 1.067;
     }
 
-#define F64_SUBS(_X) {f64_00 -= _X; f64_01 -= _X; f64_02 -= _X; f64_03 -= _X; f64_04 -= _X; f64_05 -= _X; f64_06 -= _X; f64_07 -= _X; f64_08 -= _X; f64_09 -= _X; f64_10 -= _X; f64_11 -= _X;}
+#define F64_ADDS(_X) {f64_00 += _X; f64_01 += _X; f64_02 += _X; f64_03 += _X; f64_04 += _X; f64_05 += _X; f64_06 += _X; f64_07 += _X; f64_08 += _X; f64_09 += _X; f64_10 += _X; f64_11 += _X;}
 
     for(int i=0; i<M; i++){
         for(int j=0; j<N; j++){
-            F64_SUBS(f64_100); F64_SUBS(f64_101); F64_SUBS(f64_102);
-            if( p < 4 ){
-                F64_SUBS(f64_00); F64_SUBS(f64_01); F64_SUBS(f64_02);
+            F64_ADDS(f64_100);
+            F64_ADDS(f64_101);
+            F64_ADDS(f64_102);
+            if( p < 2 ){
+                F64_ADDS(f64_00);
             }
         }
     }
@@ -861,7 +1031,7 @@ void test_f64_sub_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_SUB_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
 
     sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
     sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
@@ -871,19 +1041,20 @@ void test_f64_sub_max(int p, int M, int N, int EventSet, FILE *fp){
     return;
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
-// f64 MULTIPLICATION
+// f64 SUB
 
-void test_f64_mul(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_sub(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
     double f64_00, f64_01, f64_02, f64_03;
 
     /* Initialize the variables with values that the compiler cannot guess. */
     f64_00 =  (double)p/1.02;
-    f64_01 =  1.03/(double)p;
+    f64_01 = -(double)p/1.03;
     f64_02 =  (double)p/1.04;
-    f64_03 =  1.05/(double)p;
+    f64_03 = -(double)p/1.05;
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -893,20 +1064,20 @@ void test_f64_mul(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-#define FMUL_BLOCK() {f64_01 *= f64_00; f64_02 *= f64_01; f64_03 *= f64_02; f64_00 *= f64_03;}
+#define F64SUB_BLOCK() {f64_01 -= f64_00; f64_02 -= f64_01; f64_03 -= f64_02; f64_00 -= f64_03;}
 
     for(int i=0; i<M; i++){
         for(int j=0; j<N; j++){
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
-            FMUL_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
+            F64SUB_BLOCK();
         }
     }
 
@@ -917,7 +1088,7 @@ void test_f64_mul(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
     long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
-    fprintf(fp, "%d %lld # FP_MUL_count: %lld (%.3lf)\n", N, ev_values[0], fp_op_count, (double)ev_values[0]/fp_op_count);
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
 
     sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
 
@@ -927,7 +1098,7 @@ void test_f64_mul(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 
-void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_sub_max(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
     double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
@@ -935,22 +1106,496 @@ void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
     double f64_100, f64_101, f64_102;
 
     /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  p/431.2;
-    f64_01 = -p/431.3;
-    f64_02 =  p/431.4;
-    f64_03 = -p/431.5;
-    f64_04 =  p/431.6;
-    f64_05 = -p/431.7;
-    f64_06 =  p/431.8;
-    f64_07 = -p/431.9;
-    f64_08 =  p/432.0;
-    f64_09 = -p/432.1;
-    f64_10 =  p/432.2;
-    f64_11 = -p/432.3;
+    f64_00 =  p/1.2;
+    f64_01 = -p/1.3;
+    f64_02 =  p/1.4;
+    f64_03 = -p/1.5;
+    f64_04 =  p/1.6;
+    f64_05 = -p/1.7;
+    f64_06 =  p/1.8;
+    f64_07 = -p/1.9;
+    f64_08 =  p/2.0;
+    f64_09 = -p/2.1;
+    f64_10 =  p/2.2;
+    f64_11 = -p/2.3;
+
+    f64_100 =  0.00100;
+    f64_101 = -0.00101;
+    f64_102 =  0.00102;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 123456 ){
+        p /= 2;
+        f64_100 *= 1.045;
+        f64_101 *= 1.054;
+        f64_102 *= 1.067;
+    }
+
+#define F64_SUBS(_X) {f64_00 -= _X; f64_01 -= _X; f64_02 -= _X; f64_03 -= _X; f64_04 -= _X; f64_05 -= _X; f64_06 -= _X; f64_07 -= _X; f64_08 -= _X; f64_09 -= _X; f64_10 -= _X; f64_11 -= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64_SUBS(f64_100);
+            F64_SUBS(f64_101);
+            F64_SUBS(f64_102);
+            if( p < 2 ){
+                F64_SUBS(f64_00);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
+    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+
+clean_up:
+
+    return;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// f64 MULTIPLICATION
+
+void test_f64_mul(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  (double)p/1.02;
+    f64_01 =  1.03/(double)p;
+    f64_02 =  (double)p/1.04;
+    f64_03 =  1.05/(double)p;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+#define F64MUL_BLOCK() {f64_01 *= f64_00; f64_02 *= f64_01; f64_03 *= f64_02; f64_00 *= f64_03;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+            F64MUL_BLOCK();
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
+
+clean_up:
+
+    return;
+}
+
+
+void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
+    double f64_08, f64_09, f64_10, f64_11;
+    double f64_100, f64_101, f64_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  p/431.2;
+    f64_01 = -p/431.3;
+    f64_02 =  p/431.4;
+    f64_03 = -p/431.5;
+    f64_04 =  p/431.6;
+    f64_05 = -p/431.7;
+    f64_06 =  p/431.8;
+    f64_07 = -p/431.9;
+    f64_08 =  p/432.0;
+    f64_09 = -p/432.1;
+    f64_10 =  p/432.2;
+    f64_11 = -p/432.3;
+
+    f64_100 =  1.00001;
+    f64_101 = -1.00002;
+    f64_102 =  1.00003;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 123456 ){
+        p /= 2;
+        f64_100 *= 1.0045;
+        f64_101 *= 1.0054;
+        f64_102 *= 1.0067;
+    }
+
+#define F64_MULS(_X) {f64_00 *= _X; f64_01 *= _X; f64_02 *= _X; f64_03 *= _X; f64_04 *= _X; f64_05 *= _X; f64_06 *= _X; f64_07 *= _X; f64_08 *= _X; f64_09 *= _X; f64_10 *= _X; f64_11 *= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64_MULS(f64_100);
+            F64_MULS(f64_101);
+            F64_MULS(f64_102);
+            if( p < 2 ){
+                F64_MULS(f64_00);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
+    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+
+clean_up:
+
+    return;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// f64 DIVISION
+
+void test_f64_div(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  1.0 + 1.0/(1000.1*(double)p);
+    f64_01 =  1.0 + 1.0/(1000.2*(double)p);
+    f64_02 =  1.0 + 1.0/(1000.3*(double)p);
+    f64_03 =  1.0 + 1.0/(1000.4*(double)p);
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+#define F64DIV_BLOCK() {f64_01 /= f64_00; f64_02 /= f64_01; f64_03 /= f64_02; f64_00 /= f64_03;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+            F64DIV_BLOCK();
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], fp_op_count, (double)ev_values[0]/(double)fp_op_count);
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
+
+clean_up:
+
+    return;
+}
+
+
+void test_f64_div_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
+    double f64_08, f64_09, f64_10, f64_11;
+    double f64_100, f64_101, f64_102;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  p/431.2;
+    f64_01 = -p/431.3;
+    f64_02 =  p/431.4;
+    f64_03 = -p/431.5;
+    f64_04 =  p/431.6;
+    f64_05 = -p/431.7;
+    f64_06 =  p/431.8;
+    f64_07 = -p/431.9;
+    f64_08 =  p/432.0;
+    f64_09 = -p/432.1;
+    f64_10 =  p/432.2;
+    f64_11 = -p/432.3;
+
+    f64_100 =  1.00001;
+    f64_101 = -1.00002;
+    f64_102 =  1.00003;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p == 123456 ){
+        p /= 2;
+        f64_100 *= 1.0045;
+        f64_101 *= 1.0054;
+        f64_102 *= 1.0067;
+    }
+
+#define F64_DIVS(_X) {f64_00 /= _X; f64_01 /= _X; f64_02 /= _X; f64_03 /= _X; f64_04 /= _X; f64_05 /= _X; f64_06 /= _X; f64_07 /= _X; f64_08 /= _X; f64_09 /= _X; f64_10 /= _X; f64_11 /= _X;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64_DIVS(f64_100);
+            F64_DIVS(f64_101);
+            F64_DIVS(f64_102);
+            if( p < 2 ){
+                F64_DIVS(f64_00);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
+    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+
+clean_up:
+
+    return;
+}
+
+
+void test_f64_fma_max(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
+    double f64_08, f64_09, f64_10, f64_11;
+    double f64_100, f64_101, f64_102;
+    double f64_B;
+
+    /* Initialize the variables with values that the compiler cannot guess. */
+    f64_00 =  p/431.2;
+    f64_01 = -p/431.3;
+    f64_02 =  p/431.4;
+    f64_03 = -p/431.5;
+    f64_04 =  p/431.6;
+    f64_05 = -p/431.7;
+    f64_06 =  p/431.8;
+    f64_07 = -p/431.9;
+    f64_08 =  p/432.0;
+    f64_09 = -p/432.1;
+    f64_10 =  p/432.2;
+    f64_11 = -p/432.3;
+
+    f64_100 =  1.00001;
+    f64_101 = -1.00002;
+    f64_102 =  1.00003;
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    if( p != 12345678 ){
+        f64_100 /= 1.000045;
+        f64_101 /= 1.000054;
+        f64_102 /= 1.000067;
+    }
+    f64_B = f64_100/34567.8;
+
+#define F64_FMAS(_A,_B) {f64_00 = _A*f64_00+_B; f64_01 = _A*f64_01+_B; f64_02 = _A*f64_02+_B; f64_03 = _A*f64_03+_B; f64_04 = _A*f64_04+_B; f64_05 = _A*f64_05+_B; f64_06 = _A*f64_06+_B; f64_07 = _A*f64_07+_B; f64_08 = _A*f64_08+_B; f64_09 = _A*f64_09+_B; f64_10 = _A*f64_10+_B; f64_11 = _A*f64_11+_B;}
+
+    for(int i=0; i<M; i++){
+        for(int j=0; j<N; j++){
+            F64_FMAS(f64_100, f64_B);
+            F64_FMAS(f64_101, f64_B);
+            F64_FMAS(f64_102, f64_B);
+            if( p < 2 ){
+                F64_FMAS(f64_00, f64_B);
+            }
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+
+    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
+    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+
+clean_up:
+
+    return;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Vector double precision ADD
+
+void test_f64_add_DVEC128(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+2
+    double a[BUFFER_SIZE];
+    double b[BUFFER_SIZE];
+
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    long long int UB=1LL*M*N/(BUFFER_SIZE-2);
+    for(int i=0; i<UB; i++){
+        for(int j=2; j<BUFFER_SIZE; j++){
+            a[j] = a[j-2] + b[j];
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/2LL, (double)ev_values[0]/(N*M/2.0));
+
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += a[j];
+    }
+
+clean_up:
+
+    return;
+}
+
+void test_f64_add_DVEC256(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+4
+    double a[BUFFER_SIZE];
+    double b[BUFFER_SIZE];
+
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
+
+    // Start the counters.
+    ret = PAPI_start(EventSet);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_start() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to run the kernel.
+        goto clean_up;
+    }
+
+    long long int UB=1LL*M*N/(BUFFER_SIZE-4);
+    for(int i=0; i<UB; i++){
+        for(int j=4; j<BUFFER_SIZE; j++){
+            a[j] = a[j-4] + b[j];
+        }
+    }
+
+    ret = PAPI_stop(EventSet, ev_values);
+    if ( PAPI_OK != ret ) {
+        fprintf(stderr, "PAPI_stop() error: %s\n", PAPI_strerror(ret));
+        // If we can't measure events, no need to print anything.
+        goto clean_up;
+    }
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/4LL, (double)ev_values[0]/(N*M/4.0));
+
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += a[j];
+    }
+
+clean_up:
+
+    return;
+}
 
-    f64_100 =  1.00001;
-    f64_101 = -1.00002;
-    f64_102 =  1.00003;
+void test_f64_add_DVEC512(int p, int M, int N, int EventSet, FILE *fp){
+    int ret;
+    long long int ev_values[2];
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+8
+    double a[BUFFER_SIZE];
+    double b[BUFFER_SIZE];
+
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -960,21 +1605,10 @@ void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    if( p == 123456 ){
-        p /= 2;
-        f64_100 *= 1.0045;
-        f64_101 *= 1.0054;
-        f64_102 *= 1.0067;
-    }
-
-#define F64_MULS(_X) {f64_00 *= _X; f64_01 *= _X; f64_02 *= _X; f64_03 *= _X; f64_04 *= _X; f64_05 *= _X; f64_06 *= _X; f64_07 *= _X; f64_08 *= _X; f64_09 *= _X; f64_10 *= _X; f64_11 *= _X;}
-
-    for(int i=0; i<M; i++){
-        for(int j=0; j<N; j++){
-            F64_MULS(f64_100); F64_MULS(f64_101); F64_MULS(f64_102);
-            if( p < 4 ){
-                F64_MULS(f64_00); F64_MULS(f64_01); F64_MULS(f64_02);
-            }
+    long long int UB=1LL*M*N/(BUFFER_SIZE-8);
+    for(int i=0; i<UB; i++){
+        for(int j=8; j<BUFFER_SIZE; j++){
+            a[j] = a[j-8] + b[j];
         }
     }
 
@@ -984,10 +1618,11 @@ void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_MUL_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/8LL, (double)ev_values[0]/(N*M/8.0));
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
-    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += a[j];
+    }
 
 clean_up:
 
@@ -995,18 +1630,21 @@ void test_f64_mul_max(int p, int M, int N, int EventSet, FILE *fp){
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// f64 DIVISION
+// Vector single precision ADD
 
-void test_f64_div(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_add_SVEC128(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-    double f64_00, f64_01, f64_02, f64_03;
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+4
+    float a[BUFFER_SIZE];
+    float b[BUFFER_SIZE];
 
-    /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  1.0 + 1.0/(1000.1*(double)p);
-    f64_01 =  1.0 + 1.0/(1000.2*(double)p);
-    f64_02 =  1.0 + 1.0/(1000.3*(double)p);
-    f64_03 =  1.0 + 1.0/(1000.4*(double)p);
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -1016,20 +1654,10 @@ void test_f64_div(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-#define FDIV_BLOCK() {f64_01 /= f64_00; f64_02 /= f64_01; f64_03 /= f64_02; f64_00 /= f64_03;}
-
-    for(int i=0; i<M; i++){
-        for(int j=0; j<N; j++){
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
-            FDIV_BLOCK();
+    long long int UB=1LL*M*N/(BUFFER_SIZE-4);
+    for(int i=0; i<UB; i++){
+        for(int j=4; j<BUFFER_SIZE; j++){
+            a[j] = a[j-4] + b[j];
         }
     }
 
@@ -1039,41 +1667,30 @@ void test_f64_div(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    long long int fp_op_count = 40LL*N*M; // There are only 50 FP operations.
-    fprintf(fp, "%d %lld # FP_DIV_count: %lld (%.3lf)\n", N, ev_values[0], fp_op_count, (double)ev_values[0]/fp_op_count);
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/4LL, (double)ev_values[0]/(N*M/4.0));
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03;
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += (double)a[j];
+    }
 
 clean_up:
 
     return;
 }
 
-
-void test_f64_div_max(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_add_SVEC256(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
-    double f64_08, f64_09, f64_10, f64_11;
-    double f64_100, f64_101, f64_102;
-
-    /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  p/431.2;
-    f64_01 = -p/431.3;
-    f64_02 =  p/431.4;
-    f64_03 = -p/431.5;
-    f64_04 =  p/431.6;
-    f64_05 = -p/431.7;
-    f64_06 =  p/431.8;
-    f64_07 = -p/431.9;
-    f64_08 =  p/432.0;
-    f64_09 = -p/432.1;
-    f64_10 =  p/432.2;
-    f64_11 = -p/432.3;
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+8
+    float a[BUFFER_SIZE];
+    float b[BUFFER_SIZE];
 
-    f64_100 =  1.00001;
-    f64_101 = -1.00002;
-    f64_102 =  1.00003;
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -1083,21 +1700,10 @@ void test_f64_div_max(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    if( p == 123456 ){
-        p /= 2;
-        f64_100 *= 1.0045;
-        f64_101 *= 1.0054;
-        f64_102 *= 1.0067;
-    }
-
-#define F64_DIVS(_X) {f64_00 /= _X; f64_01 /= _X; f64_02 /= _X; f64_03 /= _X; f64_04 /= _X; f64_05 /= _X; f64_06 /= _X; f64_07 /= _X; f64_08 /= _X; f64_09 /= _X; f64_10 /= _X; f64_11 /= _X;}
-
-    for(int i=0; i<M; i++){
-        for(int j=0; j<N; j++){
-            F64_DIVS(f64_100); F64_DIVS(f64_101); F64_DIVS(f64_102);
-            if( p < 4 ){
-                F64_DIVS(f64_00); F64_DIVS(f64_01); F64_DIVS(f64_02);
-            }
+    long long int UB=1LL*M*N/(BUFFER_SIZE-8);
+    for(int i=0; i<UB; i++){
+        for(int j=8; j<BUFFER_SIZE; j++){
+            a[j] = a[j-8] + b[j];
         }
     }
 
@@ -1107,42 +1713,30 @@ void test_f64_div_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_DIV_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/8LL, (double)ev_values[0]/(N*M/8.0));
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
-    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += (double)a[j];
+    }
 
 clean_up:
 
     return;
 }
 
-
-void test_f64_fma_max(int p, int M, int N, int EventSet, FILE *fp){
+void test_f64_add_SVEC512(int p, int M, int N, int EventSet, FILE *fp){
     int ret;
     long long int ev_values[2];
-    double f64_00, f64_01, f64_02, f64_03, f64_04, f64_05, f64_06, f64_07;
-    double f64_08, f64_09, f64_10, f64_11;
-    double f64_100, f64_101, f64_102;
-    double f64_B;
-
-    /* Initialize the variables with values that the compiler cannot guess. */
-    f64_00 =  p/431.2;
-    f64_01 = -p/431.3;
-    f64_02 =  p/431.4;
-    f64_03 = -p/431.5;
-    f64_04 =  p/431.6;
-    f64_05 = -p/431.7;
-    f64_06 =  p/431.8;
-    f64_07 = -p/431.9;
-    f64_08 =  p/432.0;
-    f64_09 = -p/432.1;
-    f64_10 =  p/432.2;
-    f64_11 = -p/432.3;
+#undef BUFFER_SIZE
+#define BUFFER_SIZE 512+16
+    float a[BUFFER_SIZE];
+    float b[BUFFER_SIZE];
 
-    f64_100 =  1.00001;
-    f64_101 = -1.00002;
-    f64_102 =  1.00003;
+    /* Initialize the arrays with values that the compiler cannot guess. */
+    for(int i=0; i<BUFFER_SIZE; i++){
+        a[i] =  p/(i+1.2);
+        b[i] = -p/(i+1.3);
+    }
 
     // Start the counters.
     ret = PAPI_start(EventSet);
@@ -1152,23 +1746,10 @@ void test_f64_fma_max(int p, int M, int N, int EventSet, FILE *fp){
         goto clean_up;
     }
 
-    if( p != 12345678 ){
-        f64_100 /= 1.000045;
-        f64_101 /= 1.000054;
-        f64_102 /= 1.000067;
-    }
-    f64_B = f64_100/34567.8;
-
-#define F64_FMAS(_A,_B) {f64_00 = _A*f64_00+_B; f64_01 = _A*f64_01+_B; f64_02 = _A*f64_02+_B; f64_03 = _A*f64_03+_B; f64_04 = _A*f64_04+_B; f64_05 = _A*f64_05+_B; f64_06 = _A*f64_06+_B; f64_07 = _A*f64_07+_B; f64_08 = _A*f64_08+_B; f64_09 = _A*f64_09+_B; f64_10 = _A*f64_10+_B; f64_11 = _A*f64_11+_B;}
-
-    for(int i=0; i<M; i++){
-        for(int j=0; j<N; j++){
-            F64_FMAS(f64_100, f64_B);
-            F64_FMAS(f64_101, f64_B);
-            F64_FMAS(f64_102, f64_B);
-            if( p < 2 ){
-                F64_FMAS(f64_00, f64_B);
-            }
+    long long int UB=1LL*M*N/(BUFFER_SIZE-16);
+    for(int i=0; i<UB; i++){
+        for(int j=16; j<BUFFER_SIZE; j++){
+            a[j] = a[j-16] + b[j];
         }
     }
 
@@ -1178,16 +1759,18 @@ void test_f64_fma_max(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # FP_FMA_count_ILP12: %lld (%.3lf)\n", N, ev_values[0], 12LL*3LL*N*M, (double)ev_values[0]/(12.0*3.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], N*M/16LL, (double)ev_values[0]/(N*M/16.0));
 
-    sum_f64 += f64_00 + f64_01 + f64_02 + f64_03 + f64_04 + f64_05 + f64_06 + f64_07;
-    sum_f64 += f64_08 + f64_09 + f64_10 + f64_11;
+    for(int j=0; j<BUFFER_SIZE; j++){
+        sum_f64 += (double)a[j];
+    }
 
 clean_up:
 
     return;
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////
 // MEM ops
 
@@ -1224,7 +1807,7 @@ void test_mem_ops_serial_RO(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # MEM_OPS_RO_count: %lld (%.3lf)\n", N, ev_values[0], 1LL*N*M, ev_values[0]/(1.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 1LL*N*M, (double)ev_values[0]/(1.0*N*M));
 
     sum_i32 += index;
 
@@ -1266,7 +1849,7 @@ void test_mem_ops_serial_RW(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # MEM_OPS_RW_count: %lld (%.3lf)\n", N, ev_values[0], 2LL*N*M, ev_values[0]/(2.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 2LL*N*M, (double)ev_values[0]/(2.0*N*M));
 
     sum_i32 += buffer[0] + buffer[BUFFER_SIZE/2] + buffer[BUFFER_SIZE-1];
 
@@ -1327,7 +1910,7 @@ void test_mem_ops_parallel_RO(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # MEM_OPS_RO_count(par): %lld (%.3lf)\n", N, ev_values[0], 8LL*N*M, ev_values[0]/(8.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 8LL*N*M, (double)ev_values[0]/(8.0*N*M));
 
     sum_i32 += c0+c1+c2+c3;
 
@@ -1370,7 +1953,7 @@ void test_mem_ops_parallel_WO(int p, int M, int N, int EventSet, FILE *fp){
         // If we can't measure events, no need to print anything.
         goto clean_up;
     }
-    fprintf(fp, "%d %lld # MEM_OPS_WO_count(par): %lld (%.3lf)\n", N, ev_values[0], 1LL*N*M, ev_values[0]/(1.0*N*M));
+    fprintf(fp, "%d %lld %lld %.3lf\n", N*M, ev_values[0], 1LL*N*M, (double)ev_values[0]/(1.0*N*M));
 
     sum_i32 += buffer[0] + buffer[BUFFER_SIZE/2] + buffer[BUFFER_SIZE-1];
 
@@ -1388,8 +1971,9 @@ void instr_test(int EventSet, FILE *fp) {
     double f[4] = {1.0, 1.1892, 1.4142, 1.6818};
     int p = (int)getpid();
 
+
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# Mem_RO\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1400,7 +1984,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# Mem_RW\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1411,7 +1995,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((9+3)*N)+3)*M\n");
+    fprintf(fp,"# Mem_RO(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1422,7 +2006,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# Mem_WO(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1433,7 +2017,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((50.0+3)*N)+3)*M\n");
+    fprintf(fp,"# Int_ADD\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1444,7 +2028,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# Int_ADD(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1455,7 +2039,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# Int_MUL(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1466,7 +2050,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# Int_DIV(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1477,7 +2061,95 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((40+3)*N)+3)*M\n");
+    fprintf(fp,"# FP32_ADD\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_add(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_ADD(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_add_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_SUB(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_sub(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_SUB(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_sub_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_MUL\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_mul(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_MUL(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM);
+            N = (int)(i*f[j]*minN);
+            test_f32_mul_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_DIV\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM/4);
+            N = (int)(i*f[j]*minN/4);
+            test_f32_div(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP32_DIV(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM/4);
+            N = (int)(i*f[j]*minN/4);
+            test_f32_div_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP64_ADD\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1488,7 +2160,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# FP64_ADD(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1499,7 +2171,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((40+3)*N)+3)*M\n");
+    fprintf(fp,"# FP64_SUB(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1510,7 +2182,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# FP64_SUB(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1521,7 +2193,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((40+3)*N)+3)*M\n");
+    fprintf(fp,"# FP64_MUL\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1532,7 +2204,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# FP64_MUL(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM);
@@ -1543,7 +2215,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((40+3)*N)+3)*M\n");
+    fprintf(fp,"# FP64_DIV\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM/4);
@@ -1554,7 +2226,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# FP64_DIV(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM/4);
@@ -1565,7 +2237,18 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((12.0*3+5)*N)+3)*M\n");
+    fprintf(fp,"# FP32_FMA(ILP)\n");
+    for(i=16; i<50; i*=2){
+        for(j=0; j<4; j++){
+            M = (int)(i*f[j]*minM/4);
+            N = (int)(i*f[j]*minN/4);
+            test_f32_fma_max(p, M, N, EventSet, fp);
+        }
+    }
+    fprintf(fp, "\n");
+
+    ////////////////////////////////////////
+    fprintf(fp,"# FP64_FMA(ILP)\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM/4);
@@ -1576,7 +2259,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# SVEC128\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);
@@ -1587,7 +2270,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# SVEC256\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);
@@ -1598,7 +2281,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# SVEC512\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);
@@ -1609,7 +2292,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# DVEC128\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);
@@ -1620,7 +2303,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# DVEC256\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);
@@ -1631,7 +2314,7 @@ void instr_test(int EventSet, FILE *fp) {
     fprintf(fp, "\n");
 
     ////////////////////////////////////////
-    fprintf(fp, "# (((2+3)*N)+3)*M\n");
+    fprintf(fp,"# DVEC512\n");
     for(i=16; i<50; i*=2){
         for(j=0; j<4; j++){
             M = (int)(i*f[j]*minM*2);