From fd429ff8795c4c07bd9b0dbaf1b517d827a5a56a Mon Sep 17 00:00:00 2001 From: Colin Alworth Date: Mon, 22 Jan 2024 11:24:20 -0600 Subject: [PATCH] Chunk pools should be easier to emulate in GWT (#5053) Several changes to simplify how Chunk pooling will work in the JS API: * close() calls of borrowed instances should return the instance to the pool consistently * Separate pool implementations from interface * Flattened method calls required to borrow/create a chunk Partial #188 --- .../chunk/ResettableBooleanChunk.java | 14 +- .../deephaven/chunk/ResettableByteChunk.java | 14 +- .../deephaven/chunk/ResettableCharChunk.java | 14 +- .../chunk/ResettableDoubleChunk.java | 14 +- .../deephaven/chunk/ResettableFloatChunk.java | 14 +- .../deephaven/chunk/ResettableIntChunk.java | 14 +- .../deephaven/chunk/ResettableLongChunk.java | 14 +- .../chunk/ResettableObjectChunk.java | 14 +- .../deephaven/chunk/ResettableShortChunk.java | 14 +- .../chunk/ResettableWritableBooleanChunk.java | 18 +- .../chunk/ResettableWritableByteChunk.java | 18 +- .../chunk/ResettableWritableCharChunk.java | 18 +- .../chunk/ResettableWritableDoubleChunk.java | 18 +- .../chunk/ResettableWritableFloatChunk.java | 18 +- .../chunk/ResettableWritableIntChunk.java | 18 +- .../chunk/ResettableWritableLongChunk.java | 18 +- .../chunk/ResettableWritableObjectChunk.java | 18 +- .../chunk/ResettableWritableShortChunk.java | 18 +- .../deephaven/chunk/WritableBooleanChunk.java | 9 +- .../io/deephaven/chunk/WritableByteChunk.java | 9 +- .../io/deephaven/chunk/WritableCharChunk.java | 9 +- .../deephaven/chunk/WritableDoubleChunk.java | 9 +- .../deephaven/chunk/WritableFloatChunk.java | 9 +- .../io/deephaven/chunk/WritableIntChunk.java | 9 +- .../io/deephaven/chunk/WritableLongChunk.java | 9 +- .../deephaven/chunk/WritableObjectChunk.java | 9 +- .../deephaven/chunk/WritableShortChunk.java | 9 +- .../chunk/util/pools/BooleanChunkPool.java | 138 +------ .../util/pools/BooleanChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/ByteChunkPool.java | 138 +------ .../chunk/util/pools/ByteChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/CharChunkPool.java | 138 +------ .../chunk/util/pools/CharChunkSoftPool.java | 148 ++++++++ .../chunk/util/pools/DoubleChunkPool.java | 138 +------ .../chunk/util/pools/DoubleChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/FloatChunkPool.java | 138 +------ .../chunk/util/pools/FloatChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/IntChunkPool.java | 138 +------ .../chunk/util/pools/IntChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/LongChunkPool.java | 138 +------ .../chunk/util/pools/LongChunkSoftPool.java | 153 ++++++++ .../chunk/util/pools/MultiChunkPool.java | 348 +++++++++++++++++- .../chunk/util/pools/ObjectChunkPool.java | 142 +------ .../chunk/util/pools/ObjectChunkSoftPool.java | 181 +++++++++ .../chunk/util/pools/ShortChunkPool.java | 138 +------ .../chunk/util/pools/ShortChunkSoftPool.java | 153 ++++++++ .../ReplicateSourcesAndChunks.java | 1 + 47 files changed, 2036 insertions(+), 1328 deletions(-) create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkSoftPool.java create mode 100644 engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkSoftPool.java diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableBooleanChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableBooleanChunk.java index 0da194ee0a7..4d2dca7261b 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableBooleanChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableBooleanChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for boolean data. */ -public final class ResettableBooleanChunk +public class ResettableBooleanChunk extends BooleanChunk implements ResettableReadOnlyChunk { public static ResettableBooleanChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getBooleanChunkPool().takeResettableBooleanChunk(); + return MultiChunkPool.forThisThread().takeResettableBooleanChunk(); } return new ResettableBooleanChunk<>(); } public static ResettableBooleanChunk makeResettableChunkForPool() { - return new ResettableBooleanChunk<>(); + return new ResettableBooleanChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableBooleanChunk(this); + } + }; } private ResettableBooleanChunk(boolean[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public BooleanChunk resetFromTypedArray(boolean[ @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getBooleanChunkPool().giveResettableBooleanChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableByteChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableByteChunk.java index 2ae6e1a387a..6f99ca72416 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableByteChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableByteChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for byte data. */ -public final class ResettableByteChunk +public class ResettableByteChunk extends ByteChunk implements ResettableReadOnlyChunk { public static ResettableByteChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getByteChunkPool().takeResettableByteChunk(); + return MultiChunkPool.forThisThread().takeResettableByteChunk(); } return new ResettableByteChunk<>(); } public static ResettableByteChunk makeResettableChunkForPool() { - return new ResettableByteChunk<>(); + return new ResettableByteChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableByteChunk(this); + } + }; } private ResettableByteChunk(byte[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public ByteChunk resetFromTypedArray(byte[] data @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getByteChunkPool().giveResettableByteChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableCharChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableCharChunk.java index 1ba9de63d04..f1cb81d3d5e 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableCharChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableCharChunk.java @@ -12,19 +12,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for char data. */ -public final class ResettableCharChunk +public class ResettableCharChunk extends CharChunk implements ResettableReadOnlyChunk { public static ResettableCharChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getCharChunkPool().takeResettableCharChunk(); + return MultiChunkPool.forThisThread().takeResettableCharChunk(); } return new ResettableCharChunk<>(); } public static ResettableCharChunk makeResettableChunkForPool() { - return new ResettableCharChunk<>(); + return new ResettableCharChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableCharChunk(this); + } + }; } private ResettableCharChunk(char[] data, int offset, int capacity) { @@ -79,8 +84,5 @@ public CharChunk resetFromTypedArray(char[] data @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getCharChunkPool().giveResettableCharChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableDoubleChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableDoubleChunk.java index 7e4a6d3913c..eb253a344f2 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableDoubleChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableDoubleChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for double data. */ -public final class ResettableDoubleChunk +public class ResettableDoubleChunk extends DoubleChunk implements ResettableReadOnlyChunk { public static ResettableDoubleChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getDoubleChunkPool().takeResettableDoubleChunk(); + return MultiChunkPool.forThisThread().takeResettableDoubleChunk(); } return new ResettableDoubleChunk<>(); } public static ResettableDoubleChunk makeResettableChunkForPool() { - return new ResettableDoubleChunk<>(); + return new ResettableDoubleChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableDoubleChunk(this); + } + }; } private ResettableDoubleChunk(double[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public DoubleChunk resetFromTypedArray(double[] @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getDoubleChunkPool().giveResettableDoubleChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableFloatChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableFloatChunk.java index 303d208299d..de710b7ac3a 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableFloatChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableFloatChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for float data. */ -public final class ResettableFloatChunk +public class ResettableFloatChunk extends FloatChunk implements ResettableReadOnlyChunk { public static ResettableFloatChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getFloatChunkPool().takeResettableFloatChunk(); + return MultiChunkPool.forThisThread().takeResettableFloatChunk(); } return new ResettableFloatChunk<>(); } public static ResettableFloatChunk makeResettableChunkForPool() { - return new ResettableFloatChunk<>(); + return new ResettableFloatChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableFloatChunk(this); + } + }; } private ResettableFloatChunk(float[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public FloatChunk resetFromTypedArray(float[] da @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getFloatChunkPool().giveResettableFloatChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableIntChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableIntChunk.java index 6635f5dc992..d01f56b7f0b 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableIntChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableIntChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for int data. */ -public final class ResettableIntChunk +public class ResettableIntChunk extends IntChunk implements ResettableReadOnlyChunk { public static ResettableIntChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getIntChunkPool().takeResettableIntChunk(); + return MultiChunkPool.forThisThread().takeResettableIntChunk(); } return new ResettableIntChunk<>(); } public static ResettableIntChunk makeResettableChunkForPool() { - return new ResettableIntChunk<>(); + return new ResettableIntChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableIntChunk(this); + } + }; } private ResettableIntChunk(int[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public IntChunk resetFromTypedArray(int[] data, @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getIntChunkPool().giveResettableIntChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableLongChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableLongChunk.java index 07bee328c7a..2c7761d2b6b 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableLongChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableLongChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for long data. */ -public final class ResettableLongChunk +public class ResettableLongChunk extends LongChunk implements ResettableReadOnlyChunk { public static ResettableLongChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getLongChunkPool().takeResettableLongChunk(); + return MultiChunkPool.forThisThread().takeResettableLongChunk(); } return new ResettableLongChunk<>(); } public static ResettableLongChunk makeResettableChunkForPool() { - return new ResettableLongChunk<>(); + return new ResettableLongChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableLongChunk(this); + } + }; } private ResettableLongChunk(long[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public LongChunk resetFromTypedArray(long[] data @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getLongChunkPool().giveResettableLongChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableObjectChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableObjectChunk.java index 906902909b9..23982b1cbd2 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableObjectChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableObjectChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for Object data. */ -public final class ResettableObjectChunk +public class ResettableObjectChunk extends ObjectChunk implements ResettableReadOnlyChunk { public static ResettableObjectChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getObjectChunkPool().takeResettableObjectChunk(); + return MultiChunkPool.forThisThread().takeResettableObjectChunk(); } return new ResettableObjectChunk<>(); } public static ResettableObjectChunk makeResettableChunkForPool() { - return new ResettableObjectChunk<>(); + return new ResettableObjectChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableObjectChunk(this); + } + }; } private ResettableObjectChunk(T[] data, int offset, int capacity) { @@ -87,8 +92,5 @@ public ObjectChunk resetFromTypedArray(T[] da @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getObjectChunkPool().giveResettableObjectChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableShortChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableShortChunk.java index db2e257c569..9924622d26f 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableShortChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableShortChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableReadOnlyChunk} implementation for short data. */ -public final class ResettableShortChunk +public class ResettableShortChunk extends ShortChunk implements ResettableReadOnlyChunk { public static ResettableShortChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getShortChunkPool().takeResettableShortChunk(); + return MultiChunkPool.forThisThread().takeResettableShortChunk(); } return new ResettableShortChunk<>(); } public static ResettableShortChunk makeResettableChunkForPool() { - return new ResettableShortChunk<>(); + return new ResettableShortChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableShortChunk(this); + } + }; } private ResettableShortChunk(short[] data, int offset, int capacity) { @@ -84,8 +89,5 @@ public ShortChunk resetFromTypedArray(short[] da @Override public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getShortChunkPool().giveResettableShortChunk(this); - } } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableBooleanChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableBooleanChunk.java index c6b8f29295c..df62be71ff2 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableBooleanChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableBooleanChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for boolean data. */ -public final class ResettableWritableBooleanChunk +public class ResettableWritableBooleanChunk extends WritableBooleanChunk implements ResettableWritableChunk { public static ResettableWritableBooleanChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getBooleanChunkPool().takeResettableWritableBooleanChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableBooleanChunk(); } return new ResettableWritableBooleanChunk<>(); } public static ResettableWritableBooleanChunk makeResettableChunkForPool() { - return new ResettableWritableBooleanChunk<>(); + return new ResettableWritableBooleanChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableBooleanChunk(this); + } + }; } private ResettableWritableBooleanChunk(boolean[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableBooleanChunk resetFromTypedArray(b //noinspection unchecked return (WritableBooleanChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getBooleanChunkPool().giveResettableWritableBooleanChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableByteChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableByteChunk.java index 25e71930343..65b4b70724a 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableByteChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableByteChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for byte data. */ -public final class ResettableWritableByteChunk +public class ResettableWritableByteChunk extends WritableByteChunk implements ResettableWritableChunk { public static ResettableWritableByteChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getByteChunkPool().takeResettableWritableByteChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableByteChunk(); } return new ResettableWritableByteChunk<>(); } public static ResettableWritableByteChunk makeResettableChunkForPool() { - return new ResettableWritableByteChunk<>(); + return new ResettableWritableByteChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableByteChunk(this); + } + }; } private ResettableWritableByteChunk(byte[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableByteChunk resetFromTypedArray(byte //noinspection unchecked return (WritableByteChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getByteChunkPool().giveResettableWritableByteChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableCharChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableCharChunk.java index 149664de00a..2c880695080 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableCharChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableCharChunk.java @@ -12,19 +12,24 @@ /** * {@link ResettableWritableChunk} implementation for char data. */ -public final class ResettableWritableCharChunk +public class ResettableWritableCharChunk extends WritableCharChunk implements ResettableWritableChunk { public static ResettableWritableCharChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getCharChunkPool().takeResettableWritableCharChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableCharChunk(); } return new ResettableWritableCharChunk<>(); } public static ResettableWritableCharChunk makeResettableChunkForPool() { - return new ResettableWritableCharChunk<>(); + return new ResettableWritableCharChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableCharChunk(this); + } + }; } private ResettableWritableCharChunk(char[] data, int offset, int capacity) { @@ -76,11 +81,4 @@ public WritableCharChunk resetFromTypedArray(char //noinspection unchecked return (WritableCharChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getCharChunkPool().giveResettableWritableCharChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableDoubleChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableDoubleChunk.java index 8aa86263681..26e2f822ba3 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableDoubleChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableDoubleChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for double data. */ -public final class ResettableWritableDoubleChunk +public class ResettableWritableDoubleChunk extends WritableDoubleChunk implements ResettableWritableChunk { public static ResettableWritableDoubleChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getDoubleChunkPool().takeResettableWritableDoubleChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableDoubleChunk(); } return new ResettableWritableDoubleChunk<>(); } public static ResettableWritableDoubleChunk makeResettableChunkForPool() { - return new ResettableWritableDoubleChunk<>(); + return new ResettableWritableDoubleChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableDoubleChunk(this); + } + }; } private ResettableWritableDoubleChunk(double[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableDoubleChunk resetFromTypedArray(do //noinspection unchecked return (WritableDoubleChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getDoubleChunkPool().giveResettableWritableDoubleChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableFloatChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableFloatChunk.java index 7fce40f6031..5f812b45e04 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableFloatChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableFloatChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for float data. */ -public final class ResettableWritableFloatChunk +public class ResettableWritableFloatChunk extends WritableFloatChunk implements ResettableWritableChunk { public static ResettableWritableFloatChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getFloatChunkPool().takeResettableWritableFloatChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableFloatChunk(); } return new ResettableWritableFloatChunk<>(); } public static ResettableWritableFloatChunk makeResettableChunkForPool() { - return new ResettableWritableFloatChunk<>(); + return new ResettableWritableFloatChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableFloatChunk(this); + } + }; } private ResettableWritableFloatChunk(float[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableFloatChunk resetFromTypedArray(flo //noinspection unchecked return (WritableFloatChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getFloatChunkPool().giveResettableWritableFloatChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableIntChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableIntChunk.java index 2b8d7dcac9e..4ceba0ddf9d 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableIntChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableIntChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for int data. */ -public final class ResettableWritableIntChunk +public class ResettableWritableIntChunk extends WritableIntChunk implements ResettableWritableChunk { public static ResettableWritableIntChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getIntChunkPool().takeResettableWritableIntChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableIntChunk(); } return new ResettableWritableIntChunk<>(); } public static ResettableWritableIntChunk makeResettableChunkForPool() { - return new ResettableWritableIntChunk<>(); + return new ResettableWritableIntChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableIntChunk(this); + } + }; } private ResettableWritableIntChunk(int[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableIntChunk resetFromTypedArray(int[] //noinspection unchecked return (WritableIntChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getIntChunkPool().giveResettableWritableIntChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableLongChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableLongChunk.java index 02834212918..40eec8f04b6 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableLongChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableLongChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for long data. */ -public final class ResettableWritableLongChunk +public class ResettableWritableLongChunk extends WritableLongChunk implements ResettableWritableChunk { public static ResettableWritableLongChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getLongChunkPool().takeResettableWritableLongChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableLongChunk(); } return new ResettableWritableLongChunk<>(); } public static ResettableWritableLongChunk makeResettableChunkForPool() { - return new ResettableWritableLongChunk<>(); + return new ResettableWritableLongChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableLongChunk(this); + } + }; } private ResettableWritableLongChunk(long[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableLongChunk resetFromTypedArray(long //noinspection unchecked return (WritableLongChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getLongChunkPool().giveResettableWritableLongChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableObjectChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableObjectChunk.java index 3b2f8a0565d..6fd5149b31c 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableObjectChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableObjectChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for Object data. */ -public final class ResettableWritableObjectChunk +public class ResettableWritableObjectChunk extends WritableObjectChunk implements ResettableWritableChunk { public static ResettableWritableObjectChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getObjectChunkPool().takeResettableWritableObjectChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableObjectChunk(); } return new ResettableWritableObjectChunk<>(); } public static ResettableWritableObjectChunk makeResettableChunkForPool() { - return new ResettableWritableObjectChunk<>(); + return new ResettableWritableObjectChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableObjectChunk(this); + } + }; } private ResettableWritableObjectChunk(T[] data, int offset, int capacity) { @@ -84,11 +89,4 @@ public WritableObjectChunk resetFromTypedArray //noinspection unchecked return (WritableObjectChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getObjectChunkPool().giveResettableWritableObjectChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableShortChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableShortChunk.java index 9d5ef03f392..48c52b9c744 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableShortChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/ResettableWritableShortChunk.java @@ -17,19 +17,24 @@ /** * {@link ResettableWritableChunk} implementation for short data. */ -public final class ResettableWritableShortChunk +public class ResettableWritableShortChunk extends WritableShortChunk implements ResettableWritableChunk { public static ResettableWritableShortChunk makeResettableChunk() { if (POOL_RESETTABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getShortChunkPool().takeResettableWritableShortChunk(); + return MultiChunkPool.forThisThread().takeResettableWritableShortChunk(); } return new ResettableWritableShortChunk<>(); } public static ResettableWritableShortChunk makeResettableChunkForPool() { - return new ResettableWritableShortChunk<>(); + return new ResettableWritableShortChunk<>() { + @Override + public void close() { + MultiChunkPool.forThisThread().giveResettableWritableShortChunk(this); + } + }; } private ResettableWritableShortChunk(short[] data, int offset, int capacity) { @@ -81,11 +86,4 @@ public WritableShortChunk resetFromTypedArray(sho //noinspection unchecked return (WritableShortChunk) this; } - - @Override - public void close() { - if (POOL_RESETTABLE_CHUNKS) { - MultiChunkPool.forThisThread().getShortChunkPool().giveResettableWritableShortChunk(this); - } - } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableBooleanChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableBooleanChunk.java index cecf289bd17..668f8de2d93 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableBooleanChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableBooleanChunk.java @@ -42,17 +42,16 @@ static WritableBooleanChunk[] getEmptyChunkArray() { public static WritableBooleanChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getBooleanChunkPool().takeWritableBooleanChunk(size); + return MultiChunkPool.forThisThread().takeWritableBooleanChunk(size); } return new WritableBooleanChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableBooleanChunk makeWritableChunkForPool(int size) { - return new WritableBooleanChunk(makeArray(size), 0, size) { + public static WritableBooleanChunk makeWritableChunkForPool(int size) { + return new WritableBooleanChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getBooleanChunkPool().giveWritableBooleanChunk(this); + MultiChunkPool.forThisThread().giveWritableBooleanChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableByteChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableByteChunk.java index 013dc4a43d1..5a646eec3ac 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableByteChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableByteChunk.java @@ -45,17 +45,16 @@ static WritableByteChunk[] getEmptyChunkArray() { public static WritableByteChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getByteChunkPool().takeWritableByteChunk(size); + return MultiChunkPool.forThisThread().takeWritableByteChunk(size); } return new WritableByteChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableByteChunk makeWritableChunkForPool(int size) { - return new WritableByteChunk(makeArray(size), 0, size) { + public static WritableByteChunk makeWritableChunkForPool(int size) { + return new WritableByteChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getByteChunkPool().giveWritableByteChunk(this); + MultiChunkPool.forThisThread().giveWritableByteChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableCharChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableCharChunk.java index 31f4d521d75..4b702b55e99 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableCharChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableCharChunk.java @@ -40,17 +40,16 @@ static WritableCharChunk[] getEmptyChunkArray() { public static WritableCharChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getCharChunkPool().takeWritableCharChunk(size); + return MultiChunkPool.forThisThread().takeWritableCharChunk(size); } return new WritableCharChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableCharChunk makeWritableChunkForPool(int size) { - return new WritableCharChunk(makeArray(size), 0, size) { + public static WritableCharChunk makeWritableChunkForPool(int size) { + return new WritableCharChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getCharChunkPool().giveWritableCharChunk(this); + MultiChunkPool.forThisThread().giveWritableCharChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableDoubleChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableDoubleChunk.java index 1b02565cb77..c06ffdfbe48 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableDoubleChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableDoubleChunk.java @@ -45,17 +45,16 @@ static WritableDoubleChunk[] getEmptyChunkArray() { public static WritableDoubleChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getDoubleChunkPool().takeWritableDoubleChunk(size); + return MultiChunkPool.forThisThread().takeWritableDoubleChunk(size); } return new WritableDoubleChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableDoubleChunk makeWritableChunkForPool(int size) { - return new WritableDoubleChunk(makeArray(size), 0, size) { + public static WritableDoubleChunk makeWritableChunkForPool(int size) { + return new WritableDoubleChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getDoubleChunkPool().giveWritableDoubleChunk(this); + MultiChunkPool.forThisThread().giveWritableDoubleChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableFloatChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableFloatChunk.java index 7fb08ee3b64..a69b2d7019c 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableFloatChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableFloatChunk.java @@ -45,17 +45,16 @@ static WritableFloatChunk[] getEmptyChunkArray() { public static WritableFloatChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getFloatChunkPool().takeWritableFloatChunk(size); + return MultiChunkPool.forThisThread().takeWritableFloatChunk(size); } return new WritableFloatChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableFloatChunk makeWritableChunkForPool(int size) { - return new WritableFloatChunk(makeArray(size), 0, size) { + public static WritableFloatChunk makeWritableChunkForPool(int size) { + return new WritableFloatChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getFloatChunkPool().giveWritableFloatChunk(this); + MultiChunkPool.forThisThread().giveWritableFloatChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableIntChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableIntChunk.java index 7e0fc5155bb..48c3ea4e1c3 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableIntChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableIntChunk.java @@ -45,17 +45,16 @@ static WritableIntChunk[] getEmptyChunkArray() { public static WritableIntChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getIntChunkPool().takeWritableIntChunk(size); + return MultiChunkPool.forThisThread().takeWritableIntChunk(size); } return new WritableIntChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableIntChunk makeWritableChunkForPool(int size) { - return new WritableIntChunk(makeArray(size), 0, size) { + public static WritableIntChunk makeWritableChunkForPool(int size) { + return new WritableIntChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getIntChunkPool().giveWritableIntChunk(this); + MultiChunkPool.forThisThread().giveWritableIntChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableLongChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableLongChunk.java index 7aaa750db4b..7b6ec56717f 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableLongChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableLongChunk.java @@ -45,17 +45,16 @@ static WritableLongChunk[] getEmptyChunkArray() { public static WritableLongChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getLongChunkPool().takeWritableLongChunk(size); + return MultiChunkPool.forThisThread().takeWritableLongChunk(size); } return new WritableLongChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableLongChunk makeWritableChunkForPool(int size) { - return new WritableLongChunk(makeArray(size), 0, size) { + public static WritableLongChunk makeWritableChunkForPool(int size) { + return new WritableLongChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getLongChunkPool().giveWritableLongChunk(this); + MultiChunkPool.forThisThread().giveWritableLongChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableObjectChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableObjectChunk.java index 2053a4c2a7a..2d8f9f948d7 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableObjectChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableObjectChunk.java @@ -45,17 +45,16 @@ static WritableObjectChunk[] getEmptyChunkArray() public static WritableObjectChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getObjectChunkPool().takeWritableObjectChunk(size); + return MultiChunkPool.forThisThread().takeWritableObjectChunk(size); } return new WritableObjectChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableObjectChunk makeWritableChunkForPool(int size) { - return new WritableObjectChunk(makeArray(size), 0, size) { + public static WritableObjectChunk makeWritableChunkForPool(int size) { + return new WritableObjectChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getObjectChunkPool().giveWritableObjectChunk(this); + MultiChunkPool.forThisThread().giveWritableObjectChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/WritableShortChunk.java b/engine/chunk/src/main/java/io/deephaven/chunk/WritableShortChunk.java index 20918e739c8..1231be95e7b 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/WritableShortChunk.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/WritableShortChunk.java @@ -45,17 +45,16 @@ static WritableShortChunk[] getEmptyChunkArray() { public static WritableShortChunk makeWritableChunk(int size) { if (POOL_WRITABLE_CHUNKS) { - return MultiChunkPool.forThisThread().getShortChunkPool().takeWritableShortChunk(size); + return MultiChunkPool.forThisThread().takeWritableShortChunk(size); } return new WritableShortChunk<>(makeArray(size), 0, size); } - @SuppressWarnings("rawtypes") - public static WritableShortChunk makeWritableChunkForPool(int size) { - return new WritableShortChunk(makeArray(size), 0, size) { + public static WritableShortChunk makeWritableChunkForPool(int size) { + return new WritableShortChunk<>(makeArray(size), 0, size) { @Override public void close() { - MultiChunkPool.forThisThread().getShortChunkPool().giveWritableShortChunk(this); + MultiChunkPool.forThisThread().giveWritableShortChunk(this); } }; } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkPool.java index 45c6b59bb09..8f948ec45ec 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableBooleanChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableBooleanChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableBooleanChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of booleans. - */ -@SuppressWarnings("rawtypes") -public final class BooleanChunkPool implements ChunkPool { - - private final WritableBooleanChunk EMPTY = WritableBooleanChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_BOOLEAN_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableBooleanChunk}s. - */ - private final SegmentedSoftPool[] writableBooleanChunks; - - /** - * Sub-pool of {@link ResettableBooleanChunk}s. - */ - private final SegmentedSoftPool resettableBooleanChunks; - - /** - * Sub-pool of {@link ResettableWritableBooleanChunk}s. - */ - private final SegmentedSoftPool resettableWritableBooleanChunks; - - BooleanChunkPool() { - //noinspection unchecked - writableBooleanChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableBooleanChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableBooleanChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableBooleanChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableBooleanChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableBooleanChunk::makeResettableChunkForPool), - ResettableBooleanChunk::clear - ); - resettableWritableBooleanChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableBooleanChunk::makeResettableChunkForPool), - ResettableWritableBooleanChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableBooleanChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableBooleanChunk(writableChunk.asWritableBooleanChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableBooleanChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableBooleanChunk(resettableChunk.asResettableBooleanChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableBooleanChunk(); - } +public interface BooleanChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableBooleanChunk(resettableWritableChunk.asResettableWritableBooleanChunk()); - } + ChunkPool asChunkPool(); - public WritableBooleanChunk takeWritableBooleanChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableBooleanChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableBooleanChunk result = writableBooleanChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableBooleanChunk.makeWritableChunkForPool(capacity)); - } + WritableBooleanChunk takeWritableBooleanChunk(int capacity); - public void giveWritableBooleanChunk(@NotNull final WritableBooleanChunk writableBooleanChunk) { - if (writableBooleanChunk == EMPTY || writableBooleanChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableBooleanChunk); - final int capacity = writableBooleanChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableBooleanChunks[poolIndexForGive].give(writableBooleanChunk); - } - } + void giveWritableBooleanChunk(@NotNull WritableBooleanChunk writableBooleanChunk); - public ResettableBooleanChunk takeResettableBooleanChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableBooleanChunks.take()); - } + ResettableBooleanChunk takeResettableBooleanChunk(); - public void giveResettableBooleanChunk(@NotNull final ResettableBooleanChunk resettableBooleanChunk) { - resettableBooleanChunks.give(ChunkPoolReleaseTracking.onGive(resettableBooleanChunk)); - } + void giveResettableBooleanChunk(@NotNull ResettableBooleanChunk resettableBooleanChunk); - public ResettableWritableBooleanChunk takeResettableWritableBooleanChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableBooleanChunks.take()); - } + ResettableWritableBooleanChunk takeResettableWritableBooleanChunk(); - public void giveResettableWritableBooleanChunk(@NotNull final ResettableWritableBooleanChunk resettableWritableBooleanChunk) { - resettableWritableBooleanChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableBooleanChunk)); - } + void giveResettableWritableBooleanChunk(@NotNull ResettableWritableBooleanChunk resettableWritableBooleanChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkSoftPool.java new file mode 100644 index 00000000000..adf6bc12f8b --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/BooleanChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of booleans. + */ +@SuppressWarnings("rawtypes") +public final class BooleanChunkSoftPool implements BooleanChunkPool { + + private final WritableBooleanChunk EMPTY = WritableBooleanChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_BOOLEAN_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableBooleanChunk}s. + */ + private final SegmentedSoftPool[] writableBooleanChunks; + + /** + * Sub-pool of {@link ResettableBooleanChunk}s. + */ + private final SegmentedSoftPool resettableBooleanChunks; + + /** + * Sub-pool of {@link ResettableWritableBooleanChunk}s. + */ + private final SegmentedSoftPool resettableWritableBooleanChunks; + + BooleanChunkSoftPool() { + //noinspection unchecked + writableBooleanChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableBooleanChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableBooleanChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableBooleanChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableBooleanChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableBooleanChunk::makeResettableChunkForPool), + ResettableBooleanChunk::clear + ); + resettableWritableBooleanChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableBooleanChunk::makeResettableChunkForPool), + ResettableWritableBooleanChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableBooleanChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableBooleanChunk(writableChunk.asWritableBooleanChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableBooleanChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableBooleanChunk(resettableChunk.asResettableBooleanChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableBooleanChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableBooleanChunk(resettableWritableChunk.asResettableWritableBooleanChunk()); + } + }; + } + + @Override + public WritableBooleanChunk takeWritableBooleanChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableBooleanChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableBooleanChunk result = writableBooleanChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableBooleanChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableBooleanChunk(@NotNull final WritableBooleanChunk writableBooleanChunk) { + if (writableBooleanChunk == EMPTY || writableBooleanChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableBooleanChunk); + final int capacity = writableBooleanChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableBooleanChunks[poolIndexForGive].give(writableBooleanChunk); + } + } + + @Override + public ResettableBooleanChunk takeResettableBooleanChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableBooleanChunks.take()); + } + + @Override + public void giveResettableBooleanChunk(@NotNull final ResettableBooleanChunk resettableBooleanChunk) { + resettableBooleanChunks.give(ChunkPoolReleaseTracking.onGive(resettableBooleanChunk)); + } + + @Override + public ResettableWritableBooleanChunk takeResettableWritableBooleanChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableBooleanChunks.take()); + } + + @Override + public void giveResettableWritableBooleanChunk(@NotNull final ResettableWritableBooleanChunk resettableWritableBooleanChunk) { + resettableWritableBooleanChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableBooleanChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkPool.java index 6c29a8fe517..4addbfc64fb 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableByteChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableByteChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableByteChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of bytes. - */ -@SuppressWarnings("rawtypes") -public final class ByteChunkPool implements ChunkPool { - - private final WritableByteChunk EMPTY = WritableByteChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_BYTE_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableByteChunk}s. - */ - private final SegmentedSoftPool[] writableByteChunks; - - /** - * Sub-pool of {@link ResettableByteChunk}s. - */ - private final SegmentedSoftPool resettableByteChunks; - - /** - * Sub-pool of {@link ResettableWritableByteChunk}s. - */ - private final SegmentedSoftPool resettableWritableByteChunks; - - ByteChunkPool() { - //noinspection unchecked - writableByteChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableByteChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableByteChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableByteChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableByteChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableByteChunk::makeResettableChunkForPool), - ResettableByteChunk::clear - ); - resettableWritableByteChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableByteChunk::makeResettableChunkForPool), - ResettableWritableByteChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableByteChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableByteChunk(writableChunk.asWritableByteChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableByteChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableByteChunk(resettableChunk.asResettableByteChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableByteChunk(); - } +public interface ByteChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableByteChunk(resettableWritableChunk.asResettableWritableByteChunk()); - } + ChunkPool asChunkPool(); - public WritableByteChunk takeWritableByteChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableByteChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableByteChunk result = writableByteChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableByteChunk.makeWritableChunkForPool(capacity)); - } + WritableByteChunk takeWritableByteChunk(int capacity); - public void giveWritableByteChunk(@NotNull final WritableByteChunk writableByteChunk) { - if (writableByteChunk == EMPTY || writableByteChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableByteChunk); - final int capacity = writableByteChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableByteChunks[poolIndexForGive].give(writableByteChunk); - } - } + void giveWritableByteChunk(@NotNull WritableByteChunk writableByteChunk); - public ResettableByteChunk takeResettableByteChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableByteChunks.take()); - } + ResettableByteChunk takeResettableByteChunk(); - public void giveResettableByteChunk(@NotNull final ResettableByteChunk resettableByteChunk) { - resettableByteChunks.give(ChunkPoolReleaseTracking.onGive(resettableByteChunk)); - } + void giveResettableByteChunk(@NotNull ResettableByteChunk resettableByteChunk); - public ResettableWritableByteChunk takeResettableWritableByteChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableByteChunks.take()); - } + ResettableWritableByteChunk takeResettableWritableByteChunk(); - public void giveResettableWritableByteChunk(@NotNull final ResettableWritableByteChunk resettableWritableByteChunk) { - resettableWritableByteChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableByteChunk)); - } + void giveResettableWritableByteChunk(@NotNull ResettableWritableByteChunk resettableWritableByteChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkSoftPool.java new file mode 100644 index 00000000000..fbea90bd8be --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ByteChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of bytes. + */ +@SuppressWarnings("rawtypes") +public final class ByteChunkSoftPool implements ByteChunkPool { + + private final WritableByteChunk EMPTY = WritableByteChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_BYTE_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableByteChunk}s. + */ + private final SegmentedSoftPool[] writableByteChunks; + + /** + * Sub-pool of {@link ResettableByteChunk}s. + */ + private final SegmentedSoftPool resettableByteChunks; + + /** + * Sub-pool of {@link ResettableWritableByteChunk}s. + */ + private final SegmentedSoftPool resettableWritableByteChunks; + + ByteChunkSoftPool() { + //noinspection unchecked + writableByteChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableByteChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableByteChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableByteChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableByteChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableByteChunk::makeResettableChunkForPool), + ResettableByteChunk::clear + ); + resettableWritableByteChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableByteChunk::makeResettableChunkForPool), + ResettableWritableByteChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableByteChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableByteChunk(writableChunk.asWritableByteChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableByteChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableByteChunk(resettableChunk.asResettableByteChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableByteChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableByteChunk(resettableWritableChunk.asResettableWritableByteChunk()); + } + }; + } + + @Override + public WritableByteChunk takeWritableByteChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableByteChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableByteChunk result = writableByteChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableByteChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableByteChunk(@NotNull final WritableByteChunk writableByteChunk) { + if (writableByteChunk == EMPTY || writableByteChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableByteChunk); + final int capacity = writableByteChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableByteChunks[poolIndexForGive].give(writableByteChunk); + } + } + + @Override + public ResettableByteChunk takeResettableByteChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableByteChunks.take()); + } + + @Override + public void giveResettableByteChunk(@NotNull final ResettableByteChunk resettableByteChunk) { + resettableByteChunks.give(ChunkPoolReleaseTracking.onGive(resettableByteChunk)); + } + + @Override + public ResettableWritableByteChunk takeResettableWritableByteChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableByteChunks.take()); + } + + @Override + public void giveResettableWritableByteChunk(@NotNull final ResettableWritableByteChunk resettableWritableByteChunk) { + resettableWritableByteChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableByteChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkPool.java index 79237b07cac..293f993a30c 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkPool.java @@ -1,137 +1,27 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableCharChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableCharChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableCharChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; +public interface CharChunkPool { -/** - * {@link ChunkPool} implementation for chunks of chars. - */ -@SuppressWarnings("rawtypes") -public final class CharChunkPool implements ChunkPool { + ChunkPool asChunkPool(); - private final WritableCharChunk EMPTY = WritableCharChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_CHAR_ARRAY); + WritableCharChunk takeWritableCharChunk(int capacity); - /** - * Sub-pools by power-of-two sizes for {@link WritableCharChunk}s. - */ - private final SegmentedSoftPool[] writableCharChunks; + void giveWritableCharChunk(@NotNull WritableCharChunk writableCharChunk); - /** - * Sub-pool of {@link ResettableCharChunk}s. - */ - private final SegmentedSoftPool resettableCharChunks; + ResettableCharChunk takeResettableCharChunk(); - /** - * Sub-pool of {@link ResettableWritableCharChunk}s. - */ - private final SegmentedSoftPool resettableWritableCharChunks; + void giveResettableCharChunk(@NotNull ResettableCharChunk resettableCharChunk); - CharChunkPool() { - //noinspection unchecked - writableCharChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableCharChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableCharChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableCharChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableCharChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableCharChunk::makeResettableChunkForPool), - ResettableCharChunk::clear - ); - resettableWritableCharChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableCharChunk::makeResettableChunkForPool), - ResettableWritableCharChunk::clear - ); - } + ResettableWritableCharChunk takeResettableWritableCharChunk(); - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableCharChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableCharChunk(writableChunk.asWritableCharChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableCharChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableCharChunk(resettableChunk.asResettableCharChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableCharChunk(); - } - - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableCharChunk(resettableWritableChunk.asResettableWritableCharChunk()); - } - - public WritableCharChunk takeWritableCharChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableCharChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableCharChunk result = writableCharChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableCharChunk.makeWritableChunkForPool(capacity)); - } - - public void giveWritableCharChunk(@NotNull final WritableCharChunk writableCharChunk) { - if (writableCharChunk == EMPTY || writableCharChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableCharChunk); - final int capacity = writableCharChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableCharChunks[poolIndexForGive].give(writableCharChunk); - } - } - - public ResettableCharChunk takeResettableCharChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableCharChunks.take()); - } - - public void giveResettableCharChunk(@NotNull final ResettableCharChunk resettableCharChunk) { - resettableCharChunks.give(ChunkPoolReleaseTracking.onGive(resettableCharChunk)); - } - - public ResettableWritableCharChunk takeResettableWritableCharChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableCharChunks.take()); - } - - public void giveResettableWritableCharChunk(@NotNull final ResettableWritableCharChunk resettableWritableCharChunk) { - resettableWritableCharChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableCharChunk)); - } + void giveResettableWritableCharChunk(@NotNull ResettableWritableCharChunk resettableWritableCharChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkSoftPool.java new file mode 100644 index 00000000000..455793296f7 --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkSoftPool.java @@ -0,0 +1,148 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of chars. + */ +@SuppressWarnings("rawtypes") +public final class CharChunkSoftPool implements CharChunkPool { + + private final WritableCharChunk EMPTY = WritableCharChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_CHAR_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableCharChunk}s. + */ + private final SegmentedSoftPool[] writableCharChunks; + + /** + * Sub-pool of {@link ResettableCharChunk}s. + */ + private final SegmentedSoftPool resettableCharChunks; + + /** + * Sub-pool of {@link ResettableWritableCharChunk}s. + */ + private final SegmentedSoftPool resettableWritableCharChunks; + + CharChunkSoftPool() { + //noinspection unchecked + writableCharChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableCharChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableCharChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableCharChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableCharChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableCharChunk::makeResettableChunkForPool), + ResettableCharChunk::clear + ); + resettableWritableCharChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableCharChunk::makeResettableChunkForPool), + ResettableWritableCharChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableCharChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableCharChunk(writableChunk.asWritableCharChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableCharChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableCharChunk(resettableChunk.asResettableCharChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableCharChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableCharChunk(resettableWritableChunk.asResettableWritableCharChunk()); + } + }; + } + + @Override + public WritableCharChunk takeWritableCharChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableCharChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableCharChunk result = writableCharChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableCharChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableCharChunk(@NotNull final WritableCharChunk writableCharChunk) { + if (writableCharChunk == EMPTY || writableCharChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableCharChunk); + final int capacity = writableCharChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableCharChunks[poolIndexForGive].give(writableCharChunk); + } + } + + @Override + public ResettableCharChunk takeResettableCharChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableCharChunks.take()); + } + + @Override + public void giveResettableCharChunk(@NotNull final ResettableCharChunk resettableCharChunk) { + resettableCharChunks.give(ChunkPoolReleaseTracking.onGive(resettableCharChunk)); + } + + @Override + public ResettableWritableCharChunk takeResettableWritableCharChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableCharChunks.take()); + } + + @Override + public void giveResettableWritableCharChunk(@NotNull final ResettableWritableCharChunk resettableWritableCharChunk) { + resettableWritableCharChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableCharChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkPool.java index cf29119990b..d3b7e510542 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableDoubleChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableDoubleChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableDoubleChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of doubles. - */ -@SuppressWarnings("rawtypes") -public final class DoubleChunkPool implements ChunkPool { - - private final WritableDoubleChunk EMPTY = WritableDoubleChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_DOUBLE_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableDoubleChunk}s. - */ - private final SegmentedSoftPool[] writableDoubleChunks; - - /** - * Sub-pool of {@link ResettableDoubleChunk}s. - */ - private final SegmentedSoftPool resettableDoubleChunks; - - /** - * Sub-pool of {@link ResettableWritableDoubleChunk}s. - */ - private final SegmentedSoftPool resettableWritableDoubleChunks; - - DoubleChunkPool() { - //noinspection unchecked - writableDoubleChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableDoubleChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableDoubleChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableDoubleChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableDoubleChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableDoubleChunk::makeResettableChunkForPool), - ResettableDoubleChunk::clear - ); - resettableWritableDoubleChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableDoubleChunk::makeResettableChunkForPool), - ResettableWritableDoubleChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableDoubleChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableDoubleChunk(writableChunk.asWritableDoubleChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableDoubleChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableDoubleChunk(resettableChunk.asResettableDoubleChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableDoubleChunk(); - } +public interface DoubleChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableDoubleChunk(resettableWritableChunk.asResettableWritableDoubleChunk()); - } + ChunkPool asChunkPool(); - public WritableDoubleChunk takeWritableDoubleChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableDoubleChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableDoubleChunk result = writableDoubleChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableDoubleChunk.makeWritableChunkForPool(capacity)); - } + WritableDoubleChunk takeWritableDoubleChunk(int capacity); - public void giveWritableDoubleChunk(@NotNull final WritableDoubleChunk writableDoubleChunk) { - if (writableDoubleChunk == EMPTY || writableDoubleChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableDoubleChunk); - final int capacity = writableDoubleChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableDoubleChunks[poolIndexForGive].give(writableDoubleChunk); - } - } + void giveWritableDoubleChunk(@NotNull WritableDoubleChunk writableDoubleChunk); - public ResettableDoubleChunk takeResettableDoubleChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableDoubleChunks.take()); - } + ResettableDoubleChunk takeResettableDoubleChunk(); - public void giveResettableDoubleChunk(@NotNull final ResettableDoubleChunk resettableDoubleChunk) { - resettableDoubleChunks.give(ChunkPoolReleaseTracking.onGive(resettableDoubleChunk)); - } + void giveResettableDoubleChunk(@NotNull ResettableDoubleChunk resettableDoubleChunk); - public ResettableWritableDoubleChunk takeResettableWritableDoubleChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableDoubleChunks.take()); - } + ResettableWritableDoubleChunk takeResettableWritableDoubleChunk(); - public void giveResettableWritableDoubleChunk(@NotNull final ResettableWritableDoubleChunk resettableWritableDoubleChunk) { - resettableWritableDoubleChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableDoubleChunk)); - } + void giveResettableWritableDoubleChunk(@NotNull ResettableWritableDoubleChunk resettableWritableDoubleChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkSoftPool.java new file mode 100644 index 00000000000..6b4dd4bfb66 --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/DoubleChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of doubles. + */ +@SuppressWarnings("rawtypes") +public final class DoubleChunkSoftPool implements DoubleChunkPool { + + private final WritableDoubleChunk EMPTY = WritableDoubleChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_DOUBLE_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableDoubleChunk}s. + */ + private final SegmentedSoftPool[] writableDoubleChunks; + + /** + * Sub-pool of {@link ResettableDoubleChunk}s. + */ + private final SegmentedSoftPool resettableDoubleChunks; + + /** + * Sub-pool of {@link ResettableWritableDoubleChunk}s. + */ + private final SegmentedSoftPool resettableWritableDoubleChunks; + + DoubleChunkSoftPool() { + //noinspection unchecked + writableDoubleChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableDoubleChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableDoubleChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableDoubleChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableDoubleChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableDoubleChunk::makeResettableChunkForPool), + ResettableDoubleChunk::clear + ); + resettableWritableDoubleChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableDoubleChunk::makeResettableChunkForPool), + ResettableWritableDoubleChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableDoubleChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableDoubleChunk(writableChunk.asWritableDoubleChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableDoubleChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableDoubleChunk(resettableChunk.asResettableDoubleChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableDoubleChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableDoubleChunk(resettableWritableChunk.asResettableWritableDoubleChunk()); + } + }; + } + + @Override + public WritableDoubleChunk takeWritableDoubleChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableDoubleChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableDoubleChunk result = writableDoubleChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableDoubleChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableDoubleChunk(@NotNull final WritableDoubleChunk writableDoubleChunk) { + if (writableDoubleChunk == EMPTY || writableDoubleChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableDoubleChunk); + final int capacity = writableDoubleChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableDoubleChunks[poolIndexForGive].give(writableDoubleChunk); + } + } + + @Override + public ResettableDoubleChunk takeResettableDoubleChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableDoubleChunks.take()); + } + + @Override + public void giveResettableDoubleChunk(@NotNull final ResettableDoubleChunk resettableDoubleChunk) { + resettableDoubleChunks.give(ChunkPoolReleaseTracking.onGive(resettableDoubleChunk)); + } + + @Override + public ResettableWritableDoubleChunk takeResettableWritableDoubleChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableDoubleChunks.take()); + } + + @Override + public void giveResettableWritableDoubleChunk(@NotNull final ResettableWritableDoubleChunk resettableWritableDoubleChunk) { + resettableWritableDoubleChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableDoubleChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkPool.java index 40197dc829d..c8fdd868788 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableFloatChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableFloatChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableFloatChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of floats. - */ -@SuppressWarnings("rawtypes") -public final class FloatChunkPool implements ChunkPool { - - private final WritableFloatChunk EMPTY = WritableFloatChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_FLOAT_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableFloatChunk}s. - */ - private final SegmentedSoftPool[] writableFloatChunks; - - /** - * Sub-pool of {@link ResettableFloatChunk}s. - */ - private final SegmentedSoftPool resettableFloatChunks; - - /** - * Sub-pool of {@link ResettableWritableFloatChunk}s. - */ - private final SegmentedSoftPool resettableWritableFloatChunks; - - FloatChunkPool() { - //noinspection unchecked - writableFloatChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableFloatChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableFloatChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableFloatChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableFloatChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableFloatChunk::makeResettableChunkForPool), - ResettableFloatChunk::clear - ); - resettableWritableFloatChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableFloatChunk::makeResettableChunkForPool), - ResettableWritableFloatChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableFloatChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableFloatChunk(writableChunk.asWritableFloatChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableFloatChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableFloatChunk(resettableChunk.asResettableFloatChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableFloatChunk(); - } +public interface FloatChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableFloatChunk(resettableWritableChunk.asResettableWritableFloatChunk()); - } + ChunkPool asChunkPool(); - public WritableFloatChunk takeWritableFloatChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableFloatChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableFloatChunk result = writableFloatChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableFloatChunk.makeWritableChunkForPool(capacity)); - } + WritableFloatChunk takeWritableFloatChunk(int capacity); - public void giveWritableFloatChunk(@NotNull final WritableFloatChunk writableFloatChunk) { - if (writableFloatChunk == EMPTY || writableFloatChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableFloatChunk); - final int capacity = writableFloatChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableFloatChunks[poolIndexForGive].give(writableFloatChunk); - } - } + void giveWritableFloatChunk(@NotNull WritableFloatChunk writableFloatChunk); - public ResettableFloatChunk takeResettableFloatChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableFloatChunks.take()); - } + ResettableFloatChunk takeResettableFloatChunk(); - public void giveResettableFloatChunk(@NotNull final ResettableFloatChunk resettableFloatChunk) { - resettableFloatChunks.give(ChunkPoolReleaseTracking.onGive(resettableFloatChunk)); - } + void giveResettableFloatChunk(@NotNull ResettableFloatChunk resettableFloatChunk); - public ResettableWritableFloatChunk takeResettableWritableFloatChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableFloatChunks.take()); - } + ResettableWritableFloatChunk takeResettableWritableFloatChunk(); - public void giveResettableWritableFloatChunk(@NotNull final ResettableWritableFloatChunk resettableWritableFloatChunk) { - resettableWritableFloatChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableFloatChunk)); - } + void giveResettableWritableFloatChunk(@NotNull ResettableWritableFloatChunk resettableWritableFloatChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkSoftPool.java new file mode 100644 index 00000000000..043ba6e446e --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/FloatChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of floats. + */ +@SuppressWarnings("rawtypes") +public final class FloatChunkSoftPool implements FloatChunkPool { + + private final WritableFloatChunk EMPTY = WritableFloatChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_FLOAT_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableFloatChunk}s. + */ + private final SegmentedSoftPool[] writableFloatChunks; + + /** + * Sub-pool of {@link ResettableFloatChunk}s. + */ + private final SegmentedSoftPool resettableFloatChunks; + + /** + * Sub-pool of {@link ResettableWritableFloatChunk}s. + */ + private final SegmentedSoftPool resettableWritableFloatChunks; + + FloatChunkSoftPool() { + //noinspection unchecked + writableFloatChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableFloatChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableFloatChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableFloatChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableFloatChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableFloatChunk::makeResettableChunkForPool), + ResettableFloatChunk::clear + ); + resettableWritableFloatChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableFloatChunk::makeResettableChunkForPool), + ResettableWritableFloatChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableFloatChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableFloatChunk(writableChunk.asWritableFloatChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableFloatChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableFloatChunk(resettableChunk.asResettableFloatChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableFloatChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableFloatChunk(resettableWritableChunk.asResettableWritableFloatChunk()); + } + }; + } + + @Override + public WritableFloatChunk takeWritableFloatChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableFloatChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableFloatChunk result = writableFloatChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableFloatChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableFloatChunk(@NotNull final WritableFloatChunk writableFloatChunk) { + if (writableFloatChunk == EMPTY || writableFloatChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableFloatChunk); + final int capacity = writableFloatChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableFloatChunks[poolIndexForGive].give(writableFloatChunk); + } + } + + @Override + public ResettableFloatChunk takeResettableFloatChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableFloatChunks.take()); + } + + @Override + public void giveResettableFloatChunk(@NotNull final ResettableFloatChunk resettableFloatChunk) { + resettableFloatChunks.give(ChunkPoolReleaseTracking.onGive(resettableFloatChunk)); + } + + @Override + public ResettableWritableFloatChunk takeResettableWritableFloatChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableFloatChunks.take()); + } + + @Override + public void giveResettableWritableFloatChunk(@NotNull final ResettableWritableFloatChunk resettableWritableFloatChunk) { + resettableWritableFloatChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableFloatChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkPool.java index d3ff9c987ab..ea99ca14d54 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableIntChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableIntChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableIntChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of ints. - */ -@SuppressWarnings("rawtypes") -public final class IntChunkPool implements ChunkPool { - - private final WritableIntChunk EMPTY = WritableIntChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_INT_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableIntChunk}s. - */ - private final SegmentedSoftPool[] writableIntChunks; - - /** - * Sub-pool of {@link ResettableIntChunk}s. - */ - private final SegmentedSoftPool resettableIntChunks; - - /** - * Sub-pool of {@link ResettableWritableIntChunk}s. - */ - private final SegmentedSoftPool resettableWritableIntChunks; - - IntChunkPool() { - //noinspection unchecked - writableIntChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableIntChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableIntChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableIntChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableIntChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableIntChunk::makeResettableChunkForPool), - ResettableIntChunk::clear - ); - resettableWritableIntChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableIntChunk::makeResettableChunkForPool), - ResettableWritableIntChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableIntChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableIntChunk(writableChunk.asWritableIntChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableIntChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableIntChunk(resettableChunk.asResettableIntChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableIntChunk(); - } +public interface IntChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableIntChunk(resettableWritableChunk.asResettableWritableIntChunk()); - } + ChunkPool asChunkPool(); - public WritableIntChunk takeWritableIntChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableIntChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableIntChunk result = writableIntChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableIntChunk.makeWritableChunkForPool(capacity)); - } + WritableIntChunk takeWritableIntChunk(int capacity); - public void giveWritableIntChunk(@NotNull final WritableIntChunk writableIntChunk) { - if (writableIntChunk == EMPTY || writableIntChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableIntChunk); - final int capacity = writableIntChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableIntChunks[poolIndexForGive].give(writableIntChunk); - } - } + void giveWritableIntChunk(@NotNull WritableIntChunk writableIntChunk); - public ResettableIntChunk takeResettableIntChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableIntChunks.take()); - } + ResettableIntChunk takeResettableIntChunk(); - public void giveResettableIntChunk(@NotNull final ResettableIntChunk resettableIntChunk) { - resettableIntChunks.give(ChunkPoolReleaseTracking.onGive(resettableIntChunk)); - } + void giveResettableIntChunk(@NotNull ResettableIntChunk resettableIntChunk); - public ResettableWritableIntChunk takeResettableWritableIntChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableIntChunks.take()); - } + ResettableWritableIntChunk takeResettableWritableIntChunk(); - public void giveResettableWritableIntChunk(@NotNull final ResettableWritableIntChunk resettableWritableIntChunk) { - resettableWritableIntChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableIntChunk)); - } + void giveResettableWritableIntChunk(@NotNull ResettableWritableIntChunk resettableWritableIntChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkSoftPool.java new file mode 100644 index 00000000000..ec20ec9560b --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/IntChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of ints. + */ +@SuppressWarnings("rawtypes") +public final class IntChunkSoftPool implements IntChunkPool { + + private final WritableIntChunk EMPTY = WritableIntChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_INT_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableIntChunk}s. + */ + private final SegmentedSoftPool[] writableIntChunks; + + /** + * Sub-pool of {@link ResettableIntChunk}s. + */ + private final SegmentedSoftPool resettableIntChunks; + + /** + * Sub-pool of {@link ResettableWritableIntChunk}s. + */ + private final SegmentedSoftPool resettableWritableIntChunks; + + IntChunkSoftPool() { + //noinspection unchecked + writableIntChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableIntChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableIntChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableIntChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableIntChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableIntChunk::makeResettableChunkForPool), + ResettableIntChunk::clear + ); + resettableWritableIntChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableIntChunk::makeResettableChunkForPool), + ResettableWritableIntChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableIntChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableIntChunk(writableChunk.asWritableIntChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableIntChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableIntChunk(resettableChunk.asResettableIntChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableIntChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableIntChunk(resettableWritableChunk.asResettableWritableIntChunk()); + } + }; + } + + @Override + public WritableIntChunk takeWritableIntChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableIntChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableIntChunk result = writableIntChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableIntChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableIntChunk(@NotNull final WritableIntChunk writableIntChunk) { + if (writableIntChunk == EMPTY || writableIntChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableIntChunk); + final int capacity = writableIntChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableIntChunks[poolIndexForGive].give(writableIntChunk); + } + } + + @Override + public ResettableIntChunk takeResettableIntChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableIntChunks.take()); + } + + @Override + public void giveResettableIntChunk(@NotNull final ResettableIntChunk resettableIntChunk) { + resettableIntChunks.give(ChunkPoolReleaseTracking.onGive(resettableIntChunk)); + } + + @Override + public ResettableWritableIntChunk takeResettableWritableIntChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableIntChunks.take()); + } + + @Override + public void giveResettableWritableIntChunk(@NotNull final ResettableWritableIntChunk resettableWritableIntChunk) { + resettableWritableIntChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableIntChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkPool.java index 6dd06961ca3..4739694f1ef 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableLongChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableLongChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableLongChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of longs. - */ -@SuppressWarnings("rawtypes") -public final class LongChunkPool implements ChunkPool { - - private final WritableLongChunk EMPTY = WritableLongChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_LONG_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableLongChunk}s. - */ - private final SegmentedSoftPool[] writableLongChunks; - - /** - * Sub-pool of {@link ResettableLongChunk}s. - */ - private final SegmentedSoftPool resettableLongChunks; - - /** - * Sub-pool of {@link ResettableWritableLongChunk}s. - */ - private final SegmentedSoftPool resettableWritableLongChunks; - - LongChunkPool() { - //noinspection unchecked - writableLongChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableLongChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableLongChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableLongChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableLongChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableLongChunk::makeResettableChunkForPool), - ResettableLongChunk::clear - ); - resettableWritableLongChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableLongChunk::makeResettableChunkForPool), - ResettableWritableLongChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableLongChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableLongChunk(writableChunk.asWritableLongChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableLongChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableLongChunk(resettableChunk.asResettableLongChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableLongChunk(); - } +public interface LongChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableLongChunk(resettableWritableChunk.asResettableWritableLongChunk()); - } + ChunkPool asChunkPool(); - public WritableLongChunk takeWritableLongChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableLongChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableLongChunk result = writableLongChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableLongChunk.makeWritableChunkForPool(capacity)); - } + WritableLongChunk takeWritableLongChunk(int capacity); - public void giveWritableLongChunk(@NotNull final WritableLongChunk writableLongChunk) { - if (writableLongChunk == EMPTY || writableLongChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableLongChunk); - final int capacity = writableLongChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableLongChunks[poolIndexForGive].give(writableLongChunk); - } - } + void giveWritableLongChunk(@NotNull WritableLongChunk writableLongChunk); - public ResettableLongChunk takeResettableLongChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableLongChunks.take()); - } + ResettableLongChunk takeResettableLongChunk(); - public void giveResettableLongChunk(@NotNull final ResettableLongChunk resettableLongChunk) { - resettableLongChunks.give(ChunkPoolReleaseTracking.onGive(resettableLongChunk)); - } + void giveResettableLongChunk(@NotNull ResettableLongChunk resettableLongChunk); - public ResettableWritableLongChunk takeResettableWritableLongChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableLongChunks.take()); - } + ResettableWritableLongChunk takeResettableWritableLongChunk(); - public void giveResettableWritableLongChunk(@NotNull final ResettableWritableLongChunk resettableWritableLongChunk) { - resettableWritableLongChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableLongChunk)); - } + void giveResettableWritableLongChunk(@NotNull ResettableWritableLongChunk resettableWritableLongChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkSoftPool.java new file mode 100644 index 00000000000..83e5217eca0 --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/LongChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of longs. + */ +@SuppressWarnings("rawtypes") +public final class LongChunkSoftPool implements LongChunkPool { + + private final WritableLongChunk EMPTY = WritableLongChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_LONG_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableLongChunk}s. + */ + private final SegmentedSoftPool[] writableLongChunks; + + /** + * Sub-pool of {@link ResettableLongChunk}s. + */ + private final SegmentedSoftPool resettableLongChunks; + + /** + * Sub-pool of {@link ResettableWritableLongChunk}s. + */ + private final SegmentedSoftPool resettableWritableLongChunks; + + LongChunkSoftPool() { + //noinspection unchecked + writableLongChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableLongChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableLongChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableLongChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableLongChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableLongChunk::makeResettableChunkForPool), + ResettableLongChunk::clear + ); + resettableWritableLongChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableLongChunk::makeResettableChunkForPool), + ResettableWritableLongChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableLongChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableLongChunk(writableChunk.asWritableLongChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableLongChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableLongChunk(resettableChunk.asResettableLongChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableLongChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableLongChunk(resettableWritableChunk.asResettableWritableLongChunk()); + } + }; + } + + @Override + public WritableLongChunk takeWritableLongChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableLongChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableLongChunk result = writableLongChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableLongChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableLongChunk(@NotNull final WritableLongChunk writableLongChunk) { + if (writableLongChunk == EMPTY || writableLongChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableLongChunk); + final int capacity = writableLongChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableLongChunks[poolIndexForGive].give(writableLongChunk); + } + } + + @Override + public ResettableLongChunk takeResettableLongChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableLongChunks.take()); + } + + @Override + public void giveResettableLongChunk(@NotNull final ResettableLongChunk resettableLongChunk) { + resettableLongChunks.give(ChunkPoolReleaseTracking.onGive(resettableLongChunk)); + } + + @Override + public ResettableWritableLongChunk takeResettableWritableLongChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableLongChunks.take()); + } + + @Override + public void giveResettableWritableLongChunk(@NotNull final ResettableWritableLongChunk resettableWritableLongChunk) { + resettableWritableLongChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableLongChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/MultiChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/MultiChunkPool.java index 0469a3e8f47..bf53469e2bd 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/MultiChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/MultiChunkPool.java @@ -4,6 +4,34 @@ package io.deephaven.chunk.util.pools; import io.deephaven.chunk.ChunkType; +import io.deephaven.chunk.ResettableBooleanChunk; +import io.deephaven.chunk.ResettableByteChunk; +import io.deephaven.chunk.ResettableCharChunk; +import io.deephaven.chunk.ResettableDoubleChunk; +import io.deephaven.chunk.ResettableFloatChunk; +import io.deephaven.chunk.ResettableIntChunk; +import io.deephaven.chunk.ResettableLongChunk; +import io.deephaven.chunk.ResettableObjectChunk; +import io.deephaven.chunk.ResettableShortChunk; +import io.deephaven.chunk.ResettableWritableBooleanChunk; +import io.deephaven.chunk.ResettableWritableByteChunk; +import io.deephaven.chunk.ResettableWritableCharChunk; +import io.deephaven.chunk.ResettableWritableDoubleChunk; +import io.deephaven.chunk.ResettableWritableFloatChunk; +import io.deephaven.chunk.ResettableWritableIntChunk; +import io.deephaven.chunk.ResettableWritableLongChunk; +import io.deephaven.chunk.ResettableWritableObjectChunk; +import io.deephaven.chunk.ResettableWritableShortChunk; +import io.deephaven.chunk.WritableBooleanChunk; +import io.deephaven.chunk.WritableByteChunk; +import io.deephaven.chunk.WritableCharChunk; +import io.deephaven.chunk.WritableDoubleChunk; +import io.deephaven.chunk.WritableFloatChunk; +import io.deephaven.chunk.WritableIntChunk; +import io.deephaven.chunk.WritableLongChunk; +import io.deephaven.chunk.WritableObjectChunk; +import io.deephaven.chunk.WritableShortChunk; +import io.deephaven.chunk.attributes.Any; import org.jetbrains.annotations.NotNull; import java.util.Collections; @@ -14,7 +42,8 @@ * Provides a set of per-type {@link ChunkPool}s. Normally accessed via a {@link ThreadLocal}, to allow some threads to * share a common pool and others to allocate their own. */ -public final class MultiChunkPool { +public final class MultiChunkPool implements BooleanChunkPool, ByteChunkPool, CharChunkPool, ShortChunkPool, + IntChunkPool, LongChunkPool, FloatChunkPool, DoubleChunkPool, ObjectChunkPool { private static final MultiChunkPool SHARED_POOL = new MultiChunkPool(); private static final ThreadLocal POOL_THREAD_LOCAL = ThreadLocal.withInitial(() -> SHARED_POOL); @@ -29,29 +58,29 @@ public static MultiChunkPool forThisThread() { return POOL_THREAD_LOCAL.get(); } - private final BooleanChunkPool booleanChunkPool = new BooleanChunkPool(); - private final CharChunkPool charChunkPool = new CharChunkPool(); - private final ByteChunkPool byteChunkPool = new ByteChunkPool(); - private final ShortChunkPool shortChunkPool = new ShortChunkPool(); - private final IntChunkPool intChunkPool = new IntChunkPool(); - private final LongChunkPool longChunkPool = new LongChunkPool(); - private final FloatChunkPool floatChunkPool = new FloatChunkPool(); - private final DoubleChunkPool doubleChunkPool = new DoubleChunkPool(); - private final ObjectChunkPool objectChunkPool = new ObjectChunkPool(); + private final BooleanChunkPool booleanChunkPool = new BooleanChunkSoftPool(); + private final CharChunkPool charChunkPool = new CharChunkSoftPool(); + private final ByteChunkPool byteChunkPool = new ByteChunkSoftPool(); + private final ShortChunkPool shortChunkPool = new ShortChunkSoftPool(); + private final IntChunkPool intChunkPool = new IntChunkSoftPool(); + private final LongChunkPool longChunkPool = new LongChunkSoftPool(); + private final FloatChunkPool floatChunkPool = new FloatChunkSoftPool(); + private final DoubleChunkPool doubleChunkPool = new DoubleChunkSoftPool(); + private final ObjectChunkPool objectChunkPool = new ObjectChunkSoftPool(); private final Map pools; { final EnumMap tempPools = new EnumMap<>(ChunkType.class); - tempPools.put(ChunkType.Boolean, booleanChunkPool); - tempPools.put(ChunkType.Char, charChunkPool); - tempPools.put(ChunkType.Byte, byteChunkPool); - tempPools.put(ChunkType.Short, shortChunkPool); - tempPools.put(ChunkType.Int, intChunkPool); - tempPools.put(ChunkType.Long, longChunkPool); - tempPools.put(ChunkType.Float, floatChunkPool); - tempPools.put(ChunkType.Double, doubleChunkPool); - tempPools.put(ChunkType.Object, objectChunkPool); + tempPools.put(ChunkType.Boolean, booleanChunkPool.asChunkPool()); + tempPools.put(ChunkType.Char, charChunkPool.asChunkPool()); + tempPools.put(ChunkType.Byte, byteChunkPool.asChunkPool()); + tempPools.put(ChunkType.Short, shortChunkPool.asChunkPool()); + tempPools.put(ChunkType.Int, intChunkPool.asChunkPool()); + tempPools.put(ChunkType.Long, longChunkPool.asChunkPool()); + tempPools.put(ChunkType.Float, floatChunkPool.asChunkPool()); + tempPools.put(ChunkType.Double, doubleChunkPool.asChunkPool()); + tempPools.put(ChunkType.Object, objectChunkPool.asChunkPool()); pools = Collections.unmodifiableMap(tempPools); } @@ -97,4 +126,285 @@ public DoubleChunkPool getDoubleChunkPool() { public ObjectChunkPool getObjectChunkPool() { return objectChunkPool; } + + @Override + public ChunkPool asChunkPool() { + throw new UnsupportedOperationException( + "MultiChunkPool can't create a ChunkPool, call this on the specific type required"); + } + + @Override + public WritableBooleanChunk takeWritableBooleanChunk(int capacity) { + return booleanChunkPool.takeWritableBooleanChunk(capacity); + } + + @Override + public void giveWritableBooleanChunk(@NotNull WritableBooleanChunk writableBooleanChunk) { + booleanChunkPool.giveWritableBooleanChunk(writableBooleanChunk); + } + + @Override + public ResettableBooleanChunk takeResettableBooleanChunk() { + return booleanChunkPool.takeResettableBooleanChunk(); + } + + @Override + public void giveResettableBooleanChunk(@NotNull ResettableBooleanChunk resettableBooleanChunk) { + booleanChunkPool.giveResettableBooleanChunk(resettableBooleanChunk); + } + + @Override + public ResettableWritableBooleanChunk takeResettableWritableBooleanChunk() { + return booleanChunkPool.takeResettableWritableBooleanChunk(); + } + + @Override + public void giveResettableWritableBooleanChunk( + @NotNull ResettableWritableBooleanChunk resettableWritableBooleanChunk) { + booleanChunkPool.giveResettableWritableBooleanChunk(resettableWritableBooleanChunk); + } + + @Override + public WritableCharChunk takeWritableCharChunk(int capacity) { + return charChunkPool.takeWritableCharChunk(capacity); + } + + @Override + public void giveWritableCharChunk(@NotNull WritableCharChunk writableCharChunk) { + charChunkPool.giveWritableCharChunk(writableCharChunk); + } + + @Override + public ResettableCharChunk takeResettableCharChunk() { + return charChunkPool.takeResettableCharChunk(); + } + + @Override + public void giveResettableCharChunk(@NotNull ResettableCharChunk resettableCharChunk) { + charChunkPool.giveResettableCharChunk(resettableCharChunk); + } + + @Override + public ResettableWritableCharChunk takeResettableWritableCharChunk() { + return charChunkPool.takeResettableWritableCharChunk(); + } + + @Override + public void giveResettableWritableCharChunk(@NotNull ResettableWritableCharChunk resettableWritableCharChunk) { + charChunkPool.giveResettableWritableCharChunk(resettableWritableCharChunk); + } + + @Override + public WritableByteChunk takeWritableByteChunk(int capacity) { + return byteChunkPool.takeWritableByteChunk(capacity); + } + + @Override + public void giveWritableByteChunk(@NotNull WritableByteChunk writableByteChunk) { + byteChunkPool.giveWritableByteChunk(writableByteChunk); + } + + @Override + public ResettableByteChunk takeResettableByteChunk() { + return byteChunkPool.takeResettableByteChunk(); + } + + @Override + public void giveResettableByteChunk(@NotNull ResettableByteChunk resettableByteChunk) { + byteChunkPool.giveResettableByteChunk(resettableByteChunk); + } + + @Override + public ResettableWritableByteChunk takeResettableWritableByteChunk() { + return byteChunkPool.takeResettableWritableByteChunk(); + } + + @Override + public void giveResettableWritableByteChunk(@NotNull ResettableWritableByteChunk resettableWritableByteChunk) { + byteChunkPool.giveResettableWritableByteChunk(resettableWritableByteChunk); + } + + @Override + public WritableShortChunk takeWritableShortChunk(int capacity) { + return shortChunkPool.takeWritableShortChunk(capacity); + } + + @Override + public void giveWritableShortChunk(@NotNull WritableShortChunk writableShortChunk) { + shortChunkPool.giveWritableShortChunk(writableShortChunk); + } + + @Override + public ResettableShortChunk takeResettableShortChunk() { + return shortChunkPool.takeResettableShortChunk(); + } + + @Override + public void giveResettableShortChunk(@NotNull ResettableShortChunk resettableShortChunk) { + shortChunkPool.giveResettableShortChunk(resettableShortChunk); + } + + @Override + public ResettableWritableShortChunk takeResettableWritableShortChunk() { + return shortChunkPool.takeResettableWritableShortChunk(); + } + + @Override + public void giveResettableWritableShortChunk( + @NotNull ResettableWritableShortChunk resettableWritableShortChunk) { + shortChunkPool.giveResettableWritableShortChunk(resettableWritableShortChunk); + } + + @Override + public WritableIntChunk takeWritableIntChunk(int capacity) { + return intChunkPool.takeWritableIntChunk(capacity); + } + + @Override + public void giveWritableIntChunk(@NotNull WritableIntChunk writableIntChunk) { + intChunkPool.giveWritableIntChunk(writableIntChunk); + } + + @Override + public ResettableIntChunk takeResettableIntChunk() { + return intChunkPool.takeResettableIntChunk(); + } + + @Override + public void giveResettableIntChunk(@NotNull ResettableIntChunk resettableIntChunk) { + intChunkPool.giveResettableIntChunk(resettableIntChunk); + } + + @Override + public ResettableWritableIntChunk takeResettableWritableIntChunk() { + return intChunkPool.takeResettableWritableIntChunk(); + } + + @Override + public void giveResettableWritableIntChunk(@NotNull ResettableWritableIntChunk resettableWritableIntChunk) { + intChunkPool.giveResettableWritableIntChunk(resettableWritableIntChunk); + } + + @Override + public WritableLongChunk takeWritableLongChunk(int capacity) { + return longChunkPool.takeWritableLongChunk(capacity); + } + + @Override + public void giveWritableLongChunk(@NotNull WritableLongChunk writableLongChunk) { + longChunkPool.giveWritableLongChunk(writableLongChunk); + } + + @Override + public ResettableLongChunk takeResettableLongChunk() { + return longChunkPool.takeResettableLongChunk(); + } + + @Override + public void giveResettableLongChunk(@NotNull ResettableLongChunk resettableLongChunk) { + longChunkPool.giveResettableLongChunk(resettableLongChunk); + } + + @Override + public ResettableWritableLongChunk takeResettableWritableLongChunk() { + return longChunkPool.takeResettableWritableLongChunk(); + } + + @Override + public void giveResettableWritableLongChunk(@NotNull ResettableWritableLongChunk resettableWritableLongChunk) { + longChunkPool.giveResettableWritableLongChunk(resettableWritableLongChunk); + } + + @Override + public WritableFloatChunk takeWritableFloatChunk(int capacity) { + return floatChunkPool.takeWritableFloatChunk(capacity); + } + + @Override + public void giveWritableFloatChunk(@NotNull WritableFloatChunk writableFloatChunk) { + floatChunkPool.giveWritableFloatChunk(writableFloatChunk); + } + + @Override + public ResettableFloatChunk takeResettableFloatChunk() { + return floatChunkPool.takeResettableFloatChunk(); + } + + @Override + public void giveResettableFloatChunk(@NotNull ResettableFloatChunk resettableFloatChunk) { + floatChunkPool.giveResettableFloatChunk(resettableFloatChunk); + } + + @Override + public ResettableWritableFloatChunk takeResettableWritableFloatChunk() { + return floatChunkPool.takeResettableWritableFloatChunk(); + } + + @Override + public void giveResettableWritableFloatChunk( + @NotNull ResettableWritableFloatChunk resettableWritableFloatChunk) { + floatChunkPool.giveResettableWritableFloatChunk(resettableWritableFloatChunk); + } + + @Override + public WritableDoubleChunk takeWritableDoubleChunk(int capacity) { + return doubleChunkPool.takeWritableDoubleChunk(capacity); + } + + @Override + public void giveWritableDoubleChunk(@NotNull WritableDoubleChunk writableDoubleChunk) { + doubleChunkPool.giveWritableDoubleChunk(writableDoubleChunk); + } + + @Override + public ResettableDoubleChunk takeResettableDoubleChunk() { + return doubleChunkPool.takeResettableDoubleChunk(); + } + + @Override + public void giveResettableDoubleChunk(@NotNull ResettableDoubleChunk resettableDoubleChunk) { + doubleChunkPool.giveResettableDoubleChunk(resettableDoubleChunk); + } + + @Override + public ResettableWritableDoubleChunk takeResettableWritableDoubleChunk() { + return doubleChunkPool.takeResettableWritableDoubleChunk(); + } + + @Override + public void giveResettableWritableDoubleChunk( + @NotNull ResettableWritableDoubleChunk resettableWritableDoubleChunk) { + doubleChunkPool.giveResettableWritableDoubleChunk(resettableWritableDoubleChunk); + } + + @Override + public WritableObjectChunk takeWritableObjectChunk(int capacity) { + return objectChunkPool.takeWritableObjectChunk(capacity); + } + + @Override + public void giveWritableObjectChunk(@NotNull WritableObjectChunk writableObjectChunk) { + objectChunkPool.giveWritableObjectChunk(writableObjectChunk); + } + + @Override + public ResettableObjectChunk takeResettableObjectChunk() { + return objectChunkPool.takeResettableObjectChunk(); + } + + @Override + public void giveResettableObjectChunk(@NotNull ResettableObjectChunk resettableObjectChunk) { + objectChunkPool.giveResettableObjectChunk(resettableObjectChunk); + } + + @Override + public ResettableWritableObjectChunk takeResettableWritableObjectChunk() { + return objectChunkPool.takeResettableWritableObjectChunk(); + } + + @Override + public void giveResettableWritableObjectChunk( + @NotNull ResettableWritableObjectChunk resettableWritableObjectChunk) { + objectChunkPool.giveResettableWritableObjectChunk(resettableWritableObjectChunk); + } } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkPool.java index 1fe270bc87d..ed281fb7c8f 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkPool.java @@ -1,140 +1,26 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableObjectChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.ResettableWritableObjectChunk; +import io.deephaven.chunk.WritableChunk; +import io.deephaven.chunk.WritableObjectChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; +public interface ObjectChunkPool { + ChunkPool asChunkPool(); -/** - * {@link ChunkPool} implementation for chunks of objects. - */ -@SuppressWarnings("rawtypes") -public final class ObjectChunkPool implements ChunkPool { + WritableObjectChunk takeWritableObjectChunk(int capacity); - private final WritableObjectChunk EMPTY = WritableObjectChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_OBJECT_ARRAY); + void giveWritableObjectChunk(@NotNull WritableObjectChunk writableObjectChunk); - /** - * Sub-pools by power-of-two sizes for {@link WritableObjectChunk}s. - */ - private final SegmentedSoftPool[] writableObjectChunks; + ResettableObjectChunk takeResettableObjectChunk(); - /** - * Sub-pool of {@link ResettableObjectChunk}s. - */ - private final SegmentedSoftPool resettableObjectChunks; + void giveResettableObjectChunk(@NotNull ResettableObjectChunk resettableObjectChunk); - /** - * Sub-pool of {@link ResettableWritableObjectChunk}s. - */ - private final SegmentedSoftPool resettableWritableObjectChunks; + ResettableWritableObjectChunk takeResettableWritableObjectChunk(); - ObjectChunkPool() { - //noinspection unchecked - writableObjectChunks = (SegmentedSoftPool[]) new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableObjectChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableObjectChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableObjectChunk chunk) -> { - chunk.fillWithNullValue(0, chunkCapacity); - chunk.setSize(chunkCapacity); - } - ); - } - resettableObjectChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableObjectChunk::makeResettableChunkForPool), - ResettableObjectChunk::clear - ); - resettableWritableObjectChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableObjectChunk::makeResettableChunkForPool), - ResettableWritableObjectChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableObjectChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableObjectChunk(writableChunk.asWritableObjectChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableObjectChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableObjectChunk(resettableChunk.asResettableObjectChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableObjectChunk(); - } - - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableObjectChunk(resettableWritableChunk.asResettableWritableObjectChunk()); - } - - public WritableObjectChunk takeWritableObjectChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableObjectChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableObjectChunk result = writableObjectChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableObjectChunk.makeWritableChunkForPool(capacity)); - } - - public void giveWritableObjectChunk(@NotNull final WritableObjectChunk writableObjectChunk) { - if (writableObjectChunk == EMPTY || writableObjectChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableObjectChunk); - final int capacity = writableObjectChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableObjectChunks[poolIndexForGive].give(writableObjectChunk); - } - } - - public ResettableObjectChunk takeResettableObjectChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableObjectChunks.take()); - } - - public void giveResettableObjectChunk(@NotNull final ResettableObjectChunk resettableObjectChunk) { - resettableObjectChunks.give(ChunkPoolReleaseTracking.onGive(resettableObjectChunk)); - } - - public ResettableWritableObjectChunk takeResettableWritableObjectChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableObjectChunks.take()); - } - - public void giveResettableWritableObjectChunk(@NotNull final ResettableWritableObjectChunk resettableWritableObjectChunk) { - resettableWritableObjectChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableObjectChunk)); - } + void giveResettableWritableObjectChunk(@NotNull ResettableWritableObjectChunk resettableWritableObjectChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkSoftPool.java new file mode 100644 index 00000000000..41d34687f8f --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ObjectChunkSoftPool.java @@ -0,0 +1,181 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of objects. + */ +@SuppressWarnings("rawtypes") +public final class ObjectChunkSoftPool implements ChunkPool, ObjectChunkPool { + + private final WritableObjectChunk EMPTY = WritableObjectChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_OBJECT_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableObjectChunk}s. + */ + private final SegmentedSoftPool[] writableObjectChunks; + + /** + * Sub-pool of {@link ResettableObjectChunk}s. + */ + private final SegmentedSoftPool resettableObjectChunks; + + /** + * Sub-pool of {@link ResettableWritableObjectChunk}s. + */ + private final SegmentedSoftPool resettableWritableObjectChunks; + + ObjectChunkSoftPool() { + //noinspection unchecked + writableObjectChunks = (SegmentedSoftPool[]) new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableObjectChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableObjectChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableObjectChunk chunk) -> { + chunk.fillWithNullValue(0, chunkCapacity); + chunk.setSize(chunkCapacity); + } + ); + } + resettableObjectChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableObjectChunk::makeResettableChunkForPool), + ResettableObjectChunk::clear + ); + resettableWritableObjectChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableObjectChunk::makeResettableChunkForPool), + ResettableWritableObjectChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableObjectChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableObjectChunk(writableChunk.asWritableObjectChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableObjectChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableObjectChunk(resettableChunk.asResettableObjectChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableObjectChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableObjectChunk(resettableWritableChunk.asResettableWritableObjectChunk()); + } + }; + } + + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableObjectChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableObjectChunk(writableChunk.asWritableObjectChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableObjectChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableObjectChunk(resettableChunk.asResettableObjectChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableObjectChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableObjectChunk(resettableWritableChunk.asResettableWritableObjectChunk()); + } + + @Override + public WritableObjectChunk takeWritableObjectChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableObjectChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableObjectChunk result = writableObjectChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableObjectChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableObjectChunk(@NotNull final WritableObjectChunk writableObjectChunk) { + if (writableObjectChunk == EMPTY || writableObjectChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableObjectChunk); + final int capacity = writableObjectChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableObjectChunks[poolIndexForGive].give(writableObjectChunk); + } + } + + @Override + public ResettableObjectChunk takeResettableObjectChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableObjectChunks.take()); + } + + @Override + public void giveResettableObjectChunk(@NotNull final ResettableObjectChunk resettableObjectChunk) { + resettableObjectChunks.give(ChunkPoolReleaseTracking.onGive(resettableObjectChunk)); + } + + @Override + public ResettableWritableObjectChunk takeResettableWritableObjectChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableObjectChunks.take()); + } + + @Override + public void giveResettableWritableObjectChunk(@NotNull final ResettableWritableObjectChunk resettableWritableObjectChunk) { + resettableWritableObjectChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableObjectChunk)); + } +} diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkPool.java index deae2803997..13c23f9346e 100644 --- a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkPool.java +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkPool.java @@ -1,6 +1,3 @@ -/** - * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending - */ /* * --------------------------------------------------------------------------------------------------------------------- * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkPool and regenerate @@ -8,135 +5,28 @@ */ package io.deephaven.chunk.util.pools; -import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.ResettableShortChunk; +import io.deephaven.chunk.ResettableReadOnlyChunk; +import io.deephaven.chunk.ResettableWritableShortChunk; +import io.deephaven.chunk.ResettableWritableChunk; +import io.deephaven.chunk.WritableShortChunk; +import io.deephaven.chunk.WritableChunk; import io.deephaven.chunk.attributes.Any; -import io.deephaven.chunk.*; -import io.deephaven.util.datastructures.SegmentedSoftPool; import org.jetbrains.annotations.NotNull; -import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; - -/** - * {@link ChunkPool} implementation for chunks of shorts. - */ -@SuppressWarnings("rawtypes") -public final class ShortChunkPool implements ChunkPool { - - private final WritableShortChunk EMPTY = WritableShortChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_SHORT_ARRAY); - - /** - * Sub-pools by power-of-two sizes for {@link WritableShortChunk}s. - */ - private final SegmentedSoftPool[] writableShortChunks; - - /** - * Sub-pool of {@link ResettableShortChunk}s. - */ - private final SegmentedSoftPool resettableShortChunks; - - /** - * Sub-pool of {@link ResettableWritableShortChunk}s. - */ - private final SegmentedSoftPool resettableWritableShortChunks; - - ShortChunkPool() { - //noinspection unchecked - writableShortChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; - for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { - final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; - final int chunkCapacity = 1 << chunkLog2Capacity; - writableShortChunks[pcci] = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableShortChunk.makeWritableChunkForPool(chunkCapacity)), - (final WritableShortChunk chunk) -> chunk.setSize(chunkCapacity) - ); - } - resettableShortChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableShortChunk::makeResettableChunkForPool), - ResettableShortChunk::clear - ); - resettableWritableShortChunks = new SegmentedSoftPool<>( - SUB_POOL_SEGMENT_CAPACITY, - () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableShortChunk::makeResettableChunkForPool), - ResettableWritableShortChunk::clear - ); - } - - @Override - public WritableChunk takeWritableChunk(final int capacity) { - return takeWritableShortChunk(capacity); - } - - @Override - public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { - giveWritableShortChunk(writableChunk.asWritableShortChunk()); - } - - @Override - public ResettableReadOnlyChunk takeResettableChunk() { - return takeResettableShortChunk(); - } - - @Override - public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { - giveResettableShortChunk(resettableChunk.asResettableShortChunk()); - } - - @Override - public ResettableWritableChunk takeResettableWritableChunk() { - return takeResettableWritableShortChunk(); - } +public interface ShortChunkPool { - @Override - public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { - giveResettableWritableShortChunk(resettableWritableChunk.asResettableWritableShortChunk()); - } + ChunkPool asChunkPool(); - public WritableShortChunk takeWritableShortChunk(final int capacity) { - if (capacity == 0) { - //noinspection unchecked - return (WritableShortChunk) EMPTY; - } - final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); - if (poolIndexForTake >= 0) { - //noinspection resource - final WritableShortChunk result = writableShortChunks[poolIndexForTake].take(); - result.setSize(capacity); - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(result); - } - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(WritableShortChunk.makeWritableChunkForPool(capacity)); - } + WritableShortChunk takeWritableShortChunk(int capacity); - public void giveWritableShortChunk(@NotNull final WritableShortChunk writableShortChunk) { - if (writableShortChunk == EMPTY || writableShortChunk.isAlias(EMPTY)) { - return; - } - ChunkPoolReleaseTracking.onGive(writableShortChunk); - final int capacity = writableShortChunk.capacity(); - final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); - if (poolIndexForGive >= 0) { - writableShortChunks[poolIndexForGive].give(writableShortChunk); - } - } + void giveWritableShortChunk(@NotNull WritableShortChunk writableShortChunk); - public ResettableShortChunk takeResettableShortChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableShortChunks.take()); - } + ResettableShortChunk takeResettableShortChunk(); - public void giveResettableShortChunk(@NotNull final ResettableShortChunk resettableShortChunk) { - resettableShortChunks.give(ChunkPoolReleaseTracking.onGive(resettableShortChunk)); - } + void giveResettableShortChunk(@NotNull ResettableShortChunk resettableShortChunk); - public ResettableWritableShortChunk takeResettableWritableShortChunk() { - //noinspection unchecked - return ChunkPoolReleaseTracking.onTake(resettableWritableShortChunks.take()); - } + ResettableWritableShortChunk takeResettableWritableShortChunk(); - public void giveResettableWritableShortChunk(@NotNull final ResettableWritableShortChunk resettableWritableShortChunk) { - resettableWritableShortChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableShortChunk)); - } + void giveResettableWritableShortChunk(@NotNull ResettableWritableShortChunk resettableWritableShortChunk); } diff --git a/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkSoftPool.java b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkSoftPool.java new file mode 100644 index 00000000000..09dd7beb3d3 --- /dev/null +++ b/engine/chunk/src/main/java/io/deephaven/chunk/util/pools/ShortChunkSoftPool.java @@ -0,0 +1,153 @@ +/** + * Copyright (c) 2016-2022 Deephaven Data Labs and Patent Pending + */ +/* + * --------------------------------------------------------------------------------------------------------------------- + * AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - for any changes edit CharChunkSoftPool and regenerate + * --------------------------------------------------------------------------------------------------------------------- + */ +package io.deephaven.chunk.util.pools; + +import io.deephaven.util.type.ArrayTypeUtils; +import io.deephaven.chunk.attributes.Any; +import io.deephaven.chunk.*; +import io.deephaven.util.datastructures.SegmentedSoftPool; +import org.jetbrains.annotations.NotNull; + +import static io.deephaven.chunk.util.pools.ChunkPoolConstants.*; + +/** + * {@link ChunkPool} implementation for chunks of shorts. + */ +@SuppressWarnings("rawtypes") +public final class ShortChunkSoftPool implements ShortChunkPool { + + private final WritableShortChunk EMPTY = WritableShortChunk.writableChunkWrap(ArrayTypeUtils.EMPTY_SHORT_ARRAY); + + /** + * Sub-pools by power-of-two sizes for {@link WritableShortChunk}s. + */ + private final SegmentedSoftPool[] writableShortChunks; + + /** + * Sub-pool of {@link ResettableShortChunk}s. + */ + private final SegmentedSoftPool resettableShortChunks; + + /** + * Sub-pool of {@link ResettableWritableShortChunk}s. + */ + private final SegmentedSoftPool resettableWritableShortChunks; + + ShortChunkSoftPool() { + //noinspection unchecked + writableShortChunks = new SegmentedSoftPool[NUM_POOLED_CHUNK_CAPACITIES]; + for (int pcci = 0; pcci < NUM_POOLED_CHUNK_CAPACITIES; ++pcci) { + final int chunkLog2Capacity = pcci + SMALLEST_POOLED_CHUNK_LOG2_CAPACITY; + final int chunkCapacity = 1 << chunkLog2Capacity; + writableShortChunks[pcci] = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(() -> WritableShortChunk.makeWritableChunkForPool(chunkCapacity)), + (final WritableShortChunk chunk) -> chunk.setSize(chunkCapacity) + ); + } + resettableShortChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableShortChunk::makeResettableChunkForPool), + ResettableShortChunk::clear + ); + resettableWritableShortChunks = new SegmentedSoftPool<>( + SUB_POOL_SEGMENT_CAPACITY, + () -> ChunkPoolInstrumentation.getAndRecord(ResettableWritableShortChunk::makeResettableChunkForPool), + ResettableWritableShortChunk::clear + ); + } + + @Override + public ChunkPool asChunkPool() { + return new ChunkPool() { + @Override + public WritableChunk takeWritableChunk(final int capacity) { + return takeWritableShortChunk(capacity); + } + + @Override + public void giveWritableChunk(@NotNull final WritableChunk writableChunk) { + giveWritableShortChunk(writableChunk.asWritableShortChunk()); + } + + @Override + public ResettableReadOnlyChunk takeResettableChunk() { + return takeResettableShortChunk(); + } + + @Override + public void giveResettableChunk(@NotNull final ResettableReadOnlyChunk resettableChunk) { + giveResettableShortChunk(resettableChunk.asResettableShortChunk()); + } + + @Override + public ResettableWritableChunk takeResettableWritableChunk() { + return takeResettableWritableShortChunk(); + } + + @Override + public void giveResettableWritableChunk(@NotNull final ResettableWritableChunk resettableWritableChunk) { + giveResettableWritableShortChunk(resettableWritableChunk.asResettableWritableShortChunk()); + } + }; + } + + @Override + public WritableShortChunk takeWritableShortChunk(final int capacity) { + if (capacity == 0) { + //noinspection unchecked + return (WritableShortChunk) EMPTY; + } + final int poolIndexForTake = getPoolIndexForTake(checkCapacityBounds(capacity)); + if (poolIndexForTake >= 0) { + //noinspection resource + final WritableShortChunk result = writableShortChunks[poolIndexForTake].take(); + result.setSize(capacity); + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(result); + } + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(WritableShortChunk.makeWritableChunkForPool(capacity)); + } + + @Override + public void giveWritableShortChunk(@NotNull final WritableShortChunk writableShortChunk) { + if (writableShortChunk == EMPTY || writableShortChunk.isAlias(EMPTY)) { + return; + } + ChunkPoolReleaseTracking.onGive(writableShortChunk); + final int capacity = writableShortChunk.capacity(); + final int poolIndexForGive = getPoolIndexForGive(checkCapacityBounds(capacity)); + if (poolIndexForGive >= 0) { + writableShortChunks[poolIndexForGive].give(writableShortChunk); + } + } + + @Override + public ResettableShortChunk takeResettableShortChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableShortChunks.take()); + } + + @Override + public void giveResettableShortChunk(@NotNull final ResettableShortChunk resettableShortChunk) { + resettableShortChunks.give(ChunkPoolReleaseTracking.onGive(resettableShortChunk)); + } + + @Override + public ResettableWritableShortChunk takeResettableWritableShortChunk() { + //noinspection unchecked + return ChunkPoolReleaseTracking.onTake(resettableWritableShortChunks.take()); + } + + @Override + public void giveResettableWritableShortChunk(@NotNull final ResettableWritableShortChunk resettableWritableShortChunk) { + resettableWritableShortChunks.give(ChunkPoolReleaseTracking.onGive(resettableWritableShortChunk)); + } +} diff --git a/replication/static/src/main/java/io/deephaven/replicators/ReplicateSourcesAndChunks.java b/replication/static/src/main/java/io/deephaven/replicators/ReplicateSourcesAndChunks.java index 9cd504d79db..8e8378f2937 100644 --- a/replication/static/src/main/java/io/deephaven/replicators/ReplicateSourcesAndChunks.java +++ b/replication/static/src/main/java/io/deephaven/replicators/ReplicateSourcesAndChunks.java @@ -97,6 +97,7 @@ public static void main(String... args) throws IOException { replicateFactories(); charToAll("engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkPool.java"); + charToAll("engine/chunk/src/main/java/io/deephaven/chunk/util/pools/CharChunkSoftPool.java"); replicateChunkFillers();