[pinpoint-apm#12241] Apply Primitive Containers to optimize memory usage

Author: emeroad

commons-server/src/main/java/com/navercorp/pinpoint/common/server/scatter/OneByteFuzzyRowKeyFactory.java

@@ -1,6 +1,7 @@
 package com.navercorp.pinpoint.common.server.scatter;
 
 
+import com.google.common.primitives.Longs;
 import com.navercorp.pinpoint.common.server.util.pair.LongPair;
 import org.springframework.util.backoff.BackOffExecution;
 import org.springframework.util.backoff.ExponentialBackOff;
@@ -28,17 +29,9 @@ private long[] allocateSlot() {
                 break;
             }
         }
-        return toLongArray(backOffTimeList);
+        return Longs.toArray(backOffTimeList);
     }
 
-    private long[] toLongArray(List<Long> list) {
-        long[] buffer = new long[list.size()];
-        for (int i = 0; i < list.size(); i++) {
-            long time = list.get(i);
-            buffer[i] = time;
-        }
-        return buffer;
-    }
 
     @Override
     public Byte getKey(long timeStamp) {

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/array/DoubleArray.java

@@ -0,0 +1,36 @@
+package com.navercorp.pinpoint.common.server.util.array;
+
+import com.google.common.primitives.Doubles;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.RandomAccess;
+import java.util.function.ToDoubleFunction;
+
+public final class DoubleArray {
+
+    private DoubleArray() {
+    }
+
+    public static double[] newArray(int size, double defaultValue) {
+        double[] array = new double[size];
+        Arrays.fill(array, defaultValue);
+        return array;
+    }
+
+    public static <T> List<Double> asList(List<T> list, ToDoubleFunction<T> function) {
+        final int size = list.size();
+        final double[] values = new double[size];
+        if (list instanceof RandomAccess) {
+            for (int i = 0; i < size; i++) {
+                values[i] = function.applyAsDouble(list.get(i));
+            }
+        } else {
+            int i = 0;
+            for (T element : list) {
+                values[i++] = function.applyAsDouble(element);
+            }
+        }
+        return Doubles.asList(values);
+    }
+}

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/array/IntArray.java

@@ -0,0 +1,29 @@
+package com.navercorp.pinpoint.common.server.util.array;
+
+import com.google.common.primitives.Ints;
+
+import java.util.List;
+import java.util.RandomAccess;
+import java.util.function.ToIntFunction;
+
+public final class IntArray {
+
+    private IntArray() {
+    }
+
+    public static <T> List<Integer> asList(List<T> list, ToIntFunction<T> function) {
+        final int size = list.size();
+        final int[] values = new int[size];
+        if (list instanceof RandomAccess) {
+            for (int i = 0; i < size; i++) {
+                values[i] = function.applyAsInt(list.get(i));
+            }
+        } else {
+            int i = 0;
+            for (T element : list) {
+                values[i++] = function.applyAsInt(element);
+            }
+        }
+        return Ints.asList(values);
+    }
+}

commons-server/src/main/java/com/navercorp/pinpoint/common/server/util/array/LongArray.java

@@ -0,0 +1,30 @@
+package com.navercorp.pinpoint.common.server.util.array;
+
+import com.google.common.primitives.Longs;
+
+import java.util.List;
+import java.util.RandomAccess;
+import java.util.function.ToLongFunction;
+
+public final class LongArray {
+
+    private LongArray() {
+    }
+
+    public static <T> List<Long> asList(List<T> list, ToLongFunction<T> function) {
+        final int size = list.size();
+        final long[] values = new long[size];
+        if (list instanceof RandomAccess) {
+            for (int i = 0; i < size; i++) {
+                values[i] = function.applyAsLong(list.get(i));
+            }
+        } else {
+            int i = 0;
+            for (T element : list) {
+                values[i++] = function.applyAsLong(element);
+            }
+        }
+        return Longs.asList(values);
+    }
+
+}

commons-server/src/test/java/com/navercorp/pinpoint/common/server/util/array/DoubleArrayTest.java

@@ -0,0 +1,24 @@
+package com.navercorp.pinpoint.common.server.util.array;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class DoubleArrayTest {
+    @Test
+    void asDoubleList() {
+        DoubleRecord doubleRecord1 = new DoubleRecord(1.0);
+        DoubleRecord doubleRecord2 = new DoubleRecord(2.0);
+        DoubleRecord doubleRecord3 = new DoubleRecord(3.0);
+
+        List<DoubleRecord> records = List.of(doubleRecord1, doubleRecord2, doubleRecord3);
+        List<Double> doubleList = DoubleArray.asList(records, DoubleRecord::value);
+        assertThat(doubleList).containsExactly(1.0, 2.0, 3.0);
+    }
+
+    record DoubleRecord(double value) {
+    }
+
+}

commons-server/src/test/java/com/navercorp/pinpoint/common/server/util/array/LongArrayTest.java

@@ -0,0 +1,39 @@
+package com.navercorp.pinpoint.common.server.util.array;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LongArrayTest {
+
+    @Test
+    void asLongList() {
+        LongRecord longRecord1 = new LongRecord(1L);
+        LongRecord longRecord2 = new LongRecord(2L);
+        LongRecord longRecord3 = new LongRecord(3L);
+
+        List<LongRecord> records = List.of(longRecord1, longRecord2, longRecord3);
+        List<Long> longList = LongArray.asList(records, LongRecord::value);
+        assertThat(longList).containsExactly(1L, 2L, 3L);
+    }
+
+    record LongRecord(long value) {
+    }
+
+    @Test
+    void asLongList_linkedList() {
+        LongRecord longRecord2 = new LongRecord(2L);
+        LongRecord longRecord1 = new LongRecord(1L);
+        LongRecord longRecord3 = new LongRecord(3L);
+
+        List<LongRecord> records = new LinkedList<>();
+        records.add(longRecord1);
+        records.add(longRecord2);
+        records.add(longRecord3);
+        List<Long> longList = LongArray.asList(records, LongRecord::value);
+        assertThat(longList).containsExactly(1L, 2L, 3L);
+    }
+}

exceptiontrace/exceptiontrace-collector/src/main/java/com/navercorp/pinpoint/exceptiontrace/collector/mapper/StackTraceMapper.java

@@ -16,6 +16,7 @@
 package com.navercorp.pinpoint.exceptiontrace.collector.mapper;
 
 import com.navercorp.pinpoint.common.server.mapper.MapStructUtils;
+import com.navercorp.pinpoint.common.server.util.array.IntArray;
 import com.navercorp.pinpoint.exceptiontrace.common.model.StackTraceElementWrapper;
 import org.mapstruct.Qualifier;
 import org.springframework.stereotype.Component;
@@ -80,9 +81,7 @@ public List<String> stackTraceToFileNames(List<StackTraceElementWrapper> fileNam
 
     @StackTraceToLineNumbers
     public List<Integer> stackTraceToLineNumber(List<StackTraceElementWrapper> lineNumbers) {
-        return lineNumbers.stream()
-                .map(StackTraceElementWrapper::getLineNumber)
-                .collect(Collectors.toList());
+        return IntArray.asList(lineNumbers, StackTraceElementWrapper::getLineNumber);
     }
 
     @StackTraceToMethodNames

inspector-module/inspector-web/src/main/java/com/navercorp/pinpoint/inspector/web/definition/metric/AvgUsingIntervalPostProcessor.java

@@ -16,6 +16,7 @@
 
 package com.navercorp.pinpoint.inspector.web.definition.metric;
 
+import com.google.common.primitives.Doubles;
 import com.navercorp.pinpoint.inspector.web.model.InspectorMetricValue;
 import org.apache.commons.math3.util.Precision;
 import org.springframework.stereotype.Component;
@@ -54,17 +55,17 @@ public List<InspectorMetricValue> postProcess(List<InspectorMetricValue> metricV
 
     private void addTotalMetricValue(List<InspectorMetricValue> processedMetricValueList, int metricValueSize) {
 
-        List<Double> totalValueList = new ArrayList<>(metricValueSize);
+        double[] totalValueList = new double[metricValueSize];
         for (int i = 0; i < metricValueSize; i++) {
             double total = 0;
             for (InspectorMetricValue metricValue : processedMetricValueList) {
                 total += metricValue.getValueList().get(i);
             }
             total = Precision.round(total, NUM_DECIMAL_PLACES);
-            totalValueList.add(total);
+            totalValueList[i] = total;
         }
 
-        processedMetricValueList.add(new InspectorMetricValue("totalCount", Collections.emptyList(), "tooltip", "count", totalValueList));
+        processedMetricValueList.add(new InspectorMetricValue("totalCount", Collections.emptyList(), "tooltip", "count", Doubles.asList(totalValueList)));
     }
 
     private void calculateAvg(InspectorMetricValue collectInterval, List<InspectorMetricValue> metricCountList, List<InspectorMetricValue> processedMetricValueList) {
@@ -77,16 +78,16 @@ private void calculateAvg(InspectorMetricValue collectInterval, List<InspectorMe
     protected List<Double> calculateAvg(InspectorMetricValue collectInterval, InspectorMetricValue metricCount) {
         List<Double> valueList = metricCount.getValueList();
         List<Double> commitIntervalList = collectInterval.getValueList();
-        List<Double> avgList = new ArrayList<>(valueList.size());
+        double[] avgList = new double[valueList.size()];
         for (int i = 0; i < valueList.size(); i++) {
             if (commitIntervalList.get(i) < 0) {
-                avgList.add(i, -1.0);
+                avgList[i] = -1.0;
                 continue;
             }
-            avgList.add(calculateTps(valueList.get(i), commitIntervalList.get(i)));
+            avgList[i] = calculateTps(valueList.get(i), commitIntervalList.get(i));
         }
 
-        return avgList;
+        return Doubles.asList(avgList);
     }
 
     private double calculateTps(double count, double intervalMs) {

inspector-module/inspector-web/src/main/java/com/navercorp/pinpoint/inspector/web/definition/metric/PercentageScalePostProcessor.java

@@ -16,11 +16,11 @@
 
 package com.navercorp.pinpoint.inspector.web.definition.metric;
 
+import com.navercorp.pinpoint.common.server.util.array.DoubleArray;
 import com.navercorp.pinpoint.inspector.web.model.InspectorMetricValue;
 import com.navercorp.pinpoint.metric.common.util.DoubleUncollectedDataCreator;
 import org.springframework.stereotype.Component;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -45,9 +45,8 @@ public List<InspectorMetricValue> postProcess(List<InspectorMetricValue> metricV
     }
 
     private InspectorMetricValue processInspectorMetric(InspectorMetricValue inspectorMetric) {
-        List<Double> scaledValues = inspectorMetric.getValueList().stream()
-                .map(this::scaleToPercentage)
-                .collect(Collectors.toList());
+        List<Double> valueList = inspectorMetric.getValueList();
+        List<Double> scaledValues = DoubleArray.asList(valueList, this::scaleToPercentage);
 
         return new InspectorMetricValue(
                 inspectorMetric.getFieldName(),

inspector-module/inspector-web/src/main/java/com/navercorp/pinpoint/inspector/web/service/DefaultAgentStatService.java

@@ -16,6 +16,7 @@
 
 package com.navercorp.pinpoint.inspector.web.service;
 
+import com.navercorp.pinpoint.common.server.util.array.DoubleArray;
 import com.navercorp.pinpoint.common.server.util.timewindow.TimeWindow;
 import com.navercorp.pinpoint.inspector.web.dao.AgentStatDao;
 import com.navercorp.pinpoint.inspector.web.definition.AggregationFunction;
@@ -168,9 +169,7 @@ private InspectorMetricValue createInspectorMetricValue(TimeWindow timeWindow, F
         TimeSeriesBuilder<Double> builder = new TimeSeriesBuilder<>(timeWindow, uncollectedDataCreator);
         List<SystemMetricPoint<Double>> filledSystemMetricDataList = builder.build(postProcessedDataList);
 
-        List<Double> valueList = filledSystemMetricDataList.stream()
-                .map(SystemMetricPoint::getYVal)
-                .collect(Collectors.toList());
+        List<Double> valueList = DoubleArray.asList(filledSystemMetricDataList, SystemMetricPoint::getYVal);
 
         return new InspectorMetricValue(field.getFieldAlias(), field.getTags(), field.getChartType(), field.getUnit(), valueList);
     }