diff --git a/src/counter_analysis_toolkit/Makefile b/src/counter_analysis_toolkit/Makefile
index 31f1a4405..09a16fa1c 100644
--- a/src/counter_analysis_toolkit/Makefile
+++ b/src/counter_analysis_toolkit/Makefile
@@ -54,10 +54,10 @@ ifeq ($(ARCH),POWER)
     VEC_ALL=$(VEC) -DPOWER
 endif
 ifeq ($(ARCH),ARM)
-    FLOP+=-march=armv8.2-a+fp16 -DARM
+    FLOP+=-march=armv8.2-a+fp16+sve -DARM
     VECSRC=vec_fma_hp.o vec_fma_sp.o vec_fma_dp.o vec_nonfma_hp.o vec_nonfma_sp.o vec_nonfma_dp.o
-    VEC=-march=armv8.2-a+fp16 -O0 -DARM
-    VEC_FMA=-march=armv8.2-a+fp16 -O0 -DARM
+    VEC=-march=armv8.2-a+fp16+sve -O0 -DARM
+    VEC_FMA=-march=armv8.2-a+fp16+sve -O0 -DARM
     VEC_ALL=$(VEC) -O0 -DARM
 endif
 
diff --git a/src/counter_analysis_toolkit/cat_arch.h b/src/counter_analysis_toolkit/cat_arch.h
index db6b62e1e..6cb5f6691 100644
--- a/src/counter_analysis_toolkit/cat_arch.h
+++ b/src/counter_analysis_toolkit/cat_arch.h
@@ -3,29 +3,29 @@
 typedef unsigned long long uint64;
 
 #if defined(X86)
-void test_hp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
-void test_hp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
-void test_hp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
-void test_hp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
-void test_hp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
-void test_hp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_sp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void test_dp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void test_hp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_sp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void test_dp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 #include <immintrin.h>
 
@@ -86,18 +86,46 @@ typedef __m256d DP_VEC_TYPE;
 #endif
 
 #elif defined(ARM)
-void  test_hp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_sp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_dp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_hp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_sp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_dp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void  test_hp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_sp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_dp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_hp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void  test_sp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void  test_dp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 #include <arm_neon.h>
+#include <arm_sve.h>
 
 typedef __fp16 half;
+typedef __fp16 HP_SCALAR_TYPE;
 typedef float  SP_SCALAR_TYPE;
 typedef double DP_SCALAR_TYPE;
+
+#define CAT_DEV_SVE
+#if defined(CAT_DEV_SVE)
+typedef svfloat16_t HP_VEC_TYPE;
+typedef svfloat32_t SP_VEC_TYPE;
+typedef svfloat64_t DP_VEC_TYPE;
+
+#define SET_VEC_PH(_I_) (HP_VEC_TYPE)svdup_n_f16( _I_ )
+#define SET_VEC_PS(_I_) (SP_VEC_TYPE)svdup_n_f32( _I_ );
+#define SET_VEC_PD(_I_) (DP_VEC_TYPE)svdup_n_f64( _I_ );
+
+#define ADD_VEC_PH(_I_,_J_) (HP_VEC_TYPE)svadd_f16_m( pg, _I_ , _J_ );
+#define ADD_VEC_PS(_I_,_J_) (SP_VEC_TYPE)svadd_f32_m( pg, _I_ , _J_ );
+#define ADD_VEC_PD(_I_,_J_) (DP_VEC_TYPE)svadd_f64_m( pg, _I_ , _J_ );
+
+#define MUL_VEC_PH(_I_,_J_) (HP_VEC_TYPE)svmul_f16_m( pg, _I_ , _J_ );
+#define MUL_VEC_PS(_I_,_J_) (SP_VEC_TYPE)svmul_f32_m( pg, _I_ , _J_ );
+#define MUL_VEC_PD(_I_,_J_) (DP_VEC_TYPE)svmul_f64_m( pg, _I_ , _J_ );
+
+#define FMA_VEC_PH(_I_,_J_,_K_) (HP_VEC_TYPE)svmad_f16_m( pg, _I_ , _J_ , _K_ );
+#define FMA_VEC_PS(_I_,_J_,_K_) (SP_VEC_TYPE)svmad_f32_m( pg, _I_ , _J_ , _K_ );
+#define FMA_VEC_PD(_I_,_J_,_K_) (DP_VEC_TYPE)svmad_f64_m( pg, _I_ , _J_ , _K_ );
+#endif
+
+//#define CAT_DEV_NEON
+#if defined(CAT_DEV_NEON)
 typedef float16x8_t HP_VEC_TYPE;
 typedef float32x4_t SP_VEC_TYPE;
 typedef float64x2_t DP_VEC_TYPE;
@@ -117,11 +145,12 @@ typedef float64x2_t DP_VEC_TYPE;
 #define FMA_VEC_PH(_I_,_J_,_K_) (HP_VEC_TYPE)vfmaq_f16( _K_ , _J_ , _I_ );
 #define FMA_VEC_PS(_I_,_J_,_K_) (SP_VEC_TYPE)vfmaq_f32( _K_ , _J_ , _I_ );
 #define FMA_VEC_PD(_I_,_J_,_K_) (DP_VEC_TYPE)vfmaq_f64( _K_ , _J_ , _I_ );
+#endif /* CAT_DEV_NEON */
 
 /* There is no scalar FMA intrinsic available on this architecture. */
 #define SET_VEC_SH(_I_)         _I_ ;
-#define ADD_VEC_SH(_I_,_J_)     vaddh_f16( _I_ , _J_ );
-#define MUL_VEC_SH(_I_,_J_)     vmulh_f16( _I_ , _J_ );
+#define ADD_VEC_SH(_I_,_J_)     _I_ + _J_ ;
+#define MUL_VEC_SH(_I_,_J_)     _I_ * _J_ ;
 #define SQRT_VEC_SH(_I_)        vsqrth_f16( _I_ );
 #define FMA_VEC_SH(_out_,_I_,_J_,_K_) _out_ = _I_ * _J_ + _K_;
 
@@ -136,12 +165,12 @@ typedef float64x2_t DP_VEC_TYPE;
 #define FMA_VEC_SD(_out_,_I_,_J_,_K_) _out_ = _I_ * _J_ + _K_;
 
 #elif defined(POWER)
-void  test_hp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_sp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_dp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_hp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_sp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
-void  test_dp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+void  test_hp_power_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_sp_power_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_dp_power_VEC( int instr_per_loop, int EventSet, FILE *fp );
+void  test_hp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void  test_sp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
+void  test_dp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 #include <altivec.h>
 
diff --git a/src/counter_analysis_toolkit/vec.c b/src/counter_analysis_toolkit/vec.c
index e33f148b1..26875b570 100644
--- a/src/counter_analysis_toolkit/vec.c
+++ b/src/counter_analysis_toolkit/vec.c
@@ -48,151 +48,151 @@ void vec_driver(char* papi_event_name, hw_desc_t *hw_desc, char* outdir)
 
     // HP Non-FMA instruction trials.
     fprintf(ofp_papi, "# HP Non-FMA Scalar\n");
-    test_hp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_48( EventSet, ofp_papi );
+    test_hp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP Non-FMA Vector AVX128\n");
-    test_hp_x86_128B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_128B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_hp_x86_128B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC( 24, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC( 48, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC( 96, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# HP Non-FMA Vector AVX256\n");
-    test_hp_x86_256B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_256B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_hp_x86_256B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC( 24, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC( 48, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC( 96, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# HP Non-FMA Vector AVX512\n");
-    test_hp_x86_512B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_512B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_hp_x86_512B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC( 24, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC( 48, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC( 96, EventSet, ofp_papi );
     #endif
   #endif
 
     // SP Non-FMA instruction trials.
     fprintf(ofp_papi, "# SP Non-FMA Scalar\n");
-    test_sp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_48( EventSet, ofp_papi );
+    test_sp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP Non-FMA Vector AVX128\n");
-    test_sp_x86_128B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_128B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_sp_x86_128B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC( 24, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC( 48, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC( 96, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# SP Non-FMA Vector AVX256\n");
-    test_sp_x86_256B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_256B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_sp_x86_256B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC( 24, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC( 48, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC( 96, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# SP Non-FMA Vector AVX512\n");
-    test_sp_x86_512B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_512B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_sp_x86_512B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC( 24, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC( 48, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC( 96, EventSet, ofp_papi );
     #endif
   #endif
 
     // DP Non-FMA instruction trials.
     fprintf(ofp_papi, "# DP Non-FMA Scalar\n");
-    test_dp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_48( EventSet, ofp_papi );
+    test_dp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP Non-FMA Vector AVX128\n");
-    test_dp_x86_128B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_128B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_dp_x86_128B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC( 24, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC( 48, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC( 96, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# DP Non-FMA Vector AVX256\n");
-    test_dp_x86_256B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_256B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_dp_x86_256B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC( 24, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC( 48, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC( 96, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# DP Non-FMA Vector AVX512\n");
-    test_dp_x86_512B_VEC( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_512B_VEC( 48, ITER, EventSet, ofp_papi );
-    test_dp_x86_512B_VEC( 96, ITER, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC( 24, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC( 48, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC( 96, EventSet, ofp_papi );
     #endif
   #endif
 
     // HP FMA instruction trials.
     fprintf(ofp_papi, "# HP FMA Scalar\n");
-    test_hp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP FMA Vector AVX128\n");
-    test_hp_x86_128B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_hp_x86_128B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_128B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_hp_x86_128B_VEC_FMA( 48, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# HP FMA Vector AVX256\n");
-    test_hp_x86_256B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_hp_x86_256B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_256B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_hp_x86_256B_VEC_FMA( 48, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# HP FMA Vector AVX512\n");
-    test_hp_x86_512B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_hp_x86_512B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_hp_x86_512B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_hp_x86_512B_VEC_FMA( 48, EventSet, ofp_papi );
     #endif
   #endif
 
     // SP FMA instruction trials.
     fprintf(ofp_papi, "# SP FMA Scalar\n");
-    test_sp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP FMA Vector AVX128\n");
-    test_sp_x86_128B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_sp_x86_128B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_128B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_sp_x86_128B_VEC_FMA( 48, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# SP FMA Vector AVX256\n");
-    test_sp_x86_256B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_sp_x86_256B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_256B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_sp_x86_256B_VEC_FMA( 48, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# SP FMA Vector AVX512\n");
-    test_sp_x86_512B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_sp_x86_512B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_sp_x86_512B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_sp_x86_512B_VEC_FMA( 48, EventSet, ofp_papi );
     #endif
   #endif
 
     // DP FMA instruction trials.
     fprintf(ofp_papi, "# DP FMA Scalar\n");
-    test_dp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP FMA Vector AVX128\n");
-    test_dp_x86_128B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_dp_x86_128B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_128B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_dp_x86_128B_VEC_FMA( 48, EventSet, ofp_papi );
 
   #if defined(AVX256_AVAIL)
     fprintf(ofp_papi, "# DP FMA Vector AVX256\n");
-    test_dp_x86_256B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_dp_x86_256B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_256B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_dp_x86_256B_VEC_FMA( 48, EventSet, ofp_papi );
 
     #if defined(AVX512_AVAIL)
     fprintf(ofp_papi, "# DP FMA Vector AVX512\n");
-    test_dp_x86_512B_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_dp_x86_512B_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_dp_x86_512B_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC_FMA( 12, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC_FMA( 24, EventSet, ofp_papi );
+    test_dp_x86_512B_VEC_FMA( 48, EventSet, ofp_papi );
     #endif
   #endif
 
@@ -204,129 +204,129 @@ void vec_driver(char* papi_event_name, hw_desc_t *hw_desc, char* outdir)
 
     // Non-FMA instruction trials.
     fprintf(ofp_papi, "# HP Non-FMA Scalar\n");
-    test_hp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_48( EventSet, ofp_papi );
+    test_hp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP Non-FMA Vector\n");
-    test_hp_arm_VEC( 24, ITER, EventSet, ofp_papi );
-    test_hp_arm_VEC( 48, ITER, EventSet, ofp_papi );
-    test_hp_arm_VEC( 96, ITER, EventSet, ofp_papi );
+    test_hp_arm_VEC( 24, EventSet, ofp_papi );
+    test_hp_arm_VEC( 48, EventSet, ofp_papi );
+    test_hp_arm_VEC( 96, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP Non-FMA Scalar\n");
-    test_sp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_48( EventSet, ofp_papi );
+    test_sp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP Non-FMA Vector\n");
-    test_sp_arm_VEC( 24, ITER, EventSet, ofp_papi );
-    test_sp_arm_VEC( 48, ITER, EventSet, ofp_papi );
-    test_sp_arm_VEC( 96, ITER, EventSet, ofp_papi );
+    test_sp_arm_VEC( 24, EventSet, ofp_papi );
+    test_sp_arm_VEC( 48, EventSet, ofp_papi );
+    test_sp_arm_VEC( 96, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP Non-FMA Scalar\n");
-    test_dp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_48( EventSet, ofp_papi );
+    test_dp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP Non-FMA Vector\n");
-    test_dp_arm_VEC( 24, ITER, EventSet, ofp_papi );
-    test_dp_arm_VEC( 48, ITER, EventSet, ofp_papi );
-    test_dp_arm_VEC( 96, ITER, EventSet, ofp_papi );
+    test_dp_arm_VEC( 24, EventSet, ofp_papi );
+    test_dp_arm_VEC( 48, EventSet, ofp_papi );
+    test_dp_arm_VEC( 96, EventSet, ofp_papi );
 
     // FMA instruction trials.
     fprintf(ofp_papi, "# HP FMA Scalar\n");
-    test_hp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP FMA Vector\n");
-    test_hp_arm_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_hp_arm_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_hp_arm_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_hp_arm_VEC_FMA( 12, EventSet, ofp_papi );
+    test_hp_arm_VEC_FMA( 24, EventSet, ofp_papi );
+    test_hp_arm_VEC_FMA( 48, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP FMA Scalar\n");
-    test_sp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP FMA Vector\n");
-    test_sp_arm_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_sp_arm_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_sp_arm_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_sp_arm_VEC_FMA( 12, EventSet, ofp_papi );
+    test_sp_arm_VEC_FMA( 24, EventSet, ofp_papi );
+    test_sp_arm_VEC_FMA( 48, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP FMA Scalar\n");
-    test_dp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP FMA Vector\n");
-    test_dp_arm_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_dp_arm_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_dp_arm_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_dp_arm_VEC_FMA( 12, EventSet, ofp_papi );
+    test_dp_arm_VEC_FMA( 24, EventSet, ofp_papi );
+    test_dp_arm_VEC_FMA( 48, EventSet, ofp_papi );
 
 #elif defined(POWER)
 
     // Non-FMA instruction trials.
     fprintf(ofp_papi, "# HP Non-FMA Scalar\n");
-    test_hp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_48( EventSet, ofp_papi );
+    test_hp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP Non-FMA Vector\n");
-    test_hp_power_VEC( 24, ITER, EventSet, ofp_papi );
-    test_hp_power_VEC( 48, ITER, EventSet, ofp_papi );
-    test_hp_power_VEC( 96, ITER, EventSet, ofp_papi );
+    test_hp_power_VEC( 24, EventSet, ofp_papi );
+    test_hp_power_VEC( 48, EventSet, ofp_papi );
+    test_hp_power_VEC( 96, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP Non-FMA Scalar\n");
-    test_sp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_48( EventSet, ofp_papi );
+    test_sp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP Non-FMA Vector\n");
-    test_sp_power_VEC( 24, ITER, EventSet, ofp_papi );
-    test_sp_power_VEC( 48, ITER, EventSet, ofp_papi );
-    test_sp_power_VEC( 96, ITER, EventSet, ofp_papi );
+    test_sp_power_VEC( 24, EventSet, ofp_papi );
+    test_sp_power_VEC( 48, EventSet, ofp_papi );
+    test_sp_power_VEC( 96, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP Non-FMA Scalar\n");
-    test_dp_scalar_VEC_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_48( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_96( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_48( EventSet, ofp_papi );
+    test_dp_scalar_VEC_96( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP Non-FMA Vector\n");
-    test_dp_power_VEC( 24, ITER, EventSet, ofp_papi );
-    test_dp_power_VEC( 48, ITER, EventSet, ofp_papi );
-    test_dp_power_VEC( 96, ITER, EventSet, ofp_papi );
+    test_dp_power_VEC( 24, EventSet, ofp_papi );
+    test_dp_power_VEC( 48, EventSet, ofp_papi );
+    test_dp_power_VEC( 96, EventSet, ofp_papi );
 
     // FMA instruction trials.
     fprintf(ofp_papi, "# HP FMA Scalar\n");
-    test_hp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_hp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_hp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# HP FMA Vector\n");
-    test_hp_power_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_hp_power_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_hp_power_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_hp_power_VEC_FMA( 12, EventSet, ofp_papi );
+    test_hp_power_VEC_FMA( 24, EventSet, ofp_papi );
+    test_hp_power_VEC_FMA( 48, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP FMA Scalar\n");
-    test_sp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_sp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_sp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# SP FMA Vector\n");
-    test_sp_power_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_sp_power_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_sp_power_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_sp_power_VEC_FMA( 12, EventSet, ofp_papi );
+    test_sp_power_VEC_FMA( 24, EventSet, ofp_papi );
+    test_sp_power_VEC_FMA( 48, EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP FMA Scalar\n");
-    test_dp_scalar_VEC_FMA_12( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_24( ITER, EventSet, ofp_papi );
-    test_dp_scalar_VEC_FMA_48( ITER, EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_12( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_24( EventSet, ofp_papi );
+    test_dp_scalar_VEC_FMA_48( EventSet, ofp_papi );
 
     fprintf(ofp_papi, "# DP FMA Vector\n");
-    test_dp_power_VEC_FMA( 12, ITER, EventSet, ofp_papi );
-    test_dp_power_VEC_FMA( 24, ITER, EventSet, ofp_papi );
-    test_dp_power_VEC_FMA( 48, ITER, EventSet, ofp_papi );
+    test_dp_power_VEC_FMA( 12, EventSet, ofp_papi );
+    test_dp_power_VEC_FMA( 24, EventSet, ofp_papi );
+    test_dp_power_VEC_FMA( 48, EventSet, ofp_papi );
 
 #endif
 
diff --git a/src/counter_analysis_toolkit/vec_fma_dp.c b/src/counter_analysis_toolkit/vec_fma_dp.c
index 0f8e4ede3..5ee664346 100644
--- a/src/counter_analysis_toolkit/vec_fma_dp.c
+++ b/src/counter_analysis_toolkit/vec_fma_dp.c
@@ -1,30 +1,30 @@
 #include "vec_scalar_verify.h"
 
-static double test_dp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-static double test_dp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-static double test_dp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
-static void   test_dp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static double test_dp_mac_VEC_FMA_12( int EventSet, FILE *fp );
+static double test_dp_mac_VEC_FMA_24( int EventSet, FILE *fp );
+static double test_dp_mac_VEC_FMA_48( int EventSet, FILE *fp );
+static void   test_dp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_dp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_dp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_dp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_dp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_dp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_dp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_dp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -32,8 +32,13 @@ void test_dp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet,
 /* Loop unrolling:  12 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -58,11 +63,6 @@ double test_dp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PD(r0,r7,r9);
             r1 = FMA_VEC_PD(r1,r8,rA);
@@ -78,13 +78,20 @@ double test_dp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PD(r4,r9,rB);
             r5 = FMA_VEC_PD(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(12, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(12, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -108,8 +115,13 @@ double test_dp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -134,11 +146,6 @@ double test_dp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PD(r0,r7,r9);
             r1 = FMA_VEC_PD(r1,r8,rA);
@@ -168,13 +175,20 @@ double test_dp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PD(r4,r9,rB);
             r5 = FMA_VEC_PD(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -198,8 +212,13 @@ double test_dp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -224,11 +243,6 @@ double test_dp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PD(r0,r7,r9);
             r1 = FMA_VEC_PD(r1,r8,rA);
@@ -286,13 +300,20 @@ double test_dp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PD(r4,r9,rB);
             r5 = FMA_VEC_PD(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -313,22 +334,22 @@ double test_dp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_dp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_dp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp )
 {
     double sum = 0.0;
     double scalar_sum = 0.0;
 
     if ( instr_per_loop == 12 ) {
-        sum += test_dp_mac_VEC_FMA_12( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_FMA_12( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_FMA_12( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_FMA_12( EventSet, NULL );
     }
     else if ( instr_per_loop == 24 ) {
-        sum += test_dp_mac_VEC_FMA_24( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_FMA_24( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_FMA_24( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_FMA_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_dp_mac_VEC_FMA_48( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_FMA_48( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_FMA_48( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_FMA_48( EventSet, NULL );
     }
 
     if( sum/2.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_fma_hp.c b/src/counter_analysis_toolkit/vec_fma_hp.c
index 7eebd08fa..5bd91682b 100644
--- a/src/counter_analysis_toolkit/vec_fma_hp.c
+++ b/src/counter_analysis_toolkit/vec_fma_hp.c
@@ -1,36 +1,36 @@
 #include "vec_scalar_verify.h"
 
 #if defined(ARM)
-static half  test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-static half  test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-static half  test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_FMA_12( int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_FMA_24( int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_FMA_48( int EventSet, FILE *fp );
 #else
-static float test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-static float test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-static float test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+static float test_hp_mac_VEC_FMA_12( int EventSet, FILE *fp );
+static float test_hp_mac_VEC_FMA_24( int EventSet, FILE *fp );
+static float test_hp_mac_VEC_FMA_48( int EventSet, FILE *fp );
 #endif
-static void  test_hp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static void  test_hp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_hp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_hp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_hp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_hp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_hp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_hp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_hp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -39,8 +39,13 @@ void test_hp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet,
 /* Loop unrolling:  12 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -65,12 +70,7 @@ half test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-        /* The performance critical part */
-
+            /* The performance critical part */
             r0 = FMA_VEC_PH(r0,r7,r9);
             r1 = FMA_VEC_PH(r1,r8,rA);
             r2 = FMA_VEC_PH(r2,r9,rB);
@@ -85,13 +85,20 @@ half test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PH(r4,r9,rB);
             r5 = FMA_VEC_PH(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(12, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(12, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -117,8 +124,13 @@ half test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -143,12 +155,7 @@ half test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = FMA_VEC_PH(r0,r7,r9);
             r1 = FMA_VEC_PH(r1,r8,rA);
             r2 = FMA_VEC_PH(r2,r9,rB);
@@ -177,13 +184,20 @@ half test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PH(r4,r9,rB);
             r5 = FMA_VEC_PH(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -209,8 +223,13 @@ half test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -235,12 +254,7 @@ half test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = FMA_VEC_PH(r0,r7,r9);
             r1 = FMA_VEC_PH(r1,r8,rA);
             r2 = FMA_VEC_PH(r2,r9,rB);
@@ -297,13 +311,20 @@ half test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PH(r4,r9,rB);
             r5 = FMA_VEC_PH(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -326,22 +347,22 @@ half test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_hp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_hp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp )
 {
     half sum = 0.0;
     half scalar_sum = 0.0;
 
     if ( instr_per_loop == 12 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_12( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_12( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_12( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_12( EventSet, NULL ));
     }
     else if ( instr_per_loop == 24 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_24( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_24( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_24( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_24( EventSet, NULL ));
     }
     else if ( instr_per_loop == 48 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_48( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_48( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_FMA_48( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_FMA_48( EventSet, NULL ));
     }
 
     if( vdivh_f16(sum,4.0) != scalar_sum ) {
@@ -351,7 +372,7 @@ void test_hp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE
 
 #else
 static
-float test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_FMA_12( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -364,7 +385,7 @@ float test_hp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-float test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_FMA_24( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -377,7 +398,7 @@ float test_hp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-float test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_FMA_48( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -390,22 +411,22 @@ float test_hp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_hp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_hp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp )
 {
     float sum = 0.0;
     float scalar_sum = 0.0;
 
     if ( instr_per_loop == 12 ) {
-        sum += test_hp_mac_VEC_FMA_12( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_FMA_12( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_FMA_12( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_FMA_12( EventSet, NULL );
     }
     else if ( instr_per_loop == 24 ) {
-        sum += test_hp_mac_VEC_FMA_24( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_FMA_24( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_FMA_24( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_FMA_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_hp_mac_VEC_FMA_48( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_FMA_48( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_FMA_48( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_FMA_48( EventSet, NULL );
     }
 
     if( sum/4.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_fma_sp.c b/src/counter_analysis_toolkit/vec_fma_sp.c
index 2cb6d84c3..50b24719a 100644
--- a/src/counter_analysis_toolkit/vec_fma_sp.c
+++ b/src/counter_analysis_toolkit/vec_fma_sp.c
@@ -1,30 +1,30 @@
 #include "vec_scalar_verify.h"
 
-static float test_sp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-static float test_sp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-static float test_sp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
-static void  test_sp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static float test_sp_mac_VEC_FMA_12( int EventSet, FILE *fp );
+static float test_sp_mac_VEC_FMA_24( int EventSet, FILE *fp );
+static float test_sp_mac_VEC_FMA_48( int EventSet, FILE *fp );
+static void  test_sp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_sp_x86_128B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_128B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_sp_x86_512B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_512B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_sp_x86_256B_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_256B_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_sp_arm_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_sp_arm_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_sp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC_FMA( instr_per_loop, iterations, EventSet, fp );
+void test_sp_power_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC_FMA( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -32,8 +32,13 @@ void test_sp_power_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet,
 /* Loop unrolling:  12 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -58,11 +63,6 @@ float test_sp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PS(r0,r7,r9);
             r1 = FMA_VEC_PS(r1,r8,rA);
@@ -78,13 +78,20 @@ float test_sp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PS(r4,r9,rB);
             r5 = FMA_VEC_PS(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(12, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(12, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -110,8 +117,13 @@ float test_sp_mac_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -136,11 +148,6 @@ float test_sp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PS(r0,r7,r9);
             r1 = FMA_VEC_PS(r1,r8,rA);
@@ -170,13 +177,20 @@ float test_sp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PS(r4,r9,rB);
             r5 = FMA_VEC_PS(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -202,8 +216,13 @@ float test_sp_mac_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -228,11 +247,6 @@ float test_sp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
             /* The performance critical part */
             r0 = FMA_VEC_PS(r0,r7,r9);
             r1 = FMA_VEC_PS(r1,r8,rA);
@@ -290,13 +304,20 @@ float test_sp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             r4 = FMA_VEC_PS(r4,r9,rB);
             r5 = FMA_VEC_PS(r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -319,22 +340,22 @@ float test_sp_mac_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_sp_VEC_FMA( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_sp_VEC_FMA( int instr_per_loop, int EventSet, FILE *fp )
 {
     float sum = 0.0;
     float scalar_sum = 0.0;
 
     if ( instr_per_loop == 12 ) {
-        sum += test_sp_mac_VEC_FMA_12( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_FMA_12( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_FMA_12( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_FMA_12( EventSet, NULL );
     }
     else if ( instr_per_loop == 24 ) {
-        sum += test_sp_mac_VEC_FMA_24( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_FMA_24( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_FMA_24( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_FMA_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_sp_mac_VEC_FMA_48( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_FMA_48( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_FMA_48( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_FMA_48( EventSet, NULL );
     }
 
     if( sum/4.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_nonfma_dp.c b/src/counter_analysis_toolkit/vec_nonfma_dp.c
index b723cde0f..a6d0e7898 100644
--- a/src/counter_analysis_toolkit/vec_nonfma_dp.c
+++ b/src/counter_analysis_toolkit/vec_nonfma_dp.c
@@ -1,30 +1,30 @@
 #include "vec_scalar_verify.h"
 
-static double test_dp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-static double test_dp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-static double test_dp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp );
-static void   test_dp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static double test_dp_mac_VEC_24( int EventSet, FILE *fp );
+static double test_dp_mac_VEC_48( int EventSet, FILE *fp );
+static double test_dp_mac_VEC_96( int EventSet, FILE *fp );
+static void   test_dp_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_dp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_dp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_dp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_dp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_dp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_dp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_dp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_dp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_dp_power_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_dp_VEC( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -32,8 +32,13 @@ void test_dp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FIL
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -58,12 +63,7 @@ double test_dp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PD(r0,rC);
             r1 = ADD_VEC_PD(r1,rD);
             r2 = MUL_VEC_PD(r2,rE);
@@ -90,13 +90,20 @@ double test_dp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PD(rA,rD);
             rB = MUL_VEC_PD(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -125,8 +132,13 @@ double test_dp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -151,12 +163,7 @@ double test_dp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PD(r0,rC);
             r1 = ADD_VEC_PD(r1,rD);
             r2 = MUL_VEC_PD(r2,rE);
@@ -209,13 +216,20 @@ double test_dp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PD(rA,rD);
             rB = MUL_VEC_PD(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -244,8 +258,13 @@ double test_dp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  96 instructions */
 /************************************/
 static
-double test_dp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_mac_VEC_96( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b64();
+    volatile DP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PD(0.01);
@@ -270,12 +289,7 @@ double test_dp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PD(r0,rC);
             r1 = ADD_VEC_PD(r1,rD);
             r2 = MUL_VEC_PD(r2,rE);
@@ -380,13 +394,20 @@ double test_dp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PD(rA,rD);
             rB = MUL_VEC_PD(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(96, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(96, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PD(r0,r1);
@@ -412,22 +433,22 @@ double test_dp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_dp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_dp_VEC( int instr_per_loop, int EventSet, FILE *fp )
 {
     double sum = 0.0;
     double scalar_sum = 0.0;
 
     if ( instr_per_loop == 24 ) {
-        sum += test_dp_mac_VEC_24( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_24( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_24( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_dp_mac_VEC_48( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_48( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_48( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_48( EventSet, NULL );
     }
     else if ( instr_per_loop == 96 ) {
-        sum += test_dp_mac_VEC_96( iterations, EventSet, fp );
-        scalar_sum += test_dp_scalar_VEC_96( iterations, EventSet, NULL );
+        sum += test_dp_mac_VEC_96( EventSet, fp );
+        scalar_sum += test_dp_scalar_VEC_96( EventSet, NULL );
     }
 
     if( sum/2.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_nonfma_hp.c b/src/counter_analysis_toolkit/vec_nonfma_hp.c
index 867c9cc45..142c78c5a 100644
--- a/src/counter_analysis_toolkit/vec_nonfma_hp.c
+++ b/src/counter_analysis_toolkit/vec_nonfma_hp.c
@@ -1,36 +1,36 @@
 #include "vec_scalar_verify.h"
 
 #if defined(ARM)
-static half  test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-static half  test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-static half  test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_24( int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_48( int EventSet, FILE *fp );
+static half  test_hp_mac_VEC_96( int EventSet, FILE *fp );
 #else
-static float test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-static float test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-static float test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+static float test_hp_mac_VEC_24( int EventSet, FILE *fp );
+static float test_hp_mac_VEC_48( int EventSet, FILE *fp );
+static float test_hp_mac_VEC_96( int EventSet, FILE *fp );
 #endif
-static void  test_hp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static void  test_hp_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_hp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_hp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_hp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_hp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_hp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_hp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_hp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_hp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_hp_power_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_hp_VEC( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -39,8 +39,13 @@ void test_hp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FIL
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -65,12 +70,7 @@ half test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-        /* The performance critical part */
-
+            /* The performance critical part */
             r0 = MUL_VEC_PH(r0,rC);
             r1 = ADD_VEC_PH(r1,rD);
             r2 = MUL_VEC_PH(r2,rE);
@@ -97,13 +97,20 @@ half test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PH(rA,rD);
             rB = MUL_VEC_PH(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -134,8 +141,13 @@ half test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -160,12 +172,7 @@ half test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PH(r0,rC);
             r1 = ADD_VEC_PH(r1,rD);
             r2 = MUL_VEC_PH(r2,rE);
@@ -218,13 +225,20 @@ half test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PH(rA,rD);
             rB = MUL_VEC_PH(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -255,8 +269,13 @@ half test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  96 instructions */
 /************************************/
 static
-half test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_mac_VEC_96( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b16();
+    volatile HP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PH(0.01);
@@ -281,12 +300,7 @@ half test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PH(r0,rC);
             r1 = ADD_VEC_PH(r1,rD);
             r2 = MUL_VEC_PH(r2,rE);
@@ -391,13 +405,20 @@ half test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PH(rA,rD);
             rB = MUL_VEC_PH(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(96, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(96, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PH(r0,r1);
@@ -425,22 +446,22 @@ half test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_hp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_hp_VEC( int instr_per_loop, int EventSet, FILE *fp )
 {
     half sum = 0.0;
     half scalar_sum = 0.0;
 
     if ( instr_per_loop == 24 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_24( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_24( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_24( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_24( EventSet, NULL ));
     }
     else if ( instr_per_loop == 48 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_48( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_48( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_48( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_48( EventSet, NULL ));
     }
     else if ( instr_per_loop == 96 ) {
-        sum = vaddh_f16(sum,test_hp_mac_VEC_96( iterations, EventSet, fp ));
-        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_96( iterations, EventSet, NULL ));
+        sum = vaddh_f16(sum,test_hp_mac_VEC_96( EventSet, fp ));
+        scalar_sum = vaddh_f16(scalar_sum,test_hp_scalar_VEC_96( EventSet, NULL ));
     }
 
     if( vdivh_f16(sum,4.0) != scalar_sum ) {
@@ -450,7 +471,7 @@ void test_hp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp
 
 #else
 static
-float test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_24( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -463,7 +484,7 @@ float test_hp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-float test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_48( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -476,7 +497,7 @@ float test_hp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-float test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_mac_VEC_96( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -489,22 +510,22 @@ float test_hp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_hp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_hp_VEC( int instr_per_loop, int EventSet, FILE *fp )
 {
     float sum = 0.0;
     float scalar_sum = 0.0;
 
     if ( instr_per_loop == 24 ) {
-        sum += test_hp_mac_VEC_24( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_24( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_24( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_hp_mac_VEC_48( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_48( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_48( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_48( EventSet, NULL );
     }
     else if ( instr_per_loop == 96 ) {
-        sum += test_hp_mac_VEC_96( iterations, EventSet, fp );
-        scalar_sum += test_hp_scalar_VEC_96( iterations, EventSet, NULL );
+        sum += test_hp_mac_VEC_96( EventSet, fp );
+        scalar_sum += test_hp_scalar_VEC_96( EventSet, NULL );
     }
 
     if( sum/4.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_nonfma_sp.c b/src/counter_analysis_toolkit/vec_nonfma_sp.c
index f5e25d46b..7078ca7aa 100644
--- a/src/counter_analysis_toolkit/vec_nonfma_sp.c
+++ b/src/counter_analysis_toolkit/vec_nonfma_sp.c
@@ -1,30 +1,30 @@
 #include "vec_scalar_verify.h"
 
-static float test_sp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-static float test_sp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-static float test_sp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp );
-static void  test_sp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp );
+static float test_sp_mac_VEC_24( int EventSet, FILE *fp );
+static float test_sp_mac_VEC_48( int EventSet, FILE *fp );
+static float test_sp_mac_VEC_96( int EventSet, FILE *fp );
+static void  test_sp_VEC( int instr_per_loop, int EventSet, FILE *fp );
 
 /* Wrapper functions of different vector widths. */
 #if defined(X86_VEC_WIDTH_128B)
-void test_sp_x86_128B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_128B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_512B)
-void test_sp_x86_512B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_512B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(X86_VEC_WIDTH_256B)
-void test_sp_x86_256B_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_sp_x86_256B_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(ARM)
-void test_sp_arm_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_sp_arm_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC( instr_per_loop, EventSet, fp );
 }
 #elif defined(POWER)
-void test_sp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp ) {
-    return test_sp_VEC( instr_per_loop, iterations, EventSet, fp );
+void test_sp_power_VEC( int instr_per_loop, int EventSet, FILE *fp ) {
+    return test_sp_VEC( instr_per_loop, EventSet, fp );
 }
 #endif
 
@@ -32,8 +32,13 @@ void test_sp_power_VEC( int instr_per_loop, uint64 iterations, int EventSet, FIL
 /* Loop unrolling:  24 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_24( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -58,12 +63,7 @@ float test_sp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-        /* The performance critical part */
-
+            /* The performance critical part */
             r0 = MUL_VEC_PS(r0,rC);
             r1 = ADD_VEC_PS(r1,rD);
             r2 = MUL_VEC_PS(r2,rE);
@@ -90,13 +90,20 @@ float test_sp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PS(rA,rD);
             rB = MUL_VEC_PS(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(24, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(24, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -127,8 +134,13 @@ float test_sp_mac_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  48 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_48( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -153,12 +165,7 @@ float test_sp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PS(r0,rC);
             r1 = ADD_VEC_PS(r1,rD);
             r2 = MUL_VEC_PS(r2,rE);
@@ -211,13 +218,20 @@ float test_sp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PS(rA,rD);
             rB = MUL_VEC_PS(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(48, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(48, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -248,8 +262,13 @@ float test_sp_mac_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 /* Loop unrolling:  96 instructions */
 /************************************/
 static
-float test_sp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_mac_VEC_96( int EventSet, FILE *fp ){
+
+    svbool_t pg = svptrue_b32();
+    volatile SP_VEC_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_PS(0.01);
@@ -274,12 +293,7 @@ float test_sp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
         return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
             /* The performance critical part */
-
             r0 = MUL_VEC_PS(r0,rC);
             r1 = ADD_VEC_PS(r1,rD);
             r2 = MUL_VEC_PS(r2,rE);
@@ -384,13 +398,20 @@ float test_sp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
             rA = ADD_VEC_PS(rA,rD);
             rB = MUL_VEC_PS(rB,rC);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
-    papi_stop_and_print(96, EventSet, fp);
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
+    if ( NULL != fp ) {
+      papi_print(96, fp, values);
+    }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
     r0 = ADD_VEC_PS(r0,r1);
@@ -418,22 +439,22 @@ float test_sp_mac_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 static
-void test_sp_VEC( int instr_per_loop, uint64 iterations, int EventSet, FILE *fp )
+void test_sp_VEC( int instr_per_loop, int EventSet, FILE *fp )
 {
     float sum = 0.0;
     float scalar_sum = 0.0;
 
     if ( instr_per_loop == 24 ) {
-        sum += test_sp_mac_VEC_24( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_24( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_24( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_24( EventSet, NULL );
     }
     else if ( instr_per_loop == 48 ) {
-        sum += test_sp_mac_VEC_48( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_48( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_48( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_48( EventSet, NULL );
     }
     else if ( instr_per_loop == 96 ) {
-        sum += test_sp_mac_VEC_96( iterations, EventSet, fp );
-        scalar_sum += test_sp_scalar_VEC_96( iterations, EventSet, NULL );
+        sum += test_sp_mac_VEC_96( EventSet, fp );
+        scalar_sum += test_sp_scalar_VEC_96( EventSet, NULL );
     }
 
     if( sum/4.0 != scalar_sum ) {
diff --git a/src/counter_analysis_toolkit/vec_scalar_verify.c b/src/counter_analysis_toolkit/vec_scalar_verify.c
index 9d4a48683..b384350ee 100644
--- a/src/counter_analysis_toolkit/vec_scalar_verify.c
+++ b/src/counter_analysis_toolkit/vec_scalar_verify.c
@@ -5,22 +5,18 @@ void papi_stop_and_print_placeholder(long long theory, FILE *fp)
     fprintf(fp, "%lld 0\n", theory);
 }
 
-void papi_stop_and_print(long long theory, int EventSet, FILE *fp)
+void papi_print(long long theory, FILE *fp, double values)
 {
-    long long flpins = 0;
-    int retval;
-
-    if ( (retval=PAPI_stop(EventSet, &flpins)) != PAPI_OK){
-        fprintf(stderr, "Problem.\n");
-        return;
-    }
-
-    fprintf(fp, "%lld %lld\n", theory, flpins);
+    fprintf(fp, "%lld %.5lf\n", theory, values);
 }
 
 #if defined(ARM)
-half test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_24( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -41,52 +37,50 @@ half test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -111,8 +105,12 @@ half test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
     return out;
 }
 
-half test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_48( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -133,78 +131,76 @@ half test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
+
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -229,8 +225,12 @@ half test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
     return out;
 }
 
-half test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_96( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -251,130 +251,128 @@ half test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            r0 = MUL_VEC_SH(r0,rC);
-            r1 = ADD_VEC_SH(r1,rD);
-            r2 = MUL_VEC_SH(r2,rE);
-            r3 = ADD_VEC_SH(r3,rF);
-            r4 = MUL_VEC_SH(r4,rC);
-            r5 = ADD_VEC_SH(r5,rD);
-            r6 = MUL_VEC_SH(r6,rE);
-            r7 = ADD_VEC_SH(r7,rF);
-            r8 = MUL_VEC_SH(r8,rC);
-            r9 = ADD_VEC_SH(r9,rD);
-            rA = MUL_VEC_SH(rA,rE);
-            rB = ADD_VEC_SH(rB,rF);
-
-            r0 = ADD_VEC_SH(r0,rF);
-            r1 = MUL_VEC_SH(r1,rE);
-            r2 = ADD_VEC_SH(r2,rD);
-            r3 = MUL_VEC_SH(r3,rC);
-            r4 = ADD_VEC_SH(r4,rF);
-            r5 = MUL_VEC_SH(r5,rE);
-            r6 = ADD_VEC_SH(r6,rD);
-            r7 = MUL_VEC_SH(r7,rC);
-            r8 = ADD_VEC_SH(r8,rF);
-            r9 = MUL_VEC_SH(r9,rE);
-            rA = ADD_VEC_SH(rA,rD);
-            rB = MUL_VEC_SH(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
+
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
+
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
+
+    r0 = MUL_VEC_SH(r0,rC);
+    r1 = ADD_VEC_SH(r1,rD);
+    r2 = MUL_VEC_SH(r2,rE);
+    r3 = ADD_VEC_SH(r3,rF);
+    r4 = MUL_VEC_SH(r4,rC);
+    r5 = ADD_VEC_SH(r5,rD);
+    r6 = MUL_VEC_SH(r6,rE);
+    r7 = ADD_VEC_SH(r7,rF);
+    r8 = MUL_VEC_SH(r8,rC);
+    r9 = ADD_VEC_SH(r9,rD);
+    rA = MUL_VEC_SH(rA,rE);
+    rB = ADD_VEC_SH(rB,rF);
+
+    r0 = ADD_VEC_SH(r0,rF);
+    r1 = MUL_VEC_SH(r1,rE);
+    r2 = ADD_VEC_SH(r2,rD);
+    r3 = MUL_VEC_SH(r3,rC);
+    r4 = ADD_VEC_SH(r4,rF);
+    r5 = MUL_VEC_SH(r5,rE);
+    r6 = ADD_VEC_SH(r6,rD);
+    r7 = MUL_VEC_SH(r7,rC);
+    r8 = ADD_VEC_SH(r8,rF);
+    r9 = MUL_VEC_SH(r9,rE);
+    rA = ADD_VEC_SH(rA,rD);
+    rB = MUL_VEC_SH(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(96, EventSet, fp);
+      papi_print(96, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -400,7 +398,7 @@ half test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 #else
-float test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_24( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -412,7 +410,7 @@ float test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
     return 0.0;
 }
 
-float test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_48( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -424,7 +422,7 @@ float test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
     return 0.0;
 }
 
-float test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_96( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -440,8 +438,12 @@ float test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  24 instructions */
 /************************************/
-float test_sp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_scalar_VEC_24( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -462,52 +464,50 @@ float test_sp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -535,8 +535,12 @@ float test_sp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  48 instructions */
 /************************************/
-float test_sp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_scalar_VEC_48( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -557,78 +561,76 @@ float test_sp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
+
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -656,8 +658,12 @@ float test_sp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  96 instructions */
 /************************************/
-float test_sp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_scalar_VEC_96( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -678,130 +684,128 @@ float test_sp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            r0 = MUL_VEC_SS(r0,rC);
-            r1 = ADD_VEC_SS(r1,rD);
-            r2 = MUL_VEC_SS(r2,rE);
-            r3 = ADD_VEC_SS(r3,rF);
-            r4 = MUL_VEC_SS(r4,rC);
-            r5 = ADD_VEC_SS(r5,rD);
-            r6 = MUL_VEC_SS(r6,rE);
-            r7 = ADD_VEC_SS(r7,rF);
-            r8 = MUL_VEC_SS(r8,rC);
-            r9 = ADD_VEC_SS(r9,rD);
-            rA = MUL_VEC_SS(rA,rE);
-            rB = ADD_VEC_SS(rB,rF);
-
-            r0 = ADD_VEC_SS(r0,rF);
-            r1 = MUL_VEC_SS(r1,rE);
-            r2 = ADD_VEC_SS(r2,rD);
-            r3 = MUL_VEC_SS(r3,rC);
-            r4 = ADD_VEC_SS(r4,rF);
-            r5 = MUL_VEC_SS(r5,rE);
-            r6 = ADD_VEC_SS(r6,rD);
-            r7 = MUL_VEC_SS(r7,rC);
-            r8 = ADD_VEC_SS(r8,rF);
-            r9 = MUL_VEC_SS(r9,rE);
-            rA = ADD_VEC_SS(rA,rD);
-            rB = MUL_VEC_SS(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
+
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
+
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
+
+    r0 = MUL_VEC_SS(r0,rC);
+    r1 = ADD_VEC_SS(r1,rD);
+    r2 = MUL_VEC_SS(r2,rE);
+    r3 = ADD_VEC_SS(r3,rF);
+    r4 = MUL_VEC_SS(r4,rC);
+    r5 = ADD_VEC_SS(r5,rD);
+    r6 = MUL_VEC_SS(r6,rE);
+    r7 = ADD_VEC_SS(r7,rF);
+    r8 = MUL_VEC_SS(r8,rC);
+    r9 = ADD_VEC_SS(r9,rD);
+    rA = MUL_VEC_SS(rA,rE);
+    rB = ADD_VEC_SS(rB,rF);
+
+    r0 = ADD_VEC_SS(r0,rF);
+    r1 = MUL_VEC_SS(r1,rE);
+    r2 = ADD_VEC_SS(r2,rD);
+    r3 = MUL_VEC_SS(r3,rC);
+    r4 = ADD_VEC_SS(r4,rF);
+    r5 = MUL_VEC_SS(r5,rE);
+    r6 = ADD_VEC_SS(r6,rD);
+    r7 = MUL_VEC_SS(r7,rC);
+    r8 = ADD_VEC_SS(r8,rF);
+    r9 = MUL_VEC_SS(r9,rE);
+    rA = ADD_VEC_SS(rA,rD);
+    rB = MUL_VEC_SS(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(96, EventSet, fp);
+      papi_print(96, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -829,8 +833,12 @@ float test_sp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  24 instructions */
 /************************************/
-double test_dp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_24( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -851,52 +859,50 @@ double test_dp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -924,8 +930,12 @@ double test_dp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  48 instructions */
 /************************************/
-double test_dp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_48( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -946,78 +956,76 @@ double test_dp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
+
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1045,8 +1053,12 @@ double test_dp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  96 instructions */
 /************************************/
-double test_dp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_96( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -1067,130 +1079,128 @@ double test_dp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            r0 = MUL_VEC_SD(r0,rC);
-            r1 = ADD_VEC_SD(r1,rD);
-            r2 = MUL_VEC_SD(r2,rE);
-            r3 = ADD_VEC_SD(r3,rF);
-            r4 = MUL_VEC_SD(r4,rC);
-            r5 = ADD_VEC_SD(r5,rD);
-            r6 = MUL_VEC_SD(r6,rE);
-            r7 = ADD_VEC_SD(r7,rF);
-            r8 = MUL_VEC_SD(r8,rC);
-            r9 = ADD_VEC_SD(r9,rD);
-            rA = MUL_VEC_SD(rA,rE);
-            rB = ADD_VEC_SD(rB,rF);
-
-            r0 = ADD_VEC_SD(r0,rF);
-            r1 = MUL_VEC_SD(r1,rE);
-            r2 = ADD_VEC_SD(r2,rD);
-            r3 = MUL_VEC_SD(r3,rC);
-            r4 = ADD_VEC_SD(r4,rF);
-            r5 = MUL_VEC_SD(r5,rE);
-            r6 = ADD_VEC_SD(r6,rD);
-            r7 = MUL_VEC_SD(r7,rC);
-            r8 = ADD_VEC_SD(r8,rF);
-            r9 = MUL_VEC_SD(r9,rE);
-            rA = ADD_VEC_SD(rA,rD);
-            rB = MUL_VEC_SD(rB,rC);
-
-            i++;
-        }
-        c++;
-    }
+    /* The performance critical part */
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
+
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
+
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
+
+    r0 = MUL_VEC_SD(r0,rC);
+    r1 = ADD_VEC_SD(r1,rD);
+    r2 = MUL_VEC_SD(r2,rE);
+    r3 = ADD_VEC_SD(r3,rF);
+    r4 = MUL_VEC_SD(r4,rC);
+    r5 = ADD_VEC_SD(r5,rD);
+    r6 = MUL_VEC_SD(r6,rE);
+    r7 = ADD_VEC_SD(r7,rF);
+    r8 = MUL_VEC_SD(r8,rC);
+    r9 = ADD_VEC_SD(r9,rD);
+    rA = MUL_VEC_SD(rA,rE);
+    rB = ADD_VEC_SD(rB,rF);
+
+    r0 = ADD_VEC_SD(r0,rF);
+    r1 = MUL_VEC_SD(r1,rE);
+    r2 = ADD_VEC_SD(r2,rD);
+    r3 = MUL_VEC_SD(r3,rC);
+    r4 = ADD_VEC_SD(r4,rF);
+    r5 = MUL_VEC_SD(r5,rE);
+    r6 = ADD_VEC_SD(r6,rD);
+    r7 = MUL_VEC_SD(r7,rC);
+    r8 = ADD_VEC_SD(r8,rF);
+    r9 = MUL_VEC_SD(r9,rE);
+    rA = ADD_VEC_SD(rA,rD);
+    rB = MUL_VEC_SD(rB,rC);
 
     /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
+    }
+
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(96, EventSet, fp);
+      papi_print(96, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1216,8 +1226,12 @@ double test_dp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 #if defined(ARM)
-half test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -1238,18 +1252,11 @@ half test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SH(r0,r0,r7,r9);
             FMA_VEC_SH(r1,r1,r8,rA);
             FMA_VEC_SH(r2,r2,r9,rB);
@@ -1264,14 +1271,19 @@ half test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SH(r4,r4,r9,rB);
             FMA_VEC_SH(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(12, EventSet, fp);
+      papi_print(12, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1291,8 +1303,12 @@ half test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
     return out;
 }
 
-half test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -1313,18 +1329,11 @@ half test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SH(r0,r0,r7,r9);
             FMA_VEC_SH(r1,r1,r8,rA);
             FMA_VEC_SH(r2,r2,r9,rB);
@@ -1353,14 +1362,19 @@ half test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SH(r4,r4,r9,rB);
             FMA_VEC_SH(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1380,8 +1394,12 @@ half test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
     return out;
 }
 
-half test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+half test_hp_scalar_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    volatile half r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SH(0.01);
@@ -1402,18 +1420,11 @@ half test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SH(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SH(r0,r0,r7,r9);
             FMA_VEC_SH(r1,r1,r8,rA);
             FMA_VEC_SH(r2,r2,r9,rB);
@@ -1470,14 +1481,19 @@ half test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SH(r4,r4,r9,rB);
             FMA_VEC_SH(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1498,7 +1514,7 @@ half test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 }
 
 #else
-float test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_FMA_12( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -1510,7 +1526,7 @@ float test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
     return 0.0;
 }
 
-float test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_FMA_24( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -1522,7 +1538,7 @@ float test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
     return 0.0;
 }
 
-float test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
+float test_hp_scalar_VEC_FMA_48( int EventSet, FILE *fp ){
 
     (void)iterations;
     (void)EventSet;
@@ -1538,9 +1554,13 @@ float test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  12 instructions */
 /************************************/
-#pragma GCC optimize ("O2")
-float test_sp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+//#pragma GCC optimize ("O2")
+float test_sp_scalar_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -1561,18 +1581,11 @@ float test_sp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SS(r0,r0,r7,r9);
             FMA_VEC_SS(r1,r1,r8,rA);
             FMA_VEC_SS(r2,r2,r9,rB);
@@ -1587,14 +1600,19 @@ float test_sp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SS(r4,r4,r9,rB);
             FMA_VEC_SS(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(12, EventSet, fp);
+      papi_print(12, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1617,8 +1635,12 @@ float test_sp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  24 instructions */
 /************************************/
-float test_sp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_scalar_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -1639,18 +1661,11 @@ float test_sp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SS(r0,r0,r7,r9);
             FMA_VEC_SS(r1,r1,r8,rA);
             FMA_VEC_SS(r2,r2,r9,rB);
@@ -1679,14 +1694,19 @@ float test_sp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SS(r4,r4,r9,rB);
             FMA_VEC_SS(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1709,8 +1729,12 @@ float test_sp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  48 instructions */
 /************************************/
-float test_sp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+float test_sp_scalar_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    volatile SP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SS(0.01);
@@ -1731,18 +1755,11 @@ float test_sp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SS(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SS(r0,r0,r7,r9);
             FMA_VEC_SS(r1,r1,r8,rA);
             FMA_VEC_SS(r2,r2,r9,rB);
@@ -1799,14 +1816,19 @@ float test_sp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SS(r4,r4,r9,rB);
             FMA_VEC_SS(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1829,8 +1851,12 @@ float test_sp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  12 instructions */
 /************************************/
-double test_dp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_FMA_12( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -1851,18 +1877,11 @@ double test_dp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SD(r0,r0,r7,r9);
             FMA_VEC_SD(r1,r1,r8,rA);
             FMA_VEC_SD(r2,r2,r9,rB);
@@ -1877,14 +1896,19 @@ double test_dp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SD(r4,r4,r9,rB);
             FMA_VEC_SD(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(12, EventSet, fp);
+      papi_print(12, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1907,8 +1931,12 @@ double test_dp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  24 instructions */
 /************************************/
-double test_dp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_FMA_24( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -1929,18 +1957,11 @@ double test_dp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SD(r0,r0,r7,r9);
             FMA_VEC_SD(r1,r1,r8,rA);
             FMA_VEC_SD(r2,r2,r9,rB);
@@ -1969,14 +1990,19 @@ double test_dp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SD(r4,r4,r9,rB);
             FMA_VEC_SD(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(24, EventSet, fp);
+      papi_print(24, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
@@ -1999,8 +2025,12 @@ double test_dp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp ){
 /************************************/
 /* Loop unrolling:  48 instructions */
 /************************************/
-double test_dp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
-    register DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+double test_dp_scalar_VEC_FMA_48( int EventSet, FILE *fp ){
+
+    volatile DP_SCALAR_TYPE r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,rA,rB,rC,rD,rE,rF;
+    double values = 0.0;
+    long long iterValues[1]; iterValues[0] = 0;
+    for (int iter=0; iter<ITERS; ++iter) {
 
     /* Generate starting data */
     r0 = SET_VEC_SD(0.01);
@@ -2021,18 +2051,11 @@ double test_dp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
     rF = SET_VEC_SD(0.16);
 
     /* Start PAPI counters */
-    if ( NULL != fp ) {
-      if ( PAPI_start( EventSet ) != PAPI_OK ) {
-        return -1;
-      }
+    if ( NULL != fp && PAPI_start( EventSet ) != PAPI_OK ) {
+      return -1;
     }
 
-    uint64 c = 0;
-    while (c < iterations){
-        size_t i = 0;
-        while (i < ITER){
-
-            /* The performance critical part */
+    /* The performance critical part */
             FMA_VEC_SD(r0,r0,r7,r9);
             FMA_VEC_SD(r1,r1,r8,rA);
             FMA_VEC_SD(r2,r2,r9,rB);
@@ -2089,14 +2112,19 @@ double test_dp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp ){
             FMA_VEC_SD(r4,r4,r9,rB);
             FMA_VEC_SD(r5,r5,r8,rA);
 
-            i++;
-        }
-        c++;
+    /* Stop PAPI counters */
+    if ( NULL != fp && PAPI_stop(EventSet, iterValues) != PAPI_OK ) {
+      return -1;
     }
 
-    /* Stop PAPI counters */
+    values += iterValues[0];
+
+} // end of ITERS
+
+    values /= ITERS;
+
     if ( NULL != fp ) {
-      papi_stop_and_print(48, EventSet, fp);
+      papi_print(48, fp, values);
     }
 
     /* Use data so that compiler does not eliminate it when using -O2 */
diff --git a/src/counter_analysis_toolkit/vec_scalar_verify.h b/src/counter_analysis_toolkit/vec_scalar_verify.h
index 3335511ce..d31f4f480 100644
--- a/src/counter_analysis_toolkit/vec_scalar_verify.h
+++ b/src/counter_analysis_toolkit/vec_scalar_verify.h
@@ -3,46 +3,46 @@
 #include <stdlib.h>
 #include "cat_arch.h"
 
-#define ITER 1
+#define ITERS 100000
 
 void papi_stop_and_print_placeholder(long long theory, FILE *fp);
-void papi_stop_and_print(long long theory, int EventSet, FILE *fp);
+void papi_print(long long theory, FILE *fp, double values);
 
 // Non-FMA-like computations.
 #if defined(ARM)
-half test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-half test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-half test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+half test_hp_scalar_VEC_24( int EventSet, FILE *fp );
+half test_hp_scalar_VEC_48( int EventSet, FILE *fp );
+half test_hp_scalar_VEC_96( int EventSet, FILE *fp );
 #else
-float test_hp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-float test_hp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-float test_hp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+float test_hp_scalar_VEC_24( int EventSet, FILE *fp );
+float test_hp_scalar_VEC_48( int EventSet, FILE *fp );
+float test_hp_scalar_VEC_96( int EventSet, FILE *fp );
 #endif
 
-float test_sp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-float test_sp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-float test_sp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+float test_sp_scalar_VEC_24( int EventSet, FILE *fp );
+float test_sp_scalar_VEC_48( int EventSet, FILE *fp );
+float test_sp_scalar_VEC_96( int EventSet, FILE *fp );
 
-double test_dp_scalar_VEC_24( uint64 iterations, int EventSet, FILE *fp );
-double test_dp_scalar_VEC_48( uint64 iterations, int EventSet, FILE *fp );
-double test_dp_scalar_VEC_96( uint64 iterations, int EventSet, FILE *fp );
+double test_dp_scalar_VEC_24( int EventSet, FILE *fp );
+double test_dp_scalar_VEC_48( int EventSet, FILE *fp );
+double test_dp_scalar_VEC_96( int EventSet, FILE *fp );
 
 // Functions to emulate FMA.
 #if defined(ARM)
-half test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-half test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-half test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+half test_hp_scalar_VEC_FMA_12( int EventSet, FILE *fp );
+half test_hp_scalar_VEC_FMA_24( int EventSet, FILE *fp );
+half test_hp_scalar_VEC_FMA_48( int EventSet, FILE *fp );
 #else
-float test_hp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-float test_hp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-float test_hp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+float test_hp_scalar_VEC_FMA_12( int EventSet, FILE *fp );
+float test_hp_scalar_VEC_FMA_24( int EventSet, FILE *fp );
+float test_hp_scalar_VEC_FMA_48( int EventSet, FILE *fp );
 #endif
 
-float test_sp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-float test_sp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-float test_sp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+float test_sp_scalar_VEC_FMA_12( int EventSet, FILE *fp );
+float test_sp_scalar_VEC_FMA_24( int EventSet, FILE *fp );
+float test_sp_scalar_VEC_FMA_48( int EventSet, FILE *fp );
 
-double test_dp_scalar_VEC_FMA_12( uint64 iterations, int EventSet, FILE *fp );
-double test_dp_scalar_VEC_FMA_24( uint64 iterations, int EventSet, FILE *fp );
-double test_dp_scalar_VEC_FMA_48( uint64 iterations, int EventSet, FILE *fp );
+double test_dp_scalar_VEC_FMA_12( int EventSet, FILE *fp );
+double test_dp_scalar_VEC_FMA_24( int EventSet, FILE *fp );
+double test_dp_scalar_VEC_FMA_48( int EventSet, FILE *fp );