From 8faa3564037570fca198ab9f70534f3d359a9d40 Mon Sep 17 00:00:00 2001 From: Daming Date: Wed, 17 Jul 2019 13:26:00 +0800 Subject: [PATCH] Using ArrayList to instead of LinkedList (#3093) * Using ArrayList to instead of LinkedList --- .../commons/datacarrier/buffer/Buffer.java | 14 +- .../datacarrier/consumer/ConsumerThread.java | 36 +- .../consumer/MultipleChannelsConsumer.java | 27 +- .../commons/datacarrier/DataCarrierTest.java | 25 +- .../datacarrier/LinkedArrayBenchmark.java | 320 ++++++++++++++++++ 5 files changed, 374 insertions(+), 48 deletions(-) create mode 100644 apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/LinkedArrayBenchmark.java diff --git a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/buffer/Buffer.java b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/buffer/Buffer.java index e0f17c3139..d86983236e 100644 --- a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/buffer/Buffer.java +++ b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/buffer/Buffer.java @@ -18,10 +18,12 @@ package org.apache.skywalking.apm.commons.datacarrier.buffer; -import java.util.*; import org.apache.skywalking.apm.commons.datacarrier.callback.QueueBlockingCallback; import org.apache.skywalking.apm.commons.datacarrier.common.AtomicRangeInteger; +import java.util.LinkedList; +import java.util.List; + /** * Created by wusheng on 2016/10/25. */ @@ -79,19 +81,17 @@ public class Buffer { return buffer.length; } - public LinkedList obtain() { - return this.obtain(0, buffer.length); + public void obtain(List consumeList) { + this.obtain(consumeList, 0, buffer.length); } - public LinkedList obtain(int start, int end) { - LinkedList result = new LinkedList(); + public void obtain(List consumeList, int start, int end) { for (int i = start; i < end; i++) { if (buffer[i] != null) { - result.add((T)buffer[i]); + consumeList.add((T)buffer[i]); buffer[i] = null; } } - return result; } } diff --git a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/ConsumerThread.java b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/ConsumerThread.java index 1e4d9c4cae..6a15c1c1b9 100644 --- a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/ConsumerThread.java +++ b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/ConsumerThread.java @@ -19,10 +19,11 @@ package org.apache.skywalking.apm.commons.datacarrier.consumer; -import java.util.LinkedList; -import java.util.List; import org.apache.skywalking.apm.commons.datacarrier.buffer.Buffer; +import java.util.ArrayList; +import java.util.List; + /** * Created by wusheng on 2016/10/25. */ @@ -36,7 +37,7 @@ public class ConsumerThread extends Thread { super(threadName); this.consumer = consumer; running = false; - dataSources = new LinkedList(); + dataSources = new ArrayList(1); this.consumeCycle = consumeCycle; } @@ -64,10 +65,9 @@ public class ConsumerThread extends Thread { public void run() { running = true; + final List consumeList = new ArrayList(1500); while (running) { - boolean hasData = consume(); - - if (!hasData) { + if (!consume(consumeList)) { try { Thread.sleep(consumeCycle); } catch (InterruptedException e) { @@ -77,31 +77,27 @@ public class ConsumerThread extends Thread { // consumer thread is going to stop // consume the last time - consume(); + consume(consumeList); consumer.onExit(); } - private boolean consume() { - boolean hasData = false; - LinkedList consumeList = new LinkedList(); + private boolean consume(List consumeList) { for (DataSource dataSource : dataSources) { - LinkedList data = dataSource.obtain(); - if (data.size() == 0) { - continue; - } - consumeList.addAll(data); - hasData = true; + dataSource.obtain(consumeList); } - if (consumeList.size() > 0) { + if (!consumeList.isEmpty()) { try { consumer.consume(consumeList); } catch (Throwable t) { consumer.onError(consumeList, t); + } finally { + consumeList.clear(); } + return true; } - return hasData; + return false; } void shutdown() { @@ -122,8 +118,8 @@ public class ConsumerThread extends Thread { this.end = end; } - LinkedList obtain() { - return sourceBuffer.obtain(start, end); + void obtain(List consumeList) { + sourceBuffer.obtain(consumeList, start, end); } } } diff --git a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/MultipleChannelsConsumer.java b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/MultipleChannelsConsumer.java index 1877446ff7..4963788f17 100644 --- a/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/MultipleChannelsConsumer.java +++ b/apm-commons/apm-datacarrier/src/main/java/org/apache/skywalking/apm/commons/datacarrier/consumer/MultipleChannelsConsumer.java @@ -18,8 +18,11 @@ package org.apache.skywalking.apm.commons.datacarrier.consumer; -import java.util.*; -import org.apache.skywalking.apm.commons.datacarrier.buffer.*; +import org.apache.skywalking.apm.commons.datacarrier.buffer.Buffer; +import org.apache.skywalking.apm.commons.datacarrier.buffer.Channels; + +import java.util.ArrayList; +import java.util.List; /** * MultipleChannelsConsumer represent a single consumer thread, but support multiple channels with their {@link @@ -43,10 +46,12 @@ public class MultipleChannelsConsumer extends Thread { public void run() { running = true; + final List consumeList = new ArrayList(2000); while (running) { boolean hasData = false; for (Group target : consumeTargets) { - hasData = hasData || consume(target); + boolean consume = consume(target, consumeList); + hasData = hasData || consume; } if (!hasData) { @@ -55,34 +60,34 @@ public class MultipleChannelsConsumer extends Thread { } catch (InterruptedException e) { } } - } // consumer thread is going to stop // consume the last time for (Group target : consumeTargets) { - consume(target); + consume(target, consumeList); target.consumer.onExit(); } } - private boolean consume(Group target) { - boolean hasData; - LinkedList consumeList = new LinkedList(); + private boolean consume(Group target, List consumeList) { for (int i = 0; i < target.channels.getChannelSize(); i++) { Buffer buffer = target.channels.getBuffer(i); - consumeList.addAll(buffer.obtain()); + buffer.obtain(consumeList); } - if (hasData = consumeList.size() > 0) { + if (!consumeList.isEmpty()) { try { target.consumer.consume(consumeList); } catch (Throwable t) { target.consumer.onError(consumeList, t); + } finally { + consumeList.clear(); } + return true; } - return hasData; + return false; } /** diff --git a/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/DataCarrierTest.java b/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/DataCarrierTest.java index 85d767ed39..845b726899 100644 --- a/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/DataCarrierTest.java +++ b/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/DataCarrierTest.java @@ -19,6 +19,7 @@ package org.apache.skywalking.apm.commons.datacarrier; +import java.util.ArrayList; import java.util.List; import org.apache.skywalking.apm.commons.datacarrier.buffer.Buffer; import org.apache.skywalking.apm.commons.datacarrier.buffer.BufferStrategy; @@ -65,13 +66,15 @@ public class DataCarrierTest { Channels channels = (Channels)(MemberModifier.field(DataCarrier.class, "channels").get(carrier)); Buffer buffer1 = channels.getBuffer(0); - List result1 = buffer1.obtain(0, 100); + + List result = new ArrayList(); + buffer1.obtain(result, 0, 100); + Assert.assertEquals(2, result.size()); Buffer buffer2 = channels.getBuffer(1); - List result2 = buffer2.obtain(0, 100); + buffer2.obtain(result, 0, 100); - Assert.assertEquals(2, result1.size()); - Assert.assertEquals(4, result1.size() + result2.size()); + Assert.assertEquals(4, result.size()); } @@ -86,11 +89,12 @@ public class DataCarrierTest { Channels channels = (Channels)(MemberModifier.field(DataCarrier.class, "channels").get(carrier)); Buffer buffer1 = channels.getBuffer(0); - List result1 = buffer1.obtain(0, 100); + List result = new ArrayList(); + buffer1.obtain(result, 0, 100); Buffer buffer2 = channels.getBuffer(1); - List result2 = buffer2.obtain(0, 100); - Assert.assertEquals(200, result1.size() + result2.size()); + buffer2.obtain(result, 0, 100); + Assert.assertEquals(200, result.size()); } @Test @@ -108,11 +112,12 @@ public class DataCarrierTest { Channels channels = (Channels)(MemberModifier.field(DataCarrier.class, "channels").get(carrier)); Buffer buffer1 = channels.getBuffer(0); - List result1 = buffer1.obtain(0, 100); + List result = new ArrayList(); + buffer1.obtain(result, 0, 100); Buffer buffer2 = channels.getBuffer(1); - List result2 = buffer2.obtain(0, 100); - Assert.assertEquals(200, result1.size() + result2.size()); + buffer2.obtain(result, 0, 100); + Assert.assertEquals(200, result.size()); } @Test diff --git a/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/LinkedArrayBenchmark.java b/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/LinkedArrayBenchmark.java new file mode 100644 index 0000000000..4df3a0f2ca --- /dev/null +++ b/apm-commons/apm-datacarrier/src/test/java/org/apache/skywalking/apm/commons/datacarrier/LinkedArrayBenchmark.java @@ -0,0 +1,320 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package org.apache.skywalking.apm.commons.datacarrier; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.profile.GCProfiler; +import org.openjdk.jmh.runner.Runner; +import org.openjdk.jmh.runner.RunnerException; +import org.openjdk.jmh.runner.options.Options; +import org.openjdk.jmh.runner.options.OptionsBuilder; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + +/** + * ISSUE-3064 + */ +@BenchmarkMode({Mode.Throughput}) +public class LinkedArrayBenchmark { + + @Benchmark + public void testArrayCap1000() { + ArrayList list = new ArrayList(); + for (int i = 0; i < 1000; i++) { + list.add(new SampleData()); + } + } + + @Benchmark + public void testLinkedCap1000() { + LinkedList list = new LinkedList(); + for (int i = 0; i < 1000; i++) { + list.add(new SampleData()); + } + } + + @Benchmark + public void testArrayCap40000() { + ArrayList list = new ArrayList(); + for (int i = 0; i < 40000; i++) { + list.add(new SampleData()); + } + } + + @Benchmark + public void testLinkedCap40000() { + LinkedList list = new LinkedList(); + for (int i = 0; i < 40000; i++) { + list.add(new SampleData()); + } + } + + @Benchmark + public void testArrayStart1() { + List consumerList = new ArrayList(1); + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + } + + @Benchmark + public void testArrayStart10() { + List consumerList = new ArrayList(10); + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + } + + @Benchmark + public void testArrayStart8000() { + List consumerList = new ArrayList(8000); + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + } + + @Benchmark + public void testArrayStart40000() { + List consumerList = new ArrayList(40000); + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + } + + @Benchmark + public void testReusedArray() { + List consumerList = new ArrayList(); + for (int times = 0; times < 1000; times++) { + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + consumerList.clear(); + } + } + + @Benchmark + public void testLinked() { + for (int times = 0; times < 1000; times++) { + List consumerList = new LinkedList(); + + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + } + } + + @Benchmark + public void testReusedLinked() { + List consumerList = new LinkedList(); + for (int times = 0; times < 1000; times++) { + + for (int pos = 0; pos < 40000; pos++) { + consumerList.add(new SampleData()); + } + consumerList.clear(); + } + } + + @Benchmark + public void testArrayList200K() { + ArrayList list = new ArrayList(4000); + for (int times = 0; times < 1000; times++) { + for (int pos = 0; pos < 200000; pos++) { + list.add(new SampleData()); + } + list.clear(); + } + } + + @Benchmark + public void testReusedLinked200K() { + LinkedList list = new LinkedList(); + for (int times = 0; times < 1000; times++) { + for (int pos = 0; pos < 200000; pos++) { + list.add(new SampleData()); + } + list.clear(); + } + } + + @Benchmark + public void testLinked200K() { + for (int times = 0; times < 1000; times++) { + LinkedList list = new LinkedList(); + for (int pos = 0; pos < 200000; pos++) { + list.add(new SampleData()); + } + } + } + + public static void main(String[] args) throws RunnerException { + Options opt = new OptionsBuilder() + .include(LinkedArrayBenchmark.class.getName()) + .addProfiler(GCProfiler.class) + .jvmArgsAppend("-Xmx512m", "-Xms512m") + .forks(1) + .build(); + new Runner(opt).run(); + } + /* + Environment: + + # JMH version: 1.21 + # VM version: JDK 1.8.0_121, Java HotSpot(TM) 64-Bit Server VM, 25.121-b13 + # VM invoker: C:\Program Files\Java\jdk1.8.0_121\jre\bin\java.exe + # VM options: -javaagent:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2017.2.1\lib\idea_rt.jar=51557:C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2017.2.1\bin -Dfile.encoding=UTF-8 -Xmx512m -Xms512m + # Warmup: 5 iterations, 10 s each + # Measurement: 5 iterations, 10 s each + # Timeout: 10 min per iteration + # Threads: 1 thread, will synchronize iterations + # Benchmark mode: Throughput, ops/time + + Benchmark Mode Cnt Score Error Units + LinkedArrayBenchmark.testArrayCap1000 thrpt 5 143087.182 ± 3142.078 ops/s + LinkedArrayBenchmark.testArrayCap1000:·gc.alloc.rate thrpt 5 5067.966 ± 111.247 MB/sec + LinkedArrayBenchmark.testArrayCap1000:·gc.alloc.rate.norm thrpt 5 39000.000 ± 0.001 B/op + LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Eden_Space thrpt 5 5067.921 ± 98.198 MB/sec + LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Eden_Space.norm thrpt 5 38999.800 ± 214.267 B/op + LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Survivor_Space thrpt 5 0.649 ± 0.200 MB/sec + LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Survivor_Space.norm thrpt 5 4.993 ± 1.620 B/op + LinkedArrayBenchmark.testArrayCap1000:·gc.count thrpt 5 1570.000 counts + LinkedArrayBenchmark.testArrayCap1000:·gc.time thrpt 5 701.000 ms + LinkedArrayBenchmark.testArrayCap40000 thrpt 5 3765.411 ± 194.475 ops/s + LinkedArrayBenchmark.testArrayCap40000:·gc.alloc.rate thrpt 5 5230.501 ± 270.947 MB/sec + LinkedArrayBenchmark.testArrayCap40000:·gc.alloc.rate.norm thrpt 5 1529496.011 ± 0.001 B/op + LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Eden_Space thrpt 5 5243.183 ± 272.428 MB/sec + LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1533203.926 ± 3832.510 B/op + LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Survivor_Space thrpt 5 6.820 ± 2.362 MB/sec + LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1994.409 ± 698.911 B/op + LinkedArrayBenchmark.testArrayCap40000:·gc.count thrpt 5 1646.000 counts + LinkedArrayBenchmark.testArrayCap40000:·gc.time thrpt 5 1280.000 ms + LinkedArrayBenchmark.testArrayList200K thrpt 5 0.664 ± 0.050 ops/s + LinkedArrayBenchmark.testArrayList200K:·gc.alloc.rate thrpt 5 2903.182 ± 210.494 MB/sec + LinkedArrayBenchmark.testArrayList200K:·gc.alloc.rate.norm thrpt 5 4802736157.714 ± 0.001 B/op + LinkedArrayBenchmark.testArrayList200K:·gc.churn.PS_Eden_Space thrpt 5 2901.983 ± 222.656 MB/sec + LinkedArrayBenchmark.testArrayList200K:·gc.churn.PS_Eden_Space.norm thrpt 5 4800680520.914 ± 39561672.824 B/op + LinkedArrayBenchmark.testArrayList200K:·gc.churn.PS_Survivor_Space thrpt 5 19.788 ± 2.228 MB/sec + LinkedArrayBenchmark.testArrayList200K:·gc.churn.PS_Survivor_Space.norm thrpt 5 32731369.371 ± 1782913.951 B/op + LinkedArrayBenchmark.testArrayList200K:·gc.count thrpt 5 1012.000 counts + LinkedArrayBenchmark.testArrayList200K:·gc.time thrpt 5 9026.000 ms + LinkedArrayBenchmark.testArrayStart1 thrpt 5 3036.206 ± 146.907 ops/s + LinkedArrayBenchmark.testArrayStart1:·gc.alloc.rate thrpt 5 4004.134 ± 193.620 MB/sec + LinkedArrayBenchmark.testArrayStart1:·gc.alloc.rate.norm thrpt 5 1452104.014 ± 0.002 B/op + LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Eden_Space thrpt 5 4010.593 ± 201.502 MB/sec + LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Eden_Space.norm thrpt 5 1454441.827 ± 12106.958 B/op + LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Survivor_Space thrpt 5 4.471 ± 1.039 MB/sec + LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Survivor_Space.norm thrpt 5 1621.402 ± 380.693 B/op + LinkedArrayBenchmark.testArrayStart1:·gc.count thrpt 5 1260.000 counts + LinkedArrayBenchmark.testArrayStart1:·gc.time thrpt 5 946.000 ms + LinkedArrayBenchmark.testArrayStart10 thrpt 5 3953.451 ± 124.425 ops/s + LinkedArrayBenchmark.testArrayStart10:·gc.alloc.rate thrpt 5 5491.766 ± 172.901 MB/sec + LinkedArrayBenchmark.testArrayStart10:·gc.alloc.rate.norm thrpt 5 1529496.011 ± 0.001 B/op + LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Eden_Space thrpt 5 5506.896 ± 179.841 MB/sec + LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Eden_Space.norm thrpt 5 1533707.327 ± 6558.467 B/op + LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Survivor_Space thrpt 5 7.319 ± 1.779 MB/sec + LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Survivor_Space.norm thrpt 5 2038.423 ± 504.768 B/op + LinkedArrayBenchmark.testArrayStart10:·gc.count thrpt 5 1728.000 counts + LinkedArrayBenchmark.testArrayStart10:·gc.time thrpt 5 1350.000 ms + LinkedArrayBenchmark.testArrayStart40000 thrpt 5 3445.048 ± 38.938 ops/s + LinkedArrayBenchmark.testArrayStart40000:·gc.alloc.rate thrpt 5 3504.290 ± 39.160 MB/sec + LinkedArrayBenchmark.testArrayStart40000:·gc.alloc.rate.norm thrpt 5 1120016.013 ± 0.001 B/op + LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Eden_Space thrpt 5 3506.791 ± 62.456 MB/sec + LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1120811.902 ± 10367.121 B/op + LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Survivor_Space thrpt 5 4.731 ± 0.275 MB/sec + LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1512.123 ± 91.484 B/op + LinkedArrayBenchmark.testArrayStart40000:·gc.count thrpt 5 1100.000 counts + LinkedArrayBenchmark.testArrayStart40000:·gc.time thrpt 5 805.000 ms + LinkedArrayBenchmark.testArrayStart8000 thrpt 5 2940.747 ± 32.257 ops/s + LinkedArrayBenchmark.testArrayStart8000:·gc.alloc.rate thrpt 5 3691.430 ± 39.870 MB/sec + LinkedArrayBenchmark.testArrayStart8000:·gc.alloc.rate.norm thrpt 5 1382080.015 ± 0.001 B/op + LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Eden_Space thrpt 5 3699.920 ± 46.996 MB/sec + LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Eden_Space.norm thrpt 5 1385258.364 ± 7458.176 B/op + LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Survivor_Space thrpt 5 3.228 ± 0.276 MB/sec + LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1208.384 ± 102.584 B/op + LinkedArrayBenchmark.testArrayStart8000:·gc.count thrpt 5 1160.000 counts + LinkedArrayBenchmark.testArrayStart8000:·gc.time thrpt 5 776.000 ms + LinkedArrayBenchmark.testLinked thrpt 5 2.145 ± 0.023 ops/s + LinkedArrayBenchmark.testLinked:·gc.alloc.rate thrpt 5 3744.537 ± 38.773 MB/sec + LinkedArrayBenchmark.testLinked:·gc.alloc.rate.norm thrpt 5 1920000019.636 ± 0.001 B/op + LinkedArrayBenchmark.testLinked:·gc.churn.PS_Eden_Space thrpt 5 3743.961 ± 36.688 MB/sec + LinkedArrayBenchmark.testLinked:·gc.churn.PS_Eden_Space.norm thrpt 5 1919709109.527 ± 17177042.598 B/op + LinkedArrayBenchmark.testLinked:·gc.churn.PS_Survivor_Space thrpt 5 9.470 ± 0.430 MB/sec + LinkedArrayBenchmark.testLinked:·gc.churn.PS_Survivor_Space.norm thrpt 5 4855621.818 ± 264728.918 B/op + LinkedArrayBenchmark.testLinked:·gc.count thrpt 5 1217.000 counts + LinkedArrayBenchmark.testLinked:·gc.time thrpt 5 3697.000 ms + LinkedArrayBenchmark.testLinked200K thrpt 5 0.340 ± 0.013 ops/s + LinkedArrayBenchmark.testLinked200K:·gc.alloc.rate thrpt 5 2989.665 ± 108.530 MB/sec + LinkedArrayBenchmark.testLinked200K:·gc.alloc.rate.norm thrpt 5 9600000108.000 ± 0.001 B/op + LinkedArrayBenchmark.testLinked200K:·gc.churn.PS_Eden_Space thrpt 5 2990.920 ± 116.103 MB/sec + LinkedArrayBenchmark.testLinked200K:·gc.churn.PS_Eden_Space.norm thrpt 5 9603986226.400 ± 39954550.430 B/op + LinkedArrayBenchmark.testLinked200K:·gc.churn.PS_Survivor_Space thrpt 5 32.536 ± 4.681 MB/sec + LinkedArrayBenchmark.testLinked200K:·gc.churn.PS_Survivor_Space.norm thrpt 5 104493875.200 ± 16889681.984 B/op + LinkedArrayBenchmark.testLinked200K:·gc.count thrpt 5 1235.000 counts + LinkedArrayBenchmark.testLinked200K:·gc.time thrpt 5 15644.000 ms + LinkedArrayBenchmark.testLinkedCap1000 thrpt 5 84999.730 ± 1164.113 ops/s + LinkedArrayBenchmark.testLinkedCap1000:·gc.alloc.rate thrpt 5 3705.698 ± 50.753 MB/sec + LinkedArrayBenchmark.testLinkedCap1000:·gc.alloc.rate.norm thrpt 5 48000.001 ± 0.001 B/op + LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Eden_Space thrpt 5 3705.991 ± 71.457 MB/sec + LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Eden_Space.norm thrpt 5 48003.617 ± 320.127 B/op + LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Survivor_Space thrpt 5 0.520 ± 0.154 MB/sec + LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Survivor_Space.norm thrpt 5 6.739 ± 2.066 B/op + LinkedArrayBenchmark.testLinkedCap1000:·gc.count thrpt 5 1148.000 counts + LinkedArrayBenchmark.testLinkedCap1000:·gc.time thrpt 5 515.000 ms + LinkedArrayBenchmark.testLinkedCap40000 thrpt 5 2001.889 ± 58.692 ops/s + LinkedArrayBenchmark.testLinkedCap40000:·gc.alloc.rate thrpt 5 3490.899 ± 102.356 MB/sec + LinkedArrayBenchmark.testLinkedCap40000:·gc.alloc.rate.norm thrpt 5 1920000.022 ± 0.001 B/op + LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Eden_Space thrpt 5 3491.448 ± 111.952 MB/sec + LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1920296.231 ± 15332.688 B/op + LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Survivor_Space thrpt 5 8.708 ± 0.925 MB/sec + LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 4788.927 ± 381.943 B/op + LinkedArrayBenchmark.testLinkedCap40000:·gc.count thrpt 5 1108.000 counts + LinkedArrayBenchmark.testLinkedCap40000:·gc.time thrpt 5 3444.000 ms + LinkedArrayBenchmark.testReusedArray thrpt 5 3.128 ± 0.254 ops/s + LinkedArrayBenchmark.testReusedArray:·gc.alloc.rate thrpt 5 2731.835 ± 222.486 MB/sec + LinkedArrayBenchmark.testReusedArray:·gc.alloc.rate.norm thrpt 5 960569533.505 ± 1.150 B/op + LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Eden_Space thrpt 5 2730.828 ± 245.487 MB/sec + LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Eden_Space.norm thrpt 5 960179747.003 ± 8148505.430 B/op + LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Survivor_Space thrpt 5 1.864 ± 0.329 MB/sec + LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Survivor_Space.norm thrpt 5 656036.904 ± 159198.847 B/op + LinkedArrayBenchmark.testReusedArray:·gc.count thrpt 5 875.000 counts + LinkedArrayBenchmark.testReusedArray:·gc.time thrpt 5 2103.000 ms + LinkedArrayBenchmark.testReusedLinked thrpt 5 1.574 ± 0.015 ops/s + LinkedArrayBenchmark.testReusedLinked:·gc.alloc.rate thrpt 5 2746.313 ± 25.513 MB/sec + LinkedArrayBenchmark.testReusedLinked:·gc.alloc.rate.norm thrpt 5 1920000059.800 ± 4.218 B/op + LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Eden_Space thrpt 5 2745.434 ± 25.184 MB/sec + LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Eden_Space.norm thrpt 5 1919385600.000 ± 836969.504 B/op + LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Survivor_Space thrpt 5 6.834 ± 0.638 MB/sec + LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Survivor_Space.norm thrpt 5 4777984.000 ± 456748.586 B/op + LinkedArrayBenchmark.testReusedLinked:·gc.count thrpt 5 886.000 counts + LinkedArrayBenchmark.testReusedLinked:·gc.time thrpt 5 3041.000 ms + LinkedArrayBenchmark.testReusedLinked200K thrpt 5 0.253 ± 0.009 ops/s + LinkedArrayBenchmark.testReusedLinked200K:·gc.alloc.rate thrpt 5 2226.639 ± 75.414 MB/sec + LinkedArrayBenchmark.testReusedLinked200K:·gc.alloc.rate.norm thrpt 5 9600000178.133 ± 18.369 B/op + LinkedArrayBenchmark.testReusedLinked200K:·gc.churn.PS_Eden_Space thrpt 5 2225.749 ± 77.891 MB/sec + LinkedArrayBenchmark.testReusedLinked200K:·gc.churn.PS_Eden_Space.norm thrpt 5 9596148100.800 ± 50593440.713 B/op + LinkedArrayBenchmark.testReusedLinked200K:·gc.churn.PS_Survivor_Space thrpt 5 22.781 ± 4.309 MB/sec + LinkedArrayBenchmark.testReusedLinked200K:·gc.churn.PS_Survivor_Space.norm thrpt 5 98238464.000 ± 19995139.006 B/op + LinkedArrayBenchmark.testReusedLinked200K:·gc.count thrpt 5 930.000 counts + LinkedArrayBenchmark.testReusedLinked200K:·gc.time thrpt 5 12241.000 ms + */ +} -- GitLab