Add in initial code for image.cpp and also pow1Comp ufunc

Author: weiya711

numpy/ufuncs.py

@@ -42,7 +42,6 @@ def bench_pydata_ufunc_fused(tacoBench, dim):
     matrix2 = safeCastPydataTensorToInts(loader.random((dim, dim), 0.01, variant=2))
     def bench():
         result = numpy.logical_xor(numpy.logical_xor(matrix, matrix1), matrix2)
-        #print("nnz = ", result.nnz)
         return result
     tacoBench(bench)
 
@@ -129,7 +128,7 @@ def load(self, tensor, suiteSparse):
 # Run benchmarks against the FROSTT collection.
 FROSTTTensors = TensorCollectionFROSTT()
 @pytest.mark.parametrize("tensor", FROSTTTensors.getTensors())
-@pytest.mark.parametrize("ufunc", [numpy.logical_xor, numpy.ldexp, numpy.right_shift])
+@pytest.mark.parametrize("ufunc", [numpy.power, numpy.logical_xor, numpy.ldexp, numpy.right_shift])
 def bench_pydata_frostt_ufunc_sparse(tacoBench, tensor, ufunc):
     frTensor, other = inputCache.load(tensor, False)
     def bench():

taco/bench.cpp

@@ -61,3 +61,27 @@ taco::TensorBase loadRandomTensor(std::string name, std::vector<int> dims, float
   tensor.setName(name);
   return tensor;
 }
+
+std::string constructImageTensorKey(int num, int variant) {
+  auto path = getTacoTensorPath();
+  std::stringstream result;
+  result << path;
+  if (path[path.size() - 1] != '/') {
+    result << "/";
+  }
+  result << "image/";
+  if (variant == 0) {
+    result << "image" << num << ".tns";
+  } else {
+    result << "image" << num << "-" << variant << ".tns";
+  }
+  return result.str();
+}
+
+taco::TensorBase loadImageTensor(std::string name, int num, taco::Format format, int variant) {
+  // For now, just say that the python code must generate the random
+  // tensor before use.
+  auto tensor = taco::read(constructImageTensorKey(num, variant), format, true);
+  tensor.setName(name);
+  return tensor;
+}

taco/bench.h

@@ -50,6 +50,7 @@ std::string getValidationOutputPath();
 // cleanPath ensures that the input path ends with "/".
 std::string cleanPath(std::string path);
 taco::TensorBase loadRandomTensor(std::string name, std::vector<int> dims, float sparsity, taco::Format format, int variant=0);
+taco::TensorBase loadImageTensor(std::string name, int num, taco::Format format, int variant=0);
 
 template<typename T>
 taco::Tensor<T> castToType(std::string name, taco::Tensor<double> tensor) {

taco/image.cpp

@@ -0,0 +1,96 @@
+#include "bench.h"
+#include "benchmark/benchmark.h"
+
+#include "taco/tensor.h"
+#include "taco/format.h"
+#include "taco/index_notation/index_notation.h"
+#include "taco/index_notation/tensor_operator.h"
+
+using namespace taco;
+
+// XOR Op and Algebra
+struct GeneralAdd {
+  ir::Expr operator()(const std::vector<ir::Expr> &v) {
+    taco_iassert(v.size() >= 1) << "Add operator needs at least one operand";
+    if (v.size() == 1)
+        return ir::Add::make(v[0], ir::Literal::zero(v[0].type()));
+    ir::Expr add = ir::Add::make(v[0], v[1]);
+    for (size_t idx = 2; idx < v.size(); ++idx) {
+      add = ir::Add::make(add, v[idx]);
+    }
+    return add;
+  }
+};
+
+struct xorAlgebra {
+  IterationAlgebra operator()(const std::vector<IndexExpr>& regions) {
+    IterationAlgebra noIntersect = Complement(Intersect(regions[0], regions[1]));
+    return Intersect(noIntersect, Union(regions[0], regions[1]));
+  }
+};
+
+struct andAlgebra {
+  IterationAlgebra operator()(const std::vector<IndexExpr>& regions) {
+    return Intersect(regions[0], regions[1]);
+  }
+};
+
+Func xorOp1("logical_xor", GeneralAdd(), xorAlgebra());
+Func andOp1("logical_and", GeneralAdd(), andAlgebra());
+
+static void bench_imaging_xor(benchmark::State& state, const Format& f) {
+  int dim = state.range(0);
+  auto sparsity = 0.01;
+  Tensor<int64_t> matrix = castToType<int64_t>("A", loadImageTensor("A", 0, f));
+  Tensor<int64_t> matrix1 = castToType<int64_t>("B", loadImageTensor("B", 0, f, 1 /* variant */));
+
+  for (auto _ : state) {
+    state.PauseTiming();
+    Tensor<int64_t> result("result", {dim, dim}, f, 1);
+    IndexVar i("i"), j("j");
+    result(i, j) = xorOp1(matrix(i, j), matrix1(i, j));
+    result.setAssembleWhileCompute(true);
+    result.compile();
+    state.ResumeTiming();
+    result.compute();
+    result = result.removeExplicitZeros(result.getFormat());
+    
+    int nnz = 0;
+    for (auto& it : iterate<int64_t>(result)) {
+      nnz++;
+    }
+    std::cout << "Result NNZ = " << nnz << std::endl;
+
+  }
+}
+ TACO_BENCH_ARGS(bench_imaging_xor, csr, CSR)
+   ->ArgsProduct({{5000, 10000, 20000}});
+
+static void bench_imaging_fused(benchmark::State& state, const Format& f) {
+  int dim = state.range(0);
+  auto sparsity = 0.01;
+  Tensor<int64_t> matrix = castToType<int64_t>("A", loadImageTensor("A", 0, f));
+  Tensor<int64_t> matrix1 = castToType<int64_t>("B", loadImageTensor("B", 0, f, 1 /* variant */));
+  Tensor<int64_t> matrix2 = castToType<int64_t>("C", loadImageTensor("C", 0, f, 2 /* variant */));
+
+  for (auto _ : state) {
+    state.PauseTiming();
+    Tensor<int64_t> result("result", {dim, dim}, f, 1);
+    IndexVar i("i"), j("j");
+    result(i, j) = xorOp1(andOp1(matrix(i, j), matrix2(i, j)), andOp1(matrix1(i, j), matrix2(i, j)));
+    result.setAssembleWhileCompute(false);
+    result.compile();
+    state.ResumeTiming();
+    result.assemble();
+    result.compute();
+    result = result.removeExplicitZeros(result.getFormat());
+
+    int nnz = 0;
+    for (auto& it : iterate<int64_t>(result)) {
+      nnz++;
+    }
+    std::cout << "Result NNZ = " << nnz << std::endl;
+  }
+}
+ TACO_BENCH_ARGS(bench_imaging_fused, csr, CSR)
+   ->ArgsProduct({{5000, 10000, 20000}});

taco/taco

@@ -96,13 +96,13 @@ struct Power {
 
 struct unionRightCompAlgebra {
   IterationAlgebra operator()(const std::vector<IndexExpr>& regions) {
-    return Union(regions[0], Complement(regions[1]));
+    return Union(Intersect(regions[0], regions[1]), Complement(regions[1]));
   }
 };
 
 struct rightIncAlgebra {
   IterationAlgebra operator()(const std::vector<IndexExpr>& regions) {
-    return regions[1];
+    return Union(Intersect(regions[0], regions[1]), regions[1]);
   }
 };
 
@@ -229,10 +229,10 @@ static void bench_ufunc_fused(benchmark::State& state, const Format& f) {
     Tensor<int64_t> result("result", {dim, dim}, f);
     IndexVar i("i"), j("j");
     result(i, j) = nestedXorOp(matrix(i, j), matrix1(i, j), matrix2(i, j));
-    result.setAssembleWhileCompute(true);
+    result.setAssembleWhileCompute(false);
     result.compile();
     state.ResumeTiming();
-
+    result.assemble();
     result.compute();
     result = result.removeExplicitZeros(result.getFormat());
 
@@ -287,7 +287,7 @@ std::string ufuncBenchKey(std::string tensorName, std::string funcName) {
   return tensorName + "-" + funcName + "-taco";
 }
 
-static void bench_frostt_ufunc(benchmark::State& state, std::string tnsPath, Func op) {
+static void bench_frostt_ufunc(benchmark::State& state, std::string tnsPath, Func op, int fill_value = 0) {
   auto frosttTensorPath = getTacoTensorPath();
   frosttTensorPath += "FROSTT/";
   frosttTensorPath += tnsPath;
@@ -303,7 +303,7 @@ static void bench_frostt_ufunc(benchmark::State& state, std::string tnsPath, Fun
 
   for (auto _ : state) {
     state.PauseTiming();
-    Tensor<int64_t> result("result", frosttTensor.getDimensions(), frosttTensor.getFormat());
+    Tensor<int64_t> result("result", frosttTensor.getDimensions(), frosttTensor.getFormat(), fill_value);
     result.setAssembleWhileCompute(true);
     switch (frosttTensor.getOrder()) {
       case 3: {
@@ -331,11 +331,6 @@ static void bench_frostt_ufunc(benchmark::State& state, std::string tnsPath, Fun
     result.compute();
 
     state.PauseTiming();
-//    int nnz = 0;
-//    for (auto& it : iterate<int64_t>(result)) {
-//      nnz++;
-//    }
-//    std::cout << "Result NNZ = " << nnz << std::endl;
 
     if (auto validationPath = getValidationOutputPath(); validationPath != "") {
       auto key = ufuncBenchKey(tensorName, op.getName());
@@ -368,8 +363,8 @@ static void bench_frostt_ufunc(benchmark::State& state, std::string tnsPath, Fun
   TACO_BENCH_ARGS(bench_frostt_ufunc, name/xor, path, xorOp); \
   TACO_BENCH_ARGS(bench_frostt_ufunc, name/ldExp, path, ldExp); \
   TACO_BENCH_ARGS(bench_frostt_ufunc, name/rightShift, path, rightShift); \
-  //TACO_BENCH_ARGS(bench_frostt_ufunc, name/pow0Comp, path, pow0Comp); \
-  //TACO_BENCH_ARGS(bench_frostt_ufunc, name/pow1Comp, path, pow1Comp); \
+  TACO_BENCH_ARGS(bench_frostt_ufunc, name/pow1Comp, path, pow1Comp, 1);\
+  //TACO_BENCH_ARGS(bench_frostt_ufunc, name/pow0Comp, path, pow0Comp, 0);     \
 
 FOREACH_FROSTT_TENSOR(DECLARE_FROSTT_UFUNC_BENCH)