From ae82efc013cf0529d6156306ab1d1f4d8a9f963a Mon Sep 17 00:00:00 2001 From: Dmitry Konstantinov Date: Thu, 20 Mar 2025 16:28:50 +0000 Subject: [PATCH] Add LittleEndianMemoryUtil and NativeEndianMemoryUtil, switch memtable-related off-heap objects and Memory to use them and have Little Endian now. Add BE offsets detection on Summary loading. Add test SSTables in an old format with BE offsets in Summary component to LegacySSTableTest. Patch by Dmitry Konstantinov; reviewed by Branimir Lambov, Michael Semb Wever for CASSANDRA-20190 --- CHANGES.txt | 1 + .../apache/cassandra/db/NativeClustering.java | 25 +- .../cassandra/db/NativeDecoratedKey.java | 9 +- .../apache/cassandra/db/rows/NativeCell.java | 33 +-- .../io/sstable/indexsummary/IndexSummary.java | 12 + .../org/apache/cassandra/io/util/Memory.java | 144 +----------- .../utils/memory/LittleEndianMemoryUtil.java | 146 ++++++++++++ .../cassandra/utils/memory/MemoryUtil.java | 173 +------------- .../utils/memory/NativeEndianMemoryUtil.java | 214 ++++++++++++++++++ .../da-500-bti-CompressionInfo.db | Bin 0 -> 207 bytes .../da-500-bti-Data.db | Bin 0 -> 8602 bytes .../da-500-bti-Digest.crc32 | 1 + .../da-500-bti-Filter.db | Bin 0 -> 24 bytes .../da-500-bti-Partitions.db | Bin 0 -> 62 bytes .../da-500-bti-Rows.db | Bin 0 -> 508 bytes .../da-500-bti-Statistics.db | Bin 0 -> 7312 bytes .../da-500-bti-TOC.txt | 8 + .../ma-306-big-CompressionInfo.db | Bin 0 -> 83 bytes .../ma-306-big-Data.db | Bin 0 -> 5221 bytes .../ma-306-big-Digest.crc32 | 1 + .../ma-306-big-Filter.db | Bin 0 -> 24 bytes .../ma-306-big-Index.db | Bin 0 -> 157553 bytes .../ma-306-big-Statistics.db | Bin 0 -> 7046 bytes .../ma-306-big-Summary.db | Bin 0 -> 47 bytes .../ma-306-big-TOC.txt | 8 + .../mb-307-big-CompressionInfo.db | Bin 0 -> 83 bytes .../mb-307-big-Data.db | Bin 0 -> 5232 bytes .../mb-307-big-Digest.crc32 | 1 + .../mb-307-big-Filter.db | Bin 0 -> 24 bytes .../mb-307-big-Index.db | Bin 0 -> 157553 bytes .../mb-307-big-Statistics.db | Bin 0 -> 7058 bytes .../mb-307-big-Summary.db | Bin 0 -> 47 bytes .../mb-307-big-TOC.txt | 8 + .../mc-3113-big-CompressionInfo.db | Bin 0 -> 83 bytes .../mc-3113-big-Data.db | Bin 0 -> 5215 bytes .../mc-3113-big-Digest.crc32 | 1 + .../mc-3113-big-Filter.db | Bin 0 -> 24 bytes .../mc-3113-big-Index.db | Bin 0 -> 157553 bytes .../mc-3113-big-Statistics.db | Bin 0 -> 7070 bytes .../mc-3113-big-Summary.db | Bin 0 -> 47 bytes .../mc-3113-big-TOC.txt | 8 + .../md-31110-big-CompressionInfo.db | Bin 0 -> 83 bytes .../md-31110-big-Data.db | Bin 0 -> 5206 bytes .../md-31110-big-Digest.crc32 | 1 + .../md-31110-big-Filter.db | Bin 0 -> 24 bytes .../md-31110-big-Index.db | Bin 0 -> 157553 bytes .../md-31110-big-Statistics.db | Bin 0 -> 7134 bytes .../md-31110-big-Summary.db | Bin 0 -> 47 bytes .../md-31110-big-TOC.txt | 8 + .../me-31111-big-CompressionInfo.db | Bin 0 -> 83 bytes .../me-31111-big-Data.db | Bin 0 -> 5207 bytes .../me-31111-big-Digest.crc32 | 1 + .../me-31111-big-Filter.db | Bin 0 -> 24 bytes .../me-31111-big-Index.db | Bin 0 -> 157553 bytes .../me-31111-big-Statistics.db | Bin 0 -> 7151 bytes .../me-31111-big-Summary.db | Bin 0 -> 47 bytes .../me-31111-big-TOC.txt | 8 + .../na-40-big-CompressionInfo.db | Bin 0 -> 207 bytes .../na-40-big-Data.db | Bin 0 -> 8587 bytes .../na-40-big-Digest.crc32 | 1 + .../na-40-big-Filter.db | Bin 0 -> 24 bytes .../na-40-big-Index.db | Bin 0 -> 157553 bytes .../na-40-big-Statistics.db | Bin 0 -> 7160 bytes .../na-40-big-Summary.db | Bin 0 -> 47 bytes .../na-40-big-TOC.txt | 8 + .../nb-400-big-CompressionInfo.db | Bin 0 -> 207 bytes .../nb-400-big-Data.db | Bin 0 -> 8620 bytes .../nb-400-big-Digest.crc32 | 1 + .../nb-400-big-Filter.db | Bin 0 -> 24 bytes .../nb-400-big-Index.db | Bin 0 -> 157553 bytes .../nb-400-big-Statistics.db | Bin 0 -> 7177 bytes .../nb-400-big-Summary.db | Bin 0 -> 47 bytes .../nb-400-big-TOC.txt | 8 + .../oa-500-big-CompressionInfo.db | Bin 0 -> 207 bytes .../oa-500-big-Data.db | Bin 0 -> 8513 bytes .../oa-500-big-Digest.crc32 | 1 + .../oa-500-big-Filter.db | Bin 0 -> 24 bytes .../oa-500-big-Index.db | Bin 0 -> 157498 bytes .../oa-500-big-Statistics.db | Bin 0 -> 7312 bytes .../oa-500-big-Summary.db | Bin 0 -> 47 bytes .../oa-500-big-TOC.txt | 8 + .../db/compaction/CompactionsCQLTest.java | 2 +- .../io/sstable/LegacySSTableTest.java | 79 ++++--- .../memory/LittleEndianMemoryUtilTest.java | 148 ++++++++++++ .../memory/NativeEndianMemoryUtilTest.java | 148 ++++++++++++ 85 files changed, 852 insertions(+), 363 deletions(-) create mode 100644 src/java/org/apache/cassandra/utils/memory/LittleEndianMemoryUtil.java create mode 100644 src/java/org/apache/cassandra/utils/memory/NativeEndianMemoryUtil.java create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-CompressionInfo.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Data.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Digest.crc32 create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Filter.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Partitions.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Rows.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Statistics.db create mode 100644 test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-TOC.txt create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Data.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Filter.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Index.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Statistics.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Summary.db create mode 100644 test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-TOC.txt create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Data.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Filter.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Index.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Statistics.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Summary.db create mode 100644 test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-TOC.txt create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Data.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Filter.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Index.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Statistics.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Summary.db create mode 100644 test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-TOC.txt create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Data.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Filter.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Index.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Statistics.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Summary.db create mode 100644 test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-TOC.txt create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Data.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Filter.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Index.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Statistics.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Summary.db create mode 100644 test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-TOC.txt create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Data.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Filter.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Index.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Statistics.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Summary.db create mode 100644 test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-TOC.txt create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Data.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Filter.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Index.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Statistics.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Summary.db create mode 100644 test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-TOC.txt create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-CompressionInfo.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Data.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Digest.crc32 create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Filter.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Index.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Statistics.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Summary.db create mode 100644 test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-TOC.txt create mode 100644 test/unit/org/apache/cassandra/utils/memory/LittleEndianMemoryUtilTest.java create mode 100644 test/unit/org/apache/cassandra/utils/memory/NativeEndianMemoryUtilTest.java diff --git a/CHANGES.txt b/CHANGES.txt index 21b9f481b2..545ba01dab 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -1,4 +1,5 @@ 5.0.5 + * Switch memtable-related off-heap objects to Native Endian and Memory to Little Endian (CASSANDRA-20190) * SAI marks an index as non-empty when a partial partition/row modifications is flushed due to repair (CASSANDRA-20567) * SAI fails queries when multiple columns exist and a non-indexed column is a composite with a map (CASSANDRA-19891) * Grant permission on keyspaces system_views and system_virtual_schema not possible (CASSANDRA-20171) diff --git a/src/java/org/apache/cassandra/db/NativeClustering.java b/src/java/org/apache/cassandra/db/NativeClustering.java index e7c7e8893a..e83ded06c6 100644 --- a/src/java/org/apache/cassandra/db/NativeClustering.java +++ b/src/java/org/apache/cassandra/db/NativeClustering.java @@ -28,6 +28,7 @@ import org.apache.cassandra.utils.ObjectSizes; import org.apache.cassandra.utils.concurrent.OpOrder; import org.apache.cassandra.utils.memory.HeapCloner; import org.apache.cassandra.utils.memory.MemoryUtil; +import org.apache.cassandra.utils.memory.NativeEndianMemoryUtil; import org.apache.cassandra.utils.memory.NativeAllocator; public class NativeClustering implements Clustering @@ -50,30 +51,30 @@ public class NativeClustering implements Clustering peer = allocator.allocate(metadataSize + dataSize + bitmapSize, writeOp); long bitmapStart = peer + metadataSize; - MemoryUtil.setShort(peer, (short) count); - MemoryUtil.setShort(peer + (metadataSize - 2), (short) dataSize); // goes at the end of the other offsets + NativeEndianMemoryUtil.setShort(peer, (short) count); + NativeEndianMemoryUtil.setShort(peer + (metadataSize - 2), (short) dataSize); // goes at the end of the other offsets - MemoryUtil.setByte(bitmapStart, bitmapSize, (byte) 0); + NativeEndianMemoryUtil.setByte(bitmapStart, bitmapSize, (byte) 0); long dataStart = peer + metadataSize + bitmapSize; int dataOffset = 0; for (int i = 0 ; i < count ; i++) { - MemoryUtil.setShort(peer + 2 + i * 2, (short) dataOffset); + NativeEndianMemoryUtil.setShort(peer + 2 + i * 2, (short) dataOffset); ByteBuffer value = clustering.bufferAt(i); if (value == null) { long boffset = bitmapStart + (i >>> 3); - int b = MemoryUtil.getByte(boffset); + int b = NativeEndianMemoryUtil.getByte(boffset); b |= 1 << (i & 7); - MemoryUtil.setByte(boffset, (byte) b); + NativeEndianMemoryUtil.setByte(boffset, (byte) b); continue; } assert value.order() == ByteOrder.BIG_ENDIAN; int size = value.remaining(); - MemoryUtil.setBytes(dataStart + dataOffset, value); + NativeEndianMemoryUtil.setBytes(dataStart + dataOffset, value); dataOffset += size; } } @@ -90,13 +91,13 @@ public class NativeClustering implements Clustering public int size() { - return MemoryUtil.getShort(peer); + return NativeEndianMemoryUtil.getUnsignedShort(peer); } public int dataSize() { int dataSizeOffset = (size() * 2) + 2; // metadataSize - 2 - return MemoryUtil.getShort(peer + dataSizeOffset); + return NativeEndianMemoryUtil.getUnsignedShort(peer + dataSizeOffset); } public ByteBuffer get(int i) @@ -109,12 +110,12 @@ public class NativeClustering implements Clustering int metadataSize = (size * 2) + 4; int bitmapSize = ((size + 7) >>> 3); long bitmapStart = peer + metadataSize; - int b = MemoryUtil.getByte(bitmapStart + (i >>> 3)); + int b = NativeEndianMemoryUtil.getByte(bitmapStart + (i >>> 3)); if ((b & (1 << (i & 7))) != 0) return null; - int startOffset = MemoryUtil.getShort(peer + 2 + i * 2); - int endOffset = MemoryUtil.getShort(peer + 4 + i * 2); + int startOffset = NativeEndianMemoryUtil.getUnsignedShort(peer + 2 + i * 2); + int endOffset = NativeEndianMemoryUtil.getUnsignedShort(peer + 4 + i * 2); return MemoryUtil.getByteBuffer(bitmapStart + bitmapSize + startOffset, endOffset - startOffset, ByteOrder.BIG_ENDIAN); diff --git a/src/java/org/apache/cassandra/db/NativeDecoratedKey.java b/src/java/org/apache/cassandra/db/NativeDecoratedKey.java index bc149084d8..76b2367ae2 100644 --- a/src/java/org/apache/cassandra/db/NativeDecoratedKey.java +++ b/src/java/org/apache/cassandra/db/NativeDecoratedKey.java @@ -26,6 +26,7 @@ import org.apache.cassandra.utils.bytecomparable.ByteSource; import org.apache.cassandra.utils.concurrent.OpOrder; import org.apache.cassandra.utils.memory.MemoryUtil; import org.apache.cassandra.utils.memory.NativeAllocator; +import org.apache.cassandra.utils.memory.NativeEndianMemoryUtil; public class NativeDecoratedKey extends DecoratedKey { @@ -39,7 +40,7 @@ public class NativeDecoratedKey extends DecoratedKey int size = key.remaining(); this.peer = allocator.allocate(4 + size, writeOp); - MemoryUtil.setInt(peer, size); + NativeEndianMemoryUtil.setInt(peer, size); MemoryUtil.setBytes(peer + 4, key); } @@ -50,14 +51,14 @@ public class NativeDecoratedKey extends DecoratedKey int size = keyBytes.length; this.peer = allocator.allocate(4 + size, writeOp); - MemoryUtil.setInt(peer, size); + NativeEndianMemoryUtil.setInt(peer, size); MemoryUtil.setBytes(peer + 4, keyBytes, 0, size); } @Inline int length() { - return MemoryUtil.getInt(peer); + return NativeEndianMemoryUtil.getInt(peer); } @Inline @@ -75,7 +76,7 @@ public class NativeDecoratedKey extends DecoratedKey @Override public int getKeyLength() { - return MemoryUtil.getInt(peer); + return NativeEndianMemoryUtil.getInt(peer); } @Override diff --git a/src/java/org/apache/cassandra/db/rows/NativeCell.java b/src/java/org/apache/cassandra/db/rows/NativeCell.java index b0613f33f6..65516ff31f 100644 --- a/src/java/org/apache/cassandra/db/rows/NativeCell.java +++ b/src/java/org/apache/cassandra/db/rows/NativeCell.java @@ -28,6 +28,7 @@ import org.apache.cassandra.utils.ObjectSizes; import org.apache.cassandra.utils.concurrent.OpOrder; import org.apache.cassandra.utils.memory.MemoryUtil; import org.apache.cassandra.utils.memory.NativeAllocator; +import org.apache.cassandra.utils.memory.NativeEndianMemoryUtil; public class NativeCell extends AbstractCell { @@ -101,11 +102,11 @@ public class NativeCell extends AbstractCell // cellpath? : timestamp : ttl : localDeletionTime : length : : [cell path length] : [] peer = allocator.allocate((int) size, writeOp); - MemoryUtil.setByte(peer + HAS_CELLPATH, (byte)(path == null ? 0 : 1)); - MemoryUtil.setLong(peer + TIMESTAMP, timestamp); - MemoryUtil.setInt(peer + TTL, ttl); - MemoryUtil.setInt(peer + DELETION, localDeletionTimeUnsignedInteger); - MemoryUtil.setInt(peer + LENGTH, value.remaining()); + NativeEndianMemoryUtil.setByte(peer + HAS_CELLPATH, (byte)(path == null ? 0 : 1)); + NativeEndianMemoryUtil.setLong(peer + TIMESTAMP, timestamp); + NativeEndianMemoryUtil.setInt(peer + TTL, ttl); + NativeEndianMemoryUtil.setInt(peer + DELETION, localDeletionTimeUnsignedInteger); + NativeEndianMemoryUtil.setInt(peer + LENGTH, value.remaining()); MemoryUtil.setBytes(peer + VALUE, value); if (path != null) @@ -114,7 +115,7 @@ public class NativeCell extends AbstractCell assert pathbuffer.order() == ByteOrder.BIG_ENDIAN; long offset = peer + VALUE + value.remaining(); - MemoryUtil.setInt(offset, pathbuffer.remaining()); + NativeEndianMemoryUtil.setInt(offset, pathbuffer.remaining()); MemoryUtil.setBytes(offset + 4, pathbuffer); } } @@ -126,17 +127,17 @@ public class NativeCell extends AbstractCell public long timestamp() { - return MemoryUtil.getLong(peer + TIMESTAMP); + return NativeEndianMemoryUtil.getLong(peer + TIMESTAMP); } public int ttl() { - return MemoryUtil.getInt(peer + TTL); + return NativeEndianMemoryUtil.getInt(peer + TTL); } public ByteBuffer value()// FIXME: add native accessor { - int length = MemoryUtil.getInt(peer + LENGTH); + int length = NativeEndianMemoryUtil.getInt(peer + LENGTH); return MemoryUtil.getByteBuffer(peer + VALUE, length, ByteOrder.BIG_ENDIAN); } @@ -147,7 +148,7 @@ public class NativeCell extends AbstractCell public int valueSize() { - return MemoryUtil.getInt(peer + LENGTH); + return NativeEndianMemoryUtil.getInt(peer + LENGTH); } public CellPath path() @@ -155,8 +156,8 @@ public class NativeCell extends AbstractCell if (!hasPath()) return null; - long offset = peer + VALUE + MemoryUtil.getInt(peer + LENGTH); - int size = MemoryUtil.getInt(offset); + long offset = peer + VALUE + NativeEndianMemoryUtil.getInt(peer + LENGTH); + int size = NativeEndianMemoryUtil.getInt(offset); return CellPath.create(MemoryUtil.getByteBuffer(offset + 4, size, ByteOrder.BIG_ENDIAN)); } @@ -194,20 +195,20 @@ public class NativeCell extends AbstractCell public long offHeapSize() { - long size = offHeapSizeWithoutPath(MemoryUtil.getInt(peer + LENGTH)); + long size = offHeapSizeWithoutPath(NativeEndianMemoryUtil.getInt(peer + LENGTH)); if (hasPath()) - size += 4 + MemoryUtil.getInt(peer + size); + size += 4 + NativeEndianMemoryUtil.getInt(peer + size); return size; } private boolean hasPath() { - return MemoryUtil.getByte(peer+ HAS_CELLPATH) != 0; + return NativeEndianMemoryUtil.getByte(peer + HAS_CELLPATH) != 0; } @Override protected int localDeletionTimeAsUnsignedInt() { - return MemoryUtil.getInt(peer + DELETION); + return NativeEndianMemoryUtil.getInt(peer + DELETION); } } diff --git a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummary.java b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummary.java index 6a6546f6a4..23abe117af 100644 --- a/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummary.java +++ b/src/java/org/apache/cassandra/io/sstable/indexsummary/IndexSummary.java @@ -454,6 +454,18 @@ public class IndexSummary extends WrappedSharedCloseable entries.free(); throw ioe; } + + // Before 5.0 offsets were written using Native Endian, now they are stored as Little Endian, + // so we apply a heuristic here to detect + // if the loading index summary was created on a Big Endian machine using Native Endian format + if (offsets.size() > 0) + { + int offset = offsets.getInt(0); + int offsetReversed = Integer.reverseBytes(offset); + if (offsetReversed > 0 && offset > offsetReversed || offset - offsets.size() < 0) + throw new IOException(String.format("Rebuilding index summary because offset value (%d) at position: %d " + + "is Big Endian while Little Endian is expected", offset, 0)); + } // our on-disk representation treats the offsets and the summary data as one contiguous structure, // in which the offsets are based from the start of the structure. i.e., if the offsets occupy // X bytes, the value of the first offset will be X. In memory we split the two regions up, so that diff --git a/src/java/org/apache/cassandra/io/util/Memory.java b/src/java/org/apache/cassandra/io/util/Memory.java index 1d1fca2edf..1e6f6a2150 100644 --- a/src/java/org/apache/cassandra/io/util/Memory.java +++ b/src/java/org/apache/cassandra/io/util/Memory.java @@ -22,14 +22,15 @@ import java.nio.ByteBuffer; import net.nicoulaj.compilecommand.annotations.Inline; -import org.apache.cassandra.utils.Architecture; import org.apache.cassandra.utils.FastByteOperations; import org.apache.cassandra.utils.concurrent.Ref; +import org.apache.cassandra.utils.memory.LittleEndianMemoryUtil; import org.apache.cassandra.utils.memory.MemoryUtil; import sun.misc.Unsafe; /** * An off-heap region of memory that must be manually free'd when no longer needed. + * It uses Little Endian (LE). */ public class Memory implements AutoCloseable, ReadableMemory { @@ -90,7 +91,7 @@ public class Memory implements AutoCloseable, ReadableMemory public void setByte(long offset, byte b) { checkBounds(offset, offset + 1); - unsafe.putByte(peer + offset, b); + LittleEndianMemoryUtil.setByte(peer + offset, b); } public void setMemory(long offset, long bytes, byte b) @@ -103,86 +104,13 @@ public class Memory implements AutoCloseable, ReadableMemory public void setLong(long offset, long l) { checkBounds(offset, offset + 8); - if (Architecture.IS_UNALIGNED) - unsafe.putLong(peer + offset, Architecture.BIG_ENDIAN ? Long.reverseBytes(l) : l); - else - putLongByByte(peer + offset, l); - } - - private void putLongByByte(long address, long value) - { - if (Architecture.BIG_ENDIAN) - { - unsafe.putByte(address, (byte) (value >> 56)); - unsafe.putByte(address + 1, (byte) (value >> 48)); - unsafe.putByte(address + 2, (byte) (value >> 40)); - unsafe.putByte(address + 3, (byte) (value >> 32)); - unsafe.putByte(address + 4, (byte) (value >> 24)); - unsafe.putByte(address + 5, (byte) (value >> 16)); - unsafe.putByte(address + 6, (byte) (value >> 8)); - unsafe.putByte(address + 7, (byte) (value)); - } - else - { - unsafe.putByte(address + 7, (byte) (value >> 56)); - unsafe.putByte(address + 6, (byte) (value >> 48)); - unsafe.putByte(address + 5, (byte) (value >> 40)); - unsafe.putByte(address + 4, (byte) (value >> 32)); - unsafe.putByte(address + 3, (byte) (value >> 24)); - unsafe.putByte(address + 2, (byte) (value >> 16)); - unsafe.putByte(address + 1, (byte) (value >> 8)); - unsafe.putByte(address, (byte) (value)); - } + LittleEndianMemoryUtil.setLong(peer + offset, l); } public void setInt(long offset, int l) { checkBounds(offset, offset + 4); - if (Architecture.IS_UNALIGNED) - unsafe.putInt(peer + offset, Architecture.BIG_ENDIAN ? Integer.reverseBytes(l) : l); - else - putIntByByte(peer + offset, l); - } - - private void putIntByByte(long address, int value) - { - if (Architecture.BIG_ENDIAN) - { - unsafe.putByte(address, (byte) (value >> 24)); - unsafe.putByte(address + 1, (byte) (value >> 16)); - unsafe.putByte(address + 2, (byte) (value >> 8)); - unsafe.putByte(address + 3, (byte) (value)); - } - else - { - unsafe.putByte(address + 3, (byte) (value >> 24)); - unsafe.putByte(address + 2, (byte) (value >> 16)); - unsafe.putByte(address + 1, (byte) (value >> 8)); - unsafe.putByte(address, (byte) (value)); - } - } - - public void setShort(long offset, short l) - { - checkBounds(offset, offset + 2); - if (Architecture.IS_UNALIGNED) - unsafe.putShort(peer + offset, Architecture.BIG_ENDIAN ? Short.reverseBytes(l) : l); - else - putShortByByte(peer + offset, l); - } - - private void putShortByByte(long address, short value) - { - if (Architecture.BIG_ENDIAN) - { - unsafe.putByte(address, (byte) (value >> 8)); - unsafe.putByte(address + 1, (byte) (value)); - } - else - { - unsafe.putByte(address + 1, (byte) (value >> 8)); - unsafe.putByte(address, (byte) (value)); - } + LittleEndianMemoryUtil.setInt(peer + offset, l); } public void setBytes(long memoryOffset, ByteBuffer buffer) @@ -230,69 +158,19 @@ public class Memory implements AutoCloseable, ReadableMemory public byte getByte(long offset) { checkBounds(offset, offset + 1); - return unsafe.getByte(peer + offset); + return LittleEndianMemoryUtil.getByte(peer + offset); } public long getLong(long offset) { checkBounds(offset, offset + 8); - if (Architecture.IS_UNALIGNED) - return Architecture.BIG_ENDIAN ? Long.reverseBytes(unsafe.getLong(peer+offset)) : unsafe.getLong(peer+offset); - else - return getLongByByte(peer + offset); - } - - private long getLongByByte(long address) - { - if (Architecture.BIG_ENDIAN) - { - return (((long) unsafe.getByte(address ) ) << 56) | - (((long) unsafe.getByte(address + 1) & 0xff) << 48) | - (((long) unsafe.getByte(address + 2) & 0xff) << 40) | - (((long) unsafe.getByte(address + 3) & 0xff) << 32) | - (((long) unsafe.getByte(address + 4) & 0xff) << 24) | - (((long) unsafe.getByte(address + 5) & 0xff) << 16) | - (((long) unsafe.getByte(address + 6) & 0xff) << 8) | - (((long) unsafe.getByte(address + 7) & 0xff) ); - } - else - { - return (((long) unsafe.getByte(address + 7) ) << 56) | - (((long) unsafe.getByte(address + 6) & 0xff) << 48) | - (((long) unsafe.getByte(address + 5) & 0xff) << 40) | - (((long) unsafe.getByte(address + 4) & 0xff) << 32) | - (((long) unsafe.getByte(address + 3) & 0xff) << 24) | - (((long) unsafe.getByte(address + 2) & 0xff) << 16) | - (((long) unsafe.getByte(address + 1) & 0xff) << 8) | - (((long) unsafe.getByte(address ) & 0xff) ); - } + return LittleEndianMemoryUtil.getLong(peer + offset); } public int getInt(long offset) { checkBounds(offset, offset + 4); - if (Architecture.IS_UNALIGNED) - return Architecture.BIG_ENDIAN ? Integer.reverseBytes(unsafe.getInt(peer+offset)) : unsafe.getInt(peer+offset); - else - return getIntByByte(peer + offset); - } - - private int getIntByByte(long address) - { - if (Architecture.BIG_ENDIAN) - { - return ((unsafe.getByte(address ) ) << 24) | - ((unsafe.getByte(address + 1) & 0xff) << 16) | - ((unsafe.getByte(address + 2) & 0xff) << 8 ) | - ((unsafe.getByte(address + 3) & 0xff) ); - } - else - { - return ((unsafe.getByte(address + 3) ) << 24) | - ((unsafe.getByte(address + 2) & 0xff) << 16) | - ((unsafe.getByte(address + 1) & 0xff) << 8) | - ((unsafe.getByte(address ) & 0xff) ); - } + return LittleEndianMemoryUtil.getInt(peer + offset); } /** @@ -378,18 +256,18 @@ public class Memory implements AutoCloseable, ReadableMemory int size = (int) (size() / result.length); for (int i = 0 ; i < result.length - 1 ; i++) { - result[i] = MemoryUtil.getByteBuffer(peer + offset, size); + result[i] = LittleEndianMemoryUtil.getByteBuffer(peer + offset, size); offset += size; length -= size; } - result[result.length - 1] = MemoryUtil.getByteBuffer(peer + offset, (int) length); + result[result.length - 1] = LittleEndianMemoryUtil.getByteBuffer(peer + offset, (int) length); return result; } public ByteBuffer asByteBuffer(long offset, int length) { checkBounds(offset, offset + length); - return MemoryUtil.getByteBuffer(peer + offset, length); + return LittleEndianMemoryUtil.getByteBuffer(peer + offset, length); } // MUST provide a buffer created via MemoryUtil.getHollowDirectByteBuffer() diff --git a/src/java/org/apache/cassandra/utils/memory/LittleEndianMemoryUtil.java b/src/java/org/apache/cassandra/utils/memory/LittleEndianMemoryUtil.java new file mode 100644 index 0000000000..2553b93149 --- /dev/null +++ b/src/java/org/apache/cassandra/utils/memory/LittleEndianMemoryUtil.java @@ -0,0 +1,146 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.utils.memory; + + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import com.google.common.annotations.VisibleForTesting; + +import org.apache.cassandra.utils.Architecture; + +public class LittleEndianMemoryUtil extends MemoryUtil +{ + public static int getUnsignedShort(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b1) == 0L) + return (Architecture.BIG_ENDIAN ? Short.reverseBytes(unsafe.getShort(address)) : unsafe.getShort(address)) & 0xffff; + else + return getShortByByte(address) & 0xffff; + } + + public static int getInt(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b11) == 0L) + return Architecture.BIG_ENDIAN ? Integer.reverseBytes(unsafe.getInt(address)) : unsafe.getInt(address); + else + return getIntByByte(address); + } + + public static long getLong(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b111) == 0L) + return Architecture.BIG_ENDIAN ? Long.reverseBytes(unsafe.getLong(address)) : unsafe.getLong(address); + else + return getLongByByte(address); + } + + public static void setShort(long address, short s) + { + if (Architecture.IS_UNALIGNED || (address & 0b1) == 0L) + unsafe.putShort(address, Architecture.BIG_ENDIAN ? Short.reverseBytes(s) : s); + else + putShortByByte(address, s); + } + + public static void setInt(long address, int l) + { + if (Architecture.IS_UNALIGNED || (address & 0b11) == 0L) + unsafe.putInt(address, Architecture.BIG_ENDIAN ? Integer.reverseBytes(l) : l); + else + putIntByByte(address, l); + } + + public static void setLong(long address, long l) + { + if (Architecture.IS_UNALIGNED || (address & 0b111) == 0L) + unsafe.putLong(address, Architecture.BIG_ENDIAN ? Long.reverseBytes(l) : l); + else + putLongByByte(address, l); + } + + @VisibleForTesting + static long getLongByByte(long address) + { + return (((long) unsafe.getByte(address + 7) ) << 56) | + (((long) unsafe.getByte(address + 6) & 0xff) << 48) | + (((long) unsafe.getByte(address + 5) & 0xff) << 40) | + (((long) unsafe.getByte(address + 4) & 0xff) << 32) | + (((long) unsafe.getByte(address + 3) & 0xff) << 24) | + (((long) unsafe.getByte(address + 2) & 0xff) << 16) | + (((long) unsafe.getByte(address + 1) & 0xff) << 8) | + (((long) unsafe.getByte(address ) & 0xff) ); + } + + @VisibleForTesting + static int getIntByByte(long address) + { + return (((int) unsafe.getByte(address + 3) ) << 24) | + (((int) unsafe.getByte(address + 2) & 0xff) << 16) | + (((int) unsafe.getByte(address + 1) & 0xff) << 8) | + (((int) unsafe.getByte(address ) & 0xff) ); + } + + @VisibleForTesting + static int getShortByByte(long address) + { + return (((int) unsafe.getByte(address + 1) ) << 8) | + (((int) unsafe.getByte(address ) & 0xff) ); + } + + @VisibleForTesting + static void putLongByByte(long address, long value) + { + unsafe.putByte(address + 7, (byte) (value >> 56)); + unsafe.putByte(address + 6, (byte) (value >> 48)); + unsafe.putByte(address + 5, (byte) (value >> 40)); + unsafe.putByte(address + 4, (byte) (value >> 32)); + unsafe.putByte(address + 3, (byte) (value >> 24)); + unsafe.putByte(address + 2, (byte) (value >> 16)); + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + + @VisibleForTesting + static void putIntByByte(long address, int value) + { + unsafe.putByte(address + 3, (byte) (value >> 24)); + unsafe.putByte(address + 2, (byte) (value >> 16)); + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + + @VisibleForTesting + static void putShortByByte(long address, short value) + { + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + + public static ByteBuffer getByteBuffer(long address, int length) + { + return getByteBuffer(address, length, ByteOrder.LITTLE_ENDIAN); + } + + public static ByteBuffer getHollowDirectByteBuffer() + { + return getHollowDirectByteBuffer(ByteOrder.LITTLE_ENDIAN); + } +} diff --git a/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java b/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java index 453f3eda1b..86416c49a7 100644 --- a/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java +++ b/src/java/org/apache/cassandra/utils/memory/MemoryUtil.java @@ -24,24 +24,20 @@ import java.nio.ByteOrder; import com.sun.jna.Native; -import org.apache.cassandra.utils.Architecture; - import sun.misc.Unsafe; public abstract class MemoryUtil { private static final long UNSAFE_COPY_THRESHOLD = 1024 * 1024L; // copied from java.nio.Bits - private static final Unsafe unsafe; + protected static final Unsafe unsafe; private static final Class DIRECT_BYTE_BUFFER_CLASS, RO_DIRECT_BYTE_BUFFER_CLASS; private static final long DIRECT_BYTE_BUFFER_ADDRESS_OFFSET; private static final long DIRECT_BYTE_BUFFER_CAPACITY_OFFSET; private static final long DIRECT_BYTE_BUFFER_LIMIT_OFFSET; private static final long DIRECT_BYTE_BUFFER_POSITION_OFFSET; private static final long DIRECT_BYTE_BUFFER_ATTACHMENT_OFFSET; - private static final Class BYTE_BUFFER_CLASS; - private static final long BYTE_BUFFER_OFFSET_OFFSET; - private static final long BYTE_BUFFER_HB_OFFSET; + protected static final Class BYTE_BUFFER_CLASS; private static final long BYTE_ARRAY_BASE_OFFSET; static @@ -61,8 +57,6 @@ public abstract class MemoryUtil RO_DIRECT_BYTE_BUFFER_CLASS = ByteBuffer.allocateDirect(0).asReadOnlyBuffer().getClass(); clazz = ByteBuffer.allocate(0).getClass(); - BYTE_BUFFER_OFFSET_OFFSET = unsafe.objectFieldOffset(ByteBuffer.class.getDeclaredField("offset")); - BYTE_BUFFER_HB_OFFSET = unsafe.objectFieldOffset(ByteBuffer.class.getDeclaredField("hb")); BYTE_BUFFER_CLASS = clazz; BYTE_ARRAY_BASE_OFFSET = unsafe.arrayBaseOffset(byte[].class); @@ -104,56 +98,11 @@ public abstract class MemoryUtil unsafe.setMemory(address, count, b); } - public static void setShort(long address, short s) - { - unsafe.putShort(address, Architecture.BIG_ENDIAN ? Short.reverseBytes(s) : s); - } - - public static void setInt(long address, int l) - { - if (Architecture.IS_UNALIGNED) - unsafe.putInt(address, Architecture.BIG_ENDIAN ? Integer.reverseBytes(l) : l); - else - putIntByByte(address, l); - } - - public static void setLong(long address, long l) - { - if (Architecture.IS_UNALIGNED) - unsafe.putLong(address, Architecture.BIG_ENDIAN ? Long.reverseBytes(l) : l); - else - putLongByByte(address, l); - } - public static byte getByte(long address) { return unsafe.getByte(address); } - public static int getShort(long address) - { - if (Architecture.IS_UNALIGNED) - return (Architecture.BIG_ENDIAN ? Short.reverseBytes(unsafe.getShort(address)) : unsafe.getShort(address)) & 0xffff; - else - return getShortByByte(address) & 0xffff; - } - - public static int getInt(long address) - { - if (Architecture.IS_UNALIGNED) - return Architecture.BIG_ENDIAN ? Integer.reverseBytes(unsafe.getInt(address)) : unsafe.getInt(address); - else - return getIntByByte(address); - } - - public static long getLong(long address) - { - if (Architecture.IS_UNALIGNED) - return Architecture.BIG_ENDIAN ? Long.reverseBytes(unsafe.getLong(address)) : unsafe.getLong(address); - else - return getLongByByte(address); - } - public static ByteBuffer getByteBuffer(long address, int length) { return getByteBuffer(address, length, ByteOrder.nativeOrder()); @@ -186,21 +135,6 @@ public abstract class MemoryUtil return instance; } - public static ByteBuffer getHollowByteBuffer() - { - ByteBuffer instance; - try - { - instance = (ByteBuffer) unsafe.allocateInstance(BYTE_BUFFER_CLASS); - } - catch (InstantiationException e) - { - throw new AssertionError(e); - } - instance.order(ByteOrder.nativeOrder()); - return instance; - } - public static boolean isExactlyDirect(ByteBuffer buffer) { return buffer.getClass() == DIRECT_BYTE_BUFFER_CLASS; @@ -250,109 +184,6 @@ public abstract class MemoryUtil unsafe.putInt(instance, DIRECT_BYTE_BUFFER_CAPACITY_OFFSET, capacity); } - public static long getLongByByte(long address) - { - if (Architecture.BIG_ENDIAN) - { - return (((long) unsafe.getByte(address ) ) << 56) | - (((long) unsafe.getByte(address + 1) & 0xff) << 48) | - (((long) unsafe.getByte(address + 2) & 0xff) << 40) | - (((long) unsafe.getByte(address + 3) & 0xff) << 32) | - (((long) unsafe.getByte(address + 4) & 0xff) << 24) | - (((long) unsafe.getByte(address + 5) & 0xff) << 16) | - (((long) unsafe.getByte(address + 6) & 0xff) << 8) | - (((long) unsafe.getByte(address + 7) & 0xff) ); - } - else - { - return (((long) unsafe.getByte(address + 7) ) << 56) | - (((long) unsafe.getByte(address + 6) & 0xff) << 48) | - (((long) unsafe.getByte(address + 5) & 0xff) << 40) | - (((long) unsafe.getByte(address + 4) & 0xff) << 32) | - (((long) unsafe.getByte(address + 3) & 0xff) << 24) | - (((long) unsafe.getByte(address + 2) & 0xff) << 16) | - (((long) unsafe.getByte(address + 1) & 0xff) << 8) | - (((long) unsafe.getByte(address ) & 0xff) ); - } - } - - public static int getIntByByte(long address) - { - if (Architecture.BIG_ENDIAN) - { - return (((int) unsafe.getByte(address ) ) << 24) | - (((int) unsafe.getByte(address + 1) & 0xff) << 16) | - (((int) unsafe.getByte(address + 2) & 0xff) << 8 ) | - (((int) unsafe.getByte(address + 3) & 0xff) ); - } - else - { - return (((int) unsafe.getByte(address + 3) ) << 24) | - (((int) unsafe.getByte(address + 2) & 0xff) << 16) | - (((int) unsafe.getByte(address + 1) & 0xff) << 8) | - (((int) unsafe.getByte(address ) & 0xff) ); - } - } - - - public static int getShortByByte(long address) - { - if (Architecture.BIG_ENDIAN) - { - return (((int) unsafe.getByte(address ) ) << 8) | - (((int) unsafe.getByte(address + 1) & 0xff) ); - } - else - { - return (((int) unsafe.getByte(address + 1) ) << 8) | - (((int) unsafe.getByte(address ) & 0xff) ); - } - } - - public static void putLongByByte(long address, long value) - { - if (Architecture.BIG_ENDIAN) - { - unsafe.putByte(address, (byte) (value >> 56)); - unsafe.putByte(address + 1, (byte) (value >> 48)); - unsafe.putByte(address + 2, (byte) (value >> 40)); - unsafe.putByte(address + 3, (byte) (value >> 32)); - unsafe.putByte(address + 4, (byte) (value >> 24)); - unsafe.putByte(address + 5, (byte) (value >> 16)); - unsafe.putByte(address + 6, (byte) (value >> 8)); - unsafe.putByte(address + 7, (byte) (value)); - } - else - { - unsafe.putByte(address + 7, (byte) (value >> 56)); - unsafe.putByte(address + 6, (byte) (value >> 48)); - unsafe.putByte(address + 5, (byte) (value >> 40)); - unsafe.putByte(address + 4, (byte) (value >> 32)); - unsafe.putByte(address + 3, (byte) (value >> 24)); - unsafe.putByte(address + 2, (byte) (value >> 16)); - unsafe.putByte(address + 1, (byte) (value >> 8)); - unsafe.putByte(address, (byte) (value)); - } - } - - public static void putIntByByte(long address, int value) - { - if (Architecture.BIG_ENDIAN) - { - unsafe.putByte(address, (byte) (value >> 24)); - unsafe.putByte(address + 1, (byte) (value >> 16)); - unsafe.putByte(address + 2, (byte) (value >> 8)); - unsafe.putByte(address + 3, (byte) (value)); - } - else - { - unsafe.putByte(address + 3, (byte) (value >> 24)); - unsafe.putByte(address + 2, (byte) (value >> 16)); - unsafe.putByte(address + 1, (byte) (value >> 8)); - unsafe.putByte(address, (byte) (value)); - } - } - public static void setBytes(long address, ByteBuffer buffer) { int start = buffer.position(); diff --git a/src/java/org/apache/cassandra/utils/memory/NativeEndianMemoryUtil.java b/src/java/org/apache/cassandra/utils/memory/NativeEndianMemoryUtil.java new file mode 100644 index 0000000000..3cb5edb28b --- /dev/null +++ b/src/java/org/apache/cassandra/utils/memory/NativeEndianMemoryUtil.java @@ -0,0 +1,214 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.utils.memory; + + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import com.google.common.annotations.VisibleForTesting; + +import org.apache.cassandra.utils.Architecture; + +/** + * Use this API only for data which are stored in-memory + * and not serialized directly (without converting to Java primitives) to disk and network + */ +public class NativeEndianMemoryUtil extends MemoryUtil +{ + public static int getUnsignedShort(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b1) == 0L) + return unsafe.getShort(address) & 0xffff; + else + return getShortByByte(address) & 0xffff; + } + + public static int getInt(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b11) == 0L) + return unsafe.getInt(address); + else + return getIntByByte(address); + } + + public static long getLong(long address) + { + if (Architecture.IS_UNALIGNED || (address & 0b111) == 0L) + return unsafe.getLong(address); + else + return getLongByByte(address); + } + + public static void setShort(long address, short s) + { + if (Architecture.IS_UNALIGNED || (address & 0b1) == 0L) + unsafe.putShort(address, s); + else + putShortByByte(address, s); + } + + public static void setInt(long address, int l) + { + if (Architecture.IS_UNALIGNED || (address & 0b11) == 0L) + unsafe.putInt(address, l); + else + putIntByByte(address, l); + } + + public static void setLong(long address, long l) + { + if (Architecture.IS_UNALIGNED || (address & 0b111) == 0L) + unsafe.putLong(address, l); + else + putLongByByte(address, l); + } + + @VisibleForTesting + static long getLongByByte(long address) + { + if (Architecture.BIG_ENDIAN) + { + return (((long) unsafe.getByte(address ) ) << 56) | + (((long) unsafe.getByte(address + 1) & 0xff) << 48) | + (((long) unsafe.getByte(address + 2) & 0xff) << 40) | + (((long) unsafe.getByte(address + 3) & 0xff) << 32) | + (((long) unsafe.getByte(address + 4) & 0xff) << 24) | + (((long) unsafe.getByte(address + 5) & 0xff) << 16) | + (((long) unsafe.getByte(address + 6) & 0xff) << 8) | + (((long) unsafe.getByte(address + 7) & 0xff) ); + } + else + { + return (((long) unsafe.getByte(address + 7) ) << 56) | + (((long) unsafe.getByte(address + 6) & 0xff) << 48) | + (((long) unsafe.getByte(address + 5) & 0xff) << 40) | + (((long) unsafe.getByte(address + 4) & 0xff) << 32) | + (((long) unsafe.getByte(address + 3) & 0xff) << 24) | + (((long) unsafe.getByte(address + 2) & 0xff) << 16) | + (((long) unsafe.getByte(address + 1) & 0xff) << 8) | + (((long) unsafe.getByte(address ) & 0xff) ); + } + } + + @VisibleForTesting + static int getIntByByte(long address) + { + if (Architecture.BIG_ENDIAN) + { + return (((int) unsafe.getByte(address ) ) << 24) | + (((int) unsafe.getByte(address + 1) & 0xff) << 16) | + (((int) unsafe.getByte(address + 2) & 0xff) << 8) | + (((int) unsafe.getByte(address + 3) & 0xff) ); + } + else + { + return (((int) unsafe.getByte(address + 3) ) << 24) | + (((int) unsafe.getByte(address + 2) & 0xff) << 16) | + (((int) unsafe.getByte(address + 1) & 0xff) << 8) | + (((int) unsafe.getByte(address ) & 0xff) ); + } + } + + @VisibleForTesting + static int getShortByByte(long address) + { + if (Architecture.BIG_ENDIAN) + { + return (((int) unsafe.getByte(address ) ) << 8) | + (((int) unsafe.getByte(address + 1) & 0xff) ); + } + else + { + return (((int) unsafe.getByte(address + 1) ) << 8) | + (((int) unsafe.getByte(address ) & 0xff) ); + } + } + + @VisibleForTesting + static void putLongByByte(long address, long value) + { + if (Architecture.BIG_ENDIAN) + { + unsafe.putByte(address , (byte) (value >> 56)); + unsafe.putByte(address + 1, (byte) (value >> 48)); + unsafe.putByte(address + 2, (byte) (value >> 40)); + unsafe.putByte(address + 3, (byte) (value >> 32)); + unsafe.putByte(address + 4, (byte) (value >> 24)); + unsafe.putByte(address + 5, (byte) (value >> 16)); + unsafe.putByte(address + 6, (byte) (value >> 8)); + unsafe.putByte(address + 7, (byte) (value )); + } + else + { + unsafe.putByte(address + 7, (byte) (value >> 56)); + unsafe.putByte(address + 6, (byte) (value >> 48)); + unsafe.putByte(address + 5, (byte) (value >> 40)); + unsafe.putByte(address + 4, (byte) (value >> 32)); + unsafe.putByte(address + 3, (byte) (value >> 24)); + unsafe.putByte(address + 2, (byte) (value >> 16)); + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + } + + @VisibleForTesting + static void putIntByByte(long address, int value) + { + if (Architecture.BIG_ENDIAN) + { + unsafe.putByte(address , (byte) (value >> 24)); + unsafe.putByte(address + 1, (byte) (value >> 16)); + unsafe.putByte(address + 2, (byte) (value >> 8)); + unsafe.putByte(address + 3, (byte) (value )); + } + else + { + unsafe.putByte(address + 3, (byte) (value >> 24)); + unsafe.putByte(address + 2, (byte) (value >> 16)); + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + } + + @VisibleForTesting + static void putShortByByte(long address, short value) + { + if (Architecture.BIG_ENDIAN) + { + unsafe.putByte(address , (byte) (value >> 8)); + unsafe.putByte(address + 1, (byte) (value )); + } + else + { + unsafe.putByte(address + 1, (byte) (value >> 8)); + unsafe.putByte(address , (byte) (value )); + } + } + + public static ByteBuffer getByteBuffer(long address, int length) + { + return getByteBuffer(address, length, ByteOrder.nativeOrder()); + } + + public static ByteBuffer getHollowDirectByteBuffer() + { + return getHollowDirectByteBuffer(ByteOrder.nativeOrder()); + } +} diff --git a/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-CompressionInfo.db b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-CompressionInfo.db new file mode 100644 index 0000000000000000000000000000000000000000..aa6d6e6a102d9d20dfdf2dc252c36979e39f31d2 GIT binary patch literal 207 zcmZSJ^@%cZ&d)6rVeC{ALP!Gn{>~^a zAQC^K6le*G5($tf72H?_p_1JImZ+nYu{2VPvBPL&)B(#Nn%djOq- z`l6ae6=fCWMU|z+HFZ_xwUu=hO?8chOO_NZEo^D2Dy}UqEpMr)scK%ftfZl)uCbwJ zQC(|uT}wqpb4_Jgb#2koy87CpWsOC3G`(K;Ogkpkb@!UpH@x(`-(KeoyK8dzJTrG> zRE5^8_OCgbM{uv(&zal(dHXv2_J+&lK|71B$hJJkc_2ifL-BCZMvA>J)VA6mnN=Df zuKKtw&IKHZ%nlOl@OTq!DPVWrtbyw_xBzdR2&T`<{B<^%nw44DLm=Cgi^+FnzB>xh zWz7M5y+hugI~?RXY?*ZAFE-L=Hy4CMd<`4*5T94Y!qm_uEMK2N%h=35%sLAZ0uS#c z5&XTfd%bj)Wk~o9naqncxUlN`xMW?n1I*bn4hd848O7uOlzvwF-(}8wZ2;8`iC`or zGz`#lgBS@+0`ETx&}(5j+Cq*-htEn}+ZM`caA+2yb3-*nvsQ)1ev%Dm@i%tNCk>p6 z%gWpw2-xc!VSSqZaWEG`%$X-I;L?a<0R(B*lQOja^=+vkOt0ehrBe~J_w4$4p+M(U zWK8Zz)6cW)H2O_!@ts3}6^*ld=tpFCPX|EN-~!wq0_ZWAX#u-q1u(Cb*jEbBXAlv6 zke8BXFcDoqMCQAW3V{vLM8W&31{qYBK?M5xL@q<$WKxWGfxwmkFL(6-71EiY25nA# z(p1T%i8V5UNSep=6?_N2J}E_{QDrqvU&pplb&LoN-pWS8l+C2U2>VgGz79)1b_Sqo zZ~-141n99cPecHE4JJ|>1?IC7Pxb)R3?g3n@3jQ7b5r#7EPy^IIX`IT$@Y&=B)e;B zp1q#UOaOV^V*p%l0MA|kkPF~KkXy;#IhT&-YQR%aCaNdLwnkr0Wscpd&`KNUib@p_1)Z%gw1qSp}Bqa5haWq zsWP)Y{x%`(=|WglubU@U-+r4vYTpY9@@nTyj#~;0@4Y1;p5-)%>R|J5noyIJH z{$wgpPZD?17@%G&*KzGEXN{y!bNG_juIG7Iw6dLQN5GyJ^d>gFKYIHhav)a<`pNV@zQgb4Z6?Bqr&G?CECfm2ni-FkLOISQg#bN9 zB)0p~e1KkK6zXn_8@-iR<>Fh~;32qf90jxIVDxXXx!HZ_j8_PQu@akXaf8_>e167) zT`zH6tUiC3yGbDOnJYD9=~dn3WE%tQM4Em`HJK5h!E#j!+v{pkeo⁢%t@$`fM2XQB^1_)R_&eJ(6~rYGC1cp&;{ zb+XNbJ0OF+BP+fKP+s9p08Lu}LcACPn6w98E(Msh2Y8oE+5@lfPMO#P?+1Ccbl$S( zDXx{-2_m9$qOTOBNaeV-Wzqn97oCf5$*4w)W?M5OjNjr8Wxkz`%}Wiwev0g}Ug8c< z6fR@jBO&UeHKc==ti~XVk~};KuNDT=?HtHPc9q7&{Z)!E=fEfe%{Nep^Tru4P4`bs z=q!jy*UzJaAeye9Aie`)((Uu@NWg9n^4t5Bn+~c_NiX@~?(wpDN5Bd?^s)SGFxd00 zyCPt}ldfjg+x1X0X)qUMtYLKan% zFhu#-jW~}fj)XZg4ot5x2J%hD(r~%YN<3!+QL_?B+J-DE@AF|C3)H^c<)Va+OqlY( z*GdQpON*TgKL6-j6ZV5i8djg-$J5d5VD>65zydCS>YgI4Vt?dk>(N4i5$-JVvoZeo zj8%|egnNr(Vq@p)dnrfEHWo|ncIq!9i=NZ`)I6F|Bs{G@y%Vt46bc!h2Iw=7Lhs9J z1FD&*7-e)dq3k^z5A-y)FS{M_H5O-zK0Y<(Oe=%jdUB`be!`WB-)g)*9CN=CP88jq zDpwodb~+d6nQVWi-UeNsIYR4jXw%a4HugBa%w)oy2C%rFUQCZ!3FdS3fsK2U66$9T z*K{KS=G4#Tf0H@&%OPP-r^uXW*vr%PHpm|6XV?(tOHjYO0%FMJS&6A&BgiX(Dm%oq z5f6#Hr9jndj7dNv?nRy?>Wm<$-Wc^m@hR<>9;ubfW%-mgBFw0NM#`9xZ!3M1k=T#v z?{=&^Ps3ug>6DFj_7r}@y2*?h*wq(dxBi*R2>ceXXHCSRR(4$}wXjEc&5Z>-J6qV) z3%umUvdI}O*b0{hc!|nx6P=f6|7^HW!l>q)!5oxxyzE3YIn^8(kV7@aVyIgNfqF12 zUFTfP7Z&93ny3Iz0Q7O@>LC9(aP^nPW4TE2Z_qAxj_r$>Mg@`7=ybiZ_LMZjE=KLF z!#bk04t6s0zv8>eM(4a9h@iM+GB%%%*oP@r%jvLhQK z;T>fz3>CMj3T{4XEo4ayQvvsJcua95N{tPm*BArSCbcO2R$~1yKrKOx9pv^c9(oVD zbX#nje}nF?PZ0y^RkqpE*kydv^ZtDrDyXh&`A7S9wmCz>{%k(VWl+0pQk)DOCX9)> zm5DBdXy(2oZ!_^piF@En4#mVqN?}h4vkG;B;yGnE2BN^w(?GqZK+Nj?HlRM!Ab8z_ z0JS7)TQ#9s3udrgi5aZ|Ic`_8#XYHY_wK8BDOv7Gv{Pn?gG2w6BdJkNVedbAub9bx zHmX3R{2DTzdWY{nwgOhn^_&Td3Ul9zljmj>K)31ik303O<1$*9p2z(5I~|*1rlp3Y zu@2V-;~m_z9{Fa|dg2RVTI2ayd?v%&4@`DG@-@qP;!9{EtC@+Zp)R)!0af0OErg<> z$ol}*bH)rvX-C(A+e?Aq?$q5|wCkab*2oLscYyPP{agj1P@zZCoMiQO^?-Xup;s0?EFUbU>KNZl%BZ4$Q@3w9oL!itrPpm_Z=>9i1KW7+MSH zyfgMq6t1<1*2O5Xb1iK|+{^qt_f?3sf<& zk&H7hl=Wiy`zh;|H zckY-Soh(cdfz;zRmCfe1a~D!m#MAEig7@~jSb2s5-`RlMpu_ujn-b@Wq;HtUtt*M$ pL8lA4bD7vMv`b)JmrPK}wn%Axq4S9ge*3Z@{;z{n*uHbi{{d%&vg7~& literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Digest.crc32 b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Digest.crc32 new file mode 100644 index 0000000000..c84b9595a0 --- /dev/null +++ b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Digest.crc32 @@ -0,0 +1 @@ +1026070592 \ No newline at end of file diff --git a/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Filter.db b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..8868e5c18008783c106cc95dcb2a5942cf662a48 GIT binary patch literal 24 fcmZQzU|?lnU|?!-Qev>X6N CAqQjt literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Rows.db b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-Rows.db new file mode 100644 index 0000000000000000000000000000000000000000..d2ba4d639b61180cee624a807297dc1255abf3a1 GIT binary patch literal 508 zcmZP)`NO37JAlc^jE$Ko_$O1w&mbmab2etX-%PbXg$}vqCp{XSgNbL7}W=6K`05(G-V-pK2S4$NE4i-fRJ{AT>0|s8+1}0HP zCM`y&9U%-%nG6s+>=~Kr7{GS?2iox;$&PRu+5=9W=dC}O{>o|JnVsF= zJ@4(j@9z8Y%rXokS+~JY%FLBe;Y5VPEF7$GydfMM!#qUt%d`8LutH0=nlIwBa!l$h zzPOk#Fj{!EF~_Qo*<&>&T8t)($(Y1jtY)jZu)t(7RFr-n*XsRh#^6Ho!vL(Kc9wHliXyVi;%toIlH) z7xQO1Wf#hBl-(&SDSJ}(ro58!D#~jphfvm1-b6W`^0Sn)Det9ROSyycAU2`i2iZu) zt(4DWvnwd?$L6T}bIx%xUrmyR>r2D2Wt*|(RDWHjaNMmA+kG5+X(hJm9qi@LWBU$Z zKOBa=?j*K49b4ak9diylX&H8g4|ef0*i}4s6E%MOVsU)jf8KNRi1`1G;v_v4y8(|+ zGX4#UvnhB!vtMF!>0hJz5(ysvlB<_dT>5!6vh25JWS0~>vg?cqdC80yveJmhqi5_- zDDK_09C_u4FY>CvWaKsd_ za%T^IKEs{pc@j5|JFq@6#5wkX`-PMRp1Kd=f?T?&fo6lxqV<(Mro0B@oNoylA6(aq zt}resaoqwf-8qQ*D=RdYz_`5AHUaG#yX`jg68~;ApA_k;D=_ZCCG4VUCUZK4E zHjMkV9KH#?IwHOuI{4cio1nw4>b5>$I0xVhEuS$TPoZJiFkMxh4TDX76H+YRjgZeIYXG%W=c1wJ>*8=SRa`msU z|H>iHo3Q_$SK~WWp#CzxstE1}KBo-bY7qDTVoU|!*VH;^8sD>&%H_z zHw^yR{R;4t$Jc7|w3MA_ur jom`IU8vaxT=d~)z8D{ax-=b?Wgxk&UT6Fa(TVu*!*}lE) literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-TOC.txt b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-TOC.txt new file mode 100644 index 0000000000..298910cfdc --- /dev/null +++ b/test/data/legacy-sstables/da/legacy_tables/legacy_da_clust_be_index_summary/da-500-bti-TOC.txt @@ -0,0 +1,8 @@ +Data.db +Statistics.db +Digest.crc32 +TOC.txt +CompressionInfo.db +Filter.db +Partitions.db +Rows.db diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-CompressionInfo.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-CompressionInfo.db new file mode 100644 index 0000000000000000000000000000000000000000..49ebec126f4a4bb6ed7743e7b05d7e31d520a7cc GIT binary patch literal 83 zcmZSJ^@%cZ&d)6T5hgu%WaLUYf7(EJd+48m3b D-$V%C literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Data.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..4b0fa7ef3507df606e3262dd04cfb69b78b4e931 GIT binary patch literal 5221 zcmd6r|5Fs_8NhdigyW=YnI6fy;_UecmSTu3&4#ThkhhG}pOn8k%ao-j0aB#U1iQf;H_;!P?!PHh<0TdVi>~ z&A+Q7+#K@MHF+a-?d`$Fx~95No8R5h;`g|Np5{onHRujDc|zejpU>S|TNh{xwX}!p z-7O){E_Wo**yd{phyC8#K)5l|?rE#_LVKe{&zP{O!KwrM%8vSFQ&1Wy3YbZs8N=zm z=z)Fm>$l4xJX$1^%ptk_Xh1f#=GtaVLh_EdPP6pxb_k00Vv=+eYI)ft?!ZLHaW0i8 zo1|YVm{@Eiau6IWz)Yu+iPaWNEMXJho5w_#k%-l&=O8GYEXB5uWqh8E#W!VBNVI)G zVneb#dKK$_LJ$%%x-(yUSK1Gj3??lb;5am3hwefOONO&d{DF0bM2A2!P$ys$LA2lN)=d#7G7`Ef`$99MLCyzdaaQP>PxGJ5n$yP~+% z_g=?cVievD&NH+{j=$}PHzV5SvQrbo>yX|KVAO8qQ}s(=F}{L9N59bntWfFLc8nG; zNZo-!CzXozKgM7Qm5KE~S1{^YkoqhHg$+utFr~LpjmiB5xN>b1DIxkTWbMjiYlumE zr^)>#6Jk>TI-Dm;wuYGWtEEUfBk`ZSB7Y?`L;GxVkQ zN{P`i>CJvP41{t*xM1HLK*kN=TqW^&rm*z`qPKojTZ`am`@I^46%Xkr7Kz|4-xBo` zVM{vvGsk}cr<~N+jdyZ7Q~gw^O8Y{% j*fy3{htf_D7f`^LgbG>HK+J)6~ysAzR z@uwd=RQy|g@a#bRUt~d|Fa*3M75;{+pxeKerjWW6-di;HMZgjj=e+V0J$xI230OkQQ~rZ+u1@ zJ}f03`?x10jV6spp6m&5d%8ut<~hu;%pVu@z7Ye=^>Vfw7?V~g3_Z)xb2P0gU{qga zA#G|${jeOrG0VEXitLyA!^>YvPnEw6Npl?<%>NcWxOSeQZ)hr*W9TMBx3pJF^oE9J z<4M~++Sy&O?w>vXcXq?Nc_OLzY+{k}T{5!Z0(Ur4A4GH_fS~U-i z|I10dyOPI&SEe#gC4IMdL74dd2SKzxX;h-{iNdQ76F%X17oHyoKM%sg)z_t|A!2-@ z@Y(|76Rs#cc+vKwOrs@G-t{U*?H9G~u^v@^4TFwcqX!JWj=^FolLx`e+!%E(NF~S3 zBQo@ah9}CJAjvR3QPzx{GCrYHvc@Nr7qw-PG`{d-)_8>+NxJdMR-8>=w8{@?dfvrQ zDMK3=dYYz+)ePlRw#TH3?~?9x*$XFW*fvle)6S`^R1uJwOeNy`W#6=&bP&>F>zbw-(d&SrxCYh(I{=Z zV(eZqap%T+bnebg_X6C8dxD(zWF`5SzPqFJ9I<-g_w`PqwUV%oEE27qY2=r3z2MEZ zpjdLkI*MkOOmY^XjQn1&N3$L9)d{}q*`ag`ZUVPwplzw^C^3g1wp2_GWAY00t6(Ua^sfru(cA6wEU8Or-V|AsdqWY{;o&JrP`vY)Bqlu|V=* z9wT|xVOH|sO03r<4}Kd-m%N>02->5@;07p4qp9OILw6Xu%Shhw4@UB;Bdp||Q*>?T zbtGN#&S_@sk2JkD#?UxJ7a6)l)Bb)&^8Evh<~k5 z(A4WUXiX*gv)I6zU;ie$n&Zys-__0%Gxu`R;oiXFaCp>_#qSov#8nF}?pKIG#UGLH zSc~9FCkEGr(O_pLU$5tCzSl*F?^HG_+(C4wk}>#G)ct!acMIBI+ty1B)w0P`iGQx+ JACLWc^nWmKhdBTM literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Digest.crc32 b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Digest.crc32 new file mode 100644 index 0000000000..5f0b313cc8 --- /dev/null +++ b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Digest.crc32 @@ -0,0 +1 @@ +1371588035 \ No newline at end of file diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Filter.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..2e1d5d29ca0683d58365c1bda385a89ced35f1f9 GIT binary patch literal 24 fcmZQzU|?lnU|?ckVPs%abZX%^z`&xww2T1&5k3Nr literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Index.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Index.db new file mode 100644 index 0000000000000000000000000000000000000000..ad88ef6efc77d06f68e7b9c413932d4553d203bc GIT binary patch literal 157553 zcmeI*KaW&Z9LDjpK`_grBwCpmJ8O6T0849YDOM)7YGR=cjS($;14?)e8e#*rf9|NU z*MxZi78*lgEC@kN);(u;xD&IxCF)qdxV_erPKXr6LW zF3OdoT%X_F3%PDiwtASkB46Z-d<|Q^YBX<7WL%7kapf4-7k3vS*VMNOf){v!R}8#r z$Tg*0sD)an6+^A=>pP2(YwG(1!3(^=D+XRoxkU4*g<7Z;L#^)TUb%dsAb5cnc*Vf0 zo-2Bj3$#EBv|^yu{dQ+I-)O(CXj;TB?82@Xc2(grC4v@cfmRH(y8D05ZlBz%v|fL| zl;?ge<;6>-y!=xsuUsr;>#I^;eW{e!J}c#o6Q#U$xsOHmCUNQHI z`LJIx_lqzG{US^~pHz#DWJrc&IkeoV#Xi}-Xkw&%!`x}^G26kZ=cEzx(8JF`()Iu%PilNr^2gaoqTRbnG7tiO!^VPW2Vxtynp;ivH zzB}`vqfz&UY08S~1Y-{y8`S}?D6+!{!)u=#x!G^F>_|j z{XS_upHz#DWJrc&`|)9zKU0fs+B9vNHe;sE9-~dT)MDcoe&JUPztmzI5sipO#NK0a zu9|TKOMZ2ZD6{OYMN^eeU4h=o{)HFQqx_xYM} zsl}FY$+%=(F&URyY|GVhjajbyiN}-sv#MNbv5kyIMk8Ym1=V6B7Gfb*4zc=A+Kfvr zwvfxzY-)~~n$==ku9j=ea_x1))z-zPTxzi?7lvba48uFM*itSjmy|0};dYcuEjE0? z7kuU5OD(nm$$%6yAmxB%6`!<*Txzi?7v-W{tKiM!`G2Uzrd*VZaz%c#RZ}iSXU-Kd z9K&N6-l@elC7KdViH~Q3TkW4x&lSDN#kd$3a7Bi5{a?Y= zmVZGT&=a%)JyI?9r9AfpKv}Rmmwb(K)8JCPJCgW0zZMj;mG0U~r4Oe@OL7VQxK`*?yL++4Z zVJN|ZT5QkaP@Y9QgPq|ptFeY$6SdevE>p9qIc92Bi*31Dt})A%lrBqYQ!ZboO1Ur` z!($k(7Ta>QTw|6i<@%3usl`4_Ea>rBetg^wcVqRdM=dtvVqAubqrQ!!7MpTWF3OdwTxzkMD`Gf?$1q$iw&iNM#w=I)!g9W_lX9uW7B?IaKCixaIjf zYDCc@F6Wbsi*Yfo7~@ilZO1$6j>i}I;&HB?YFuiukMmyu0T96RcewpiEw(4-a8C@% zqUuy!9iCS#Rh2a<;!*I3O!x-4@rOSJ% zyWwseye^w@sl{eojEiyQ7}u4J*?g@ucuj3|HoAj1I!}qGWEf9Lqn281%0;;-SB`RB zJw3a%y{lZhH^2+Lz$*q`JIbXNdl>d>4l{>&5+CNBXtmfJgJZ-vhK+4`W2+&TT5KEL z!)$a`&hpA}H;(UasKusSl#6mjezR3mF44Sb9>Xy_hT&?lEmzAmX1SV9m#5QuuINoJ u#s%RJ9)obT*kXCH{1~xfh}BDH6|Tr|uKz2zS~h5R!`=A5Z^w^Ni~TRd%lBUZ literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Statistics.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Statistics.db new file mode 100644 index 0000000000000000000000000000000000000000..2c3a57350c2c8efd1d7dd9be8f3d2f18a7bf0d82 GIT binary patch literal 7046 zcmeI%drVtZ90%}w?rqCsP@%v!x(wX_hr|?wF(BEfuui}%f$`YzvA7Fu2FnJdZ6?E+ znaTbk%5ZVRC40D;5W*e}pbpqGnS#3MHlm_NHcTp-8LciGGC=CBrP=R$^pC|qjK+JC zlY2k>PA})2d(OSTw1OaL1b<0T4os=*l`1NAyHX`VFir_6b@q)Wxn8cSwwbDAheNKl z+GUfq+G)z$=Cl>rtv0*OS}fb0HO`v4TASV6)c8&Q$>{?MZI3rb)Nfj?>kC$mQ#=OE6(oI^Q>an^H= zq`ePt|>=r)6u#W=pb&q!BZFy9YlwD&=2fF8{S0EeHv{XLO+y(e)urjRDsSsh|W8M zE{;KOh($ZrpqpiMJGXuZEg1L2&Dy_@SlllVXBB1WgSbAK=W~dQrMREPkI+)ZC(vG_ z!S%1Xb{XQ@4_d&wpF6?9rCxBzj14?zCJL;#;(CmAz`gI`{EYO%e6rApJG4DB=f48p zvA6?#>0&Cixa1T(U&Vd;Pib5-Ho*Fj`qqcgxTYZ_hg$pWFpO7MSJOb_LA~yA>JZDS z+thR7`e8qXR~W9+c!X3qKpmBt2npbE$F6R^2NI4)G1f1Pf}-Z zc<~Um<*U?n)Fp?vWKdTnzWX@!*2(ZO>X!FA^Qn)O?q5v(aa+@F>hX7mRuQwL@X9{w zs+BA0{%4)Vrvm%m*Nk~z*VFwk+T7Pqlh2Ez$8#EqB`0(5A=V^ZF%(iyOl+t3NBe8* zUi$tBdL(Krm$VOV>uP+PIJD@k`1M~#-lXG?yjIX-Anjx1=6d=*i0v@< zn@BwF!!ZNBUkSJJ3!6#&(Q;2B%?C2le;Ck{xOw=y{^yBTA8;L~{dvZdok7=gZHcA5 zm9%fF>>V5>KJ@j-nReoHN8fVM{<<$F4`tqqGsDZ5r}KylH{F@qdC!7l_8gzVf6l=~ z@)_Uh|0U=0zw-nkjT=AgaV4haTrfdu&IQvU{Oz2}e;GCBQgbe{pqQF-b(853{@I+1 z?OSxBGDZl?^$5B&$Ez+^#~;V89ODk<`wd?W^v%5c#Oe!c;x8$-DwXBlP=Xf%Q3iRc zFRtlIO?@maeQCzB%&ctnOq~OD9jJTZ-~BxBKep6|mHNO|Us~#m`#+Ps1ah#+*^|lN u3`sXWOHsbrO#17ew<=9rWV@qU-fSu_dm^iBTfL3lcT0guTjkC7-TZgiW`T16 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Summary.db b/test/data/legacy-sstables/ma/legacy_tables/legacy_ma_clust_be_index_summary/ma-306-big-Summary.db new file mode 100644 index 0000000000000000000000000000000000000000..0c575b7c1bf65927bfcd8400c08c799a2e867ef3 GIT binary patch literal 47 icmZQzU}#`qU|T6Bgu%WaLUYfB(EKG3TG#~u D-)ji! literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Data.db b/test/data/legacy-sstables/mb/legacy_tables/legacy_mb_clust_be_index_summary/mb-307-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..4b4fe735f53f800e6f79b95f20b577264b180446 GIT binary patch literal 5232 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 D-lYi4 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Data.db b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..5208946c1d29206795769cbd5ab863d00e2fca18 GIT binary patch literal 5215 zcmd6r|4&p`7Qo*F24SjwvMH@#nuiVDK)2}|W(F8qJ8z_BgSIKC=_+lyd~;xCWMGE* z0!&jF6%|SAqBaqCO*-o8P)$|nrd90fjNMe(?yl$$8;jkIb+fMJhmAI^u_X5Oocrd@ zyO;V0@Qd+t?z#7!d*^-bnStYYZV$(s`V~cq!v7Vnm>U=~naa!-Yk5Vbt;)#3h_X+4 zJGxEaa-z}p&Tz=p-RkLW+1T9`4hI5})(&^LWn;t}_Oy0+ntR**y}mYA(Cv3Nd)nJW z-lk1$fl!yTqcyNG)YjAz3AA;%dYfF`?QTzVSEMZx^oP7IZ?Gre@9c1QxLSKWL0_lG z+wEiW>&D7UwF(Mm+qWMoG zctn=ZMPYN|ScQa1N2MK8WK*f}!<~cM?1^fZ1D5G0yT^zlQSHXa$7GGeoWmgfx()-M zr~%$#5Z54|))Q9SFmOgss6w956J9OCz*#+E8SMiF;Qe1lNE-s=`{WYZX0!in7d`znUk{*6D!BCQ+3p6#2GV}pM$FNMR_Dtt6 zsquVqy2ibOq((hsH$C0ChbDIqlJZ!pV!Pz-rH8$Z3^mc@uVH8vL#s(qa-q6zpHp`-X4wC*VSZRV z_8h-Uh>_cc=j;aQeTUuPJH&H*SwCz9@1h2B6`jb!gW!e5S?_|`LLy{()!@S+O>WhL zfhjmPxCc72-_=&_kD?ACxC8JeaHuyyt(+LR0_QE7Z{(&I=A%Yw;3`HfCO$nMRFMWx zW7Hbci^u?h&S0>dO2yy=1}mscoc~S?qm^?~4`R?ZCv|ubqQdizUBZ-BLnE%c6W>|$ zd1B3xT1R4dNPR)br4W}wX0pFjLR@;!hs#9Cg#hG7QYQm-F%+Ok95K3s(s+8Ak@~1n zpE&Y5oqFJ%fSXhp@P11q9N&|iDZfof8r>V916T|z2M564QV#iUp%Qi6ydmtxP* zV}D%CP##V3`#@slxi}HzIyBKoQ^jRH4Yt)aGXbt5QLMssLgpR;V`!@6k z^%gi)M>_NWezkBjaU6wLJ%`SAS&71159$0ovE0_1pL9>p;2ybnyd>mFtNZgPsE3 z>v=f&<}d~;*~Hxt6Bf#_Jq10!NxI3RG~a@L!iatg`U$j9IVJiRMXczzBDkI=`b;B| z_VUg&G1N@c|7#dp#Skh-FaenDu;Vs+_uz0yXi(^Svj zK&u{?R#wq-S3XZuO%amT&1;r1V^7iaN)AK03>g`EMExiWpQPsxKd#``M&N%)e9U%buBxXRf<}# zK-ClEH&LqqSz>j{b8A0XK|EiWFPg6FYZ1?D?>yA=^%vk2!SibJZPqEkL-@&JsrK$% z%h!JfhcB8JX6q$_an3NUyKGt1{>9>-7AC_~}I=Z0Zq-S39o z$hzMRY(q~r?49FxOON_er2MY^mi4=(7uVDLZiygiez&|uQ(GfLO$;^Dw5f)nRSd0W z{O&Z7>NLOC!Bq~wo6?=Qvy7e_Sc0Va9VlSN3Tf)*7~&a%qu2Ksxy{fwjNg$NQk~}a zI_N1-U0VOXDSB?-6`Ho3M$-J=a)ue3plN%Ip@TXV)e&nq)K7oDwTRM3=;C0Z0gJQ)3-l-+4zOTDZe5bO} k?5~LKR5D%y>l5hvOH0vp)I<`KvZ1{W|4_%f{<}8kCqN5*b^rhX literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Digest.crc32 b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Digest.crc32 new file mode 100644 index 0000000000..3f9e062437 --- /dev/null +++ b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Digest.crc32 @@ -0,0 +1 @@ +1373250029 \ No newline at end of file diff --git a/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Filter.db b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..2e1d5d29ca0683d58365c1bda385a89ced35f1f9 GIT binary patch literal 24 fcmZQzU|?lnU|?ckVPs%abZX%^z`&xww2T1&5k3Nr literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Index.db b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Index.db new file mode 100644 index 0000000000000000000000000000000000000000..f1bccb20c57192d8c7181dfe848628cf7c5ce3de GIT binary patch literal 157553 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 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Summary.db b/test/data/legacy-sstables/mc/legacy_tables/legacy_mc_clust_be_index_summary/mc-3113-big-Summary.db new file mode 100644 index 0000000000000000000000000000000000000000..0c575b7c1bf65927bfcd8400c08c799a2e867ef3 GIT binary patch literal 47 icmZQzU}#`qU|T5hgu%WILUT`o(EP~|T38zZ D+)oIq literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Data.db b/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..a6a94e6b5ec3b3d079087a1576a85916c34c95cd GIT binary patch literal 5206 zcmd6r|5Fs_9mn^OLpU@Go#F_#T}+r3JL&9kcfgUD+pBdPOxi%=bf~>_;5-B_9KvyX zIk?2*C|F6-X~>s}*mPPA${CX=kXDH%aHp9;lSxF=WDJQJ%uG87AU$Kzf8ZrRruZf=)-a$|Rs9BFCniiWm@qg?@SQ%9)P*WnEWn*yy52O_PJ zNZYm@-W|b6YoKXcsI$}OePsLg&Tz2xkzjLMS9ePovb|A%Tf`e~3(4W2EJuO?*&k_b zYz{YVmt}vTt*xug7xFdAVP7EH8T9%)p}g_3d(2qWaQ*IG>tFblWDbdAWkCz6GixNX zJ-&OF)OW=N_IQ~@A`eQg7q&{~@G9FyGoM}&7qf_eaf2z?%Sq54$mJxnI9!U6j=h`~ zX_CysIt(ml0~2`|SiuJ7V_+p4c=&4!bh3drz~c{9Vbw!fALrnckIYGCS+M<;mNV7G`@k+K zxuL}k^Zt$0gpND8!S9AL?Z;G$bDPCYwQekQVI3BFP;&2{A(h&X>shYkrU!7IiFDE= zFW&1!V~WR|VUyb|RG~g$%zA$@8Yd0o!E7|%Pz}t;LH(u?@XPCHOcLW@jXSyZqM;Mw zZ<1KILmf_t-b1A5sS;8E>?QY;6QpcCV*4PS?(YJ%%AWhUzAs{e*w%m{%6Iiec4_QY|^_MgX7V!X_)9tSm2 z@<1NEe!(`Mqfcy#Tf_tT=-Pj1((_@PiHWb#bsRQ|$bijv1I=-_UB1ao)4Ib!}7n&VFr_Y+i{R4GD2zf~+qckPu%R!)fB= zXh?|1hft}>p!PEAkF+`&XH+k(rdk*Uhk!BX=~{9mXpcAztiyIy$a#_t5^6TT+p?^}tI-~a7*A9ICyse{GYQSke`7Z zmG^n?V%`@3MBsgNxi&50z5r+e?hVVdY(#AtdX5hL`RHY$S8l|?Wa7;$XjZU+SJA69 z0x@|WJbr})t5cvUrA#xZR~q^}%XZ3iLER8(wy#ywY>!AO)B8Aq3O7je1WI-HqI{i| zCs=uskvaQVx!;fpG3P}_4Ks-693Vxih>u9gYnxfdR}Rq0D<4OtG7dGae1aK#l2-X0 zloIkczbcF4`pJ>s8MkO_O^Ep+I<(;J;}EK2T(C86fip;L?@-_uRu=PuU(?BjPfQ27 z^``_qz3`{_B$afixNrj%Ef)TaR^KmW)H+7}m{x1^DAchgxStZ%JJgPSZt@o&{9nh0 zZIhR#`@gG~2;G&h12Rex|527AXTbHi5HGIIf(%9Ge+SGeMQ9e`;(l@)$b1Zpp|>Ut zyS)c&0{gqXU==fz7(a-Kc}RO|ZT_ujPu=;pO8YgSUCHB%mnkuVdur`>7U7<3Bv zYz@oxiII2f7`paREMCn=KF85?6dN@l-Hsu2%NK=W>l7-eP|PPCG*^N-3E$2*1W~*@ zdr=#_JAb=~cV{2NdkK6kz+FY}%xH{Mpwm$ce)5tY`*0Mlc7#ewm0m`uD?i}u{3dci_aMNZ5z@8b zhcoTi!|#L-Rhd6VzJea&C3BSkpQhv<@8|(42AuYV3*`$Bp_m<>Sty3loeXq15LcB5HNg`yb+ zleb7vIRV=DC~5<6-(#qahVI*m+5o({VG-cXUUgTb8+zSaEa1)CFkb__*@sF)v$dL0 zn;CU4qwb?syOmL8jIuF+x7$f|+GX8yhy}deLFa~6qtXBm6*6N*j9SB}@6js4F$#Vj zW5p5p1t`FyS4edl;GUOQz@t~`+~_=`{)I{dJo;~XEH=Za^NhM+s2|mmTlS^t*`~*e zIqshSFJ(Tk&-ImX~`U@#lO#)X8-fm{Qm$WiiEfT literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Digest.crc32 b/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Digest.crc32 new file mode 100644 index 0000000000..44c7c2710e --- /dev/null +++ b/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Digest.crc32 @@ -0,0 +1 @@ +2461228597 \ No newline at end of file diff --git a/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Filter.db b/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..2e1d5d29ca0683d58365c1bda385a89ced35f1f9 GIT binary patch literal 24 fcmZQzU|?lnU|?ckVPs%abZX%^z`&xww2T1&5k3Nr literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Index.db b/test/data/legacy-sstables/md/legacy_tables/legacy_md_clust_be_index_summary/md-31110-big-Index.db new file mode 100644 index 0000000000000000000000000000000000000000..0860005fb9d80cd863649b7c2093ba2d7bd2fe11 GIT binary patch literal 157553 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 D+@}bx literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Data.db b/test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..6fb056218cc9126f17eb56208daaf3025c4d0453 GIT binary patch literal 5207 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 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Statistics.db b/test/data/legacy-sstables/me/legacy_tables/legacy_me_clust_be_index_summary/me-31111-big-Statistics.db new file mode 100644 index 0000000000000000000000000000000000000000..2482df5a8151944c29d8a248b35b03b27cc8ef24 GIT binary patch literal 7151 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 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Digest.crc32 b/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Digest.crc32 new file mode 100644 index 0000000000..7ffa3bc3c7 --- /dev/null +++ b/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Digest.crc32 @@ -0,0 +1 @@ +309317098 \ No newline at end of file diff --git a/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Filter.db b/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..8868e5c18008783c106cc95dcb2a5942cf662a48 GIT binary patch literal 24 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 P*NUqjyLv#ySC{Vr3r&}s literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Summary.db b/test/data/legacy-sstables/na/legacy_tables/legacy_na_clust_be_index_summary/na-40-big-Summary.db new file mode 100644 index 0000000000000000000000000000000000000000..0c575b7c1bf65927bfcd8400c08c799a2e867ef3 GIT binary patch literal 47 icmZQzU}#`qU|v?xRzMl!C1u$bK-G|PPm%?8!a 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 B&gcLD literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Digest.crc32 b/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Digest.crc32 new file mode 100644 index 0000000000..b0e4cbb28e --- /dev/null +++ b/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Digest.crc32 @@ -0,0 +1 @@ +3874015080 \ No newline at end of file diff --git a/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Filter.db b/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..8868e5c18008783c106cc95dcb2a5942cf662a48 GIT binary patch literal 24 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 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Summary.db b/test/data/legacy-sstables/nb/legacy_tables/legacy_nb_clust_be_index_summary/nb-400-big-Summary.db new file mode 100644 index 0000000000000000000000000000000000000000..0c575b7c1bf65927bfcd8400c08c799a2e867ef3 GIT binary patch literal 47 icmZQzU}#`qU|&|>lsT6`CTmV~-bS^>hBISirY JiXpUuC;%KG6Wss+ literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Data.db b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Data.db new file mode 100644 index 0000000000000000000000000000000000000000..7d422681cb7ac00ca473a94a42da8cdf76bdb738 GIT binary patch literal 8513 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 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Digest.crc32 b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Digest.crc32 new file mode 100644 index 0000000000..e86ec54b54 --- /dev/null +++ b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Digest.crc32 @@ -0,0 +1 @@ +1158768921 \ No newline at end of file diff --git a/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Filter.db b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Filter.db new file mode 100644 index 0000000000000000000000000000000000000000..8868e5c18008783c106cc95dcb2a5942cf662a48 GIT binary patch literal 24 fcmZQzU|?lnU|?!-Qe9lWFv@*pp_tY)@ElW$!=?FX{-b-Rcy4e5yiqUV9?JH6q~gUdMAo~ ziY(X)1|(n=LP#X*oRdt>8nB2-mix^8rMjd@X6ByvfB)}$?!8ahI#q^GPi%kj+;;hL z|J13S*?e*O%-P*NM}7nAKrM`$2Po-Ykuv;LQkKn%n{ zY}^oQ)H;n-ScO$sHEvdQN`3wJ^5Dc><2uv-))9)K7>bRXV$HaW<84XUma#Pzvpx6i zt>u-&W?VCyir9r+*cHRBYFsmudDKEJ)QX|jkGIw{uG!pV%Vf)B%VcZZldVpvW?Uxo zjEiwGt{CGQ-n@B#$aS{E%n|t_U*v1t@>P{Q0*QLgvb%C&FEgX2(exljwWP%DO7!^P|C zA=kqD1i=fuz$*q`O}UKbQ46(DD~4Lb<*r;_CSrMx+y6O+Y>UL zkQw(AGQDCQ?e49zuusau4!qo0ydFoL_QkddmwQ(=j2cD_W6Tx&o2~VI_d60dunW7e zD~4UoxNJ(I7HXkZ47I+yZ(Oplr#&$+Gcz;Gs(@--vaqwx8Oor{v{&p;Tg!v3wyP)$ zd)g}j3$ZY(0-AA|%$sqUahY+&%(#YgWxcI9^O!bxffsniz^f{kEbJ^z*4Sz6roCc^ z57x>h3wzot0SmD(s{)#F$->qr>J#;eF@56jd0Fo(%EHdN;7}xrH0>4Jl*?$Ia#1eI zm7`qe57+yOvaqLp0i$pfE~^4o$|Vas>y&{E$V_|14i^sBLoQj^(_RW-2!>e|P={Qy zu(Qq?%Am}&SL|@{&U(lt3wzp20Sv(~s{)#GNjI~vXkXF3V$Qze<*r;_Cx+NtsDad&O4a(j^iu!bP}pgzNV0<+ZKHE}N2!>w$HFmS{O%TFSy6@3}z^9 zgr(!C6j|8gI1h+`2v*|5T|1j`$-*|{GUKwV7_+M=3tPD=*O+o8=10Z6Dwiy5qW*BA zu7-}*kYD4te+^mKh=o`))){D>&A4P?8*=HI@hgU3vapq_a*ZihE$Pvgv?-T2s8TKr z$M6`253;aLxlFlCxe{e=rChSG;S0XtD+gb)ur){;q?iUN2Q0_&N$ZeH7B=OgT$JlL zc=LGv4_Vlhi*iw}$TwRx<&uSMUlGGGJci+eENoq(E>V~GcsjV_{a5O~qC2@57vo}F zImRUm8?g`zv0{kTrLGEBY4up2S3v5RgHh$q3e#P)h7WSqOL8seH_~x6v#nFt*rX=HH zT#PHmxMX27F1Ovg?LN^?t8vM~#xMNBuN;2K!bU8_LaZEO^-tQ2OBS{nml>BCSImq{ z7PfL#t}*4>b;Hr_UR5qx*jh#{qn0s;hqAB{3$YL@hgkiSHsg|oZOEl-)-}g;&9bnS zt8$Gg*RC6m?hU!TL6vf0IEKeCTo$%+Rjx7RO05YD&jF(>Y{td7 z7+2(L7V5sDENsd}xhPkVa$UT$ymD9?yu44)gr0yB&=>)2)RKjbTBwCuG1QWUtz4CB zOu6Rta>wyW>%O8pxfmCOLwF3r2U*yNg;!X|8ljj&}3n=EX#t9Aoxce-va3!89(HfRSzyWRyR3wzT?3e&wb`{tWC zFqDOjSRNJfs8Ax^n{nBc)G_K9b&N3`qbzL3#kd$(s&UD}#xMNBuN;2K!bU8_LaZEO z^-o%7Tr*kNW?W`mW?V5dE?L;hRk_BLYu61&vaqdzO}x>^S>5cjDhu0?%aF^EE0Obc z$TgRRZOEl-)-}g;&9bnSt8$Gg*F-UTa-X>=mp73KjR<6o5rd*$#z9jz3 zE9H`fZAfoOZ%ChmFIm`(i*Yfo$k!~?A(t#{%0;;-SCDea!iFr!f~*{5^-tQAOBS|$ zMQyXTIi_uvg{@qbYfQOz-Eh>NSCoaVW7IL~7;|ta3mdTz3$b#D)jw&ykt=dPw0{Lh SoBcKb=hylDw_rR%7WO})`2M8; literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Statistics.db b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Statistics.db new file mode 100644 index 0000000000000000000000000000000000000000..a548e130d2e9d940c3fad6d002cea5abe37ebfbb GIT binary patch literal 7312 zcmeI$drVtZ7y$5lZXY}b9TfHe9FuK~jj)0R290bL)(IF5$iv~Bkqd30$Sb8mh9fKp z|Da(wWsGDGoe3eZKmg|oPRz0i>gHf%8M+MuTA7*A&dHE51aE0OzVGNC#J^m;C%L)z z*YEV^oO>Sk%Viiwym_migt3(n{zUjg&mSy*yu%+NhIxV%9LyPHLW>MJ3a*&T&ebWh zxsnpDP;1~6+FYX|Zog5NWYFpiI&Cs%FzSu^qC%ZPU0psA-|qcp=Cw>hb!;`7yrAG5)X?Ya3vpZEYJYd>c^_BQcDle~zD} zjtl$QiLx_gSITabWt2TBdsALZc^&1Al!GZNDaTMwp!^c$9LfhMH&E`TJc3QA@gUo& zxRG)nHoJy$6}E`FzsNC9?A65SxV|JDTe<_=iR!QOLmYPudKnAe}KJuFShS6 z_LHI5n@?gZGO(kLW5=DtPF{tb>4RPJB6cl@-Av8j0S%5@{Oz`_BjW!Xij#~q?BjTT z63cZIXH)TdX1~T3Wn4k^#bP}F#aAz*xa7+^Wa-^jWarccWS4mz@``ycWSJJvM^DX9 zDDK^}8hP!QFY>yP6y%MAc)WvW@OX#Ue~#+!82=IZxmeu3mwnABp7)C!`Cw89a?^uo zWYb0bd`3;^c@kHT`>;My$6Mb6j|!>W(DDfU1-Wz~44Mr(i}qLci0m4Si+sz_{1ElL z>H_29GMAmul6@nnztSRo8H_ub%+t^=n%z^-EBt%WdUDT@55c&HD6t>fD=HAp=QXki zM`7Hr?cF=j0TBsZ&_UnsiGdCs%58^MWmcSk*4zl&1D$fRAQCz|@RMhtOK06Dq3gbA zjfZYaZQ20+O=I;T=;<@VyMf6T_pBc1>|MLy`X{Z)XC3R`T8%8cFN5o!)tSdW1^;Kq zPwy-T78!~8FtB*jpga+JX667KAITr}4e@5En*fr_Hegm-EYjwZE z{>#4eyaW61c{QP14(hMsYK!6fz^6sss{nETuO{Viyf)p7Ppk#;kaSBR%m*UFf9{uo zxO(Jv?;F6+AL}>`+w+P=6$$5aVTz`?9@MYSG7XFapSU%8t{J%R)JGk#z2*zS!%<6d zB7f`hTpVy>-u;JFz;C}0v~3Xh#=eHUkR`LKrzb0Of!n;>l@&`Cg?Hthnp-mC=qujS z|DMya;6K*O|4R;MdxtWNlIlO&Gx(U0!=VQx;e;FxOei6Tdz^DP zawH&e@CU}JXo8U{4bEq}h8EAJiWdHp%VKd1wYsU(FD9V$mc#H&w*2$=oh(HGXDG?# z@)hZ6&qk;1FV+$M15I^jSlCm_@QBFmQPC>lN_YmsJP_8xe|tZWE^b@GW+iOc!b?kd zaX&W6iz7#ywO{aOd&0-ep67q#KeRxDWRM{fURS<9e>?Vi&9=U(n=1VjL&8Wz<&5o4 k{&(}&|0xgJdsE4O4_$upx9pk>5tVZJ%dY<3@0mG&0YgH?1ONa4 literal 0 HcmV?d00001 diff --git a/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Summary.db b/test/data/legacy-sstables/oa/legacy_tables/legacy_oa_clust_be_index_summary/oa-500-big-Summary.db new file mode 100644 index 0000000000000000000000000000000000000000..0c575b7c1bf65927bfcd8400c08c799a2e867ef3 GIT binary patch literal 47 icmZQzU}#`qU| new RuntimeException(String.format("No files for verion=%s and table=%s", legacyVersion, table))); + .orElseThrow(() -> new RuntimeException(String.format("No files for path=%s", dir.absolutePath()))); return Descriptor.fromFile(new File(file)); } @@ -493,15 +498,19 @@ public class LegacySSTableTest streamLegacyTable("legacy_%s_clust", legacyVersion); streamLegacyTable("legacy_%s_clust_counter", legacyVersion); streamLegacyTable("legacy_%s_tuple", legacyVersion); + streamLegacyTable("legacy_%s_clust_be_index_summary", legacyVersion); } private void streamLegacyTable(String tablePattern, String legacyVersion) throws Exception { String table = String.format(tablePattern, legacyVersion); - Descriptor descriptor = getDescriptor(legacyVersion, table); + // streaming can mutate test data (rewrite IndexSummary, so we have to copy them) + File testDataDir = new File(tempFolder.newFolder(LEGACY_TABLES_KEYSPACE, table)); + copySstablesToTestData(legacyVersion, table, testDataDir); + Descriptor descriptor = getDescriptor(testDataDir); if (null != descriptor) { - SSTableReader sstable = SSTableReader.open(null, getDescriptor(legacyVersion, table)); + SSTableReader sstable = SSTableReader.open(null, descriptor); IPartitioner p = sstable.getPartitioner(); List> ranges = new ArrayList<>(); ranges.add(new Range<>(p.getMinimumToken(), p.getToken(ByteBufferUtil.bytes("100")))); @@ -525,6 +534,7 @@ public class LegacySSTableTest Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust", legacyVersion)).truncateBlocking(); Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust_counter", legacyVersion)).truncateBlocking(); Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_tuple", legacyVersion)).truncateBlocking(); + Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust_be_index_summary", legacyVersion)).truncateBlocking(); CacheService.instance.invalidateCounterCache(); CacheService.instance.invalidateKeyCache(); } @@ -537,6 +547,7 @@ public class LegacySSTableTest Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust", legacyVersion)).forceMajorCompaction(); Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust_counter", legacyVersion)).forceMajorCompaction(); Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_tuple", legacyVersion)).forceMajorCompaction(); + Keyspace.open(LEGACY_TABLES_KEYSPACE).getColumnFamilyStore(String.format("legacy_%s_clust_be_index_summary", legacyVersion)).forceMajorCompaction(); } public static void loadLegacyTables(String legacyVersion) throws Exception @@ -547,6 +558,7 @@ public class LegacySSTableTest loadLegacyTable(legacyVersion, "clust"); loadLegacyTable(legacyVersion, "clust_counter"); loadLegacyTable(legacyVersion, "tuple"); + loadLegacyTable(legacyVersion, "clust_be_index_summary"); } private static void verifyCache(String legacyVersion, long startCount) throws InterruptedException, java.util.concurrent.ExecutionException @@ -584,7 +596,8 @@ public class LegacySSTableTest readSimpleCounterTable(legacyVersion, pkValue); } - readClusteringTable(legacyVersion, ck, ckValue, pkValue); + readClusteringTable("legacy_%s_clust", legacyVersion, ck, ckValue, pkValue); + readClusteringTable("legacy_%s_clust_be_index_summary", legacyVersion, ck, ckValue, pkValue); readClusteringCounterTable(legacyVersion, ckValue, pkValue); } } @@ -600,16 +613,16 @@ public class LegacySSTableTest Assert.assertEquals(1L, rs.one().getLong("val")); } - private static void readClusteringTable(String legacyVersion, int ck, String ckValue, String pkValue) + private static void readClusteringTable(String tableName, String legacyVersion, int ck, String ckValue, String pkValue) { logger.debug("Read legacy_{}_clust", legacyVersion); UntypedResultSet rs; - rs = QueryProcessor.executeInternal(String.format("SELECT val FROM legacy_tables.legacy_%s_clust WHERE pk=? AND ck=?", legacyVersion), pkValue, ckValue); + rs = QueryProcessor.executeInternal(String.format("SELECT val FROM legacy_tables." + tableName + " WHERE pk=? AND ck=?", legacyVersion), pkValue, ckValue); assertLegacyClustRows(1, rs); String ckValue2 = Integer.toString(ck < 10 ? 40 : ck - 1) + longString; String ckValue3 = Integer.toString(ck > 39 ? 10 : ck + 1) + longString; - rs = QueryProcessor.executeInternal(String.format("SELECT val FROM legacy_tables.legacy_%s_clust WHERE pk=? AND ck IN (?, ?, ?)", legacyVersion), pkValue, ckValue, ckValue2, ckValue3); + rs = QueryProcessor.executeInternal(String.format("SELECT val FROM legacy_tables." + tableName + " WHERE pk=? AND ck IN (?, ?, ?)", legacyVersion), pkValue, ckValue, ckValue2, ckValue3); assertLegacyClustRows(3, rs); } @@ -644,7 +657,7 @@ public class LegacySSTableTest QueryProcessor.executeInternal(String.format("CREATE TABLE legacy_tables.legacy_%s_simple_counter (pk text PRIMARY KEY, val counter)", legacyVersion)); QueryProcessor.executeInternal(String.format("CREATE TABLE legacy_tables.legacy_%s_clust (pk text, ck text, val text, PRIMARY KEY (pk, ck))", legacyVersion)); QueryProcessor.executeInternal(String.format("CREATE TABLE legacy_tables.legacy_%s_clust_counter (pk text, ck text, val counter, PRIMARY KEY (pk, ck))", legacyVersion)); - + QueryProcessor.executeInternal(String.format("CREATE TABLE legacy_tables.legacy_%s_clust_be_index_summary (pk text, ck text, val text, PRIMARY KEY (pk, ck))", legacyVersion)); QueryProcessor.executeInternal(String.format("CREATE TYPE legacy_tables.legacy_%s_tuple_udt (name tuple)", legacyVersion)); @@ -667,6 +680,7 @@ public class LegacySSTableTest QueryProcessor.executeInternal(String.format("TRUNCATE legacy_tables.legacy_%s_simple_counter", legacyVersion)); QueryProcessor.executeInternal(String.format("TRUNCATE legacy_tables.legacy_%s_clust", legacyVersion)); QueryProcessor.executeInternal(String.format("TRUNCATE legacy_tables.legacy_%s_clust_counter", legacyVersion)); + QueryProcessor.executeInternal(String.format("TRUNCATE legacy_tables.legacy_%s_clust_be_index_summary", legacyVersion)); CacheService.instance.invalidateCounterCache(); CacheService.instance.invalidateKeyCache(); } @@ -746,6 +760,13 @@ public class LegacySSTableTest QueryProcessor.executeInternal(String.format("UPDATE legacy_tables.legacy_%s_clust_counter SET val = val + 1 WHERE pk = '%s' AND ck='%s'", format.getLatestVersion(), valPk, valCk + longString)); + + // note: to emulate BE for offsets in Summary you can comment temporary the following line: + // offset = Integer.reverseBytes(offset); + // in org.apache.cassandra.io.sstable.indexsummary.IndexSummary.IndexSummarySerializer.serialize + QueryProcessor.executeInternal(String.format("INSERT INTO legacy_tables.legacy_%s_clust_be_index_summary (pk, ck, val) VALUES ('%s', '%s', '%s')", + format.getLatestVersion(), valPk, valCk + longString, randomString)); + } } @@ -758,6 +779,7 @@ public class LegacySSTableTest copySstablesFromTestData(format.getLatestVersion(), "legacy_%s_clust", ksDir); copySstablesFromTestData(format.getLatestVersion(), "legacy_%s_clust_counter", ksDir); copySstablesFromTestData(format.getLatestVersion(), "legacy_%s_tuple", ksDir); + copySstablesFromTestData(format.getLatestVersion(), "legacy_%s_clust_be_index_summary", ksDir); } public static void copySstablesFromTestData(Version legacyVersion, String tablePattern, File ksDir) throws IOException @@ -773,42 +795,47 @@ public class LegacySSTableTest for (File srcDir : Keyspace.open(ks).getColumnFamilyStore(table).getDirectories().getCFDirectories()) { - for (File file : srcDir.tryList()) + for (File sourceFile : srcDir.tryList()) { // Sequence IDs represent the C* version used when creating the SSTable, i.e. with #testGenerateSstables() (if not uuid based) String newSeqId = FBUtilities.getReleaseVersionString().split("-")[0].replaceAll("[^0-9]", ""); - File target = new File(cfDir, file.name().replace(legacyVersion + "-1-", legacyVersion + "-" + newSeqId + "-")); - copyFile(cfDir, file, target); + File target = new File(cfDir, sourceFile.name().replace(legacyVersion + "-1-", legacyVersion + "-" + newSeqId + "-")); + copyFile(sourceFile, target); } } } - private static void copySstablesToTestData(String legacyVersion, String table, File cfDir) throws IOException + private static void copySstablesToTestData(String legacyVersion, String table, File targetDir) throws IOException { - File tableDir = getTableDir(legacyVersion, table); - Assert.assertTrue("The table directory " + tableDir + " was not found", tableDir.isDirectory()); - for (File file : tableDir.tryList()) - copyFile(cfDir, file); + File testDataTableDir = getTestDataTableDir(legacyVersion, table); + Assert.assertTrue("The table directory " + testDataTableDir + " was not found", testDataTableDir.isDirectory()); + for (File sourceTestFile : testDataTableDir.tryList()) + copyFileToDir(sourceTestFile, targetDir); } - private static File getTableDir(String legacyVersion, String table) + private static File getTestDataTableDir(File parentDir, String legacyVersion, String table) { - return new File(LEGACY_SSTABLE_ROOT, String.format("%s/legacy_tables/%s", legacyVersion, table)); + return new File(parentDir, String.format("%s/legacy_tables/%s", legacyVersion, table)); } - public static void copyFile(File cfDir, File file) throws IOException + private static File getTestDataTableDir(String legacyVersion, String table) { - copyFile(cfDir, file, new File(cfDir, file.name())); + return getTestDataTableDir(LEGACY_SSTABLE_ROOT, legacyVersion, table); } - public static void copyFile(File cfDir, File file, File target) throws IOException + public static void copyFileToDir(File sourceFile, File targetDir) throws IOException + { + copyFile(sourceFile, new File(targetDir, sourceFile.name())); + } + + public static void copyFile(File sourceFile, File targetFile) throws IOException { byte[] buf = new byte[65536]; - if (file.isFile()) + if (sourceFile.isFile()) { int rd; - try (FileInputStreamPlus is = new FileInputStreamPlus(file); - FileOutputStreamPlus os = new FileOutputStreamPlus(target);) + try (FileInputStreamPlus is = new FileInputStreamPlus(sourceFile); + FileOutputStreamPlus os = new FileOutputStreamPlus(targetFile);) { while ((rd = is.read(buf)) >= 0) os.write(buf, 0, rd); diff --git a/test/unit/org/apache/cassandra/utils/memory/LittleEndianMemoryUtilTest.java b/test/unit/org/apache/cassandra/utils/memory/LittleEndianMemoryUtilTest.java new file mode 100644 index 0000000000..592d01906b --- /dev/null +++ b/test/unit/org/apache/cassandra/utils/memory/LittleEndianMemoryUtilTest.java @@ -0,0 +1,148 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.utils.memory; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import org.junit.Assert; +import org.junit.Test; + +public class LittleEndianMemoryUtilTest +{ + private static final int TEST_BUFFER_LENGTH = 8; + private final ByteBuffer directBuffer = ByteBuffer.allocateDirect(TEST_BUFFER_LENGTH); + { + directBuffer.order(ByteOrder.LITTLE_ENDIAN); + } + private final long address = LittleEndianMemoryUtil.getAddress(directBuffer); + + @Test + public void testGetSetLong() + { + long originalValue = 0xAB_CD_EF_12_34_56_78_90L; + directBuffer.putLong(originalValue); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getLong(address)); + + directBuffer.rewind(); + directBuffer.putLong(0); + LittleEndianMemoryUtil.setLong(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getLong(0)); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getLong(address)); + + } + + @Test + public void testGetSetInt() + { + int originalValue = 0xAB_CD_EF_12; + directBuffer.putInt(originalValue); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getInt(address)); + + directBuffer.rewind(); + directBuffer.putInt(0); + LittleEndianMemoryUtil.setInt(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getInt(0)); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getInt(address)); + + } + + @Test + public void testGetSetUnsighedShort() + { + short originalValue = (short) 0xAB_CD; + directBuffer.putShort(originalValue); + Assert.assertEquals(originalValue & 0xffff, LittleEndianMemoryUtil.getUnsignedShort(address)); + + directBuffer.rewind(); + directBuffer.putShort((short) 0); + LittleEndianMemoryUtil.setShort(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getShort(0)); + Assert.assertEquals(originalValue & 0xffff, LittleEndianMemoryUtil.getUnsignedShort(address)); + } + + @Test + public void testGetSetLongByBytes() + { + long originalValue = 0xAB_CD_EF_12_34_56_78_90L; + directBuffer.putLong(originalValue); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getLongByByte(address)); + + directBuffer.rewind(); + directBuffer.putLong(0); + LittleEndianMemoryUtil.putLongByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getLong(0)); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getLongByByte(address)); + + } + + @Test + public void testGetSetIntByBytes() + { + int originalValue = 0xAB_CD_EF_12; + directBuffer.putInt(originalValue); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getIntByByte(address)); + + directBuffer.rewind(); + directBuffer.putInt(0); + LittleEndianMemoryUtil.putIntByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getInt(0)); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getIntByByte(address)); + + } + + @Test + public void testGetSetShortByBytes() + { + short originalValue = (short) 0xAB_CD; + directBuffer.putShort(originalValue); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getShortByByte(address)); + + directBuffer.rewind(); + directBuffer.putShort((short) 0); + LittleEndianMemoryUtil.putShortByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getShort(0)); + Assert.assertEquals(originalValue, LittleEndianMemoryUtil.getShortByByte(address)); + } + + + @Test + public void testGetHollowDirectByteBuffer() + { + ByteBuffer byteBuffer = LittleEndianMemoryUtil.getHollowDirectByteBuffer(); + Assert.assertEquals(directBuffer.getClass(), byteBuffer.getClass()); + Assert.assertEquals(ByteOrder.LITTLE_ENDIAN, byteBuffer.order()); + } + + @Test + public void testGetByteBuffer() + { + ByteBuffer byteBuffer = LittleEndianMemoryUtil.getByteBuffer(address, TEST_BUFFER_LENGTH); + Assert.assertEquals(directBuffer.getClass(), byteBuffer.getClass()); + Assert.assertEquals(ByteOrder.LITTLE_ENDIAN, byteBuffer.order()); + Assert.assertEquals(TEST_BUFFER_LENGTH, byteBuffer.capacity()); + Assert.assertEquals(0, byteBuffer.position()); + } +} diff --git a/test/unit/org/apache/cassandra/utils/memory/NativeEndianMemoryUtilTest.java b/test/unit/org/apache/cassandra/utils/memory/NativeEndianMemoryUtilTest.java new file mode 100644 index 0000000000..ba0527b18a --- /dev/null +++ b/test/unit/org/apache/cassandra/utils/memory/NativeEndianMemoryUtilTest.java @@ -0,0 +1,148 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.cassandra.utils.memory; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +import org.junit.Assert; +import org.junit.Test; + +public class NativeEndianMemoryUtilTest +{ + private static final int TEST_BUFFER_LENGTH = 8; + private final ByteBuffer directBuffer = ByteBuffer.allocateDirect(TEST_BUFFER_LENGTH); + { + directBuffer.order(ByteOrder.nativeOrder()); + } + private final long address = NativeEndianMemoryUtil.getAddress(directBuffer); + + @Test + public void testGetSetLong() + { + long originalValue = 0xAB_CD_EF_12_34_56_78_90L; + directBuffer.putLong(originalValue); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getLong(address)); + + directBuffer.rewind(); + directBuffer.putLong(0); + NativeEndianMemoryUtil.setLong(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getLong(0)); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getLong(address)); + + } + + @Test + public void testGetSetInt() + { + int originalValue = 0xAB_CD_EF_12; + directBuffer.putInt(originalValue); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getInt(address)); + + directBuffer.rewind(); + directBuffer.putInt(0); + NativeEndianMemoryUtil.setInt(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getInt(0)); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getInt(address)); + + } + + @Test + public void testGetSetUnsighedShort() + { + short originalValue = (short) 0xAB_CD; + directBuffer.putShort(originalValue); + Assert.assertEquals(originalValue & 0xffff, NativeEndianMemoryUtil.getUnsignedShort(address)); + + directBuffer.rewind(); + directBuffer.putShort((short) 0); + NativeEndianMemoryUtil.setShort(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getShort(0)); + Assert.assertEquals(originalValue & 0xffff, NativeEndianMemoryUtil.getUnsignedShort(address)); + } + + @Test + public void testGetSetLongByBytes() + { + long originalValue = 0xAB_CD_EF_12_34_56_78_90L; + directBuffer.putLong(originalValue); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getLongByByte(address)); + + directBuffer.rewind(); + directBuffer.putLong(0); + NativeEndianMemoryUtil.putLongByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getLong(0)); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getLongByByte(address)); + + } + + @Test + public void testGetSetIntByBytes() + { + int originalValue = 0xAB_CD_EF_12; + directBuffer.putInt(originalValue); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getIntByByte(address)); + + directBuffer.rewind(); + directBuffer.putInt(0); + NativeEndianMemoryUtil.putIntByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getInt(0)); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getIntByByte(address)); + + } + + @Test + public void testGetSetShortByBytes() + { + short originalValue = (short) 0xAB_CD; + directBuffer.putShort(originalValue); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getShortByByte(address)); + + directBuffer.rewind(); + directBuffer.putShort((short) 0); + NativeEndianMemoryUtil.putShortByByte(address, originalValue); + + Assert.assertEquals(originalValue, directBuffer.getShort(0)); + Assert.assertEquals(originalValue, NativeEndianMemoryUtil.getShortByByte(address)); + } + + + @Test + public void testGetHollowDirectByteBuffer() + { + ByteBuffer byteBuffer = NativeEndianMemoryUtil.getHollowDirectByteBuffer(); + Assert.assertEquals(directBuffer.getClass(), byteBuffer.getClass()); + Assert.assertEquals(ByteOrder.nativeOrder(), byteBuffer.order()); + } + + @Test + public void testGetByteBuffer() + { + ByteBuffer byteBuffer = NativeEndianMemoryUtil.getByteBuffer(address, TEST_BUFFER_LENGTH); + Assert.assertEquals(directBuffer.getClass(), byteBuffer.getClass()); + Assert.assertEquals(ByteOrder.nativeOrder(), byteBuffer.order()); + Assert.assertEquals(TEST_BUFFER_LENGTH, byteBuffer.capacity()); + Assert.assertEquals(0, byteBuffer.position()); + } +}