[SYSTEMDS-3730] Add MatrixRollPerf.java

Introduced a new test class to properly measure the performance of single-threaded and multithreaded rolling and remove unnecessary if condition

Author: Biranavan Parameswaran

src/main/java/org/apache/sysds/runtime/matrix/data/LibMatrixReorg.java

@@ -532,7 +532,7 @@ public static MatrixBlock roll(MatrixBlock input, MatrixBlock output, int shift,
 			return output;
 		}
 
-		if(numThreads <= 1 || input.isEmptyBlock(false) || input.getLength() < PAR_NUMCELL_THRESHOLD) {
+		if(numThreads <= 1 || input.getLength() < PAR_NUMCELL_THRESHOLD) {
 			return roll(input, output, shift); // fallback to single-threaded
 		}
 

src/test/java/org/apache/sysds/performance/matrix/MatrixRollPerf.java

@@ -0,0 +1,108 @@
+package org.apache.sysds.performance.matrix;
+
+import org.apache.sysds.performance.compression.APerfTest;
+import org.apache.sysds.performance.generators.ConstMatrix;
+import org.apache.sysds.performance.generators.IGenerate;
+import org.apache.sysds.runtime.functionobjects.IndexFunction;
+import org.apache.sysds.runtime.functionobjects.RollIndex;
+import org.apache.sysds.runtime.matrix.data.MatrixBlock;
+import org.apache.sysds.runtime.matrix.operators.ReorgOperator;
+import org.apache.sysds.test.TestUtils;
+import org.apache.sysds.utils.stats.InfrastructureAnalyzer;
+
+import java.util.Random;
+
+public class MatrixRollPerf extends APerfTest<Object, MatrixBlock> {
+
+	private final int rows;
+	private final int cols;
+	private final int shift;
+	private final int k;
+
+	private final ReorgOperator reorg;
+	private MatrixBlock out;
+
+	public MatrixRollPerf(int N, int W, IGenerate<MatrixBlock> gen, int rows, int cols, int shift, int k) {
+		super(N, W, gen);
+		this.rows = rows;
+		this.cols = cols;
+		this.shift = shift;
+		this.k = k;
+
+		IndexFunction op = new RollIndex(shift);
+		this.reorg = new ReorgOperator(op, k);
+	}
+
+	public void run() throws Exception {
+		MatrixBlock mb = gen.take();
+		logInfos(rows, cols, shift, mb.getSparsity(), k);
+
+
+		String info = String.format("rows: %5d cols: %5d sp: %.4f shift: %4d k: %2d",
+			rows, cols, mb.getSparsity(), shift, k);
+
+
+		warmup(this::rollOnce, W);
+
+		execute(this::rollOnce, info);
+	}
+
+	private void logInfos(int rows, int cols, int shift, double sparsity, int k) {
+		String matrixType = sparsity == 1 ? "Dense" : "Sparse";
+		if (k == 1) {
+			System.out.println("---------------------------------------------------------------------------------------------------------");
+			System.out.printf("%s Experiment for rows %d columns %d and shift %d \n", matrixType, rows, cols, shift);
+			System.out.println("---------------------------------------------------------------------------------------------------------");
+		}
+	}
+
+	private void rollOnce() {
+		MatrixBlock in = gen.take();
+
+		if (out == null)
+			out = new MatrixBlock(rows, cols, in.isInSparseFormat());
+
+		out.reset(rows, cols, in.isInSparseFormat());
+
+		in.reorgOperations(reorg, out, 0, 0, 0);
+
+		ret.add(null);
+	}
+
+	@Override
+	protected String makeResString() {
+		return "";
+	}
+
+	public static void main(String[] args) throws Exception {
+		int kMulti = InfrastructureAnalyzer.getLocalParallelism();
+		int reps = 2000;
+		int warmup = 200;
+
+		int minRows = 2017;
+		int minCols = 1001;
+		double spSparse = 0.01;
+		int minShift = -50;
+		int maxShift = 1022;
+		int iterations = 10;
+
+		Random rand = new Random(42);
+
+		for (int i = 0; i < iterations; i++) {
+			int rows = minRows + rand.nextInt(500);
+			int cols = minCols + rand.nextInt(500);
+			int shift = rand.nextInt((maxShift - minShift) + 1) + minShift;
+
+			MatrixBlock denseIn = TestUtils.generateTestMatrixBlock(rows, cols, -100, 100, 1.0, 42);
+			MatrixBlock sparseIn = TestUtils.generateTestMatrixBlock(rows, cols, -100, 100, spSparse, 42);
+
+			// Run Dense Case (Single vs Multi-threaded)
+			new MatrixRollPerf(reps, warmup, new ConstMatrix(denseIn, -1), rows, cols, shift, 1).run();
+			new MatrixRollPerf(reps, warmup, new ConstMatrix(denseIn, -1), rows, cols, shift, kMulti).run();
+
+			// Run Sparse Case (Single vs Multi-threaded)
+			new MatrixRollPerf(reps, warmup, new ConstMatrix(sparseIn, -1), rows, cols, shift, 1).run();
+			new MatrixRollPerf(reps, warmup, new ConstMatrix(sparseIn, -1), rows, cols, shift, kMulti).run();
+		}
+	}
+}

src/test/java/org/apache/sysds/test/component/matrix/libMatrixReorg/RollOperationThreadSafetyTest.java

@@ -28,7 +28,6 @@
 import org.apache.sysds.runtime.matrix.data.MatrixBlock;
 import org.apache.sysds.runtime.matrix.operators.ReorgOperator;
 import org.apache.sysds.test.TestUtils;
-import org.apache.sysds.utils.stats.Timing;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -89,17 +88,9 @@ public static Collection<Object[]> data() {
 	public void denseRollOperationSingleAndMultiThreadedShouldReturnSameResult() {
 		int numThreads = getNumThreads();
 
-		// Single-threaded timing
-		Timing tSingle = new Timing(true);
 		MatrixBlock outSingle = rollOperation(inputDense, 1);
-		double timeSingle = tSingle.stop();
 
-		// Multithreaded timing
-		Timing tMulti = new Timing(true);
 		MatrixBlock outMulti = rollOperation(inputDense, numThreads);
-		double timeMulti = tMulti.stop();
-
-		logTiming("Dense", numThreads, timeSingle, timeMulti);
 
 		TestUtils.compareMatrices(outSingle, outMulti, 1e-12,
 			"Dense Mismatch (numThreads=1 vs numThreads>1) for Size=" + rows + "x" + cols + " Shift=" + shift);
@@ -109,17 +100,9 @@ public void denseRollOperationSingleAndMultiThreadedShouldReturnSameResult() {
 	public void sparseRollOperationSingleAndMultiThreadedShouldReturnSameResult() {
 		int numThreads = getNumThreads();
 
-		// Single-threaded timing
-		Timing tSingle = new Timing(true);
 		MatrixBlock outSingle = rollOperation(inputSparse, 1);
-		double timeSingle = tSingle.stop();
 
-		// Multithreaded timing
-		Timing tMulti = new Timing(true);
 		MatrixBlock outMulti = rollOperation(inputSparse, numThreads);
-		double timeMulti = tMulti.stop();
-
-		logTiming("Sparse", numThreads, timeSingle, timeMulti);
 
 		TestUtils.compareMatrices(outSingle, outMulti, 1e-12,
 			"Sparse Mismatch (numThreads=1 vs numThreads>1) for Size=" + rows + "x" + cols + " Shift=" + shift);
@@ -139,14 +122,4 @@ private static int getNumThreads() {
 		int cores = Runtime.getRuntime().availableProcessors();
 		return Math.max(2, cores);
 	}
-
-	private void logTiming(String type, int numThreads, double timeSingle, double timeMulti) {
-		double speedup = timeSingle / timeMulti;
-
-		System.out.println("\n--- " + type + " Roll Operation Timing for " + rows + "x" + cols + ", Shift=" + shift + " ---");
-		System.out.printf("Single-threaded (1 core) took: %.3f ms\n", timeSingle);
-		System.out.printf("Multithreaded (%d cores) took: %.3f ms\n", numThreads, timeMulti);
-		System.out.printf("Speedup: %.2f\n", speedup);
-		System.out.println("--------------------------------------------------------------------------------");
-	}
 }