[CC] [test] The C backend is now passing all the tests

taichi/backends/cc/cc_program.h

@@ -46,7 +46,7 @@ class CCProgram {
   }
 
   void *get_gtmp_buffer() {
-    return root_buf.data();
+    return gtmp_buf.data();
   }
 
  private:

taichi/backends/cc/codegen_cc.cpp

@@ -140,30 +140,29 @@ class CCTransformer : public IRVisitor {
     emit("{} = ({}) (ti_ctx->gtmp + {});", var, ptr_type, stmt->offset);
   }
 
+  void visit(LinearizeStmt *stmt) override {
+    std::string val = "0";
+    for (int i = 0; i < stmt->inputs.size(); i++) {
+      val = fmt::format("({} * {} + {})", val, stmt->strides[i],
+                        stmt->inputs[i]->raw_name());
+    }
+    emit("{} = {};", define_var("Ti_i32", stmt->raw_name()), val);
+  }
+
   void visit(ExternalPtrStmt *stmt) override {
     TI_ASSERT(stmt->width() == 1);
-    const auto linear_index_name = fmt::format("_li_{}", stmt->raw_name());
-    emit("Ti_i32 {} = 0;", linear_index_name);
+    std::string offset = "0";
     const auto *argload = stmt->base_ptrs[0]->as<ArgLoadStmt>();
     const int arg_id = argload->arg_id;
-    const int num_indices = stmt->indices.size();
-    std::vector<std::string> size_var_names;
-    for (int i = 0; i < num_indices; i++) {
-      auto var_name = fmt::format("_s{}_{}", i, stmt->raw_name());
-      auto var = define_var("Ti_i32", var_name);
-      emit("{} = ti_ctx->earg[{} * {} + {}];", var, arg_id,
-           taichi_max_num_indices, i);
-      size_var_names.push_back(std::move(var_name));
+    for (int i = 0; i < stmt->indices.size(); i++) {
+      auto stride = fmt::format("ti_ctx->earg[{} * {} + {}]", arg_id,
+                                taichi_max_num_indices, i);
+      offset = fmt::format("({} * {} + {})", offset, stride,
+                           stmt->indices[i]->raw_name());
     }
-    for (int i = 0; i < num_indices; i++) {
-      emit("{} *= {};", linear_index_name, size_var_names[i]);
-      emit("{} += {};", linear_index_name, stmt->indices[i]->raw_name());
-    }
-
     auto var = define_var(cc_data_type_name(stmt->element_type()) + " *",
                           stmt->raw_name());
-    emit("{} = {} + {};", var, stmt->base_ptrs[0]->raw_name(),
-         linear_index_name);
+    emit("{} = {} + {};", var, stmt->base_ptrs[0]->raw_name(), offset);
   }
 
   void visit(ArgLoadStmt *stmt) override {
@@ -216,6 +215,36 @@ class CCTransformer : public IRVisitor {
     emit("{} = {};", stmt->ptr->raw_name(), stmt->data->raw_name());
   }
 
+  void visit(ExternalFuncCallStmt *stmt) override {
+    TI_ASSERT(!stmt->func);
+    auto format = stmt->source;
+    std::string source;
+
+    for (int i = 0; i < format.size(); i++) {
+      char c = format[i];
+      if (c == '%' || c == '$') {  // '$' for output, '%' for input
+        int num = 0;
+        while (i < format.size()) {
+          i += 1;
+          if (!::isdigit(format[i])) {
+            i -= 1;
+            break;
+          }
+          num *= 10;
+          num += format[i] - '0';
+        }
+        auto args = (c == '%') ? stmt->arg_stmts : stmt->output_stmts;
+        TI_ASSERT_INFO(num < args.size(), "{}{} out of {} argument range {}", c,
+                       num, ((c == '%') ? "input" : "output"), args.size());
+        source += args[num]->raw_name();
+      } else {
+        source.push_back(c);
+      }
+    }
+
+    emit("{};", source);
+  }
+
   static std::string _get_libc_function_name(std::string name, DataType dt) {
     switch (dt) {
       case DataType::i32:
@@ -234,7 +263,14 @@ class CCTransformer : public IRVisitor {
 
   static std::string get_libc_function_name(std::string name, DataType dt) {
     auto ret = _get_libc_function_name(name, dt);
-    if (name == "max" || name == "min" || name == "abs") {
+    if (name == "rsqrt") {
+      ret = "Ti_" + ret;
+    } else if (name == "sgn") {
+      if (is_real(dt)) {
+        ret = "f" + ret;
+      }
+      ret = "Ti_" + ret;
+    } else if (name == "max" || name == "min" || name == "abs") {
       if (is_real(dt)) {
         ret = "f" + ret;
       } else if (ret != "abs") {
@@ -260,6 +296,13 @@ class CCTransformer : public IRVisitor {
     return invoke_libc(name, dt, arguments);
   }
 
+  void visit(TernaryOpStmt *tri) override {
+    TI_ASSERT(tri->op_type == TernaryOpType::select);
+    emit("{} {} = {} != 0 ? {} : {};", cc_data_type_name(tri->element_type()),
+         tri->raw_name(), tri->op1->raw_name(), tri->op2->raw_name(),
+         tri->op3->raw_name());
+  }
+
   void visit(BinaryOpStmt *bin) override {
     TI_ASSERT(bin->width() == 1);
     const auto dt_name = cc_data_type_name(bin->element_type());
@@ -276,11 +319,14 @@ class CCTransformer : public IRVisitor {
       } else if (bin->op_type == BinaryOpType::truediv) {
         emit("{} = ({}) {} / {};", var, dt_name, lhs_name, rhs_name);
       } else if (bin->op_type == BinaryOpType::floordiv) {
+        auto lhs_dt_name = data_type_short_name(bin->lhs->element_type());
         if (is_integral(bin->lhs->element_type()) &&
             is_integral(bin->rhs->element_type())) {
-          emit("{} = {} / {};", var, lhs_name, rhs_name);
+          emit("{} = Ti_floordiv_{}({}, {});", var, lhs_dt_name, lhs_name,
+               rhs_name);
         } else {
-          emit("{} = ({}) {} / {};", var, dt_name, lhs_name, rhs_name);
+          emit("{} = Ti_floordiv_{}({}, {});", var, lhs_dt_name, lhs_name,
+               rhs_name);
         }
       } else {
         emit("{} = {} {} {};", var, lhs_name, binop, rhs_name);
@@ -326,21 +372,13 @@ class CCTransformer : public IRVisitor {
     emit("{} = *{};", var, dest_ptr);
     if (stmt->op_type == AtomicOpType::max ||
         stmt->op_type == AtomicOpType::min) {
-      emit("*{} = {};", invoke_libc(op, type, "*{}, {}", dest_ptr, src_name));
+      emit("*{} = {};", dest_ptr,
+           invoke_libc(op, type, "*{}, {}", dest_ptr, src_name));
     } else {
       emit("*{} {}= {};", dest_ptr, op, src_name);
     }
   }
 
-  void visit(LinearizeStmt *stmt) override {
-    std::string val = "0";
-    for (int i = 0; i < stmt->inputs.size(); i++) {
-      val = fmt::format("({} * {} + {})", val, stmt->strides[i],
-                        stmt->inputs[i]->raw_name());
-    }
-    emit("{} = {};", define_var("Ti_i32", stmt->raw_name()), val);
-  }
-
   void visit(PrintStmt *stmt) override {
     std::string format;
     std::vector<std::string> values;
@@ -369,15 +407,38 @@ class CCTransformer : public IRVisitor {
   }
 
   void generate_range_for_kernel(OffloadedStmt *stmt) {
-    // TI_ASSERT(stmt->const_begin && stmt->const_end);
-    ScopedIndent _s(line_appender);
-    auto begin_value = stmt->begin_value;
-    auto end_value = stmt->end_value;
-    auto var = define_var("Ti_i32", stmt->raw_name());
-    emit("for ({} = {}; {} < {}; {} += {}) {{", var, begin_value,
-         stmt->raw_name(), end_value, stmt->raw_name(), 1 /* stmt->step? */);
-    stmt->body->accept(this);
-    emit("}}");
+    if (stmt->const_begin && stmt->const_end) {
+      ScopedIndent _s(line_appender);
+      auto begin_value = stmt->begin_value;
+      auto end_value = stmt->end_value;
+      auto var = define_var("Ti_i32", stmt->raw_name());
+      emit("for ({} = {}; {} < {}; {} += {}) {{", var, begin_value,
+           stmt->raw_name(), end_value, stmt->raw_name(), 1 /* stmt->step? */);
+      stmt->body->accept(this);
+      emit("}}");
+    } else {
+      auto var = define_var("Ti_i32", stmt->raw_name());
+      auto begin_expr = "tmp_begin_" + stmt->raw_name();
+      auto end_expr = "tmp_end_" + stmt->raw_name();
+      auto begin_var = define_var("Ti_i32", begin_expr);
+      auto end_var = define_var("Ti_i32", end_expr);
+      if (!stmt->const_begin) {
+        emit("{} = *(Ti_i32 *) (ti_ctx->gtmp + {});", begin_var,
+             stmt->begin_offset);
+      } else {
+        emit("{} = {};", begin_var, stmt->begin_value);
+      }
+      if (!stmt->const_end) {
+        emit("{} = *(Ti_i32 *) (ti_ctx->gtmp + {});", end_var,
+             stmt->end_offset);
+      } else {
+        emit("{} = {};", end_var, stmt->end_value);
+      }
+      emit("for ({} = {}; {} < {}; {} += {}) {{", var, begin_expr,
+           stmt->raw_name(), end_expr, stmt->raw_name(), 1 /* stmt->step? */);
+      stmt->body->accept(this);
+      emit("}}");
+    }
   }
 
   void visit(OffloadedStmt *stmt) override {
@@ -419,7 +480,7 @@ class CCTransformer : public IRVisitor {
     } else {
       // reversed for loop
       emit("for ({} = {} - {}; {} >= {}; {} -= {}) {{", var,
-           stmt->end->raw_name(), stmt->raw_name(), 1, stmt->begin->raw_name(),
+           stmt->end->raw_name(), 1, stmt->raw_name(), stmt->begin->raw_name(),
            stmt->raw_name(), 1);
     }
     stmt->body->accept(this);

taichi/backends/cc/runtime/base.h

@@ -32,6 +32,38 @@ static inline Ti_i64 Ti_llmax(Ti_i64 x, Ti_i64 y) {
 static inline Ti_i64 Ti_llmin(Ti_i64 x, Ti_i64 y) {
   return x < y ? x : y;
 }
+static inline Ti_i64 Ti_llsgn(Ti_i64 x) {
+  return x < 0 ? -1 : x != 0;
+}
+static inline Ti_i32 Ti_sgn(Ti_i32 x) {
+  return x < 0 ? -1 : x != 0;
+}
+static inline Ti_f32 Ti_fsgnf(Ti_f32 x) {
+  return x < 0 ? -1 : x != 0;
+}
+static inline Ti_f64 Ti_fsgn(Ti_f64 x) {
+  return x < 0 ? -1 : x != 0;
+}
+static inline Ti_i64 Ti_floordiv_i64(Ti_i64 x, Ti_i64 y) {
+  Ti_i64 r = x / y;
+  return r - ((x < 0) != (y < 0) && x && y * r != x);
+}
+static inline Ti_i32 Ti_floordiv_i32(Ti_i32 x, Ti_i32 y) {
+  Ti_i32 r = x / y;
+  return r - ((x < 0) != (y < 0) && x && y * r != x);
+}
+static inline Ti_f32 Ti_floordiv_f32(Ti_f32 x, Ti_f32 y) {
+  return floorf(x / y);
+}
+static inline Ti_f64 Ti_floordiv_f64(Ti_f64 x, Ti_f64 y) {
+  return floor(x / y);
+}
+static inline Ti_f32 Ti_rsqrtf(Ti_f32 x) {
+  return 1 / sqrt(x);
+}
+static inline Ti_f64 Ti_rsqrt(Ti_f64 x) {
+  return 1 / sqrt(x);
+}
 
 ) "\n" STR(
 

taichi/program/extension.cpp

@@ -19,6 +19,7 @@ bool is_extension_supported(Arch arch, Extension ext) {
         Extension::bls, Extension::assertion}},
       {Arch::metal, {Extension::adstack}},
       {Arch::opengl, {Extension::extfunc}},
+      {Arch::cc, {Extension::data64, Extension::extfunc}},
   };
   // if (with_opengl_extension_data64())
   // arch2ext[Arch::opengl].insert(Extension::data64); // TODO: singleton

tests/python/test_atomic.py

@@ -30,10 +30,15 @@ def func():
     y_actual = sorted(y.to_numpy())
     expect = [i * step for i in range(n)]
     for (xa, ya, e) in zip(x_actual, y_actual, expect):
+        print(xa, ya, e)
         assert valproc(xa) == e
         assert valproc(ya) == e
 
 
+ti.init(ti.cc, log_level=ti.DEBUG)
+run_atomic_add_global_case(ti.i32, 42)
+
+
 @ti.all_archs
 def test_atomic_add_global_i32():
     run_atomic_add_global_case(ti.i32, 42)

tests/python/test_bitmasked.py

@@ -2,7 +2,7 @@
 
 
 def archs_support_bitmasked(func):
-    return ti.archs_excluding(ti.opengl)(func)
+    return ti.archs_excluding(ti.opengl, ti.cc)(func)
 
 
 @archs_support_bitmasked

tests/python/test_dynamic.py

@@ -2,11 +2,11 @@
 
 
 def ti_support_dynamic(test):
-    return ti.all_archs(test)
+    return ti.archs_excluding(ti.cc)(test)
 
 
 def ti_support_non_top_dynamic(test):
-    return ti.archs_excluding(ti.opengl)(test)
+    return ti.archs_excluding(ti.opengl, ti.cc)(test)
 
 
 @ti_support_dynamic

tests/python/test_struct_for_dynamic.py

@@ -2,7 +2,7 @@
 
 
 def ti_support_dynamic(test):
-    return ti.archs_excluding(ti.opengl)(test)
+    return ti.archs_excluding(ti.opengl, ti.cc)(test)
 
 
 @ti_support_dynamic