add different groups, timing logic, cmd line args

gpu-slo/Makefile

@@ -4,5 +4,3 @@ main : main.cu util.h
 clean :
 	rm main
 
-run : main
-	./main

gpu-slo/groups.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include "util.h"
+
+#include <iostream>
+
+/*
+ * Order 4*res*res
+ */
+Coxeter torus(int res) {
+    return make_coxeter(4, {
+        {0, 1, res},
+        {2, 3, res},
+    });
+}
+
+Coxeter hypercube(int dim) {
+    std::vector<Rel> rels;
+    rels.push_back({0, 1, 4});
+    for (int d = 2; d < dim; d++) {
+        rels.push_back({d-1, d, 3});
+    }
+    return make_coxeter(dim, rels);
+}
+
+/*
+ * Order 14,400
+ */
+Coxeter H4() {
+    return make_coxeter(4, {
+        {0, 1, 5},
+        {1, 2, 3},
+        {2, 3, 3},
+    });
+}
+
+/*
+ * Order 51,840
+ */
+Coxeter E6() {
+    return make_coxeter(6, {
+        {0, 1, 3},
+        {1, 2, 3},
+        {2, 3, 3},
+        {2, 4, 3},
+        {4, 5, 3},
+    });
+}
+
+/*
+ * Order 2,903,040
+ */
+Coxeter E7() {
+    return make_coxeter(7, {
+        {0, 1, 3},
+        {1, 2, 3},
+        {2, 3, 3},
+        {2, 4, 3},
+        {4, 5, 3},
+        {5, 6, 3},
+    });
+}
+
+/*
+ * Order 696,729,600
+ */
+Coxeter E8() {
+    return make_coxeter(8, {
+        {0, 1, 3},
+        {1, 2, 3},
+        {2, 3, 3},
+        {2, 4, 3},
+        {4, 5, 3},
+        {5, 6, 3},
+        {6, 7, 3},
+    });
+}
+
+/*
+ * returns coxeter group based on the arguments
+ * prints out type and arguments, without an endline
+ */
+Coxeter proc_args(int argc, const char* argv[]) {
+    if (argc < 2) {
+        std::cerr << "missing type argument." << std::endl;
+        exit(EXIT_FAILURE);
+    }
+
+    int type = std::strtol(argv[1], nullptr, 10);
+    std::cout << type << ',';
+
+    int arg;
+    switch (type) {
+    case 0:
+        if (argc < 3) {
+            std::cerr << "Must provide a size for torus!" << std::endl;
+            exit(EXIT_FAILURE);
+        }
+        arg = std::strtol(argv[2], nullptr, 10);
+        std::cout << arg << ',';
+        return torus(arg);
+    case 1:
+        std::cout << -1 << ',';
+        return H4();
+    case 2:
+        std::cout << -1 << ',';
+        return E6();
+    case 3:
+        std::cout << -1 << ',';
+        return E7();
+    case 4:
+        std::cout << -1 << ',';
+        return E8();
+    case 5:
+        if (argc < 3) {
+            std::cerr << "Must provide a dimension for hypercube!" << std::endl;
+            exit(EXIT_FAILURE);
+        }
+        arg = std::strtol(argv[2], nullptr, 10);
+        std::cout << arg << ',';
+        return hypercube(arg);
+    }
+
+    std::cerr << "Not a valid type!" << std::endl;
+    exit(EXIT_FAILURE);
+}
+

gpu-slo/main.cu

@@ -4,8 +4,10 @@
 
 #include <vector>
 #include <iostream>
+#include <chrono>
 
 #include "util.h"
+#include "groups.h"
 
 struct Row {
     int rel;
@@ -36,11 +38,6 @@ std::ostream &operator<<(std::ostream &o, const Row &r) {
     return o << "Row[" << r.rel << "]{" << r.l << ":" << r.from << "-" << r.to << ":" << r.r << "}(" << r.learning << ")";
 }
 
-struct Rel {
-    int gens[2];
-    int mul;
-};
-
 // this performs a pass on one relation table row, applying learned data to the coset table.
 struct Solver {
     int ngens;
@@ -264,42 +261,20 @@ thrust::device_vector<int> solve(
 }
 
 
-int main(int argc, char* argv[]) {
+int main(int argc, const char* argv[]) {
-    // int ngens = 4;
+    Coxeter cox;
-    // std::vector<Rel> rels = {
+    cox = proc_args(argc, argv);
-    //     {0, 1, 3},
-    //     {1, 2, 3},
-    //     {2, 3, 3},
-
-    //     {0, 2, 2},
-    //     {1, 2, 2},
-    //     {1, 3, 2},
-    // };
-    // std::vector<int> subs = {};
-
-    int ngens = 4;
-    std::vector<Rel> rels = {
-        {0, 1, 4},
-        {1, 2, 3},
-        {2, 3, 3},
-
-        {0, 2, 2},
-        {1, 3, 2},
-        {0, 3, 2},
-    };
     std::vector<int> subs = {};
 
-    thrust::host_vector<int> cosets = solve(ngens, subs, rels);
+    auto s = std::chrono::system_clock::now();
+    thrust::host_vector<int> cosets = solve(cox.ngens, subs, cox.rels);
+    auto e = std::chrono::system_clock::now();
 
-    std::cout << cosets.size() / ngens << " cosets" << std::endl;
+    std::chrono::duration<float> diff = e - s;
+    int order = cosets.size() / cox.ngens;
 
-    /*
+    // type, arg, ngens, time, order
-    for (int c = 0; c < cosets.size(); c += ngens) {
+    std::cout << cox.ngens << ',' << diff.count() << ',' << order << std::endl;
-        for (int g = c; g < c + ngens; g++ ) {
-            std::cout << cosets[g] << " ";
-        } std::cout << std::endl;
-    }
-    */
 
     return 0;
 }

gpu-slo/util.h

@@ -2,7 +2,7 @@
 
 #include <thrust/device_vector.h>
 #include <thrust/host_vector.h>
-
+#include <vector>
 #include <iostream>
 
 template<class T>
@@ -26,3 +26,38 @@ std::ostream &operator<<(std::ostream &o, const thrust::device_vector<T> &vec) {
     return o << "device_vector{size=" << vec.size() << "}";
 }
 
+struct Rel {
+    int gens[2];
+    int mul;
+};
+
+struct Coxeter {
+    int ngens;
+    std::vector<Rel> rels;
+};
+
+Coxeter make_coxeter(int ngens, const std::vector<Rel> &rels) {
+    int mults[ngens][ngens];
+
+    for (int i = 0; i < ngens; i++) {
+        for (int j = 0; j < ngens; j++) {
+            mults[i][j] = 2;
+            mults[j][i] = 2;
+        }
+    }
+
+    for (const auto &r : rels) {
+        mults[r.gens[0]][r.gens[1]] = r.mul;
+        mults[r.gens[1]][r.gens[0]] = r.mul;
+    }
+
+    std::vector<Rel> res;
+    
+    for (int i = 0; i < ngens; i++) {
+        for (int j = i + 1; j < ngens; j++) {
+            res.push_back({i, j, mults[i][j]});
+        }
+    }
+
+    return {ngens, res};
+}