Cleanup and AVX10 Support

.github/workflows/codegen.yml

@@ -64,17 +64,20 @@ jobs:
       - name: pspamm-tests-generate
         run: |
           cd tests/
-          python unit_tests_hsw.py
+          python unit_test.py hsw256
+          python unit_test.py hsw128
 
       - name: pspamm-tests-compile
         run: |
           cd tests/
-          g++ -static -mavx512f build/hsw_testsuite.cpp -o build/hsw-test
+          g++ -static -mavx2 build/hsw256_testsuite.cpp -o build/hsw256-test
+          g++ -static -mavx2 build/hsw128_testsuite.cpp -o build/hsw128-test
 
       - name: pspamm-tests-run
         run: |
           cd tests/
-          qemu-x86_64-static -cpu Haswell build/hsw-test
+          qemu-x86_64-static -cpu Haswell build/hsw256-test
+          qemu-x86_64-static -cpu Haswell build/hsw128-test
 
   pspamm-codegen-avx512-no-run:
     name: pspamm-codegen-avx512-no-run
@@ -102,18 +105,24 @@ jobs:
       - name: pspamm-tests-generate
         run: |
           cd tests/
-          python unit_tests_knl.py
+          python unit_test.py knl512
+          python unit_test.py knl256
+          python unit_test.py knl128
 
       - name: pspamm-tests-compile
         run: |
           cd tests/
-          g++ -static -mavx512f build/knl_testsuite.cpp -o build/knl-test
+          g++ -static -mavx512f build/knl512_testsuite.cpp -o build/knl512-test
+          g++ -static -mavx512f build/knl256_testsuite.cpp -o build/knl256-test
+          g++ -static -mavx512f build/knl128_testsuite.cpp -o build/knl128-test
 
       # disabled, since qemu doesn't support AVX512F (yet) with of Ubuntu 24.04
       # - name: pspamm-tests-run
       #   run: |
       #     cd tests/
-      #     qemu-x86_64-static -cpu Skylake-Server build/knl-test
+      #     qemu-x86_64-static -cpu Skylake-Server build/knl512-test
+      #     qemu-x86_64-static -cpu Skylake-Server build/knl256-test
+      #     qemu-x86_64-static -cpu Skylake-Server build/knl128-test
 
   pspamm-codegen-aarch64:
     name: pspamm-codegen-aarch64
@@ -141,24 +150,25 @@ jobs:
       - name: pspamm-tests-generate
         run: |
           cd tests/
-          python unit_tests_arm.py
+          python unit_test.py arm128
 
       - name: pspamm-tests-compile
         run: |
           cd tests/
-          aarch64-linux-gnu-g++ -static -march=armv8.2-a build/arm_testsuite.cpp -o build/arm-test
+          aarch64-linux-gnu-g++ -static -march=armv8.2-a build/arm128_testsuite.cpp -o build/arm128-test
 
       - name: pspamm-tests-run
         run: |
           cd tests/
-          qemu-aarch64-static -cpu max build/arm-test
+          qemu-aarch64-static -cpu max build/arm128-test
 
   pspamm-codegen-armsve:
     name: pspamm-codegen-armsve
     runs-on: ubuntu-24.04
     needs: install-pspamm
     # include vector lengths for SVE manually (for now)
     strategy:
+      fail-fast: false
       matrix:
         vectorlen:
           - 128
@@ -188,7 +198,7 @@ jobs:
       - name: pspamm-tests-generate
         run: |
           cd tests/
-          python unit_tests_arm_sve.py ${{matrix.vectorlen}}
+          python unit_test.py arm_sve${{matrix.vectorlen}}
 
       - name: pspamm-tests-compile
         run: |

README.md

@@ -1,7 +1,10 @@
-# Code Generator for Sparse Matrix Multiplication
-Generates inline-Assembly for sparse Matrix Multiplication.
+# PSpaMM
+A Code Generator For Small Sparse (and Dense) Matrix Multiplications.
 
-Currently Intel Xeon Phi 'Knights Landing' (AVX512), Haswell/Zen2 (AVX2), and ARM Cortex-A53 (ARMv8) are supported.
+Currently supported:
+
+* x86_64: AVX2, AVX512/AVX10.1
+* ARM/AARCH64: NEON, SVE (128,256,512,1024,2048 bit)
 
 ## Installation
 

pspamm/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

pspamm/architecture.py

@@ -8,17 +8,5 @@ def init():
     generator = None
     operands = None
 
-
-
-#https://stackoverflow.com/questions/452969/does-python-have-an-equivalent-to-java-class-forname
-
 def get_class( kls ):
     return import_module(kls)
-    parts = kls.split('.')
-    module = ".".join(parts[:-1])
-    m = __import__( module )
-    for comp in parts[1:]:
-        m = getattr(m, comp)
-    return m
-
-

pspamm/codegen/analysis.py

@@ -55,5 +55,3 @@ def visitBlock(self, block: Block):
             stmt.accept(self)
         self.stack.pop()
 
-
-

pspamm/codegen/architectures/arm/blocksize.py

@@ -0,0 +1,125 @@
+
+class Old:
+    @classmethod
+    def getBlocksize(cls, m , n, bk, v_size, prec):
+
+        bm = m
+        bn = n
+
+        if cls.ARM_condition(bm, bn, bk, v_size):
+            while cls.ARM_condition(bm, bn, bk+1, v_size):
+                bk += 1
+            return (bm, bn, bk)
+
+        while not cls.ARM_condition(bm, bn, bk, v_size):
+            bm, bn = cls.lowerToNextDiv(m, n, bm, bn, v_size)
+
+        while cls.ARM_condition(bm, bn, bk+1, v_size):
+            bk += 1
+
+        return (bm, bn, bk)
+
+    @classmethod
+    def lowerToNextDiv(cls, m, n, bm, bn, v_size):
+        if bm > bn and bm > v_size:
+            bm -= v_size
+            while m % bm != 0:
+                bm -= v_size
+        else:
+            bn -= 1
+            while n % bn != 0:
+                bn -= 1
+
+        return bm, bn
+
+    @classmethod
+    def ARM_condition(cls, bm, bn, bk, v_size):
+        # ceiling division
+        vm = -(bm // -v_size)
+        return (bn+bk) * vm + bn*bk <= 32
+
+class Max:
+    @classmethod
+    def getBlocksize(cls, m, n, bk, v_size, prec):
+        bm = 2
+        bn = 1
+        maxval = 0
+
+        for i in range(v_size, m+1, v_size):
+            for j in range(1, n+1):
+                if cls.ARM_condition(i, j, bk, v_size):
+                    if i*j > maxval:
+                        maxval = i*j
+                        bm = i
+                        bn = j
+
+        while cls.ARM_condition(bm, bn, bk+1, v_size):
+            bk += 1
+
+        return (bm, bn, bk)
+
+
+    @classmethod
+    def ARM_condition(cls, bm, bn, bk, v_size):
+        # ceiling division
+        vm = -(bm // -v_size)
+        return (bn+bk) * vm + bn*bk <= 32
+
+class MaxK:
+    @classmethod
+    def getBlocksize(cls, m, n, bk, v_size, prec):
+        bm = 2
+        bn = 1
+        maxval = 0
+
+        elem128 = 16 // prec.size()
+
+        for i in range(v_size, m+1, v_size):
+            for j in range(1, n+1):
+                if cls.ARM_condition(i, j, bk, v_size, elem128):
+                    if i*j > maxval:
+                        maxval = i*j
+                        bm = i
+                        bn = j
+
+        while cls.ARM_condition(bm, bn, bk+1, v_size, elem128):
+            bk += 1
+
+        return (bm, bn, bk)
+
+    @classmethod
+    def ARM_condition(cls, bm, bn, bk, v_size, elem128):
+        # ceiling division
+        vm = -(bm // -v_size)
+        vk = -(bk // -elem128)
+        return (bn+bk) * vm + bn*vk <= 32
+
+class Cube:
+    @classmethod
+    def getBlocksize(cls, m, n, bk, v_size, prec):
+        bm = 2
+        bn = 1
+        maxval = 0
+
+        elem128 = 16 // prec.size()
+
+        for i in range(v_size, m+1, v_size):
+            for j in range(1, n+1):
+                for k in range(1, 200):
+                    if cls.ARM_condition(i, j, k, v_size, elem128):
+                        if i*j*k > maxval:
+                            maxval = i*j*k
+                            bm = i
+                            bn = j
+                            bk = k
+
+        return (bm, bn, bk)
+
+    @classmethod
+    def ARM_condition(cls, bm, bn, bk, v_size, elem128):
+        # ceiling division
+        vm = -(bm // -v_size)
+        vk = -(bk // -elem128)
+        return (bn+bk) * vm + bn*vk <= 32
+
+Default = MaxK