gather.cpp

Simulator/src/cache_simulator.py

@@ -38,7 +38,7 @@ def main():
 
     logger.info('Loading config...')
     config_file = open(arguments['config_file'])
-    configs = yaml.load(config_file)
+    configs = yaml.load(config_file, Loader=yaml.FullLoader)
     hierarchy = build_hierarchy(configs, logger)
     logger.info('Memory hierarchy built.')
 

src/convolve.cpp

@@ -0,0 +1,101 @@
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+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>> initializeIdentityKernel(int size) {
+    vector<vector<int>> kernel(size, vector<int>(size, 0));
+    for (int i = 0; i < size; ++i) {
+        kernel[i][i] = 1; 
+    }
+    return kernel;
+}
+
+vector<vector<int>> convolve(const vector<vector<int>>& matrix, const vector<vector<int>>& kernel) {
+    int matrixSize = matrix.size();
+    int kernelSize = kernel.size();
+    int outputSize = matrixSize - kernelSize + 1;
+
+    vector<vector<int>> result(outputSize, vector<int>(outputSize, 0));
+
+    for (int row = 0; row <= matrixSize - kernelSize; ++row) {
+        for (int col = 0; col <= matrixSize - kernelSize; ++col) {
+            int convSum = 0;
+            for (int i = 0; i < kernelSize; ++i) {
+                for (int j = 0; j < kernelSize; ++j) {
+                    convSum += matrix[row + i][col + j] * kernel[i][j];
+                }
+            }
+            result[row][col] = convSum;
+        }
+    }
+
+    return result;
+}
+
+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[]) {
+	string filename;
+	if (argc < 3) {
+		filename = "2000.in";
+	} else {
+		filename = argv[2];
+	}
+	Result result = read(filename);
+    vector<vector<int>> kernel = initializeIdentityKernel(7); 
+    parsec_roi_begin();
+	vector< vector<int> > C = convolve(result.A, kernel);
+    parsec_roi_end();
+	return 0;
+}

src/gather.cpp

@@ -0,0 +1,95 @@
+#include <sstream>
+#include <string>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <ctime>
+#include <unordered_set>
+
+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 elements = 1000;
+    vector<int> indices(elements), result(elements);
+    unordered_set<int> unique_indices;
+
+    for(int i = 0; i < elements; ++i) {
+        int random_index;
+        do {
+            random_index = rand() % (n * n);
+        } while(unique_indices.find(random_index) != unique_indices.end());
+
+        indices[i] = random_index;
+        unique_indices.insert(random_index);
+    }
+
+    int offset = 5;
+    for(int idx = 0; idx < elements; ++idx) {
+        int rowIndex = indices[idx] / n;
+        int columnIndex = indices[idx] % n;
+        result[idx] = A[rowIndex][columnIndex] + offset;
+    }
+
+    return result;
+}
+
+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);
+    parsec_roi_end();
+    return 0;
+}

src/scatter.cpp

@@ -0,0 +1,95 @@
+#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 numElements = 1000;
+    vector<int> indices(numElements);
+    vector<int> values(numElements);
+
+    for(int i = 0; i < numElements; i++) {
+        int randomIndex = rand() % (n * n);
+        indices[i] = randomIndex;
+        values[i] = rand();
+    }
+
+    for(int i = 0; i < numElements; i++) {
+        int row = indices[i] / n;
+        int column = indices[i] % n;
+        A[row][column] = values[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();
+    return 0;
+}

utils/random_matrix_generator.py

@@ -27,7 +27,7 @@ def saveMatrix(matrixA, matrixB, 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,6 @@ def main():
     outpath = args.dump
     #Create dense matrix
     matrixA = createRandomMatrix(n)
-    matrixB = createRandomMatrix(n)
     #print(matrixA)
     #Convert to sparse matrix by replacing value below threshold to 0
     if (args.sparsity):
@@ -71,27 +70,13 @@ def main():
                            size=int(matrixA.size * (args.sparsity/100)))
         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
         #Reshape it back to square matrix    
         flatA = flatA.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)
         matrixA = flatA.tolist()
-        matrixB = flatB.tolist()
         csr_Amatrix = "csrA_"+args.dump
-        csr_Bmatrix = "csrB_"+args.dump
         saveCSRMatrix(matrixA_csr, csr_Amatrix)
-        saveCSRMatrix(matrixB_csr, csr_Bmatrix)
-        #print(matrixA)
-    saveMatrix(matrixA, matrixB, args.dump)
+    saveMatrix(matrixA, args.dump, "input_matrix.in")
 
 if __name__ == '__main__':
     main()