scatter.cpp

Simulator/config/config_simple_multilevel

@@ -20,6 +20,11 @@ cache_3:
   associativity: 8
   hit_time: 100
 
+#cache_4:
+#  blocks: 512
+#  associativity: 16
+#  hit_time: 150
+
 mem: #required
   hit_time: 1000 #cycles
 

Simulator/src/cache_simulator.py

@@ -188,6 +188,10 @@ def build_hierarchy(configs, logger):
     main_memory = build_cache(configs, 'mem', None, logger)
     prev_level = main_memory
     hierarchy['mem'] = main_memory
+    if 'cache_4' in list(configs.keys()):
+        cache_4 = build_cache(configs, 'cache_4', prev_level, logger)
+        prev_level = cache_4
+        hierarchy['cache_4'] = cache_4
     if 'cache_3' in list(configs.keys()):
         cache_3 = build_cache(configs, 'cache_3', prev_level, logger)
         prev_level = cache_3

src/convolve.cpp

@@ -0,0 +1,103 @@
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <ctime>
+
+using namespace std;
+
+void parsec_roi_begin() 
+{
+
+}
+
+void parsec_roi_end() 
+{
+
+}
+
+struct Result {
+	vector< vector<int> > A;
+};
+
+Result read(string filename) {
+	vector< vector<int> > A;
+	Result ab;
+	string line;
+	ifstream infile;
+	infile.open (filename.c_str());
+
+	int i = 0;
+	while (getline(infile, line) && !line.empty()) {
+		istringstream iss(line);
+		A.resize(A.size() + 1);
+		int a, j = 0;
+		while (iss >> a) {
+			A[i].push_back(a);
+			j++;
+		}
+		i++;
+	}
+	infile.close();
+	ab.A = A;
+	return ab;
+}
+
+// Define the 3x3 Gaussian kernel with integer values
+vector<vector<int>> gaussianKernel() {
+    return {
+        {1, 2, 1},
+        {2, 4, 2},
+        {1, 2, 1}
+    };
+}
+
+vector<vector<int>> padMatrix(const vector<vector<int>>& matrix) {
+    int rows = matrix.size();
+    int cols = matrix[0].size();
+    vector<vector<int>> padded(rows + 2, vector<int>(cols + 2, 0));
+
+    for (int i = 0; i < rows; ++i) {
+        for (int j = 0; j < cols; ++j) {
+            padded[i + 1][j + 1] = matrix[i][j];
+        }
+    }
+    return padded;
+}
+
+vector<vector<int>> convolve(const vector<vector<int>>& matrix) {
+    vector<vector<int>> kernel = gaussianKernel();
+    vector<vector<int>> padded = padMatrix(matrix);
+    int rows = padded.size();
+    int cols = padded[0].size();
+    vector<vector<int>> result(matrix.size(), vector<int>(matrix[0].size(), 0));
+
+    for (int i = 1; i < rows - 1; ++i) {
+        for (int j = 1; j < cols - 1; ++j) {
+            int sum = 0;
+            for (int ki = -1; ki <= 1; ++ki) {
+                for (int kj = -1; kj <= 1; ++kj) {
+                    sum += padded[i + ki][j + kj] * kernel[ki + 1][kj + 1];
+                }
+            }
+            result[i - 1][j - 1] = sum;
+        }
+    }
+    return result;
+}
+
+int main (int argc, char* argv[]) {
+    srand(time(0));
+    string filename;
+    if (argc < 3) {
+        filename = "2000.in";
+    } else {
+        filename = argv[2];
+    }
+    Result result = read(filename);
+    parsec_roi_begin();
+    vector< vector<int> > C = convolve(result.A);
+    parsec_roi_end();
+    return 0;
+}

src/gather.cpp

@@ -0,0 +1,93 @@
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <ctime>
+
+using namespace std;
+
+void parsec_roi_begin() 
+{
+}
+
+void parsec_roi_end() 
+{
+}
+
+struct Result {
+    vector< vector<int> > A;
+};
+
+Result read(string filename) {
+    vector< vector<int> > A;
+    Result ab;
+    string line;
+    ifstream infile;
+    infile.open (filename.c_str());
+
+    int i = 0;
+    while (getline(infile, line) && !line.empty()) {
+        istringstream iss(line);
+        A.resize(A.size() + 1);
+        int a, j = 0;
+        while (iss >> a) {
+            A[i].push_back(a);
+            j++;
+        }
+        i++;
+    }
+    infile.close();
+    ab.A = A;
+    return ab;
+}
+
+vector<int> gather(const vector<vector<int>>& A) {
+    int n = A.size();
+    int number_of_indices = 1000;
+    vector<int> indices(number_of_indices), gathered_data(number_of_indices);
+
+    // Generate 1,000 random indices
+    for(int i = 0; i < number_of_indices; i++) {
+        indices[i] = rand() % (n * n);  // Random index within the flattened matrix
+    }
+
+    // Gather elements at the random indices
+    for(int i = 0; i < number_of_indices; i++) {
+        int row = indices[i] / n;  // Compute row
+        int col = indices[i] % n;  // Compute column
+        gathered_data[i] = A[row][col];  // Gather the element
+    }
+
+    return gathered_data;  // Return the gathered data
+}
+
+// Updated to print a 1D vector
+void printVector(const vector<int>& vec) {
+    for (size_t i = 0; i < vec.size(); i++) {
+        cout << vec[i];
+        if (i + 1 != vec.size()) {
+            cout << "\t";
+        }
+    }
+    cout << endl;
+}
+
+int main (int argc, char* argv[]) {
+    srand(time(0));
+    string filename;
+    if (argc < 3) {
+        filename = "2000.in";
+    } else {
+        filename = argv[2];
+    }
+    Result result = read (filename);
+    parsec_roi_begin();
+    vector<int> C = gather(result.A);  // Corrected to vector<int>
+    parsec_roi_end();
+
+    // Optionally print the gathered data as a 1D vector
+    //printVector(C);
+
+    return 0;
+}

src/scatter.cpp

@@ -0,0 +1,91 @@
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <ctime>
+
+using namespace std;
+
+void parsec_roi_begin() 
+{
+
+}
+
+void parsec_roi_end() 
+{
+
+}
+
+struct Result {
+	vector< vector<int> > A;
+};
+
+Result read(string filename) {
+	vector< vector<int> > A;
+	Result ab;
+	string line;
+	ifstream infile;
+	infile.open (filename.c_str());
+
+	int i = 0;
+	while (getline(infile, line) && !line.empty()) {
+		istringstream iss(line);
+		A.resize(A.size() + 1);
+		int a, j = 0;
+		while (iss >> a) {
+			A[i].push_back(a);
+			j++;
+		}
+		i++;
+	}
+	infile.close();
+	ab.A = A;
+	return ab;
+}
+
+vector< vector<int> > scatter(vector< vector<int> > A) {
+	int n = A.size();
+	int number_of_indices = 1000;
+	vector<int> indices(number_of_indices), data(number_of_indices);
+	for(int i = 0; i < number_of_indices ; i++){
+		indices[i] = rand() % (n*n);
+		data[i] = rand();
+	}
+	for(int i = 0 ; i < number_of_indices ; i++){
+		int row = indices[i]/n;
+		int col = indices[i]%n;
+		A[row][col] = data[i];
+	}
+	return A;
+}
+
+void printMatrix(vector< vector<int> > matrix) {
+	vector< vector<int> >::iterator it;
+	vector<int>::iterator inner;
+	for (it=matrix.begin(); it != matrix.end(); it++) {
+		for (inner = it->begin(); inner != it->end(); inner++) {
+			cout << *inner;
+			if(inner+1 != it->end()) {
+				cout << "\t";
+			}
+		}
+		cout << endl;
+	}
+}
+
+int main (int argc, char* argv[]) {
+	srand(time(0));
+	string filename;
+	if (argc < 3) {
+		filename = "2000.in";
+	} else {
+		filename = argv[2];
+	}
+	Result result = read (filename);
+    parsec_roi_begin();
+	vector< vector<int> > C = scatter(result.A);
+    parsec_roi_end();
+	//printMatrix(C);
+	return 0;
+}

utils/random_matrix_generator.py

@@ -21,13 +21,13 @@ def createRandomMatrix(n):
     return matrix
 
 
-def saveMatrix(matrixA, matrixB, filename):
+def saveMatrix(matrixA, filename):
     if os.path.exists(filename): 
         os.remove(filename)
     else:   
         print("New file created: ",filename)
     f = open(filename, "w")
-    for i, matrix in enumerate([matrixA, matrixB]):
+    for i, matrix in enumerate([matrixA]):
         if i != 0:
             f.write("\n")
         for line in matrix:
@@ -61,7 +61,7 @@ def main():
     outpath = args.dump
     #Create dense matrix
     matrixA = createRandomMatrix(n)
-    matrixB = createRandomMatrix(n)
+    #matrixB = createRandomMatrix(n)
     #print(matrixA)
     #Convert to sparse matrix by replacing value below threshold to 0
     if (args.sparsity):
@@ -72,26 +72,26 @@ def main():
         flatA  = matrixA.flatten()
         flatA[indicesA] = 0
         #Replace random x %element to 0 in matrixB
-        matrixB = np.asarray(matrixB)
-        indicesB = np.random.choice(np.arange(matrixB.size), replace=False,
-                           size=int(matrixB.size * (args.sparsity/100)))
-        flatB  = matrixB.flatten()
-        flatB[indicesB] = 0
+        #matrixB = np.asarray(matrixB)
+        #indicesB = np.random.choice(np.arange(matrixB.size), replace=False,
+                           #size=int(matrixB.size * (args.sparsity/100)))
+        #flatB  = matrixB.flatten()
+        #flatB[indicesB] = 0
         #Reshape it back to square matrix    
         flatA = flatA.reshape(n,n)
-        flatB = flatB.reshape(n,n)
+        #flatB = flatB.reshape(n,n)
         #print(flatA)
         matrixA_csr = sparse.csr_matrix(flatA)
         #print(matrixA_csr)
-        matrixB_csr = sparse.csr_matrix(flatB)
+        #matrixB_csr = sparse.csr_matrix(flatB)
         matrixA = flatA.tolist()
-        matrixB = flatB.tolist()
+        #matrixB = flatB.tolist()
         csr_Amatrix = "csrA_"+args.dump
-        csr_Bmatrix = "csrB_"+args.dump
+        #csr_Bmatrix = "csrB_"+args.dump
         saveCSRMatrix(matrixA_csr, csr_Amatrix)
-        saveCSRMatrix(matrixB_csr, csr_Bmatrix)
+        #saveCSRMatrix(matrixB_csr, csr_Bmatrix)
         #print(matrixA)
-    saveMatrix(matrixA, matrixB, args.dump)
+    saveMatrix(matrixA, args.dump)
 
 if __name__ == '__main__':
     main()