This is an automated email from the ASF dual-hosted git repository. east pushed a commit to branch nvmlogging in repository https://gitbox.apache.org/repos/asf/incubator-iotdb.git
commit 5e9c2f31537958f2acd1f3735118094b7f0d8659 Author: mdf369 <[email protected]> AuthorDate: Thu Jan 16 16:19:54 2020 +0800 sort nvm in mem --- .../db/nvm/memtable/NVMPrimitiveMemTable.java | 4 + .../nvm/recover/NVMMemtableRecoverPerformer.java | 4 + .../apache/iotdb/db/nvm/space/NVMDataSpace.java | 6 +- .../db/utils/datastructure/AbstractTVList.java | 30 +++++-- .../iotdb/db/utils/datastructure/BinaryTVList.java | 10 +++ .../db/utils/datastructure/BooleanTVList.java | 10 +++ .../iotdb/db/utils/datastructure/DoubleTVList.java | 10 +++ .../iotdb/db/utils/datastructure/FloatTVList.java | 23 ++++++ .../iotdb/db/utils/datastructure/IntTVList.java | 10 +++ .../iotdb/db/utils/datastructure/LongTVList.java | 10 +++ .../db/utils/datastructure/NVMBinaryTVList.java | 92 ++++++++++++++------- .../db/utils/datastructure/NVMBooleanTVList.java | 94 ++++++++++++++------- .../db/utils/datastructure/NVMDoubleTVList.java | 92 ++++++++++++++------- .../db/utils/datastructure/NVMFloatTVList.java | 92 ++++++++++++++------- .../iotdb/db/utils/datastructure/NVMIntTVList.java | 90 +++++++++++++------- .../db/utils/datastructure/NVMLongTVList.java | 92 ++++++++++++++------- .../iotdb/db/utils/datastructure/NVMTVList.java | 95 ++++++++++++++++++++++ .../iotdb/db/utils/datastructure/TVList.java | 5 ++ 18 files changed, 584 insertions(+), 185 deletions(-) diff --git a/server/src/main/java/org/apache/iotdb/db/nvm/memtable/NVMPrimitiveMemTable.java b/server/src/main/java/org/apache/iotdb/db/nvm/memtable/NVMPrimitiveMemTable.java index c58f7bb..175e2ab 100644 --- a/server/src/main/java/org/apache/iotdb/db/nvm/memtable/NVMPrimitiveMemTable.java +++ b/server/src/main/java/org/apache/iotdb/db/nvm/memtable/NVMPrimitiveMemTable.java @@ -71,6 +71,10 @@ public class NVMPrimitiveMemTable extends AbstractMemTable { } public void loadData(Map<String, Map<String, Pair<List<NVMDataSpace>, List<NVMDataSpace>>>> dataMap) { + if (dataMap == null) { + return; + } + for (Entry<String, Map<String, Pair<List<NVMDataSpace>, List<NVMDataSpace>>>> deviceDataEntry : dataMap .entrySet()) { String deviceId = deviceDataEntry.getKey(); diff --git a/server/src/main/java/org/apache/iotdb/db/nvm/recover/NVMMemtableRecoverPerformer.java b/server/src/main/java/org/apache/iotdb/db/nvm/recover/NVMMemtableRecoverPerformer.java index 8829f9f..bbb3cd5 100644 --- a/server/src/main/java/org/apache/iotdb/db/nvm/recover/NVMMemtableRecoverPerformer.java +++ b/server/src/main/java/org/apache/iotdb/db/nvm/recover/NVMMemtableRecoverPerformer.java @@ -68,6 +68,10 @@ public class NVMMemtableRecoverPerformer { public void reconstructMemtable(NVMPrimitiveMemTable memTable, TsFileResource tsFileResource) { String sgId = memTable.getStorageGroupId(); Map<String, Map<String, Pair<List<NVMDataSpace>, List<NVMDataSpace>>>> dataOfSG = dataMap.remove(sgId); + if (dataOfSG == null) { + return; + } + memTable.loadData(dataOfSG); Map<String, Long>[] maps = getMinMaxTimeMapFromData(dataOfSG); diff --git a/server/src/main/java/org/apache/iotdb/db/nvm/space/NVMDataSpace.java b/server/src/main/java/org/apache/iotdb/db/nvm/space/NVMDataSpace.java index d515593..06be125 100644 --- a/server/src/main/java/org/apache/iotdb/db/nvm/space/NVMDataSpace.java +++ b/server/src/main/java/org/apache/iotdb/db/nvm/space/NVMDataSpace.java @@ -10,12 +10,14 @@ public class NVMDataSpace extends NVMSpace { private int index; private TSDataType dataType; private int unitSize; + private int unitNum; NVMDataSpace(long offset, long size, ByteBuffer byteBuffer, int index, TSDataType dataType, boolean refresh) { super(offset, size, byteBuffer); this.index = index; this.dataType = dataType; unitSize = NVMSpaceManager.getPrimitiveTypeByteSize(dataType); + unitNum = (int) (size / unitSize); if (refresh) { refreshData(); @@ -23,7 +25,7 @@ public class NVMDataSpace extends NVMSpace { } public int getUnitNum() { - return (int) (size / unitSize); + return unitNum; } private void refreshData() { @@ -35,7 +37,7 @@ public class NVMDataSpace extends NVMSpace { public int getValidUnitNum() { // TODO only for time int count = 0; - while (true) { + while (count < unitNum) { long v = (long) getData(count); if (v == INVALID_VALUE) { break; diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/AbstractTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/AbstractTVList.java index 9f6a8c9..5e96455 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/AbstractTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/AbstractTVList.java @@ -177,13 +177,13 @@ public abstract class AbstractTVList { } // Find end of run, and reverse range if descending - if (getTime(runHi++) < getTime(lo)) { // Descending - while (runHi < hi && getTime(runHi) < getTime(runHi - 1)) { + if (getTimeForSort(runHi++) < getTimeForSort(lo)) { // Descending + while (runHi < hi && getTimeForSort(runHi) < getTimeForSort(runHi - 1)) { runHi++; } reverseRange(lo, runHi); } else { // Ascending - while (runHi < hi && getTime(runHi) >= getTime(runHi - 1)) { + while (runHi < hi && getTimeForSort(runHi) >= getTimeForSort(runHi - 1)) { runHi++; } } @@ -191,6 +191,10 @@ public abstract class AbstractTVList { return runHi - lo; } + protected abstract long getTimeForSort(int index); + + protected abstract void setForSort(int index, long timestamp, Object value); + /** * this field is effective only in the Tvlist in a RealOnlyMemChunk. * @return @@ -203,9 +207,9 @@ public abstract class AbstractTVList { this.timeOffset = timeOffset; } - protected int compare(int idx1, int idx2) { - long t1 = getTime(idx1); - long t2 = getTime(idx2); + protected int compareForSort(int idx1, int idx2) { + long t1 = getTimeForSort(idx1); + long t2 = getTimeForSort(idx2); return Long.compare(t1, t2); } @@ -235,7 +239,7 @@ public abstract class AbstractTVList { */ while (left < right) { int mid = (left + right) >>> 1; - if (compare(start, mid) < 0) { + if (compareForSort(start, mid) < 0) { right = mid; } else { left = mid + 1; @@ -252,7 +256,7 @@ public abstract class AbstractTVList { */ int n = start - left; // The number of elements to move for (int i = n; i >= 1; i--) { - set(left + i - 1, left + i); + setForSort(left + i - 1, left + i); } setPivotTo(left); } @@ -261,6 +265,14 @@ public abstract class AbstractTVList { } } + private void setForSort(int src, int dest) { + long srcT = getTimeForSort(src); + Object srcV = getValueForSort(src); + setForSort(dest, srcT, srcV); + } + + protected abstract Object getValueForSort(int index); + protected void merge(int lo, int mid, int hi) { // end of sorting buffer int tmpIdx = 0; @@ -272,7 +284,7 @@ public abstract class AbstractTVList { // copy the minimum elements to sorting buffer until one sequence is exhausted int endSide = 0; while (endSide == 0) { - if (compare(leftIdx, rightIdx) <= 0) { + if (compareForSort(leftIdx, rightIdx) <= 0) { setToSorted(leftIdx, lo + tmpIdx); tmpIdx ++; leftIdx ++; diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BinaryTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BinaryTVList.java index 821d5c2..6fd265f 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BinaryTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BinaryTVList.java @@ -214,4 +214,14 @@ public class BinaryTVList extends TVList { void addBatchValue(Binary[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getBinary(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (Binary) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BooleanTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BooleanTVList.java index 9b00d7e..0eb92a6 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BooleanTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/BooleanTVList.java @@ -213,4 +213,14 @@ public class BooleanTVList extends TVList { void addBatchValue(boolean[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getBoolean(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (boolean) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/DoubleTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/DoubleTVList.java index 1ef56c4..a3ada8f 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/DoubleTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/DoubleTVList.java @@ -213,4 +213,14 @@ public class DoubleTVList extends TVList { void addBatchValue(double[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getDouble(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (double) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/FloatTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/FloatTVList.java index 867c1b0..578fc13 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/FloatTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/FloatTVList.java @@ -22,6 +22,7 @@ import static org.apache.iotdb.db.rescon.PrimitiveArrayPool.ARRAY_SIZE; import java.util.ArrayList; import java.util.List; +import org.apache.iotdb.db.nvm.PerfMonitor; import org.apache.iotdb.db.rescon.PrimitiveArrayPool; import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType; @@ -90,6 +91,7 @@ public class FloatTVList extends TVList { @Override public void sort() { + long time = System.currentTimeMillis(); if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); @@ -98,9 +100,20 @@ public class FloatTVList extends TVList { sortedValues = (float[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.FLOAT, size); } + System.out.println("init arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-initarr", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); sort(0, size); + System.out.println("sort:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-sort", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); clearSortedValue(); clearSortedTime(); + System.out.println("clear arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-cleararr", System.currentTimeMillis() - time); + sorted = true; } @@ -213,4 +226,14 @@ public class FloatTVList extends TVList { void addBatchValue(float[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getFloat(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (float) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/IntTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/IntTVList.java index 79a9ccc..61ebeae 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/IntTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/IntTVList.java @@ -213,4 +213,14 @@ public class IntTVList extends TVList { void addBatchValue(int[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getInt(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (int) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/LongTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/LongTVList.java index 5c25416..f9d84d5 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/LongTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/LongTVList.java @@ -213,4 +213,14 @@ public class LongTVList extends TVList { void addBatchValue(long[] batch) { values.add(batch); } + + @Override + protected Object getValueForSort(int index) { + return getLong(index); + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + set(index, timestamp, (long) value); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBinaryTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBinaryTVList.java index 75cb3b0..a5b270e 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBinaryTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBinaryTVList.java @@ -11,8 +11,7 @@ public class NVMBinaryTVList extends NVMTVList { // TODO private Binary[][] sortedValues; - - private Binary pivotValue; + private Binary[][] tempValuesForSort; NVMBinaryTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -54,19 +53,56 @@ public class NVMBinaryTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (Binary[][]) PrimitiveArrayPool .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (Binary[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + Binary value = (Binary) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + Binary value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -77,11 +113,18 @@ public class NVMBinaryTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (Binary[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -92,35 +135,26 @@ public class NVMBinaryTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getBinary(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (Binary) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - Binary loV = getBinary(lo); - long hiT = getTime(hi); - Binary hiV = getBinary(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getBinary(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (Binary) getValueForSort(src); } - + @Override public void putBinaries(long[] time, Binary[] value) { checkExpansion(); diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBooleanTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBooleanTVList.java index 2a4ca8e..3c8a8e7 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBooleanTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMBooleanTVList.java @@ -10,8 +10,7 @@ public class NVMBooleanTVList extends NVMTVList { // TODO private boolean[][] sortedValues; - - private boolean pivotValue; + private boolean[][] tempValuesForSort; NVMBooleanTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -53,19 +52,56 @@ public class NVMBooleanTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (boolean[][]) PrimitiveArrayPool - .getInstance().getDataListsByType(TSDataType.BOOLEAN, size); + .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (boolean[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + boolean value = (boolean) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + boolean value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -76,11 +112,18 @@ public class NVMBooleanTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (boolean[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -91,35 +134,26 @@ public class NVMBooleanTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getBoolean(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (boolean) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - boolean loV = getBoolean(lo); - long hiT = getTime(hi); - boolean hiV = getBoolean(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getBoolean(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (boolean) getValueForSort(src); } - + @Override public void putBooleans(long[] time, boolean[] value) { checkExpansion(); diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMDoubleTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMDoubleTVList.java index ac61d8e..0ebdc11 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMDoubleTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMDoubleTVList.java @@ -10,8 +10,7 @@ public class NVMDoubleTVList extends NVMTVList { // TODO private double[][] sortedValues; - - private double pivotValue; + private double[][] tempValuesForSort; NVMDoubleTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -53,19 +52,56 @@ public class NVMDoubleTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (double[][]) PrimitiveArrayPool - .getInstance().getDataListsByType(TSDataType.DOUBLE, size); + .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (double[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + double value = (double) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + double value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -76,11 +112,18 @@ public class NVMDoubleTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (double[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -91,33 +134,24 @@ public class NVMDoubleTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getDouble(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (double) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - double loV = getDouble(lo); - long hiT = getTime(hi); - double hiV = getDouble(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getDouble(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (double) getValueForSort(src); } @Override diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMFloatTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMFloatTVList.java index c200cfd..b9814e8 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMFloatTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMFloatTVList.java @@ -10,8 +10,7 @@ public class NVMFloatTVList extends NVMTVList { // TODO private float[][] sortedValues; - - private float pivotValue; + private float[][] tempValuesForSort; NVMFloatTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -53,19 +52,56 @@ public class NVMFloatTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (float[][]) PrimitiveArrayPool - .getInstance().getDataListsByType(TSDataType.FLOAT, size); + .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (float[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + float value = (float) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + float value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -76,11 +112,18 @@ public class NVMFloatTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (float[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -91,33 +134,24 @@ public class NVMFloatTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getFloat(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (float) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - float loV = getFloat(lo); - long hiT = getTime(hi); - float hiV = getFloat(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getFloat(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (float) getValueForSort(src); } @Override diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMIntTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMIntTVList.java index bbcf381..5ff1403 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMIntTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMIntTVList.java @@ -10,8 +10,7 @@ public class NVMIntTVList extends NVMTVList { // TODO private int[][] sortedValues; - - private int pivotValue; + private int[][] tempValuesForSort; public NVMIntTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -53,19 +52,56 @@ public class NVMIntTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (int[][]) PrimitiveArrayPool .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (int[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + int value = (int) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + int value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -76,11 +112,18 @@ public class NVMIntTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (int[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -91,33 +134,24 @@ public class NVMIntTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getInt(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (int) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - int loV = getInt(lo); - long hiT = getTime(hi); - int hiV = getInt(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getInt(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (int) getValueForSort(src); } @Override diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMLongTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMLongTVList.java index 4cffd35..956880f 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMLongTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMLongTVList.java @@ -10,8 +10,7 @@ public class NVMLongTVList extends NVMTVList { // TODO private long[][] sortedValues; - - private long pivotValue; + private long[][] tempValuesForSort; NVMLongTVList(String sgId, String deviceId, String measurementId) { super(sgId, deviceId, measurementId); @@ -53,19 +52,56 @@ public class NVMLongTVList extends NVMTVList { } @Override - public void sort() { + protected void initTempArrays() { if (sortedTimestamps == null || sortedTimestamps.length < size) { sortedTimestamps = (long[][]) PrimitiveArrayPool .getInstance().getDataListsByType(TSDataType.INT64, size); + tempTimestampsForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(TSDataType.INT64, size); } if (sortedValues == null || sortedValues.length < size) { sortedValues = (long[][]) PrimitiveArrayPool - .getInstance().getDataListsByType(TSDataType.INT64, size); + .getInstance().getDataListsByType(dataType, size); + tempValuesForSort = (long[][]) PrimitiveArrayPool + .getInstance().getDataListsByType(dataType, size); + } + } + + @Override + protected void copyTVToTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = (long) timestamps.get(arrayIndex).getData(elementIndex); + long value = (long) values.get(arrayIndex).getData(elementIndex); + tempTimestampsForSort[arrayIndex][elementIndex] = time; + tempValuesForSort[arrayIndex][elementIndex] = value; + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } + } + } + + @Override + protected void copyTVFromTempArrays() { + int arrayIndex = 0; + int elementIndex = 0; + for (int i = 0; i < size; i++) { + long time = tempTimestampsForSort[arrayIndex][elementIndex]; + long value = tempValuesForSort[arrayIndex][elementIndex]; + + timestamps.get(arrayIndex).setData(elementIndex, time); + values.get(arrayIndex).setData(elementIndex, value); + + elementIndex++; + if (elementIndex == ARRAY_SIZE) { + elementIndex = 0; + arrayIndex++; + } } - sort(0, size); - clearSortedValue(); - clearSortedTime(); - sorted = true; } @Override @@ -76,11 +112,18 @@ public class NVMLongTVList extends NVMTVList { } sortedValues = null; } + + if (tempValuesForSort != null) { + for (long[] dataArray : tempValuesForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempValuesForSort = null; + } } @Override protected void setFromSorted(int src, int dest) { - set(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); + setForSort(dest, sortedTimestamps[src/ARRAY_SIZE][src%ARRAY_SIZE], sortedValues[src/ARRAY_SIZE][src%ARRAY_SIZE]); } @Override @@ -91,33 +134,24 @@ public class NVMLongTVList extends NVMTVList { } @Override - protected void setToSorted(int src, int dest) { - sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTime(src); - sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = getLong(src); + protected void setValueForSort(int arrayIndex, int elementIndex, Object value) { + tempValuesForSort[arrayIndex][elementIndex] = (long) value; } @Override - protected void reverseRange(int lo, int hi) { - hi--; - while (lo < hi) { - long loT = getTime(lo); - long loV = getLong(lo); - long hiT = getTime(hi); - long hiV = getLong(hi); - set(lo++, hiT, hiV); - set(hi--, loT, loV); + protected Object getValueForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempValuesForSort[arrayIndex][elementIndex]; } @Override - protected void saveAsPivot(int pos) { - pivotTime = getTime(pos); - pivotValue = getLong(pos); - } - - @Override - protected void setPivotTo(int pos) { - set(pos, pivotTime, pivotValue); + protected void setToSorted(int src, int dest) { + sortedTimestamps[dest/ARRAY_SIZE][dest% ARRAY_SIZE] = getTimeForSort(src); + sortedValues[dest/ARRAY_SIZE][dest%ARRAY_SIZE] = (long) getValueForSort(src); } @Override diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMTVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMTVList.java index 4570d66..613f860 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMTVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/NVMTVList.java @@ -4,6 +4,7 @@ import static org.apache.iotdb.db.nvm.rescon.NVMPrimitiveArrayPool.ARRAY_SIZE; import java.util.ArrayList; import java.util.List; +import org.apache.iotdb.db.nvm.PerfMonitor; import org.apache.iotdb.db.nvm.rescon.NVMPrimitiveArrayPool; import org.apache.iotdb.db.nvm.space.NVMDataSpace; import org.apache.iotdb.db.nvm.space.NVMSpaceMetadataManager; @@ -19,6 +20,9 @@ public abstract class NVMTVList extends AbstractTVList { protected List<NVMDataSpace> values; protected TSDataType dataType; + protected long[][] tempTimestampsForSort; + protected Object pivotValue; + public NVMTVList(String sgId, String deviceId, String measurementId) { this.sgId = sgId; this.deviceId = deviceId; @@ -149,6 +153,13 @@ public abstract class NVMTVList extends AbstractTVList { } sortedTimestamps = null; } + + if (tempTimestampsForSort != null) { + for (long[] dataArray : tempTimestampsForSort) { + PrimitiveArrayPool.getInstance().release(dataArray); + } + tempTimestampsForSort = null; + } } @Override @@ -220,4 +231,88 @@ public abstract class NVMTVList extends AbstractTVList { // sorted sorted = false; } + + @Override + public void sort() { + long time = System.currentTimeMillis(); + initTempArrays(); +// System.out.println("init arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-initarr", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); + copyTVToTempArrays(); +// System.out.println("copy to arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-copytoarr", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); + sort(0, size); +// System.out.println("sort:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-sort", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); + copyTVFromTempArrays(); +// System.out.println("copy from arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-copyfromarr", System.currentTimeMillis() - time); + + time = System.currentTimeMillis(); + clearSortedValue(); + clearSortedTime(); +// System.out.println("clear arr:" + (System.currentTimeMillis() - time)); + PerfMonitor.add("sort-cleararr", System.currentTimeMillis() - time); + + sorted = true; + } + + protected abstract void initTempArrays(); + + protected abstract void copyTVToTempArrays(); + + protected abstract void copyTVFromTempArrays(); + + @Override + protected void reverseRange(int lo, int hi) { + hi--; + while (lo < hi) { + long loT = getTimeForSort(lo); + Object loV = getValueForSort(lo); + long hiT = getTimeForSort(hi); + Object hiV = getValueForSort(hi); + setForSort(lo++, hiT, hiV); + setForSort(hi--, loT, loV); + } + } + + @Override + protected long getTimeForSort(int index) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); + } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + return tempTimestampsForSort[arrayIndex][elementIndex]; + } + + @Override + protected void setForSort(int index, long timestamp, Object value) { + if (index >= size) { + throw new ArrayIndexOutOfBoundsException(index); + } + int arrayIndex = index / ARRAY_SIZE; + int elementIndex = index % ARRAY_SIZE; + tempTimestampsForSort[arrayIndex][elementIndex] = timestamp; + setValueForSort(arrayIndex, elementIndex, value); + } + + protected abstract void setValueForSort(int arrayIndex, int elementIndex, Object value); + + @Override + protected void saveAsPivot(int pos) { + pivotTime = getTimeForSort(pos); + pivotValue = getValueForSort(pos); + } + + @Override + protected void setPivotTo(int pos) { + setForSort(pos, pivotTime, pivotValue); + } } diff --git a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/TVList.java b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/TVList.java index f241562..a189e24 100644 --- a/server/src/main/java/org/apache/iotdb/db/utils/datastructure/TVList.java +++ b/server/src/main/java/org/apache/iotdb/db/utils/datastructure/TVList.java @@ -48,6 +48,11 @@ public abstract class TVList extends AbstractTVList { } @Override + protected long getTimeForSort(int index) { + return getTime(index); + } + + @Override protected void releaseLastTimeArray() { PrimitiveArrayPool.getInstance().release(timestamps.remove(timestamps.size() - 1)); }
