Vortex 2.0 changes:

+ Microarchitecture optimizations + 64-bit support + Xilinx FPGA support + LLVM-16 support + Refactoring and quality control fixes minor update minor update minor update minor update minor update minor update cleanup cleanup cache bindings and memory perf refactory minor update minor update hw unit tests fixes minor update minor update minor update minor update minor update minor udpate minor update minor update minor update minor update minor update minor update minor update minor updates minor updates minor update minor update minor update minor update minor update minor update minor updates minor updates minor updates minor updates minor update minor update
2023-10-19 20:51:22 -07:00
parent d69a64c32c
commit c1e168fdbe
1309 changed files with 247412 additions and 311463 deletions
--- a/tests/regression/dogfood/testcases.h
+++ b/tests/regression/dogfood/testcases.h
@@ -3,6 +3,19 @@
 #include <iostream>
 #include <math.h>
 #include <limits>
+#include <assert.h>
+
+void cleanup();
+
+#define RT_CHECK(_expr)                                         \
+   do {                                                         \
+     int _ret = _expr;                                          \
+     if (0 == _ret)                                             \
+       break;                                                   \
+     printf("Error: '%s' returned %d!\n", #_expr, (int)_ret);   \
+	 cleanup();			                                              \
+     exit(-1);                                                  \
+   } while (false)

 union Float_t {    
    float f;
@@ -47,33 +60,72 @@ inline bool almost_equal(float a, float b) {
  return almost_equal_ulp(a, b);
 }

+class ITestCase;
+
+class TestSuite {
+public:
+  TestSuite(vx_device_h device);
+  ~TestSuite();
+
+  ITestCase* get_test(int testid) const;
+
+  void add_test(ITestCase* test);
+
+  size_t size() const;
+
+  vx_device_h device() const;
+
+private:
+  std::vector<ITestCase*> _tests;
+  vx_device_h device_;
+};
+
 class ITestCase {
 public:
-  ITestCase() {}
+  ITestCase(TestSuite* suite, const char* name) 
+    : suite_(suite) 
+    , name_(name)
+  {}
+
  virtual ~ITestCase() {}

-  virtual void setup(int n, void* src1, void* src2)  = 0;  
-  virtual int verify(int n, void* dst, const void* src1, const void* src2) = 0;
+  TestSuite* suite() const {
+    return suite_;
+  }
+
+  const char* name() const {
+    return name_;
+  }
+
+  virtual int setup(uint32_t n, void* src1, void* src2) = 0;
+
+  virtual int verify(uint32_t n, void* dst, const void* src1, const void* src2) = 0;
+
+protected:
+  TestSuite*  suite_;
+  const char* const name_;  
 };

 class Test_IADD : public ITestCase {
 public:
+  Test_IADD(TestSuite* suite) : ITestCase(suite, "iadd") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = n/2 - i;
      b[i] = n/2 + i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
    auto c = (int32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] + b[i]; 
      if (c[i] != ref) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -86,22 +138,24 @@ public:

 class Test_IMUL : public ITestCase {
 public:
+  Test_IMUL(TestSuite* suite) : ITestCase(suite, "imul") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = n/2 - i;
      b[i] = n/2 + i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
    auto c = (int32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] * b[i]; 
      if (c[i] != ref) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -114,22 +168,24 @@ public:

 class Test_IDIV : public ITestCase {
 public:
+  Test_IDIV(TestSuite* suite) : ITestCase(suite, "idiv") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = n/2 - i;
      b[i] = n/2 + i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
    auto c = (int32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] / b[i]; 
      if (c[i] != ref) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -142,22 +198,24 @@ public:

 class Test_IDIV_MUL : public ITestCase {
 public:
+  Test_IDIV_MUL(TestSuite* suite) : ITestCase(suite, "idiv-mul") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = n/2 - i;
      b[i] = n/2 + i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
    auto c = (int32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] / b[i]; 
      auto y = a[i] * b[i]; 
      auto ref = x + y; 
@@ -172,22 +230,24 @@ public:

 class Test_FADD : public ITestCase {
 public:
+  Test_FADD(TestSuite* suite) : ITestCase(suite, "fadd") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] + b[i]; 
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -200,22 +260,24 @@ public:

 class Test_FSUB : public ITestCase {
 public:
+  Test_FSUB(TestSuite* suite) : ITestCase(suite, "fsub") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] - b[i]; 
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -228,22 +290,24 @@ public:

 class Test_FMUL : public ITestCase {
 public:
+  Test_FMUL(TestSuite* suite) : ITestCase(suite, "fmul") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] * b[i]; 
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -256,22 +320,24 @@ public:

 class Test_FMADD : public ITestCase {
 public:
+  Test_FMADD(TestSuite* suite) : ITestCase(suite, "fmadd") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] * b[i] + b[i];
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -284,22 +350,24 @@ public:

 class Test_FMSUB : public ITestCase {
 public:
+  Test_FMSUB(TestSuite* suite) : ITestCase(suite, "fmsub") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] * b[i] - b[i];
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -312,22 +380,24 @@ public:

 class Test_FNMADD : public ITestCase {
 public:
+  Test_FNMADD(TestSuite* suite) : ITestCase(suite, "fnmadd") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = -a[i] * b[i] - b[i];
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -340,22 +410,24 @@ public:

 class Test_FNMSUB : public ITestCase {
 public:
+  Test_FNMSUB(TestSuite* suite) : ITestCase(suite, "fnmsub") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = -a[i] * b[i] + b[i];
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -368,22 +440,24 @@ public:

 class Test_FNMADD_MADD : public ITestCase {
 public:
+  Test_FNMADD_MADD(TestSuite* suite) : ITestCase(suite, "fnmadd-madd") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = -a[i] * b[i] - b[i];
      auto y =  a[i] * b[i] + b[i];
      auto ref = x + y;
@@ -398,22 +472,24 @@ public:

 class Test_FDIV : public ITestCase {
 public:
+  Test_FDIV(TestSuite* suite) : ITestCase(suite, "fdiv") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = a[i] / b[i];
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -426,22 +502,24 @@ public:

 class Test_FDIV2 : public ITestCase {
 public:
+  Test_FDIV2(TestSuite* suite) : ITestCase(suite, "fdiv2") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = fround((n - i) * (1.0f/n));
      b[i] = fround((n + i) * (1.0f/n));
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] / b[i];
      auto y = b[i] / a[i];
      auto ref = x + y;
@@ -456,23 +534,25 @@ public:

 class Test_FSQRT : public ITestCase {
 public:
+  Test_FSQRT(TestSuite* suite) : ITestCase(suite, "fsqrt") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      float q = 1.0f + (i % 64);
      a[i] = q;
      b[i] = q;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto ref = sqrt(a[i] * b[i]);
      if (!almost_equal(c[i], ref)) {
        std::cout << "error at result #" << i << ": expected=" << ref << ", actual=" << c[i] << ", a=" << a[i] << ", b=" << b[i] << std::endl;
@@ -485,22 +565,25 @@ public:

 class Test_FTOI : public ITestCase {
 public:
+  Test_FTOI(TestSuite* suite) : ITestCase(suite, "ftoi") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
-      a[i] = fround((n/2 - i) + (float(i)/n));
-      b[i] = fround((n/2 - i) + (float(i)/n));
+    for (uint32_t i = 0; i < n; ++i) {
+      float q = fround(float(n/2) - i + (float(i) / n));
+      a[i] = q;
+      b[i] = q;      
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (int32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] + b[i];
      auto ref = (int32_t)x;
      if (c[i] != ref) {
@@ -514,22 +597,25 @@ public:

 class Test_FTOU : public ITestCase {
 public:
+  Test_FTOU(TestSuite* suite) : ITestCase(suite, "ftou") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (float*)src1;
    auto b = (float*)src2;
-    for (int i = 0; i < n; ++i) {
-      a[i] = fround(i + (float(i)/n));
-      b[i] = fround(i + (float(i)/n));
+    for (uint32_t i = 0; i < n; ++i) {
+      float q = fround(i + (float(i) / n));
+      a[i] = q;
+      b[i] = q;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (float*)src1;
    auto b = (float*)src2;
    auto c = (uint32_t*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] + b[i];
      auto ref = (uint32_t)x;
      if (c[i] != ref) {
@@ -543,22 +629,24 @@ public:

 class Test_ITOF : public ITestCase {
 public:
+  Test_ITOF(TestSuite* suite) : ITestCase(suite, "itof") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = n/2 - i;
      b[i] = n/2 - i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (int32_t*)src1;
    auto b = (int32_t*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] + b[i];
      auto ref = (float)x;
      if (!almost_equal(c[i], ref)) {
@@ -572,22 +660,24 @@ public:

 class Test_UTOF : public ITestCase {
 public:
+  Test_UTOF(TestSuite* suite) : ITestCase(suite, "utof") {}

-  void setup(int n, void* src1, void* src2) override {
+  int setup(uint32_t n, void* src1, void* src2) override {
    auto a = (uint32_t*)src1;
    auto b = (uint32_t*)src2;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      a[i] = i;
      b[i] = i;
    }
+    return 0;
  }
  
-  int verify(int n, void* dst, const void* src1, const void* src2) override {
+  int verify(uint32_t n, void* dst, const void* src1, const void* src2) override {
    int errors = 0;
    auto a = (uint32_t*)src1;
    auto b = (uint32_t*)src2;
    auto c = (float*)dst;
-    for (int i = 0; i < n; ++i) {
+    for (uint32_t i = 0; i < n; ++i) {
      auto x = a[i] + b[i];
      auto ref = (float)x;
      if (!almost_equal(c[i], ref)) {
@@ -597,4 +687,135 @@ public:
    }
    return errors;
  }
-};
+};
+
+class Test_BAR : public ITestCase {
+public:
+  Test_BAR(TestSuite* suite) : ITestCase(suite, "bar") {}
+
+  int setup(uint32_t n, void* src1, void* /*src2*/) override {    
+    RT_CHECK(vx_dev_caps(suite_->device(), VX_CAPS_NUM_WARPS, &num_warps_));
+    if (num_warps_ == 1) {
+      std::cout << "Error: multiple warps configuration required!" << std::endl;
+      return -1;
+    }
+    RT_CHECK(vx_dev_caps(suite_->device(), VX_CAPS_NUM_THREADS, &num_threads_));
+    auto a = (uint32_t*)src1;  
+    for (uint32_t i = 0; i < n; ++i) {
+      a[i] = i;
+    }
+    return 0;
+  }
+  
+  int verify(uint32_t n, void* dst, const void* src1, const void* /*src2*/) override {
+    int errors = 0;
+    auto a = (uint32_t*)src1;
+    auto c = (uint32_t*)dst;
+    for (uint32_t i = 0; i < n; ++i) {
+      auto tid = i % num_threads_;
+      auto wid = (i / num_threads_) % num_warps_;
+      auto cid = i / (num_warps_ * num_threads_);
+      auto src_idx = (cid * num_warps_ + (num_warps_ - 1 - wid)) * num_threads_ + tid;
+      uint32_t ref = a[src_idx];
+      if (c[i] != ref) {
+        std::cout << "error at result #" << i << ": expected=" << std::hex << ref << ", actual=" << c[i] << std::endl;
+        ++errors;
+      }
+    }
+    return errors;
+  }
+
+  uint64_t num_warps_;
+  uint64_t num_threads_;
+};
+
+class Test_GBAR : public ITestCase {
+public:
+  Test_GBAR(TestSuite* suite) : ITestCase(suite, "gbar") {}
+
+  int setup(uint32_t n, void* src1, void* /*src2*/) override {
+    RT_CHECK(vx_dev_caps(suite_->device(), VX_CAPS_NUM_CORES, &num_cores_));
+    if (num_cores_ == 1) {
+      std::cout << "Error: multiple cores configuration required!" << std::endl;
+      return -1;
+    }
+    RT_CHECK(vx_dev_caps(suite_->device(), VX_CAPS_NUM_WARPS, &num_warps_));
+    RT_CHECK(vx_dev_caps(suite_->device(), VX_CAPS_NUM_THREADS, &num_threads_));
+    auto a = (uint32_t*)src1;
+    for (uint32_t i = 0; i < n; ++i) {
+      a[i] = i;
+    }
+    return 0;
+  }
+  
+  int verify(uint32_t n, void* dst, const void* src1, const void* /*src2*/) override {
+    int errors = 0;
+    auto a = (uint32_t*)src1;
+    auto c = (uint32_t*)dst;
+    for (uint32_t i = 0; i < n; ++i) {
+      auto tid = i % num_threads_;
+      auto wid = (i / num_threads_) % num_warps_;
+      auto cid = i / (num_warps_ * num_threads_);
+      auto src_idx = ((num_cores_ - 1 - cid) * num_warps_ + (num_warps_ - 1 - wid)) * num_threads_ + tid;
+      uint32_t ref = a[src_idx];
+      if (c[i] != ref) {
+        std::cout << "error at result #" << i << ": expected=" << std::hex << ref << ", actual=" << c[i] << std::endl;
+        ++errors;
+      }
+    }
+    return errors;
+  }
+
+  uint64_t num_cores_;
+  uint64_t num_warps_;  
+  uint64_t num_threads_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+TestSuite::TestSuite(vx_device_h device) 
+  : device_(device) {
+  this->add_test(new Test_IADD(this));
+  this->add_test(new Test_IMUL(this));
+  this->add_test(new Test_IDIV(this));
+  this->add_test(new Test_IDIV_MUL(this));
+  this->add_test(new Test_FADD(this));
+  this->add_test(new Test_FSUB(this));
+  this->add_test(new Test_FMUL(this));
+  this->add_test(new Test_FMADD(this));
+  this->add_test(new Test_FMSUB(this));
+  this->add_test(new Test_FNMADD(this));
+  this->add_test(new Test_FNMSUB(this));
+  this->add_test(new Test_FNMADD_MADD(this));
+  this->add_test(new Test_FDIV(this));
+  this->add_test(new Test_FDIV2(this));
+  this->add_test(new Test_FSQRT(this));
+  this->add_test(new Test_FTOI(this));
+  this->add_test(new Test_FTOU(this));
+  this->add_test(new Test_ITOF(this));
+  this->add_test(new Test_UTOF(this));
+  this->add_test(new Test_BAR(this));
+  this->add_test(new Test_GBAR(this));
+}
+
+TestSuite::~TestSuite() {
+  for (size_t i = 0; i < _tests.size(); ++i) {
+    delete _tests[i];
+  }
+}
+
+ITestCase* TestSuite::get_test(int testid) const {
+  return _tests.at(testid);
+}
+
+void TestSuite::add_test(ITestCase* test) {
+  _tests.push_back(test);
+}
+
+size_t TestSuite::size() const {
+  return _tests.size();
+}
+
+vx_device_h TestSuite::device() const {
+  return device_;
+}