Commit 30052454 authored by Eric Bruneton's avatar Eric Bruneton

Improve the read-write performance test by using the JMH framework.

Results:
AdapterBenchmark.getClassInfo_asm4_0                      thrpt   20  12964,540 ± 100,411  ops/s
AdapterBenchmark.getClassInfo_asm5_0                      thrpt   20  12410,599 ±  64,511  ops/s
AdapterBenchmark.getClassInfo_asm6_0                      thrpt   20  12538,801 ±  67,891  ops/s
AdapterBenchmark.getClassInfo_asm6_1                      thrpt   20  15744,919 ±  54,819  ops/s
AdapterBenchmark.getClassObjectModel_asm4_0               thrpt   20    536,993 ±   2,805  ops/s
AdapterBenchmark.getClassObjectModel_asm5_0               thrpt   20    539,811 ±   2,934  ops/s
AdapterBenchmark.getClassObjectModel_asm6_0               thrpt   20    529,741 ±   1,942  ops/s
AdapterBenchmark.getClassObjectModel_asm6_1               thrpt   20    553,037 ±   3,225  ops/s
AdapterBenchmark.readAndWriteWithComputeFrames_asm4_0     thrpt   20    167,452 ±   0,664  ops/s
AdapterBenchmark.readAndWriteWithComputeFrames_asm5_0     thrpt   20    164,215 ±   0,689  ops/s
AdapterBenchmark.readAndWriteWithComputeFrames_asm6_0     thrpt   20    165,821 ±   0,688  ops/s
AdapterBenchmark.readAndWriteWithComputeFrames_asm6_1     thrpt   20    174,736 ±   0,673  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_asm4_0       thrpt   20    301,145 ±   1,328  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_asm5_0       thrpt   20    303,352 ±   1,269  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_asm6_0       thrpt   20    317,626 ±   1,079  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_asm6_1       thrpt   20    321,737 ±   1,544  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_aspectJBcel  thrpt   20     82,308 ±   0,389  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_bcel         thrpt   20     65,963 ±   0,261  ops/s
AdapterBenchmark.readAndWriteWithComputeMaxs_serp         thrpt   20     33,711 ±   0,090  ops/s
AdapterBenchmark.readAndWriteWithCopyPool_asm4_0          thrpt   20   1144,297 ±   4,976  ops/s
AdapterBenchmark.readAndWriteWithCopyPool_asm5_0          thrpt   20   1142,265 ±   5,866  ops/s
AdapterBenchmark.readAndWriteWithCopyPool_asm6_0          thrpt   20   1128,241 ±   5,340  ops/s
AdapterBenchmark.readAndWriteWithCopyPool_asm6_1          thrpt   20   1235,521 ±   4,344  ops/s
AdapterBenchmark.readAndWriteWithObjectModel_asm4_0       thrpt   20    252,227 ±   1,036  ops/s
AdapterBenchmark.readAndWriteWithObjectModel_asm5_0       thrpt   20    248,238 ±   1,110  ops/s
AdapterBenchmark.readAndWriteWithObjectModel_asm6_0       thrpt   20    246,449 ±   1,103  ops/s
AdapterBenchmark.readAndWriteWithObjectModel_asm6_1       thrpt   20    261,525 ±   1,003  ops/s
AdapterBenchmark.readAndWrite_asm4_0                      thrpt   20    313,583 ±   1,429  ops/s
AdapterBenchmark.readAndWrite_asm5_0                      thrpt   20    319,958 ±   2,057  ops/s
AdapterBenchmark.readAndWrite_asm6_0                      thrpt   20    316,718 ±   1,316  ops/s
AdapterBenchmark.readAndWrite_asm6_1                      thrpt   20    319,508 ±   0,990  ops/s
AdapterBenchmark.readAndWrite_aspectJBcel                 thrpt   20    100,253 ±   0,353  ops/s
AdapterBenchmark.readAndWrite_bcel                        thrpt   20     79,329 ±   0,235  ops/s
AdapterBenchmark.readAndWrite_javassist                   thrpt   20    531,673 ±   1,894  ops/s
AdapterBenchmark.readAndWrite_serp                        thrpt   20     37,049 ±   0,102  ops/s
AdapterBenchmark.read_asm4_0                              thrpt   20    642,491 ±   2,536  ops/s
AdapterBenchmark.read_asm5_0                              thrpt   20    682,731 ±   5,122  ops/s
AdapterBenchmark.read_asm6_0                              thrpt   20    671,490 ±   3,581  ops/s
AdapterBenchmark.read_asm6_1                              thrpt   20    665,407 ±   2,716  ops/s
parent b5e6dc44
Pipeline #536 passed with stage
in 10 minutes and 23 seconds
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package org.objectweb.asm.benchmarks;
/**
* An empty class adapter, which reads and writes Java classes with no intermediate transformation.
*
* @author Eric Bruneton
*/
public abstract class Adapter {
/** The access flags, name, super class and interfaces of a class. */
public static class ClassInfo {
int access;
String name;
String superClass;
String[] interfaces;
public ClassInfo(
final int access, final String name, final String superClass, final String[] interfaces) {
this.access = access;
this.name = name;
this.superClass = superClass;
this.interfaces = interfaces;
}
}
/** @return the version of this class adapter */
public String getVersion() {
return null;
}
/**
* @param classFile a JVMS ClassFile structure
* @return access flags, name, super class and interfaces of the given class.
*/
public ClassInfo getClassInfo(final byte[] classFile) {
throw new UnsupportedOperationException();
}
/**
* Returns an in-memory, object representation of the given class.
*
* @param classFile a JVMS ClassFile structure
* @return an in-memory, object representation of the given class.
*/
public Object getClassObjectModel(final byte[] classFile) {
throw new UnsupportedOperationException();
}
/**
* Reads a class and returns the number of 'elements' it contains.
*
* @param classFile a JVMS ClassFile structure
* @return the number of 'elements' found in the given class.
*/
public int read(final byte[] classFile) {
throw new UnsupportedOperationException();
}
/**
* Reads a class and writes and returns an equivalent one.
*
* @param classFile a JVMS ClassFile structure
* @param computeMaxs whether to recompute the maximum stack size and maximum number of local
* variables for each method.
* @return the rebuilt class.
*/
public byte[] readAndWrite(final byte[] classFile, final boolean computeMaxs) {
throw new UnsupportedOperationException();
}
/**
* Reads a class and writes and returns an equivalent one with all its stack map frames
* recomputed.
*
* @param classFile a JVMS ClassFile structure
* @return the rebuilt class.
*/
public byte[] readAndWriteWithComputeFrames(final byte[] classFile) {
throw new UnsupportedOperationException();
}
/**
* Reads a class and writes and returns an equivalent one, sharing the same constant pool.
*
* @param classFile a JVMS ClassFile structure
* @return the rebuilt class.
*/
public byte[] readAndWriteWithCopyPool(final byte[] classFile) {
throw new UnsupportedOperationException();
}
/**
* Reads a class and writes and returns an equivalent one, via the construction of in-memory,
* object representation of the class.
*
* @param classFile a JVMS ClassFile structure
* @return the rebuilt class.
*/
public byte[] readAndWriteWithObjectModel(final byte[] classFile) {
throw new UnsupportedOperationException();
}
}
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package org.objectweb.asm.benchmarks;
import java.io.ByteArrayInputStream;
import org.aspectj.apache.bcel.classfile.ClassParser;
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.classfile.JavaClass;
import org.aspectj.apache.bcel.classfile.Method;
import org.aspectj.apache.bcel.generic.ClassGen;
import org.aspectj.apache.bcel.generic.InstructionHandle;
import org.aspectj.apache.bcel.generic.InstructionList;
import org.aspectj.apache.bcel.generic.MethodGen;
/**
* An {@link Adapter} implemented with the AspectJ BCEL library.
*
* @author Eric Bruneton
*/
public class AspectJBCELAdapter extends Adapter {
@Override
public byte[] readAndWrite(final byte[] classFile, final boolean computeMaxs) {
JavaClass javaClass;
try {
javaClass = new ClassParser(new ByteArrayInputStream(classFile), "class-name").parse();
} catch (Exception e) {
throw new IllegalArgumentException();
Please register or sign in to reply
}
ClassGen classGen = new ClassGen(javaClass);
ConstantPool constantPool = classGen.getConstantPool();
Method[] methods = classGen.getMethods();
for (int i = 0; i < methods.length; ++i) {
Please register or sign in to reply
MethodGen methodGen = new MethodGen(methods[i], classGen.getClassName(), constantPool);
if (methods[i].getLocalVariableTable() == null) {
methodGen.removeLocalVariables();
}
if (methods[i].getLineNumberTable() == null) {
methodGen.removeLineNumbers();
}
InstructionList insnList = methodGen.getInstructionList();
if (insnList != null) {
InstructionHandle insnHandle = insnList.getStart();
while (insnHandle != null) {
insnHandle = insnHandle.getNext();
}
if (computeMaxs) {
methodGen.setMaxStack();
methodGen.setMaxLocals();
}
}
classGen.replaceMethod(methods[i], methodGen.getMethod());
}
return classGen.getJavaClass().getBytes();
}
}
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package org.objectweb.asm.benchmarks;
import java.io.ByteArrayInputStream;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.MethodGen;
/**
* An {@link Adapter} implemented with the BCEL library.
*
* @author Eric Bruneton
*/
public class BCELAdapter extends Adapter {
@Override
public byte[] readAndWrite(final byte[] classFile, final boolean computeMaxs) {
JavaClass javaClass;
try {
javaClass = new ClassParser(new ByteArrayInputStream(classFile), "class-name").parse();
} catch (Exception e) {
throw new IllegalArgumentException();
Please register or sign in to reply
}
ClassGen classGen = new ClassGen(javaClass);
ConstantPoolGen constantPoolGen = classGen.getConstantPool();
Method[] methods = classGen.getMethods();
for (int i = 0; i < methods.length; ++i) {
Please register or sign in to reply
MethodGen methodGen = new MethodGen(methods[i], classGen.getClassName(), constantPoolGen);
if (methods[i].getLocalVariableTable() == null) {
methodGen.removeLocalVariables();
}
if (methods[i].getLineNumberTable() == null) {
methodGen.removeLineNumbers();
}
InstructionList insnList = methodGen.getInstructionList();
if (insnList != null) {
InstructionHandle insnHandle = insnList.getStart();
while (insnHandle != null) {
insnHandle = insnHandle.getNext();
}
if (computeMaxs) {
methodGen.setMaxStack();
methodGen.setMaxLocals();
}
}
classGen.replaceMethod(methods[i], methodGen.getMethod());
}
return classGen.getJavaClass().getBytes();
}
}
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package org.objectweb.asm.benchmarks;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import javassist.ClassPool;
import javassist.CtClass;
/**
* An {@link Adapter} implemented with the Javassist library.
*
* @author Eric Bruneton
*/
public class JavassistAdapter extends Adapter {
@Override
public byte[] readAndWrite(final byte[] classFile, final boolean computeMax) {
try {
CtClass ctClass = new ClassPool().makeClass(new ByteArrayInputStream(classFile));
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);
ctClass.getClassFile().write(dataOutputStream);
dataOutputStream.close();
return byteArrayOutputStream.toByteArray();
} catch (Exception e) {
throw new IllegalArgumentException();
Please register or sign in to reply
}
}
}
// ASM: a very small and fast Java bytecode manipulation framework
// Copyright (c) 2000-2011 INRIA, France Telecom
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holders nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
package org.objectweb.asm.benchmarks;
import java.io.ByteArrayInputStream;
import serp.bytecode.BCClass;
import serp.bytecode.BCMethod;
import serp.bytecode.Code;
import serp.bytecode.Project;
/**
* An {@link Adapter} implemented with the SERP library.
*
* @author Eric Bruneton
*/
public class SERPAdapter extends Adapter {
@Override
public byte[] readAndWrite(final byte[] classFile, final boolean computeMaxs) {
BCClass bcClass = new Project().loadClass(new ByteArrayInputStream(classFile));
bcClass.getDeclaredFields();
BCMethod[] bcMethods = bcClass.getDeclaredMethods();
for (int i = 0; i < bcMethods.length; ++i) {
Please register or sign in to reply
Code code = bcMethods[i].getCode(false);
if (code != null) {
while (code.hasNext()) {
code.next();
}
if (computeMaxs) {
code.calculateMaxStack();
code.calculateMaxLocals();
}
}
}
return bcClass.toByteArray();
}
}
......@@ -27,12 +27,13 @@
// THE POSSIBILITY OF SUCH DAMAGE.
buildscript {
repositories { mavenCentral() }
dependencies { classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.1' }
repositories { mavenCentral() }
dependencies { classpath 'org.junit.platform:junit-platform-gradle-plugin:1.0.1' }
}
plugins { id 'biz.aQute.bnd.builder' version '3.3.0' apply false }
plugins { id 'com.github.sherter.google-java-format' version '0.6' apply false }
plugins { id 'me.champeau.gradle.jmh' version '0.4.4' apply false }
plugins { id 'org.sonarqube' version '2.6' apply false }
description = 'ASM, a very small and fast Java bytecode manipulation framework'
......@@ -118,14 +119,25 @@ project(':benchmarks:memory') {
project(':benchmarks:read-write') {
description = "Read-Write benchmark for ${rootProject.description}"
requires = [':asm', ':asm-analysis', ':asm-commons', ':asm-tree']
apply plugin: 'me.champeau.gradle.jmh'
dependencies { jmh project(':asm'), project(':asm-tree') }
depends = [
'net.sourceforge.serp:serp:1.15.1',
'org.apache.bcel:bcel:6.0',
'org.aspectj:aspectjweaver:1.8.10',
'org.javassist:javassist:3.21.0-GA'
]
runWith = ['org.objectweb.asm.ALLPerfTest']
['4.0', '5.0.1', '6.0'].each { version ->
configurations.create("asm${version}")
dependencies.add("asm${version}", "org.ow2.asm:asm:${version}@jar")
dependencies.add("asm${version}", "org.ow2.asm:asm-tree:${version}@jar")
task "asm${version}"(type: Copy) {
from configurations."asm${version}".collect { zipTree(it) }
into "${buildDir}/asm${version}"
}
classes.dependsOn "asm${version}"
}
jmh { fork = 1; warmupIterations = 5; iterations = 20 }
}
project(':benchmarks:write') {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment