diff --git a/example/README.md b/example/README.md
new file mode 100644
index 0000000..e9241c0
--- /dev/null
+++ b/example/README.md
@@ -0,0 +1,34 @@
+# Description
+Simple SpMV (Spare Matrix Vector) based GEMV kernel for cpu-pin tool example. Each ROI has either sparse gather or scatter instructions, or vectorization target for vector instruction. 
+
+# Matrix Input
+_.mtx_ file is used as an input from https://sparse.tamu.edu/HB/. Each _.mtx_ has a banner on the top in the form of _MatrixMarket banner1 banner2 banner3 ..._ For this example _matrix, coordinate, real_ are required and only compatible.
+
+# ROI
+ - spmv_serial: serial gemv kernel (activated w/o -t)
+ - spmv_omp: omp gemv kernel (activated w/ -t <greater than 1>)
+ - set_sparse_vector: scatter based sparse operand vector generator
+
+# Use
+## Compile & Run
+```
+gcc -g -fopenmp -o maxim_spmv src/*.c
+./maxim_spmv -t <thread_num> -f mat/<mat_file>
+```
+## Run PIN
+```
+echo <ROI> > roi_funcs.txt
+$PIN_ROOT/pin -t ../pin_tracing/obj-intel64/ImemROIThreads.so -- ./maxim_spmv -t <thread_num> -f mat/<mat_file>
+```
+## Run GS Pattern
+```
+gzip roitrace.00.<ROI>.bin
+<gs_pattern_build_root>/gs_pattern roitrace.00.<ROI>.bin.gz maxim_spmv
+```
+
+# Troubleshoot
+## PIN
+If no ROI instructions are tracked, try with less or no compiler optimization options. gcc tends to be more reliable for the optimizations for this example.
+
+## gs_pattern
+If empty outputs are generated with the valid trace file, the fastest solutions you may consider would be to try with 1) _SYMBOLS_ONLY_ turned off or 2) larger problem size. From experience, lower threshold of the number of indices is ~100 for this example.  
\ No newline at end of file
diff --git a/example/cpu/mat/bcsstk01.mtx b/example/cpu/mat/bcsstk01.mtx
new file mode 100644
index 0000000..728073c
--- /dev/null
+++ b/example/cpu/mat/bcsstk01.mtx
@@ -0,0 +1,238 @@
+%%MatrixMarket matrix coordinate real symmetric
+%-------------------------------------------------------------------------------
+% UF Sparse Matrix Collection, Tim Davis
+% http://www.cise.ufl.edu/research/sparse/matrices/HB/bcsstk01
+% name: HB/bcsstk01
+% [SYMMETRIC STIFFNESS MATRIX SMALL GENERALIZED EIGENVALUE PROBLEM]
+% id: 23
+% date: 1982
+% author: J. Lewis
+% ed: I. Duff, R. Grimes, J. Lewis
+% fields: title A name id date author ed kind
+% kind: structural problem
+%-------------------------------------------------------------------------------
+48 48 224
+1 1 2832268.51852
+5 1 1e6
+6 1 2083333.33333
+7 1 -3333.33333333
+11 1 1e6
+19 1 -2.8e6
+25 1 -28935.1851852
+30 1 2083333.33333
+2 2 1635447.53086
+4 2 -2e6
+6 2 5555555.55555
+8 2 -6666.66666667
+10 2 -2e6
+20 2 -30864.1975309
+24 2 5555555.55555
+26 2 -1597916.66667
+3 3 1724367.28395
+4 3 -2083333.33333
+5 3 -2777777.77778
+9 3 -1.68e6
+21 3 -15432.0987654
+23 3 -2777777.77778
+27 3 -28935.1851852
+28 3 -2083333.33333
+4 4 1003333333.33
+8 4 2e6
+10 4 4e8
+22 4 -3333333.33333
+27 4 2083333.33333
+28 4 1e8
+5 5 1.0675e9
+7 5 -1e6
+11 5 2e8
+21 5 2777777.77778
+23 5 333333333.333
+29 5 -833333.333333
+6 6 1535333333.33
+12 6 -2e6
+20 6 -5555555.55555
+24 6 666666666.667
+25 6 -2083333.33333
+30 6 1e8
+7 7 2832268.51852
+11 7 -1e6
+12 7 2083333.33333
+13 7 -2.8e6
+31 7 -28935.1851852
+36 7 2083333.33333
+8 8 1635447.53086
+10 8 2e6
+12 8 5555555.55555
+14 8 -30864.1975309
+18 8 5555555.55555
+32 8 -1597916.66667
+9 9 1724367.28395
+10 9 -2083333.33333
+11 9 -2777777.77778
+15 9 -15432.0987654
+17 9 -2777777.77778
+33 9 -28935.1851852
+34 9 -2083333.33333
+10 10 1003333333.33
+16 10 -3333333.33333
+33 10 2083333.33333
+34 10 1e8
+11 11 1.0675e9
+15 11 2777777.77778
+17 11 333333333.333
+35 11 -833333.333333
+12 12 1535333333.33
+14 12 -5555555.55555
+18 12 666666666.667
+31 12 -2083333.33333
+36 12 1e8
+13 13 2836099.4695
+17 13 -2149285.29451
+18 13 2359161.80402
+19 13 -3333.33333333
+23 13 -1e6
+37 13 -28935.1851852
+42 13 2083333.33333
+43 13 -3830.95098171
+47 13 -1149285.29451
+48 13 275828.470683
+14 14 1767410.74446
+15 14 517922.131816
+16 14 4298570.58902
+18 14 -5555555.55555
+20 14 -6666.66666667
+22 14 2e6
+38 14 -1597916.66667
+44 14 -131963.213599
+45 14 -517922.131816
+46 14 2298570.58902
+15 15 3890038.06848
+16 15 -2634990.2747
+17 15 2777777.77778
+21 15 -1.68e6
+39 15 -28935.1851852
+40 15 -2083333.33333
+44 15 -517922.131816
+45 15 -2165670.78453
+46 15 -551656.941367
+16 16 1975720635.31
+20 16 -2e6
+22 16 4e8
+39 16 2083333.33333
+40 16 1e8
+44 16 -2298570.58902
+45 16 551656.941366
+46 16 486193650.99
+17 17 1527346515.47
+18 17 -109779731.332
+19 17 1e6
+23 17 2e8
+41 17 -833333.333333
+43 17 1149285.29451
+47 17 229724661.236
+48 17 -55717351.0779
+18 18 1564111437.11
+24 18 -2e6
+37 18 -2083333.33333
+42 18 1e8
+43 18 -275828.470683
+47 18 -55717351.0779
+48 18 10941196.0038
+19 19 2832268.51852
+23 19 1e6
+24 19 2083333.33333
+43 19 -28935.1851852
+48 19 2083333.33333
+20 20 1635447.53086
+22 20 -2e6
+24 20 -5555555.55555
+44 20 -1597916.66667
+21 21 1724367.28395
+22 21 -2083333.33333
+23 21 2777777.77778
+45 21 -28935.1851852
+46 21 -2083333.33333
+22 22 1003333333.33
+45 22 2083333.33333
+46 22 1e8
+23 23 1.0675e9
+47 23 -833333.333333
+24 24 1535333333.33
+43 24 -2083333.33333
+48 24 1e8
+25 25 60879.6296296
+29 25 1.25e6
+30 25 416666.666667
+31 25 -4166.66666667
+35 25 1.25e6
+26 26 3372916.66667
+28 26 -2.5e6
+32 26 -8333.33333333
+34 26 -2.5e6
+27 27 2411712.96296
+28 27 -416666.666667
+33 27 -2.355e6
+28 28 1.5e9
+32 28 2.5e6
+34 28 5e8
+29 29 501833333.333
+31 29 -1.25e6
+35 29 2.5e8
+30 30 5.025e8
+36 30 -2.5e6
+31 31 3985879.62963
+35 31 -1.25e6
+36 31 416666.666667
+37 31 -3.925e6
+32 32 3411496.91358
+34 32 2.5e6
+36 32 6944444.44444
+38 32 -38580.2469136
+42 32 6944444.44445
+33 33 2431003.08642
+34 33 -416666.666667
+35 33 -3472222.22222
+39 33 -19290.1234568
+41 33 -3472222.22222
+34 34 1504166666.67
+40 34 -4166666.66667
+35 35 1335166666.67
+39 35 3472222.22222
+41 35 416666666.667
+36 36 2169166666.67
+38 36 -6944444.44444
+42 36 833333333.333
+37 37 3985879.62963
+41 37 -1.25e6
+42 37 416666.666667
+43 37 -4166.66666667
+47 37 -1.25e6
+38 38 3411496.91358
+40 38 2.5e6
+42 38 -6944444.44445
+44 38 -8333.33333333
+46 38 2.5e6
+39 39 2431003.08642
+40 39 -416666.666667
+41 39 3472222.22222
+45 39 -2.355e6
+40 40 1504166666.67
+44 40 -2.5e6
+46 40 5e8
+41 41 1335166666.67
+43 41 1.25e6
+47 41 2.5e8
+42 42 2169166666.67
+48 42 -2.5e6
+43 43 64710.5806113
+47 43 2399285.29451
+48 43 140838.195984
+44 44 3504879.88027
+45 44 517922.131816
+46 44 -4798570.58902
+45 45 4577383.74749
+46 45 134990.2747
+46 46 2472387301.98
+47 47 961679848.804
+48 47 -109779731.332
+48 48 531278103.775
diff --git a/example/cpu/src/maxim_spmv.c b/example/cpu/src/maxim_spmv.c
new file mode 100644
index 0000000..0a40db3
--- /dev/null
+++ b/example/cpu/src/maxim_spmv.c
@@ -0,0 +1,164 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <omp.h>
+#include <math.h>
+#include <string.h>
+#include "mmio.h"
+
+typedef struct {
+	int i;
+	int j;
+	double v;
+} elem;
+
+int compare(const void *a, const void *b) {
+	elem lhs = *(elem *) a;
+	elem rhs = *(elem *) b;
+	return (lhs.i == rhs.i) ? (lhs.j - rhs.j) : (lhs.i - rhs.i);
+}
+
+int read(const char *fname, int *M, int *N, int **row, int **col, double **val) {
+	int ret_code;
+    MM_typecode matcode;
+    FILE *f;
+    int nz;
+
+    if ((f = fopen(fname, "r")) == NULL) {
+		fprintf(stderr, "error in fopen\n");
+		exit(1);
+    }
+    if (mm_read_banner(f, &matcode) != 0) {
+        fprintf(stderr, "error reading matrix banner\n");
+        exit(1);
+    }
+    if (!mm_is_real(matcode) || !mm_is_matrix(matcode) || !mm_is_coordinate(matcode)) {
+        fprintf(stderr, "unsupported ");
+        fprintf(stderr, "Market Market type: [%s]\n", mm_typecode_to_str(matcode));
+        exit(1);
+    }
+    if ((ret_code = mm_read_mtx_crd_size(f, M, N, &nz)) !=0) {
+		fprintf(stderr, "error reading matrix size\n");
+        exit(1);
+	}
+
+    // reserve memory for coordinate form
+	elem *coords = (elem *) malloc (nz * sizeof(elem));
+
+	// read
+	for (int i = 0; i < nz; i++) {
+		if (fscanf(f, "%d %d %lg\n", &coords[i].i, &coords[i].j, &coords[i].v) != 3) {
+			fprintf(stderr, "invalid format at entry %d\n", i+1);
+		}
+	}
+
+	// sort
+	qsort(coords, nz, sizeof(elem), compare);
+
+	// reserve memory for CSR
+	*row = (int *) malloc ((*M+1) * sizeof(int));
+	*col = (int *) malloc (nz * sizeof(int));
+	*val = (double *) malloc (nz * sizeof(double));
+	for (int i = 0; i < (*M)+1; i++) { (*row)[i] = 0; }
+
+	// convert to CSR
+	for (int i = 0; i < nz; i++) {
+		(*row)[coords[i].i]++;
+		(*col)[i] = coords[i].j - 1;
+		(*val)[i] = coords[i].v;
+	}
+	for (int i = 0; i < *M; i++) {
+		(*row)[i+1] += (*row)[i];
+	}
+
+	fclose(f);
+	free(coords);
+	return nz;
+}
+
+void set_sparse_vector(int N, double *vec) {
+
+	int* scatter = (int *) malloc (N * sizeof(int));
+
+	for (int i = 0; i < N; i++) {
+		scatter[i] = rand() % N;
+	}
+	
+	for (int i = 0; i < N; i++) {
+		vec[scatter[i]] = i;
+	}
+
+	free(scatter);
+}
+
+void spmv_serial(int M, int *row, int *col, double *val, double *vec, double *res) {
+	for (int i = 0; i < M; i++) {
+		res[i] = 0;
+		for (int j = row[i]; j < row[i+1]; j++) {
+			res[i] += val[j] * vec[col[j]];
+		}
+	}
+	return;
+}
+
+void spmv_omp(int M, int *row, int *col, double *val, double *vec, double *res, int num_threads) {
+	#pragma omp parallel for num_threads(num_threads)
+	for (int i = 0; i < M; i++) {
+		res[i] = 0;
+		for (int j = row[i]; j < row[i+1]; j++) {
+			res[i] += val[j] * vec[col[j]];
+		}
+	}
+}
+
+int compare_results(double *a, double *b, int size, double tol) {
+	for (int i = 0; i < size; i++) {
+		if (fabs(a[i] - b[i]) > tol) {
+			return 0; // match
+		}
+	}
+	return 1; // mismatch
+}
+
+int main(int argc, char *argv[]) {
+	if (argc < 2) {
+		fprintf(stderr, "usage: %s -f [martix-market-filename] -t [num_thread]\n", argv[0]);
+		exit(1);
+	}
+	
+	int num_threads = 1;
+	int f_idx = 0;
+	int print = 0;
+	
+	for (int i = 1; i < argc; i++) {
+		if (strcmp(argv[i], "-f") == 0) {
+			f_idx = i + 1;
+		} else if (strcmp(argv[i], "-t") == 0) {
+			printf("num_thread: %s\n", argv[i+1]);
+			num_threads = atoi(argv[i+1]);
+		}
+	}
+
+	int M, N, *row, *col;
+	double *val, *vec, *res;
+	
+	read(argv[f_idx], &M, &N, &row, &col, &val);
+
+	vec = (double *) malloc (N * sizeof(double));
+	res = (double *) malloc (M * sizeof(double));
+
+	// For the evaluation of vectorized g/s instruction
+	set_sparse_vector(N, vec);
+	
+	if (num_threads <= 1) {
+		spmv_serial(M, row, col, val, vec, res);
+	} else {
+		spmv_omp(M, row, col, val, vec, res, num_threads);
+	}
+
+	free(row);
+	free(col);
+	free(val);
+	free(vec);
+	free(res);
+	return 0;
+}
diff --git a/example/cpu/src/mmio.c b/example/cpu/src/mmio.c
new file mode 100644
index 0000000..c250ff2
--- /dev/null
+++ b/example/cpu/src/mmio.c
@@ -0,0 +1,511 @@
+/* 
+*   Matrix Market I/O library for ANSI C
+*
+*   See http://math.nist.gov/MatrixMarket for details.
+*
+*
+*/
+
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "mmio.h"
+
+int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_,
+                double **val_, int **I_, int **J_)
+{
+    FILE *f;
+    MM_typecode matcode;
+    int M, N, nz;
+    int i;
+    double *val;
+    int *I, *J;
+ 
+    if ((f = fopen(fname, "r")) == NULL)
+            return -1;
+ 
+ 
+    if (mm_read_banner(f, &matcode) != 0)
+    {
+        printf("mm_read_unsymetric: Could not process Matrix Market banner ");
+        printf(" in file [%s]\n", fname);
+        return -1;
+    }
+ 
+ 
+ 
+    if ( !(mm_is_real(matcode) && mm_is_matrix(matcode) &&
+            mm_is_sparse(matcode)))
+    {
+        fprintf(stderr, "Sorry, this application does not support ");
+        fprintf(stderr, "Market Market type: [%s]\n",
+                mm_typecode_to_str(matcode));
+        return -1;
+    }
+ 
+    /* find out size of sparse matrix: M, N, nz .... */
+ 
+    if (mm_read_mtx_crd_size(f, &M, &N, &nz) !=0)
+    {
+        fprintf(stderr, "read_unsymmetric_sparse(): could not parse matrix size.\n");
+        return -1;
+    }
+ 
+    *M_ = M;
+    *N_ = N;
+    *nz_ = nz;
+ 
+    /* reseve memory for matrices */
+ 
+    I = (int *) malloc(nz * sizeof(int));
+    J = (int *) malloc(nz * sizeof(int));
+    val = (double *) malloc(nz * sizeof(double));
+ 
+    *val_ = val;
+    *I_ = I;
+    *J_ = J;
+ 
+    /* NOTE: when reading in doubles, ANSI C requires the use of the "l"  */
+    /*   specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
+    /*  (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15)            */
+ 
+    for (i=0; i<nz; i++)
+    {
+        fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]);
+        I[i]--;  /* adjust from 1-based to 0-based */
+        J[i]--;
+    }
+    fclose(f);
+ 
+    return 0;
+}
+
+int mm_is_valid(MM_typecode matcode)
+{
+    if (!mm_is_matrix(matcode)) return 0;
+    if (mm_is_dense(matcode) && mm_is_pattern(matcode)) return 0;
+    if (mm_is_real(matcode) && mm_is_hermitian(matcode)) return 0;
+    if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) || 
+                mm_is_skew(matcode))) return 0;
+    return 1;
+}
+
+int mm_read_banner(FILE *f, MM_typecode *matcode)
+{
+    char line[MM_MAX_LINE_LENGTH];
+    char banner[MM_MAX_TOKEN_LENGTH];
+    char mtx[MM_MAX_TOKEN_LENGTH]; 
+    char crd[MM_MAX_TOKEN_LENGTH];
+    char data_type[MM_MAX_TOKEN_LENGTH];
+    char storage_scheme[MM_MAX_TOKEN_LENGTH];
+    char *p;
+
+
+    mm_clear_typecode(matcode);  
+
+    if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL) 
+        return MM_PREMATURE_EOF;
+
+    if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, data_type, 
+        storage_scheme) != 5)
+        return MM_PREMATURE_EOF;
+
+    for (p=mtx; *p!='\0'; *p=tolower(*p),p++);  /* convert to lower case */
+    for (p=crd; *p!='\0'; *p=tolower(*p),p++);  
+    for (p=data_type; *p!='\0'; *p=tolower(*p),p++);
+    for (p=storage_scheme; *p!='\0'; *p=tolower(*p),p++);
+
+    /* check for banner */
+    if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0)
+        return MM_NO_HEADER;
+
+    /* first field should be "mtx" */
+    if (strcmp(mtx, MM_MTX_STR) != 0)
+        return  MM_UNSUPPORTED_TYPE;
+    mm_set_matrix(matcode);
+
+
+    /* second field describes whether this is a sparse matrix (in coordinate
+            storgae) or a dense array */
+
+
+    if (strcmp(crd, MM_SPARSE_STR) == 0)
+        mm_set_sparse(matcode);
+    else
+    if (strcmp(crd, MM_DENSE_STR) == 0)
+            mm_set_dense(matcode);
+    else
+        return MM_UNSUPPORTED_TYPE;
+    
+
+    /* third field */
+
+    if (strcmp(data_type, MM_REAL_STR) == 0)
+        mm_set_real(matcode);
+    else
+    if (strcmp(data_type, MM_COMPLEX_STR) == 0)
+        mm_set_complex(matcode);
+    else
+    if (strcmp(data_type, MM_PATTERN_STR) == 0)
+        mm_set_pattern(matcode);
+    else
+    if (strcmp(data_type, MM_INT_STR) == 0)
+        mm_set_integer(matcode);
+    else
+        return MM_UNSUPPORTED_TYPE;
+    
+
+    /* fourth field */
+
+    if (strcmp(storage_scheme, MM_GENERAL_STR) == 0)
+        mm_set_general(matcode);
+    else
+    if (strcmp(storage_scheme, MM_SYMM_STR) == 0)
+        mm_set_symmetric(matcode);
+    else
+    if (strcmp(storage_scheme, MM_HERM_STR) == 0)
+        mm_set_hermitian(matcode);
+    else
+    if (strcmp(storage_scheme, MM_SKEW_STR) == 0)
+        mm_set_skew(matcode);
+    else
+        return MM_UNSUPPORTED_TYPE;
+        
+
+    return 0;
+}
+
+int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
+{
+    if (fprintf(f, "%d %d %d\n", M, N, nz) != 3)
+        return MM_COULD_NOT_WRITE_FILE;
+    else 
+        return 0;
+}
+
+int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz )
+{
+    char line[MM_MAX_LINE_LENGTH];
+    int num_items_read;
+
+    /* set return null parameter values, in case we exit with errors */
+    *M = *N = *nz = 0;
+
+    /* now continue scanning until you reach the end-of-comments */
+    do 
+    {
+        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
+            return MM_PREMATURE_EOF;
+    }while (line[0] == '%');
+
+    /* line[] is either blank or has M,N, nz */
+    if (sscanf(line, "%d %d %d", M, N, nz) == 3)
+        return 0;
+        
+    else
+    do
+    { 
+        num_items_read = fscanf(f, "%d %d %d", M, N, nz); 
+        if (num_items_read == EOF) return MM_PREMATURE_EOF;
+    }
+    while (num_items_read != 3);
+
+    return 0;
+}
+
+
+int mm_read_mtx_array_size(FILE *f, int *M, int *N)
+{
+    char line[MM_MAX_LINE_LENGTH];
+    int num_items_read;
+    /* set return null parameter values, in case we exit with errors */
+    *M = *N = 0;
+	
+    /* now continue scanning until you reach the end-of-comments */
+    do 
+    {
+        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
+            return MM_PREMATURE_EOF;
+    }while (line[0] == '%');
+
+    /* line[] is either blank or has M,N, nz */
+    if (sscanf(line, "%d %d", M, N) == 2)
+        return 0;
+        
+    else /* we have a blank line */
+    do
+    { 
+        num_items_read = fscanf(f, "%d %d", M, N); 
+        if (num_items_read == EOF) return MM_PREMATURE_EOF;
+    }
+    while (num_items_read != 2);
+
+    return 0;
+}
+
+int mm_write_mtx_array_size(FILE *f, int M, int N)
+{
+    if (fprintf(f, "%d %d\n", M, N) != 2)
+        return MM_COULD_NOT_WRITE_FILE;
+    else 
+        return 0;
+}
+
+
+
+/*-------------------------------------------------------------------------*/
+
+/******************************************************************/
+/* use when I[], J[], and val[]J, and val[] are already allocated */
+/******************************************************************/
+
+int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
+        double val[], MM_typecode matcode)
+{
+    int i;
+    if (mm_is_complex(matcode))
+    {
+        for (i=0; i<nz; i++)
+            if (fscanf(f, "%d %d %lg %lg", &I[i], &J[i], &val[2*i], &val[2*i+1])
+                != 4) return MM_PREMATURE_EOF;
+    }
+    else if (mm_is_real(matcode))
+    {
+        for (i=0; i<nz; i++)
+        {
+            if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i])
+                != 3) return MM_PREMATURE_EOF;
+
+        }
+    }
+
+    else if (mm_is_pattern(matcode))
+    {
+        for (i=0; i<nz; i++)
+            if (fscanf(f, "%d %d", &I[i], &J[i])
+                != 2) return MM_PREMATURE_EOF;
+    }
+    else
+        return MM_UNSUPPORTED_TYPE;
+
+    return 0;
+        
+}
+
+int mm_read_mtx_crd_entry(FILE *f, int *I, int *J,
+        double *real, double *imag, MM_typecode matcode)
+{
+    if (mm_is_complex(matcode))
+    {
+            if (fscanf(f, "%d %d %lg %lg", I, J, real, imag)
+                != 4) return MM_PREMATURE_EOF;
+    }
+    else if (mm_is_real(matcode))
+    {
+            if (fscanf(f, "%d %d %lg\n", I, J, real)
+                != 3) return MM_PREMATURE_EOF;
+
+    }
+
+    else if (mm_is_pattern(matcode))
+    {
+            if (fscanf(f, "%d %d", I, J) != 2) return MM_PREMATURE_EOF;
+    }
+    else
+        return MM_UNSUPPORTED_TYPE;
+
+    return 0;
+        
+}
+
+
+/************************************************************************
+    mm_read_mtx_crd()  fills M, N, nz, array of values, and return
+                        type code, e.g. 'MCRS'
+
+                        if matrix is complex, values[] is of size 2*nz,
+                            (nz pairs of real/imaginary values)
+************************************************************************/
+
+int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J, 
+        double **val, MM_typecode *matcode)
+{
+    int ret_code;
+    FILE *f;
+
+    if (strcmp(fname, "stdin") == 0) f=stdin;
+    else
+    if ((f = fopen(fname, "r")) == NULL)
+        return MM_COULD_NOT_READ_FILE;
+
+
+    if ((ret_code = mm_read_banner(f, matcode)) != 0)
+        return ret_code;
+
+    if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) && 
+            mm_is_matrix(*matcode)))
+        return MM_UNSUPPORTED_TYPE;
+
+    if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
+        return ret_code;
+
+
+    *I = (int *)  malloc(*nz * sizeof(int));
+    *J = (int *)  malloc(*nz * sizeof(int));
+    *val = NULL;
+
+    if (mm_is_complex(*matcode))
+    {
+        *val = (double *) malloc(*nz * 2 * sizeof(double));
+        ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
+                *matcode);
+        if (ret_code != 0) return ret_code;
+    }
+    else if (mm_is_real(*matcode))
+    {
+        *val = (double *) malloc(*nz * sizeof(double));
+        ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
+                *matcode);
+        if (ret_code != 0) return ret_code;
+    }
+
+    else if (mm_is_pattern(*matcode))
+    {
+        ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val, 
+                *matcode);
+        if (ret_code != 0) return ret_code;
+    }
+
+    if (f != stdin) fclose(f);
+    return 0;
+}
+
+int mm_write_banner(FILE *f, MM_typecode matcode)
+{
+    char *str = mm_typecode_to_str(matcode);
+    int ret_code;
+
+    ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
+    free(str);
+    if (ret_code !=2 )
+        return MM_COULD_NOT_WRITE_FILE;
+    else
+        return 0;
+}
+
+int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
+        double val[], MM_typecode matcode)
+{
+    FILE *f;
+    int i;
+
+    if (strcmp(fname, "stdout") == 0) 
+        f = stdout;
+    else
+    if ((f = fopen(fname, "w")) == NULL)
+        return MM_COULD_NOT_WRITE_FILE;
+    
+    /* print banner followed by typecode */
+    fprintf(f, "%s ", MatrixMarketBanner);
+    fprintf(f, "%s\n", mm_typecode_to_str(matcode));
+
+    /* print matrix sizes and nonzeros */
+    fprintf(f, "%d %d %d\n", M, N, nz);
+
+    /* print values */
+    if (mm_is_pattern(matcode))
+        for (i=0; i<nz; i++)
+            fprintf(f, "%d %d\n", I[i], J[i]);
+    else
+    if (mm_is_real(matcode))
+        for (i=0; i<nz; i++)
+            fprintf(f, "%d %d %20.16g\n", I[i], J[i], val[i]);
+    else
+    if (mm_is_complex(matcode))
+        for (i=0; i<nz; i++)
+            fprintf(f, "%d %d %20.16g %20.16g\n", I[i], J[i], val[2*i], 
+                        val[2*i+1]);
+    else
+    {
+        if (f != stdout) fclose(f);
+        return MM_UNSUPPORTED_TYPE;
+    }
+
+    if (f !=stdout) fclose(f);
+
+    return 0;
+}
+  
+
+/**
+*  Create a new copy of a string s.  mm_strdup() is a common routine, but
+*  not part of ANSI C, so it is included here.  Used by mm_typecode_to_str().
+*
+*/
+char *mm_strdup(const char *s)
+{
+	int len = strlen(s);
+	char *s2 = (char *) malloc((len+1)*sizeof(char));
+	return strcpy(s2, s);
+}
+
+char  *mm_typecode_to_str(MM_typecode matcode)
+{
+    char buffer[MM_MAX_LINE_LENGTH];
+    char *types[4];
+	char *mm_strdup(const char *);
+    int error =0;
+
+    /* check for MTX type */
+    if (mm_is_matrix(matcode)) 
+        types[0] = MM_MTX_STR;
+    else
+        error=1;
+
+    /* check for CRD or ARR matrix */
+    if (mm_is_sparse(matcode))
+        types[1] = MM_SPARSE_STR;
+    else
+    if (mm_is_dense(matcode))
+        types[1] = MM_DENSE_STR;
+    else
+        return NULL;
+
+    /* check for element data type */
+    if (mm_is_real(matcode))
+        types[2] = MM_REAL_STR;
+    else
+    if (mm_is_complex(matcode))
+        types[2] = MM_COMPLEX_STR;
+    else
+    if (mm_is_pattern(matcode))
+        types[2] = MM_PATTERN_STR;
+    else
+    if (mm_is_integer(matcode))
+        types[2] = MM_INT_STR;
+    else
+        return NULL;
+
+
+    /* check for symmetry type */
+    if (mm_is_general(matcode))
+        types[3] = MM_GENERAL_STR;
+    else
+    if (mm_is_symmetric(matcode))
+        types[3] = MM_SYMM_STR;
+    else 
+    if (mm_is_hermitian(matcode))
+        types[3] = MM_HERM_STR;
+    else 
+    if (mm_is_skew(matcode))
+        types[3] = MM_SKEW_STR;
+    else
+        return NULL;
+
+    sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
+    return mm_strdup(buffer);
+
+}
diff --git a/example/cpu/src/mmio.h b/example/cpu/src/mmio.h
new file mode 100644
index 0000000..7cfd0a1
--- /dev/null
+++ b/example/cpu/src/mmio.h
@@ -0,0 +1,133 @@
+/* 
+*   Matrix Market I/O library for ANSI C
+*
+*   See http://math.nist.gov/MatrixMarket for details.
+*
+*
+*/
+
+#ifndef MM_IO_H
+#define MM_IO_H
+
+#define MM_MAX_LINE_LENGTH 1025
+#define MatrixMarketBanner "%%MatrixMarket"
+#define MM_MAX_TOKEN_LENGTH 64
+
+typedef char MM_typecode[4];
+
+char *mm_typecode_to_str(MM_typecode matcode);
+
+int mm_read_banner(FILE *f, MM_typecode *matcode);
+int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz);
+int mm_read_mtx_array_size(FILE *f, int *M, int *N);
+
+int mm_write_banner(FILE *f, MM_typecode matcode);
+int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz);
+int mm_write_mtx_array_size(FILE *f, int M, int N);
+
+
+/********************* MM_typecode query fucntions ***************************/
+
+#define mm_is_matrix(typecode)	((typecode)[0]=='M')
+
+#define mm_is_sparse(typecode)	((typecode)[1]=='C')
+#define mm_is_coordinate(typecode)((typecode)[1]=='C')
+#define mm_is_dense(typecode)	((typecode)[1]=='A')
+#define mm_is_array(typecode)	((typecode)[1]=='A')
+
+#define mm_is_complex(typecode)	((typecode)[2]=='C')
+#define mm_is_real(typecode)		((typecode)[2]=='R')
+#define mm_is_pattern(typecode)	((typecode)[2]=='P')
+#define mm_is_integer(typecode) ((typecode)[2]=='I')
+
+#define mm_is_symmetric(typecode)((typecode)[3]=='S')
+#define mm_is_general(typecode)	((typecode)[3]=='G')
+#define mm_is_skew(typecode)	((typecode)[3]=='K')
+#define mm_is_hermitian(typecode)((typecode)[3]=='H')
+
+int mm_is_valid(MM_typecode matcode);		/* too complex for a macro */
+
+
+/********************* MM_typecode modify fucntions ***************************/
+
+#define mm_set_matrix(typecode)	((*typecode)[0]='M')
+#define mm_set_coordinate(typecode)	((*typecode)[1]='C')
+#define mm_set_array(typecode)	((*typecode)[1]='A')
+#define mm_set_dense(typecode)	mm_set_array(typecode)
+#define mm_set_sparse(typecode)	mm_set_coordinate(typecode)
+
+#define mm_set_complex(typecode)((*typecode)[2]='C')
+#define mm_set_real(typecode)	((*typecode)[2]='R')
+#define mm_set_pattern(typecode)((*typecode)[2]='P')
+#define mm_set_integer(typecode)((*typecode)[2]='I')
+
+
+#define mm_set_symmetric(typecode)((*typecode)[3]='S')
+#define mm_set_general(typecode)((*typecode)[3]='G')
+#define mm_set_skew(typecode)	((*typecode)[3]='K')
+#define mm_set_hermitian(typecode)((*typecode)[3]='H')
+
+#define mm_clear_typecode(typecode) ((*typecode)[0]=(*typecode)[1]= \
+									(*typecode)[2]=' ',(*typecode)[3]='G')
+
+#define mm_initialize_typecode(typecode) mm_clear_typecode(typecode)
+
+
+/********************* Matrix Market error codes ***************************/
+
+
+#define MM_COULD_NOT_READ_FILE	11
+#define MM_PREMATURE_EOF		12
+#define MM_NOT_MTX				13
+#define MM_NO_HEADER			14
+#define MM_UNSUPPORTED_TYPE		15
+#define MM_LINE_TOO_LONG		16
+#define MM_COULD_NOT_WRITE_FILE	17
+
+
+/******************** Matrix Market internal definitions ********************
+
+   MM_matrix_typecode: 4-character sequence
+
+				    ojbect 		sparse/   	data        storage 
+						  		dense     	type        scheme
+
+   string position:	 [0]        [1]			[2]         [3]
+
+   Matrix typecode:  M(atrix)  C(oord)		R(eal)   	G(eneral)
+						        A(array)	C(omplex)   H(ermitian)
+											P(attern)   S(ymmetric)
+								    		I(nteger)	K(kew)
+
+ ***********************************************************************/
+
+#define MM_MTX_STR		"matrix"
+#define MM_ARRAY_STR	"array"
+#define MM_DENSE_STR	"array"
+#define MM_COORDINATE_STR "coordinate" 
+#define MM_SPARSE_STR	"coordinate"
+#define MM_COMPLEX_STR	"complex"
+#define MM_REAL_STR		"real"
+#define MM_INT_STR		"integer"
+#define MM_GENERAL_STR  "general"
+#define MM_SYMM_STR		"symmetric"
+#define MM_HERM_STR		"hermitian"
+#define MM_SKEW_STR		"skew-symmetric"
+#define MM_PATTERN_STR  "pattern"
+
+
+/*  high level routines */
+
+int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
+		 double val[], MM_typecode matcode);
+int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
+		double val[], MM_typecode matcode);
+int mm_read_mtx_crd_entry(FILE *f, int *I, int *J, double *real, double *img,
+			MM_typecode matcode);
+
+int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_,
+                double **val_, int **I_, int **J_);
+
+
+
+#endif