import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public OffHeapBitSet(long numBits)
{
    // OpenBitSet.bits2words calculation is there for backward compatibility.
    long wordCount = OpenBitSet.bits2words(numBits);
    if (wordCount > Integer.MAX_VALUE)
        throw new UnsupportedOperationException("Bloom filter size is > 16GB, reduce the bloom_filter_fp_chance");
    try
    {
        long byteCount = wordCount * 8L;
        bytes = RefCountedMemory.allocate(byteCount);
    }
    catch (OutOfMemoryError e)
    {
        throw new RuntimeException("Out of native memory occured, You can avoid it by increasing the system ram space or by increasing bloom_filter_fp_chance.");
    }
    // flush/clear the existing memory.
    clear();
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public static OffHeapBitSet deserialize(DataInput in) throws IOException
{
    long byteCount = in.readInt() * 8L;
    Memory memory = RefCountedMemory.allocate(byteCount);
    for (long i = 0; i < byteCount;)
    {
        long v = in.readLong();
        memory.setByte(i++, (byte) (v >>> 0));
        memory.setByte(i++, (byte) (v >>> 8));
        memory.setByte(i++, (byte) (v >>> 16));
        memory.setByte(i++, (byte) (v >>> 24));
        memory.setByte(i++, (byte) (v >>> 32));
        memory.setByte(i++, (byte) (v >>> 40));
        memory.setByte(i++, (byte) (v >>> 48));
        memory.setByte(i++, (byte) (v >>> 56));
    }
    return new OffHeapBitSet(memory);
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public static OffHeapBitSet deserialize(DataInput dis) throws IOException
{
    long byteCount = dis.readInt() * 8L;
    Memory memory = RefCountedMemory.allocate(byteCount);
    for (long i = 0; i < byteCount;)
    {
        long v = dis.readLong();
        memory.setByte(i++, (byte) (v >>> 0));
        memory.setByte(i++, (byte) (v >>> 8));
        memory.setByte(i++, (byte) (v >>> 16));
        memory.setByte(i++, (byte) (v >>> 24));
        memory.setByte(i++, (byte) (v >>> 32));
        memory.setByte(i++, (byte) (v >>> 40));
        memory.setByte(i++, (byte) (v >>> 48));
        memory.setByte(i++, (byte) (v >>> 56));
    }
    return new OffHeapBitSet(memory);
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public IndexSummary(IPartitioner partitioner, RefCountedMemory memory, int summarySize, int sizeAtFullSampling,
                    int minIndexInterval, int samplingLevel)
{
    this.partitioner = partitioner;
    this.minIndexInterval = minIndexInterval;
    this.summarySize = summarySize;
    this.sizeAtFullSampling = sizeAtFullSampling;
    this.bytes = memory;
    this.samplingLevel = samplingLevel;
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public IndexSummary deserialize(DataInputStream in, IPartitioner partitioner, boolean haveSamplingLevel, int expectedMinIndexInterval, int maxIndexInterval) throws IOException
{
    int minIndexInterval = in.readInt();
    if (minIndexInterval != expectedMinIndexInterval)
    {
        throw new IOException(String.format("Cannot read index summary because min_index_interval changed from %d to %d.",
                                            minIndexInterval, expectedMinIndexInterval));
    }

    int summarySize = in.readInt();
    long offheapSize = in.readLong();
    int samplingLevel, fullSamplingSummarySize;
    if (haveSamplingLevel)
    {
        samplingLevel = in.readInt();
        fullSamplingSummarySize = in.readInt();
    }
    else
    {
        samplingLevel = BASE_SAMPLING_LEVEL;
        fullSamplingSummarySize = summarySize;
    }

    int effectiveIndexInterval = (int) Math.ceil((BASE_SAMPLING_LEVEL / (double) samplingLevel) * minIndexInterval);
    if (effectiveIndexInterval > maxIndexInterval)
    {
        throw new IOException(String.format("Rebuilding index summary because the effective index interval (%d) is higher than" +
                                            " the current max index interval (%d)", effectiveIndexInterval, maxIndexInterval));
    }

    RefCountedMemory memory = new RefCountedMemory(offheapSize);
    FBUtilities.copy(in, new MemoryOutputStream(memory), offheapSize);
    return new IndexSummary(partitioner, memory, summarySize, fullSamplingSummarySize, minIndexInterval, samplingLevel);
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
private CompressionMetadata(String filePath, CompressionParameters parameters, RefCountedMemory offsets, long offsetsSize, long dataLength, long compressedLength, boolean hasPostCompressionAdlerChecksums)
{
    this.indexFilePath = filePath;
    this.parameters = parameters;
    this.dataLength = dataLength;
    this.compressedFileLength = compressedLength;
    this.hasPostCompressionAdlerChecksums = hasPostCompressionAdlerChecksums;
    this.chunkOffsets = offsets;
    offsets.reference();
    this.chunkOffsetsSize = offsetsSize;
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public void close()
{
    if (chunkOffsets instanceof RefCountedMemory)
        ((RefCountedMemory) chunkOffsets).unreference();
    else
        chunkOffsets.free();
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public void addOffset(long offset)
{
    if (count == maxCount)
    {
        RefCountedMemory newOffsets = offsets.copy((maxCount *= 2) * 8);
        offsets.unreference();
        offsets = newOffsets;
    }
    offsets.setLong(8 * count++, offset);
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public CompressionMetadata openAfterClose(long dataLength, long compressedLength)
{
    RefCountedMemory newOffsets = offsets.copy(count * 8L);
    offsets.unreference();
    return new CompressionMetadata(filePath, parameters, newOffsets, count * 8L, dataLength, compressedLength, Descriptor.Version.CURRENT.hasPostCompressionAdlerChecksums);
}
 

import org.apache.cassandra.cache.RefCountedMemory; //导入依赖的package包/类
public MemoryInputStream(RefCountedMemory mem)
{
    this.mem = mem;
}