diff --git a/README.md b/README.md index 6ffb4dc69f1eaaef84ed3fc4e51c5d87006f4501..1b29692d65994b40d5c848361c8946e0f8e8f77f 100644 --- a/README.md +++ b/README.md @@ -30,6 +30,12 @@ 运行时依赖： - JDK16+ +运行benchmark +```shell +${JAVA_HOME}/bin/java -jar vectorBlas-benchmark/target/vectorBlas-benchmarks.jar + +``` + #### 参与贡献 1. Fork 本仓库 diff --git a/pom.xml b/pom.xml index 0862590d747adcc596aac9c5738eb1c737d416e8..9e001dd5a81a7e901f3799d52e2f609a061ca623 100644 --- a/pom.xml +++ b/pom.xml @@ -11,6 +11,7 @@ vectorBlas + vectorBlas-benchmark diff --git a/vectorBlas-benchmark/.gitignore b/vectorBlas-benchmark/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..e9286b3737f58763912fa3ba3b480af752c1b28a --- /dev/null +++ b/vectorBlas-benchmark/.gitignore @@ -0,0 +1,7 @@ +# Java +*.class +vecblas.iml +*.xml +.idea +/target/generated-sources +/target/classes diff --git a/vectorBlas-benchmark/pom.xml b/vectorBlas-benchmark/pom.xml new file mode 100644 index 0000000000000000000000000000000000000000..29ee4d17b2c8ebdd1332cf16fdbc56c93d4dacd9 --- /dev/null +++ b/vectorBlas-benchmark/pom.xml @@ -0,0 +1,145 @@ + + + + 4.0.0 + + + com.huawei.vector + parent + 1.0.0 + ../pom.xml + + + vectorBlas-benchmark + 1.0.0 + jar + + + + org.openjdk.jmh + jmh-core + ${jmh.version} + + + org.openjdk.jmh + jmh-generator-annprocess + ${jmh.version} + provided + + + com.huawei.vector + vectorBlas + 1.0.0 + + + + + UTF-8 + 1.29 + vectorBlas-benchmarks + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.1 + + + package + + shade + + + ${uberjar.name} + + + org.openjdk.jmh.Main + + + + + + *:* + + META-INF/*.SF + META-INF/*.DSA + META-INF/*.RSA + + + + + + + + + + + + maven-clean-plugin + 2.5 + + + maven-deploy-plugin + 2.8.1 + + + maven-install-plugin + 2.5.1 + + + maven-jar-plugin + 2.4 + + + maven-javadoc-plugin + 2.9.1 + + + maven-resources-plugin + 2.6 + + + maven-site-plugin + 3.3 + + + maven-source-plugin + 2.2.1 + + + + + + diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BenchmarkUtils.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BenchmarkUtils.java new file mode 100644 index 0000000000000000000000000000000000000000..e5bb75192c70c402c3be30a326eb5e793e69de89 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BenchmarkUtils.java @@ -0,0 +1,31 @@ +package com.huawei.vectorblas; + +import java.util.Random; + +public class BenchmarkUtils { + private static final Random rand = new Random(0); + + public static double randomDouble() { + return rand.nextDouble(); + } + + public static double[] randomDoubleArray(int n) { + double[] res = new double[n]; + for (int i = 0; i < n; i++) { + res[i] = rand.nextDouble(); + } + return res; + } + + public static float randomFloat() { + return rand.nextFloat(); + } + + public static float[] randomFloatArray(int n) { + float[] res = new float[n]; + for (int i = 0; i < n; i++) { + res[i] = rand.nextFloat(); + } + return res; + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BlasBenchmark.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BlasBenchmark.java new file mode 100644 index 0000000000000000000000000000000000000000..4f991c3641b11cb7de6fcf2b0a6adfccf2687bb2 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/BlasBenchmark.java @@ -0,0 +1,22 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. + */ + +package com.huawei.vectorblas; + +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; + +import java.util.concurrent.TimeUnit; + +@BenchmarkMode(Mode.Throughput) +@OutputTimeUnit(TimeUnit.SECONDS) +@State(Scope.Thread) +@Fork(value = 1, jvmArgsAppend = {"--add-modules=jdk.incubator.vector"}) +public class BlasBenchmark { + protected BLAS vBlas = new VectorBLAS(); +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/DdotTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/DdotTest.java new file mode 100644 index 0000000000000000000000000000000000000000..6443913e3c327de1c3942ab8595566788222fd38 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/DdotTest.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. + */ + +package com.huawei.vectorblas.l1; + +import com.huawei.vectorblas.BenchmarkUtils; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + +public class DdotTest extends L1Benchmark { + @Param({"100", "1000", "10000", "100000", "1000000", "10000000", "100000000"}) + public int n; + public double[] x; + public double[] y; + + @Setup(Level.Trial) + public void setup() { + x = BenchmarkUtils.randomDoubleArray(n); + y = BenchmarkUtils.randomDoubleArray(n); + } + + @Benchmark + public void vecBlasDdot(Blackhole bh) { + bh.consume(vBlas.ddot(n, x, 0, 1, y, 0, 1)); + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/L1Benchmark.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/L1Benchmark.java new file mode 100644 index 0000000000000000000000000000000000000000..dd51b7ca64afd1e8dde78821dbf1dbf9fc3d3147 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/L1Benchmark.java @@ -0,0 +1,10 @@ +package com.huawei.vectorblas.l1; + +import com.huawei.vectorblas.BlasBenchmark; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Warmup; + +@Warmup(iterations = 3, time = 3) +@Measurement(iterations = 6, time = 3) +public class L1Benchmark extends BlasBenchmark { +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/SdotTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/SdotTest.java new file mode 100644 index 0000000000000000000000000000000000000000..598d339c9a14bd90d6938e83fb332c12329f3e98 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l1/SdotTest.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. + */ + +package com.huawei.vectorblas.l1; + +import com.huawei.vectorblas.BenchmarkUtils; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + + +public class SdotTest extends L1Benchmark { + @Param({"100", "1000", "10000", "100000", "1000000", "10000000", "100000000"}) + public int n; + public float[] x; + public float[] y; + + @Setup(Level.Trial) + public void setup() { + x = BenchmarkUtils.randomFloatArray(n); + y = BenchmarkUtils.randomFloatArray(n); + } + + @Benchmark + public void vecBlasSdot(Blackhole bh) { + bh.consume(vBlas.sdot(n, x, 0, 1, y, 0, 1)); + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/DgemvTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/DgemvTest.java new file mode 100644 index 0000000000000000000000000000000000000000..6b3ff8693b8b396f5a624c379881a90ef753c9ec --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/DgemvTest.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. + */ + +package com.huawei.vectorblas.l2; + +import com.huawei.vectorblas.BenchmarkUtils; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + +public class DgemvTest extends L2Benchmark { + @Param({"N", "T"}) + public String trans; + + @Param({"500", "4000", "10000"}) + public int m; + public int n; + + public double alpha; + public double[] a; + public double[] x; + public double beta; + public double[] y, yclone; + + @Setup(Level.Trial) + public void setup() { + n = m; + alpha = BenchmarkUtils.randomDouble(); + a = BenchmarkUtils.randomDoubleArray(m * n); + x = BenchmarkUtils.randomDoubleArray(trans.equals("T") ? m : n); + beta = BenchmarkUtils.randomDouble(); + y = BenchmarkUtils.randomDoubleArray(trans.equals("T") ? n : m); + } + + @Benchmark + public void vecBlasDgemv(Blackhole bh) { + vBlas.dgemv(trans, m, n, alpha, a, 0, m, x, 0, 1, beta, yclone = y.clone(), 0, 1); + bh.consume(yclone); + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/L2Benchmark.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/L2Benchmark.java new file mode 100644 index 0000000000000000000000000000000000000000..f3eadd9e73b62dfcd5b0ed05e4baee1de3cbfb9e --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/L2Benchmark.java @@ -0,0 +1,10 @@ +package com.huawei.vectorblas.l2; + +import com.huawei.vectorblas.BlasBenchmark; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Warmup; + +@Warmup(iterations = 3) +@Measurement(iterations = 6, time = 10) +public class L2Benchmark extends BlasBenchmark { +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/SgemvTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/SgemvTest.java new file mode 100644 index 0000000000000000000000000000000000000000..00a678be2066814f9ccceb2328918d15b5834936 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l2/SgemvTest.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. + */ + +package com.huawei.vectorblas.l2; + +import com.huawei.vectorblas.BenchmarkUtils; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + +public class SgemvTest extends L2Benchmark { + @Param({"N", "T"}) + public String trans; + + @Param({"500", "4000", "10000"}) + public int m; + public int n; + + public float alpha; + public float[] a; + public float[] x; + public float beta; + public float[] y, yclone; + + @Setup(Level.Trial) + public void setup() { + n = m; + alpha = BenchmarkUtils.randomFloat(); + a = BenchmarkUtils.randomFloatArray(m * n); + x = BenchmarkUtils.randomFloatArray(trans.equals("T") ? m : n); + beta = BenchmarkUtils.randomFloat(); + y = BenchmarkUtils.randomFloatArray(trans.equals("T") ? n : m); + } + + @Benchmark + public void vecBlasSgemv(Blackhole bh) { + vBlas.sgemv(trans, m, n, alpha, a, 0, m, x, 0, 1, beta, yclone = y.clone(), 0, 1); + bh.consume(yclone); + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/DgemmTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/DgemmTest.java new file mode 100644 index 0000000000000000000000000000000000000000..ef5fc3fc497a9a5a291ab36d6e5b12ef2a517508 --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/DgemmTest.java @@ -0,0 +1,43 @@ +package com.huawei.vectorblas.l3; + +import com.huawei.vectorblas.BenchmarkUtils; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + +public class DgemmTest extends L3Benchmark { + @Param({"N", "T"}) + public String transa; + @Param({"N", "T"}) + public String transb; + + public int m; + public int n; + @Param({"1000", "2000", "3000"}) + public int k; + + public double alpha; + public double[] a; + public double[] b; + public double beta; + public double[] c, cclone; + + @Setup(Level.Trial) + public void setup() { + m = k; + n = k; + alpha = BenchmarkUtils.randomDouble(); + a = BenchmarkUtils.randomDoubleArray(k * m); + b = BenchmarkUtils.randomDoubleArray(k * n); + beta = BenchmarkUtils.randomDouble(); + c = BenchmarkUtils.randomDoubleArray(m * n); + } + + @Benchmark + public void vecBlasDgemm(Blackhole bh) { + vBlas.dgemm(transa, transb, m, n, k, alpha, a, 0, transa.equals("N") ? m : k, b, 0, transb.equals("N") ? k : n, beta, cclone = c.clone(), 0, m); + bh.consume(cclone); + } +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/L3Benchmark.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/L3Benchmark.java new file mode 100644 index 0000000000000000000000000000000000000000..3eeb8a5bae4071d041404a09893781ef7b4e2f3f --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/L3Benchmark.java @@ -0,0 +1,12 @@ +package com.huawei.vectorblas.l3; + +import com.huawei.vectorblas.BlasBenchmark; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Warmup; + +@Warmup(iterations = 3, time = 10) +@Measurement(iterations = 3, time = 20) +@Fork(value = 1, jvmArgsAppend = {"--add-modules=jdk.incubator.vector"}) +public class L3Benchmark extends BlasBenchmark { +} diff --git a/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/SgemmTest.java b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/SgemmTest.java new file mode 100644 index 0000000000000000000000000000000000000000..a278be797ece0fdb591723dba590d4c376b4b58e --- /dev/null +++ b/vectorBlas-benchmark/src/main/java/com/huawei/vectorblas/l3/SgemmTest.java @@ -0,0 +1,43 @@ +package com.huawei.vectorblas.l3; + +import com.huawei.vectorblas.BenchmarkUtils; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.infra.Blackhole; + +public class SgemmTest extends L3Benchmark { + @Param({"N", "T"}) + public String transa; + @Param({"N", "T"}) + public String transb; + + @Param({"1000", "2000", "3000"}) + public int m; + public int n; + public int k; + + public float alpha; + public float[] a; + public float[] b; + public float beta; + public float[] c, cclone; + + @Setup(Level.Trial) + public void setup() { + n = m; + k = m; + alpha = BenchmarkUtils.randomFloat(); + a = BenchmarkUtils.randomFloatArray(k * m); + b = BenchmarkUtils.randomFloatArray(k * n); + beta = BenchmarkUtils.randomFloat(); + c = BenchmarkUtils.randomFloatArray(m * n); + } + + @Benchmark + public void vecBlasSgemm(Blackhole bh) { + vBlas.sgemm(transa, transb, m, n, k, alpha, a, 0, transa.equals("N") ? m : k, b, 0, transb.equals("N") ? k : n, beta, cclone = c.clone(), 0, m); + bh.consume(cclone); + } +}