404
+ +Page not found
+ + +
+
+
+
+ Page not found
+ + +The performance of Python applications that use TACO can be measured using
+Python's built-in time.perf_counter function with minimal changes to the
+applications. As an example, we can benchmark the performance of the
+scientific computing application shown here as
+follows:
import pytaco as pt
+from pytaco import compressed, dense
+import numpy as np
+import time
+
+csr = pt.format([dense, compressed])
+dv = pt.format([dense])
+
+A = pt.read("pwtk.mtx", csr)
+x = pt.from_array(np.random.uniform(size=A.shape[1]))
+z = pt.from_array(np.random.uniform(size=A.shape[0]))
+y = pt.tensor([A.shape[0]], dv)
+
+i, j = pt.get_index_vars(2)
+y[i] = A[i, j] * x[j] + z[i]
+
+# Tell TACO to generate code to perform the SpMV computation
+y.compile()
+
+# Benchmark the actual SpMV computation
+start = time.perf_counter()
+y.compute()
+end = time.perf_counter()
+
+print("Execution time: {0} seconds".format(end - start))In order to accurately measure TACO's computational performance, only the
+time it takes to actually perform a computation should be measured. The time
+it takes to generate code under the hood for performing that computation should
+not be measured, since this overhead can be quite variable but can often be
+amortized in practice. By default though, TACO will only generate and compile
+code it needs for performing a computation immediately before it has to
+actually perform the computation. As the example above demonstrates, by
+manually calling the result tensor's compile method, we can tell TACO to
+generate code needed for performing the computation before benchmarking starts,
+letting us measure only the performance of the computation itself.
Warning
+pytaco.evaluate and pytaco.einsum should not be used to benchmark
+TACO's computational performance, since timing those functions will
+include the time it takes to generate code for performing the computation.
The time it takes to construct the initial operand tensors should also not be
+measured, since again this overhead can often be amortized in practice. By
+default, pytaco.read and functions for converting NumPy arrays and SciPy
+matrices to TACO tensors return fully constructed tensors. If you add nonzero
+elements to an operand tensor by invoking its insert method though, then
+pack must also be explicitly invoked before any benchmarking is done:
import pytaco as pt
+from pytaco import compressed, dense
+import numpy as np
+import random
+import time
+
+csr = pt.format([dense, compressed])
+dv = pt.format([dense])
+
+A = pt.read("pwtk.mtx", csr)
+x = pt.tensor([A.shape[1]], dv)
+z = pt.tensor([A.shape[0]], dv)
+y = pt.tensor([A.shape[0]], dv)
+
+# Insert random values into x and z and pack them into dense arrays
+for k in range(A.shape[1]):
+ x.insert([k], random.random())
+x.pack()
+for k in range(A.shape[0]):
+ z.insert([k], random.random())
+z.pack()
+
+i, j = pt.get_index_vars(2)
+y[i] = A[i, j] * x[j] + z[i]
+
+y.compile()
+
+start = time.perf_counter()
+y.compute()
+end = time.perf_counter()
+
+print("Execution time: {0} seconds".format(end - start))TACO avoids regenerating code for performing the same computation though as +long as the computation is redefined with the same index variables and with the +same operand and result tensors. Thus, if your application executes the same +computation many times in a loop and if the computation is executed on +sufficiently large data sets, TACO will naturally amortize the overhead +associated with generating code for performing the computation. In such +scenarios, it is acceptable to include the initial code generation overhead +in the performance measurement:
+import pytaco as pt
+from pytaco import compressed, dense
+import numpy as np
+import time
+
+csr = pt.format([dense, compressed])
+dv = pt.format([dense])
+
+A = pt.read("pwtk.mtx", csr)
+x = pt.tensor([A.shape[1]], dv)
+z = pt.tensor([A.shape[0]], dv)
+y = pt.tensor([A.shape[0]], dv)
+
+for k in range(A.shape[1]):
+ x.insert([k], random.random())
+x.pack()
+for k in range(A.shape[0]):
+ z.insert([k], random.random())
+z.pack()
+
+i, j = pt.get_index_vars(2)
+
+# Benchmark the iterative SpMV computation, including overhead for
+# generating code in the first iteration to perform the computation
+start = time.perf_counter()
+for k in range(1000):
+ y[i] = A[i, j] * x[j] + z[i]
+ y.evaluate()
+ x[i] = y[i]
+ x.evaluate()
+end = time.perf_counter()
+
+print("Execution time: {0} seconds".format(end - start))Warning
+In order to avoid regenerating code for performing a computation, the
+computation must be redefined with the exact same index variable objects
+and also with the exact same tensor objects for operands and result. In
+the example above, every loop iteration redefines the computation of y
+and x using the same tensor and index variable objects costructed outside
+the loop, so TACO will only generate code to compute y and x in the
+first iteration. If the index variables were constructed inside the loop
+though, TACO would regenerate code to compute y and x in every loop
+iteration, and the compilation overhead would not be amortized.
Note
+As a rough rule of thumb, if a computation takes on the order of seconds or +more in total to perform across all invocations with identical operands and +result (and is always redefined with identical index variables), then it is +acceptable to include the overhead associated with generating code for +performing the computation in performance measurements.
+Tensor algebra computations can be expressed in TACO with tensor index +notation, which at a high level describes how each element in the output tensor +can be computed from elements in the input tensors. As an example, matrix +addition can be expressed in index notation as
+A(i,j) = B(i,j) + C(i,j)where A, B, and C denote order-2 tensors (i.e. matrices) while i and
+j are index variables that represent abstract indices into the corresponding
+dimensions of the tensors. In words, the example above essentially states that,
+for every i and j, the element in the i-th row and j-th column of the
+A should be assigned the sum of the corresponding elements in B and C.
+Similarly, element-wise multiplication of three order-3 tensors can be
+expressed in index notation as follows
A(i,j,k) = B(i,j,k) * C(i,j,k) * D(i,j,k)The syntax shown above corresponds to exactly what you would have to write in +C++ with TACO to define tensor algebra computations. Note, however, that prior +to defining a tensor algebra computation, all index variables have to be +declared. This can be done as shown below:
+IndexVar i, j, k; // Declare index variables for previous exampleIn both of the previous examples, all of the index variables are used to index +into both the output and the inputs. However, it is possible for an index +variable to be used to index into the inputs only, in which case the index +variable is reduced (summed) over. For instance, the following example
+y(i) = A(i,j) * x(j)can be rewritten with the summation more explicit as and demonstrates how matrix-vector multiplication can be expressed +in index notation.
+Note that, in TACO, reductions are assumed to be over the smallest +subexpression that captures all uses of the corresponding reduction variable. +For instance, the following computation
+y(i) = A(i,j) * x(j) + z(i)can be rewritten with the summation more explicit as
++ +
+whereas the following computation
+y(i) = A(i,j) * x(j) + z(j)can be rewritten with the summation more explicit as
++ +
+Once a tensor algebra computation has been defined (and all of the inputs have
+been initialized), you can simply invoke the
+output tensor's evaluate method to perform the actual computation:
A.evaluate(); // Perform the computation defined previously for output tensor AUnder the hood, when you invoke the evaluate method, TACO first invokes the
+output tensor's compile method to generate kernels that assembles the output
+indices (if the tensor contains any sparse dimensions) and that performs the
+actual computation. TACO would then call the two generated kernels by invoking
+the output tensor's assemble and compute methods. You can manually invoke
+these methods instead of calling evaluate as demonstrated below:
A.compile(); // Generate output assembly and compute kernels
+A.assemble(); // Invoke the output assembly kernel to assemble the output indices
+A.compute(); // Invoke the compute kernel to perform the actual computationThis can be useful if you want to perform the same computation multiple times,
+in which case it suffices to invoke compile once before the first time the
+computation is performed.
It is also possible to compute on tensors without having to explicitly invoke
+compile, assemble, or compute. Once you attempt to modify or view the
+output of a computation, TACO would automatically invoke those methods if
+necessary in order to compute the values in the output tensor. If the input to
+a computation is itself the output of another computation, then TACO would also
+automatically ensure that the latter computation is fully executed first.
When using the TACO C++ library, the typical usage is to declare your input
+taco::Tensor structures, then add data to these structures using the insert
+method. This is wasteful if the data is already loaded into memory in a
+compatible format; TACO can use this data directly without copying it. Below
+are some usage examples for common situations where a user may want to do this.
A two-dimensional CSR matrix can be created using three arrays:
+rowptr (array of int): list of indices in colidx representing starts of rowscolidx (array of int): list of column indices of non-zero valuesvals (array of T for Tensor<T>): list of non-zero values corresponding to columns in colidxThe taco::makeCSR<T> function takes these arrays and creates a
+taco::Tensor<T>. The following example constructs a 5x10 matrix populated
+with a few values.
int *rowptr = new int[6]{0, 2, 4, 4, 4, 7};
+int *colidx = new int[7]{3, 5, 0, 7, 7, 8, 9};
+double *values = new double[7]{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7};
+Tensor<double> A = makeCSR("A", {5, 10}, rowptr, colidx, values);Similarly, a two-dimensional CSC matrix can be created from the appropriate
+arrays using the taco::makeCSC<T> function. This example constructs the same
+5x10 matrix from the CSR example above, but in CSC format.
int *colptr = new int[11]{0, 1, 1, 1, 2, 2, 3, 3, 5, 6, 7};
+int *rowidx = new int[7]{1, 0, 0, 1, 4, 4, 4};
+double *values = new double[7]{0.3, 0.1, 0.2, 0.4, 0.5, 0.6, 0.7};
+Tensor<double> B = makeCSC("B", {5, 10}, colptr, rowidx, values);For single-dimension dense vectors, you can use an array of values (of type T
+for a Tensor<T>). There is no helper function for this (like makeCSR or
+makeCSC), but it can be done. This example constructs a 1x10 dense vector.
// Create an array of double values.
+double *x_values = new double[10];
+for (int i = 0; i < 10; i++) {
+ x_values[i] = i;
+}
+
+// Create the Tensor and set its storage to our array of values.
+Tensor<double> x({10}, Dense);
+Array x_array = makeArray<double>(x_values, 10);
+TensorStorage x_storage = x.getStorage();
+x_storage.setValues(x_array);
+x.setStorage(x_storage);!pma|lSQ?8FBe{DRl|@FzhU7Cb>&@ataZS{g
zrCQo@Lushkm71KyL3$%QD?KeSA #R4x5a04mzf2YJ>#U<-Nc81}`=EFMdUjIP>d|
zG57p9Z{fmuKgy=mdh|^p{vLBqr2nl~Uvs