feat: add alvaro code

Makefile

@@ -21,6 +21,12 @@ CCFLAGSKRUSKAL= ${CCFLAGSBASE} \
 	-s EXPORTED_FUNCTIONS='["_init", "_insertadjver", "_kruskal", "_printResults"]' \
 	-s EXTRA_EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
 	-s SAFE_HEAP=1
+CCFLAGSSTRASSENS= ${CCFLAGSBASE} \
+	-s ALLOW_MEMORY_GROWTH=1 \
+	-s ASSERTIONS=1  \
+	-s EXPORTED_FUNCTIONS='["_matrixMultiplication"]' \
+	-s EXTRA_EXPORTED_RUNTIME_METHODS='["ccall", "cwrap"]' \
+	-s SAFE_HEAP=1
 CCFLAGSPTHREADS= ${CCFLAGSBASE} \
 	-s USE_PTHREADS=1 \
 	-s PTHREAD_POOL_SIZE=4 
@@ -68,11 +74,11 @@ make-alvaro:
 	mkdir -p ./dist/alvaro/js
 
 build-alvaro: build-deps clean-alvaro make-alvaro
-	$(CC) ./src/alvaro/wasm/main.c -o ./dist/alvaro/wasm/main.wasm $(CCFLAGS)
-	$(CC) ./src/alvaro/wasm-pthread/main.c -o ./dist/alvaro/wasm-pthread/main.js $(CCFLAGSPTHREADS)
-	cp ./src/alvaro/js/main.js ./dist/alvaro/js/main.js
+	$(CC) ./src/alvaro/wasm/main.c -o ./dist/alvaro/wasm/emscripten.js $(CCFLAGSSTRASSENS)
+	# $(CC) ./src/alvaro/wasm-pthread/main.c -o ./dist/alvaro/wasm-pthread/main.js $(CCFLAGSPTHREADS)
+	cp -r ./src/alvaro/js ./dist/alvaro
 	cp ./src/alvaro/wasm/main.js ./dist/alvaro/wasm/main.js
-	cp ./src/htmlTemplates/indexChild.html ./dist/alvaro/wasm/index.html
+	cp ./src/htmlTemplates/indexGlueCode.html ./dist/alvaro/wasm/index.html
 	cp ./src/htmlTemplates/indexPthreads.html ./dist/alvaro/wasm-pthread/index.html
 	cp ./src/htmlTemplates/indexChild.html ./dist/alvaro/js/index.html
 	cp -r ./src/alvaro/common ./dist/alvaro/

src/alvaro/common/tests.js

@@ -1,7 +1,3 @@
-export function runTests(fibonacci) {
-    [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30].forEach(desiredSolution => {
-        console.time(`fibonacci(${desiredSolution})`);
-        console.log(fibonacci(desiredSolution))
-        console.timeEnd(`fibonacci(${desiredSolution})`);
-    })
+export function runTests(matrixMultiplication) {
+    matrixMultiplication(2048);
 }

src/alvaro/js/main.js

@@ -1,23 +1,122 @@
 import { runTests } from "../common/tests.js"
 
-function fibonacci(iterations) {
-    let val = 1;
-    let last = 0;
+// Constructor Function
+class Matrix {
+    constructor(width, height, value = 0) {
+        this.W = width;
+        this.H = height;
+        this.element = [];
 
-    if (iterations == 0) {
-        return 0;
+        for (let y = 0; y < height; y++) {
+            this.element[y] = []
+            for (let x = 0; x < width; x++) {
+                this.element[y][x] = value;
+            }
+        }
     }
-    for (let i = 1; i < iterations; i++) {
-        let seq;
 
-        seq = val + last;
-        last = val;
-        val = seq;
+    print = function (string = "") {
+        if (!string == "") console.log(string);
+        console.log(this.element.join('\n'));
     }
-    return val;
+
+    static add(m1, m2) {
+        let m3 = new Matrix(m1.W, m1.H);
+        for (let y = 0; y < m1.H; y++) {
+            for (let x = 0; x < m2.W; x++) {
+                m3.element[y][x] = m1.element[y][x] + m2.element[y][x];
+            }
+        }
+        return m3;
+    }
+
+    static multiply(m1, m2) {
+        let m3 = new Matrix(m1.W, m1.H);
+
+        for (let y = 0; y < m1.H; y++) {
+            for (let x = 0; x < m1.W; x++) {
+                let sum = 0;
+                for (let z = 0; z < m1.W; z++) {
+                    sum += m1.element[x][z] * m2.element[z][y];
+                }
+                m3.element[x][y] = sum;
+            }
+        }
+        return m3;
+    }
+
+
+    getSubMatrix(xSection, ySection) {
+        let fromX, fromY;
+        if (xSection == 1) fromX = 0;
+        else fromX = this.W / 2;
+
+        if (ySection == 1) fromY = 0;
+        else fromY = this.W / 2;
+
+        let m = new Matrix(this.W / 2, this.H / 2);
+
+        for (var y = 0; y < m.H; y++) {
+            for (var x = 0; x < m.W; x++) {
+                m.element[y][x] = this.element[y + fromY][x + fromX];
+            }
+        }
+        return m;
+    }
+
+    static getSuperMatrix(C11, C12, C21, C22) {
+        let C = new Matrix(C11.W * 2, C11.H * 2);
+        let size = C11.W;
+        for (var y = 0; y < size; y++) {
+            for (var x = 0; x < size; x++) {
+                C.element[x][y] = C11.element[x][y];
+                C.element[x][y + size] = C12.element[x][y];
+                C.element[x + size][y] = C21.element[x][y];
+                C.element[x + size][y + size] = C22.element[x][y];
+            }
+        }
+
+        return C;
+    }
+
+    static multipyStrassens(m1, m2) {
+
+        if (m1.H < 256) return Matrix.multiply(m1, m2);
+
+        let A11 = m1.getSubMatrix(1, 1);
+        let A12 = m1.getSubMatrix(1, 2);
+        let A21 = m1.getSubMatrix(2, 1);
+        let A22 = m1.getSubMatrix(2, 2);
+
+        let B11 = m2.getSubMatrix(1, 1);
+        let B12 = m2.getSubMatrix(1, 2);
+        let B21 = m2.getSubMatrix(2, 1);
+        let B22 = m2.getSubMatrix(2, 2);
+
+        let C11 = Matrix.add(Matrix.multipyStrassens(A11, B11), Matrix.multipyStrassens(A12, B21));
+        let C12 = Matrix.add(Matrix.multipyStrassens(A11, B12), Matrix.multipyStrassens(A12, B22));
+        let C21 = Matrix.add(Matrix.multipyStrassens(A21, B11), Matrix.multipyStrassens(A22, B21));
+        let C22 = Matrix.add(Matrix.multipyStrassens(A21, B12), Matrix.multipyStrassens(A22, B22));
+
+        let C = Matrix.getSuperMatrix(C11, C12, C21, C22);
+        return C;
+    }
+
+}
+
+function matrixMultiplication(matrixSize) {
+    let m1 = new Matrix(matrixSize, matrixSize, 2);
+    let m2 = new Matrix(matrixSize, matrixSize, 3);
+
+    console.log("Multiplication started")
+    let start = new Date().getTime();
+    let m6 = Matrix.multipyStrassens(m1, m2);
+    let end = new Date().getTime();
+    console.log("Strassens process time for " + matrixSize + "x" + matrixSize + " matrix multiplication: " + (end - start) + " ms");
 }
 
+
 async function main() {
-    runTests(fibonacci);
+    runTests(matrixMultiplication);
 }
 main()