dmsolr edited a comment on issue #3064: To improve DataCarrier URL: https://github.com/apache/skywalking/issues/3064#issuecomment-511273975 1. The max capacity is 40k with default initial capacity. It showed that the ArrayList seem like better in ops. And the reused ListedList is better at GC. ```java @Benchmark public void testReusedArray() { List<SampleData> consumerList = new ArrayList<SampleData>(); 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<SampleData> consumerList = new LinkedList<SampleData>(); for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } } } @Benchmark public void testReusedLinked() { List<SampleData> consumerList = new LinkedList<SampleData>(); for (int times=0; times<1000; times++) { for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } consumerList.clear(); } } ``` Result: ``` Benchmark Mode Cnt Score Error Units LinkedArrayBenchmark.testReusedArray thrpt 5 4.099 ± 0.254 ops/s LinkedArrayBenchmark.testReusedArray:·gc.alloc.rate thrpt 5 3577.493 ± 218.971 MB/sec LinkedArrayBenchmark.testReusedArray:·gc.alloc.rate.norm thrpt 5 960569530.436 ± 0.529 B/op LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Eden_Space thrpt 5 3579.288 ± 227.314 MB/sec LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Eden_Space.norm thrpt 5 961045357.161 ± 7069943.693 B/op LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Survivor_Space thrpt 5 2.369 ± 0.343 MB/sec LinkedArrayBenchmark.testReusedArray:·gc.churn.PS_Survivor_Space.norm thrpt 5 636105.700 ± 95920.377 B/op LinkedArrayBenchmark.testReusedArray:·gc.count thrpt 5 1133.000 counts LinkedArrayBenchmark.testReusedArray:·gc.time thrpt 5 3254.000 ms LinkedArrayBenchmark.testReusedLinked thrpt 5 1.578 ± 0.068 ops/s LinkedArrayBenchmark.testReusedLinked:·gc.alloc.rate thrpt 5 2753.590 ± 112.877 MB/sec LinkedArrayBenchmark.testReusedLinked:·gc.alloc.rate.norm thrpt 5 1920000059.000 ± 0.001 B/op LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Eden_Space thrpt 5 2752.897 ± 113.153 MB/sec LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Eden_Space.norm thrpt 5 1919516672.000 ± 713769.991 B/op LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Survivor_Space thrpt 5 6.904 ± 0.680 MB/sec LinkedArrayBenchmark.testReusedLinked:·gc.churn.PS_Survivor_Space.norm thrpt 5 4813619.200 ± 404066.441 B/op LinkedArrayBenchmark.testReusedLinked:·gc.count thrpt 5 885.000 counts LinkedArrayBenchmark.testReusedLinked:·gc.time thrpt 5 2996.000 ms LinkedArrayBenchmark.testLinked thrpt 5 2.489 ± 0.077 ops/s LinkedArrayBenchmark.testLinked:·gc.alloc.rate thrpt 5 4346.145 ± 145.163 MB/sec LinkedArrayBenchmark.testLinked:·gc.alloc.rate.norm thrpt 5 1920000016.881 ± 1.402 B/op LinkedArrayBenchmark.testLinked:·gc.churn.PS_Eden_Space thrpt 5 4347.414 ± 163.445 MB/sec LinkedArrayBenchmark.testLinked:·gc.churn.PS_Eden_Space.norm thrpt 5 1920547279.983 ± 12167953.775 B/op LinkedArrayBenchmark.testLinked:·gc.churn.PS_Survivor_Space thrpt 5 10.691 ± 1.312 MB/sec LinkedArrayBenchmark.testLinked:·gc.churn.PS_Survivor_Space.norm thrpt 5 4722251.934 ± 452198.476 B/op LinkedArrayBenchmark.testLinked:·gc.count thrpt 5 1417.000 counts LinkedArrayBenchmark.testLinked:·gc.time thrpt 5 4794.000 ms ``` 2. This part tests default capacity and the max size of List is 1000. ```java @Benchmark public void testArrayCap1000() { ArrayList<SampleData> list = new ArrayList<SampleData>(); for (int i=0; i<1000; i++) { list.add(new SampleData()); } } @Benchmark public void testLinkedCap1000() { LinkedList<SampleData> list = new LinkedList<SampleData>(); for (int i=0; i<1000; i++) { list.add(new SampleData()); } } ``` Result: ```java Benchmark Mode Cnt Score Error Units LinkedArrayBenchmark.testArrayCap1000 thrpt 5 176522.532 ± 4448.276 ops/s LinkedArrayBenchmark.testArrayCap1000:·gc.alloc.rate thrpt 5 6252.366 ± 157.348 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 6252.940 ± 161.485 MB/sec LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Eden_Space.norm thrpt 5 39003.545 ± 51.090 B/op LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Survivor_Space thrpt 5 0.803 ± 0.219 MB/sec LinkedArrayBenchmark.testArrayCap1000:·gc.churn.PS_Survivor_Space.norm thrpt 5 5.007 ± 1.286 B/op LinkedArrayBenchmark.testArrayCap1000:·gc.count thrpt 5 1937.000 counts LinkedArrayBenchmark.testArrayCap1000:·gc.time thrpt 5 1473.000 ms LinkedArrayBenchmark.testLinkedCap1000 thrpt 5 101449.110 ± 7841.344 ops/s LinkedArrayBenchmark.testLinkedCap1000:·gc.alloc.rate thrpt 5 4422.601 ± 342.269 MB/sec LinkedArrayBenchmark.testLinkedCap1000:·gc.alloc.rate.norm thrpt 5 48000.000 ± 0.001 B/op LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Eden_Space thrpt 5 4425.733 ± 336.180 MB/sec LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Eden_Space.norm thrpt 5 48034.296 ± 229.819 B/op LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Survivor_Space thrpt 5 0.872 ± 0.304 MB/sec LinkedArrayBenchmark.testLinkedCap1000:·gc.churn.PS_Survivor_Space.norm thrpt 5 9.466 ± 3.005 B/op LinkedArrayBenchmark.testLinkedCap1000:·gc.count thrpt 5 1371.000 counts LinkedArrayBenchmark.testLinkedCap1000:·gc.time thrpt 5 997.000 ms ``` 3. This part tests default capacity and the max size of List is 40000. ```java @Benchmark public void testArrayCap40000() { ArrayList<SampleData> list = new ArrayList<SampleData>(); for (int i=0; i<40000; i++) { list.add(new SampleData()); } } @Benchmark public void testLinkedCap40000() { LinkedList<SampleData> list = new LinkedList<SampleData>(); for (int i=0; i<40000; i++) { list.add(new SampleData()); } } ``` Result: ``` Benchmark Mode Cnt Score Error Units LinkedArrayBenchmark.testArrayCap40000 thrpt 5 3367.247 ± 457.619 ops/s LinkedArrayBenchmark.testArrayCap40000:·gc.alloc.rate thrpt 5 4677.556 ± 635.732 MB/sec LinkedArrayBenchmark.testArrayCap40000:·gc.alloc.rate.norm thrpt 5 1529496.013 ± 0.002 B/op LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Eden_Space thrpt 5 4690.330 ± 655.901 MB/sec LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1533628.010 ± 7701.263 B/op LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Survivor_Space thrpt 5 6.110 ± 2.169 MB/sec LinkedArrayBenchmark.testArrayCap40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1995.479 ± 485.706 B/op LinkedArrayBenchmark.testArrayCap40000:·gc.count thrpt 5 1473.000 counts LinkedArrayBenchmark.testArrayCap40000:·gc.time thrpt 5 1641.000 ms LinkedArrayBenchmark.testLinkedCap40000 thrpt 5 2367.759 ± 121.662 ops/s LinkedArrayBenchmark.testLinkedCap40000:·gc.alloc.rate thrpt 5 4128.794 ± 211.930 MB/sec LinkedArrayBenchmark.testLinkedCap40000:·gc.alloc.rate.norm thrpt 5 1920000.018 ± 0.001 B/op LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Eden_Space thrpt 5 4127.384 ± 224.263 MB/sec LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1919330.567 ± 15068.179 B/op LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Survivor_Space thrpt 5 10.019 ± 0.828 MB/sec LinkedArrayBenchmark.testLinkedCap40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 4658.864 ± 272.178 B/op LinkedArrayBenchmark.testLinkedCap40000:·gc.count thrpt 5 1310.000 counts LinkedArrayBenchmark.testLinkedCap40000:·gc.time thrpt 5 4550.000 ms ``` 4. This part tests different initial capacity(1, 10, 8000, 40000). The max length is 40k. Here's a odd appearance. We can notice the initial capacity is 10(default value) will execute the most GC times and cost the most time. But its ops is better than others. (I have executed several times, the results almost are the same.) ```java @Benchmark public void testArrayStart1() { List<SampleData> consumerList = new ArrayList<SampleData>(1); for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } } @Benchmark public void testArrayStart10() { List<SampleData> consumerList = new ArrayList<SampleData>(10); for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } } @Benchmark public void testArrayStart8000() { List<SampleData> consumerList = new ArrayList<SampleData>(8000); for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } } @Benchmark public void testArrayStart40000() { List<SampleData> consumerList = new ArrayList<SampleData>(40000); for (int pos = 0; pos < 40000; pos++) { consumerList.add(new SampleData()); } } ``` Result: ``` LinkedArrayBenchmark.testArrayStart1 thrpt 5 3650.344 ± 430.214 ops/s LinkedArrayBenchmark.testArrayStart1:·gc.alloc.rate thrpt 5 4814.170 ± 567.231 MB/sec LinkedArrayBenchmark.testArrayStart1:·gc.alloc.rate.norm thrpt 5 1452104.012 ± 0.001 B/op LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Eden_Space thrpt 5 4825.797 ± 575.542 MB/sec LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Eden_Space.norm thrpt 5 1455598.022 ± 5557.754 B/op LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Survivor_Space thrpt 5 5.943 ± 1.387 MB/sec LinkedArrayBenchmark.testArrayStart1:·gc.churn.PS_Survivor_Space.norm thrpt 5 1792.091 ± 297.976 B/op LinkedArrayBenchmark.testArrayStart1:·gc.count thrpt 5 1513.000 counts LinkedArrayBenchmark.testArrayStart1:·gc.time thrpt 5 1637.000 ms LinkedArrayBenchmark.testArrayStart10 thrpt 5 4557.648 ± 121.325 ops/s LinkedArrayBenchmark.testArrayStart10:·gc.alloc.rate thrpt 5 6331.232 ± 168.013 MB/sec LinkedArrayBenchmark.testArrayStart10:·gc.alloc.rate.norm thrpt 5 1529496.010 ± 0.001 B/op LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Eden_Space thrpt 5 6347.599 ± 190.562 MB/sec LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Eden_Space.norm thrpt 5 1533442.650 ± 6747.452 B/op LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Survivor_Space thrpt 5 8.601 ± 1.989 MB/sec LinkedArrayBenchmark.testArrayStart10:·gc.churn.PS_Survivor_Space.norm thrpt 5 2078.243 ± 514.259 B/op LinkedArrayBenchmark.testArrayStart10:·gc.count thrpt 5 1992.000 counts LinkedArrayBenchmark.testArrayStart10:·gc.time thrpt 5 2371.000 ms LinkedArrayBenchmark.testArrayStart8000 thrpt 5 3822.186 ± 109.671 ops/s LinkedArrayBenchmark.testArrayStart8000:·gc.alloc.rate thrpt 5 4797.774 ± 138.117 MB/sec LinkedArrayBenchmark.testArrayStart8000:·gc.alloc.rate.norm thrpt 5 1382080.011 ± 0.001 B/op LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Eden_Space thrpt 5 4807.450 ± 140.827 MB/sec LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Eden_Space.norm thrpt 5 1384866.917 ± 5337.475 B/op LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Survivor_Space thrpt 5 4.457 ± 0.342 MB/sec LinkedArrayBenchmark.testArrayStart8000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1283.812 ± 64.992 B/op LinkedArrayBenchmark.testArrayStart8000:·gc.count thrpt 5 1507.000 counts LinkedArrayBenchmark.testArrayStart8000:·gc.time thrpt 5 1526.000 ms LinkedArrayBenchmark.testArrayStart40000 thrpt 5 4312.118 ± 37.028 ops/s LinkedArrayBenchmark.testArrayStart40000:·gc.alloc.rate thrpt 5 4386.398 ± 37.389 MB/sec LinkedArrayBenchmark.testArrayStart40000:·gc.alloc.rate.norm thrpt 5 1120016.010 ± 0.001 B/op LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Eden_Space thrpt 5 4390.996 ± 48.359 MB/sec LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Eden_Space.norm thrpt 5 1121190.745 ± 9368.223 B/op LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Survivor_Space thrpt 5 5.880 ± 0.514 MB/sec LinkedArrayBenchmark.testArrayStart40000:·gc.churn.PS_Survivor_Space.norm thrpt 5 1501.392 ± 143.043 B/op LinkedArrayBenchmark.testArrayStart40000:·gc.count thrpt 5 1378.000 counts LinkedArrayBenchmark.testArrayStart40000:·gc.time thrpt 5 1602.000 ms ```
---------------------------------------------------------------- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. For queries about this service, please contact Infrastructure at: [email protected] With regards, Apache Git Services
