import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
/**
 * As build(), except:
 * @param size    < 0 if size is unknown
 */
private static <C, K extends C, V extends C> Object[] buildInternal(Iterable<K> source, int size, UpdateFunction<K, V> updateF)
{
    if ((size >= 0) & (size < FAN_FACTOR))
    {
        if (size == 0)
            return EMPTY_LEAF;
        // pad to odd length to match contract that all leaf nodes are odd
        V[] values = (V[]) new Object[size | 1];
        {
            int i = 0;
            for (K k : source)
                values[i++] = updateF.apply(k);
        }
        if (updateF != UpdateFunction.noOp())
            updateF.allocated(ObjectSizes.sizeOfArray(values));
        return values;
    }

    TreeBuilder builder = TreeBuilder.newInstance();
    Object[] btree = builder.build(source, updateF, size);

    return btree;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
private Object[] buildFromRange(int offset, int keyLength, boolean isLeaf, boolean isExtra)
{
    // if keyLength is 0, we didn't copy anything from the original, which means we didn't
    // modify any of the range owned by it, so can simply return it as is
    if (keyLength == 0)
        return copyFrom;

    Object[] a;
    if (isLeaf)
    {
        a = new Object[keyLength + (keyLength & 1)];
        System.arraycopy(buildKeys, offset, a, 0, keyLength);
    }
    else
    {
        a = new Object[1 + (keyLength * 2)];
        System.arraycopy(buildKeys, offset, a, 0, keyLength);
        System.arraycopy(buildChildren, offset, a, keyLength, keyLength + 1);
    }
    if (isExtra)
        updateFunction.allocated(ObjectSizes.sizeOfArray(a));
    else if (a.length != copyFrom.length)
        updateFunction.allocated(ObjectSizes.sizeOfArray(a) -
                                 (copyFrom.length == 0 ? 0 : ObjectSizes.sizeOfArray(copyFrom)));
    return a;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
/**
 * As build(), except:
 * @param size    < 0 if size is unknown
 */
private static <C, K extends C, V extends C> Object[] buildInternal(Iterable<K> source, int size, UpdateFunction<K, V> updateF)
{
    if ((size >= 0) & (size < FAN_FACTOR))
    {
        if (size == 0)
            return EMPTY_LEAF;
        // pad to odd length to match contract that all leaf nodes are odd
        V[] values = (V[]) new Object[size | 1];
        {
            int i = 0;
            for (K k : source)
                values[i++] = updateF.apply(k);
        }
        updateF.allocated(ObjectSizes.sizeOfArray(values));
        return values;
    }

    Queue<TreeBuilder> queue = modifier.get();
    TreeBuilder builder = queue.poll();
    if (builder == null)
        builder = new TreeBuilder();
    Object[] btree = builder.build(source, updateF, size);
    queue.add(builder);
    return btree;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
private static int estimateRowOverhead(final int count)
{
    // calculate row overhead
    try (final OpOrder.Group group = new OpOrder().start())
    {
        int rowOverhead;
        MemtableAllocator allocator = MEMORY_POOL.newAllocator();
        ConcurrentNavigableMap<PartitionPosition, Object> partitions = new ConcurrentSkipListMap<>();
        final Object val = new Object();
        for (int i = 0 ; i < count ; i++)
            partitions.put(allocator.clone(new BufferDecoratedKey(new LongToken(i), ByteBufferUtil.EMPTY_BYTE_BUFFER), group), val);
        double avgSize = ObjectSizes.measureDeep(partitions) / (double) count;
        rowOverhead = (int) ((avgSize - Math.floor(avgSize)) < 0.05 ? Math.floor(avgSize) : Math.ceil(avgSize));
        rowOverhead -= ObjectSizes.measureDeep(new LongToken(0));
        rowOverhead += AtomicBTreePartition.EMPTY_SIZE;
        allocator.setDiscarding();
        allocator.setDiscarded();
        return rowOverhead;
    }
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
public static long sizeOfStructureOnHeap(Object[] tree)
{
    long size = ObjectSizes.sizeOfArray(tree);
    if (isLeaf(tree))
        return size;
    for (int i = getChildStart(tree) ; i < getChildEnd(tree) ; i++)
        size += sizeOfStructureOnHeap((Object[]) tree[i]);
    return size;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
private Object[] buildFromRange(int offset, int keyLength, boolean isLeaf, boolean isExtra)
{
    // if keyLength is 0, we didn't copy anything from the original, which means we didn't
    // modify any of the range owned by it, so can simply return it as is
    if (keyLength == 0)
        return copyFrom;

    Object[] a;
    if (isLeaf)
    {
        a = new Object[keyLength | 1];
        System.arraycopy(buildKeys, offset, a, 0, keyLength);
    }
    else
    {
        a = new Object[2 + (keyLength * 2)];
        System.arraycopy(buildKeys, offset, a, 0, keyLength);
        System.arraycopy(buildChildren, offset, a, keyLength, keyLength + 1);

        // calculate the indexOffsets of each key in this node, within the sub-tree rooted at this node
        int[] indexOffsets = new int[keyLength + 1];
        int size = BTree.size((Object[]) a[keyLength]);
        for (int i = 0 ; i < keyLength ; i++)
        {
            indexOffsets[i] = size;
            size += 1 + BTree.size((Object[]) a[keyLength + 1 + i]);
        }
        indexOffsets[keyLength] = size;
        a[a.length - 1] = indexOffsets;
    }
    if (isExtra)
        updateFunction.allocated(ObjectSizes.sizeOfArray(a));
    else if (a.length != copyFrom.length)
        updateFunction.allocated(ObjectSizes.sizeOfArray(a) -
                                 (copyFrom.length == 0 ? 0 : ObjectSizes.sizeOfArray(copyFrom)));
    return a;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Override
public long unsharedHeapSize()
{
    return EMPTY_SIZE
            + boundaryHeapSize
            + ObjectSizes.sizeOfArray(starts)
            + ObjectSizes.sizeOfArray(ends)
            + ObjectSizes.sizeOfArray(markedAts)
            + ObjectSizes.sizeOfArray(delTimes);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Override
public long unsharedHeapSize()
{
    long entrySize = 0;
    for (IndexInfo idx : columnsIndex)
        entrySize += idx.unsharedHeapSize();
    return BASE_SIZE
        + entrySize
        + ObjectSizes.sizeOfReferenceArray(columnsIndex.length);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
public long unsharedHeapSizeExcludingData()
{
    long heapSize = EMPTY_SIZE + ObjectSizes.sizeOfArray(cells);
    // TODO: this can be turned into a simple multiplication, at least while we have only one Cell implementation
    for (Cell cell : this)
        heapSize += cell.unsharedHeapSizeExcludingData();
    return heapSize;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
/**
 * Creates a BTree containing all of the objects in the provided collection
 *
 * @param source     the items to build the tree with
 * @param comparator the comparator that defines the ordering over the items in the tree
 * @param sorted     if false, the collection will be copied and sorted to facilitate construction
 * @param <V>
 * @return
 */
public static <V> Object[] build(Iterable<V> source, int size, Comparator<V> comparator, boolean sorted, UpdateFunction<V> updateF)
{
    if (size < FAN_FACTOR)
    {
        // pad to even length to match contract that all leaf nodes are even
        V[] values = (V[]) new Object[size + (size & 1)];
        {
            int i = 0;
            for (V v : source)
                values[i++] = v;
        }

        // inline sorting since we're already calling toArray
        if (!sorted)
            Arrays.sort(values, 0, size, comparator);

        // if updateF is specified
        if (updateF != null)
        {
            for (int i = 0 ; i < size ; i++)
                values[i] = updateF.apply(values[i]);
            updateF.allocated(ObjectSizes.sizeOfArray(values));
        }
        return values;
    }

    if (!sorted)
        source = sorted(source, comparator, size);

    Queue<Builder> queue = modifier.get();
    Builder builder = queue.poll();
    if (builder == null)
        builder = new Builder();
    Object[] btree = builder.build(source, updateF, size);
    queue.add(builder);
    return btree;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Override
public long unsharedHeapSize()
{
    long entrySize = 0;
    for (IndexHelper.IndexInfo idx : columnsIndex)
        entrySize += idx.unsharedHeapSize();

    return BASE_SIZE
           + entrySize
           + deletionTime.unsharedHeapSize()
           + ObjectSizes.sizeOfReferenceArray(columnsIndex.size());
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Override
public long memorySize()
{
    long entrySize = 0;
    for (IndexHelper.IndexInfo idx : columnsIndex)
        entrySize += idx.memorySize();

    return ObjectSizes.getSuperClassFieldSize(TypeSizes.NATIVE.sizeof(position))
           + ObjectSizes.getFieldSize(// deletionTime
                                      ObjectSizes.getReferenceSize() +
                                      // columnsIndex
                                      ObjectSizes.getReferenceSize())
           + deletionTime.memorySize()
           + ObjectSizes.getArraySize(columnsIndex.size(), ObjectSizes.getReferenceSize()) + entrySize + 4;
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
public long memorySize()
{
    return ObjectSizes.getFieldSize(// cfId
                                    ObjectSizes.getReferenceSize() +
                                    // key
                                    ObjectSizes.getReferenceSize())
           + ObjectSizes.getArraySize(key);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
public long memorySize()
{
    return ObjectSizes.getFieldSize(// desc
                                    ObjectSizes.getReferenceSize() +
                                    // key
                                    ObjectSizes.getReferenceSize())
           + ObjectSizes.getArraySize(key);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Test
public void testArraySizes()
{
    long size = ObjectSizes.getArraySize(0, 1);
    long size2 = meter.measureDeep(new byte[0]);
    Assert.assertEquals(size, size2);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Test
public void testBiggerArraySizes()
{
    long size = ObjectSizes.getArraySize(0, 1);
    long size2 = meter.measureDeep(new byte[0]);
    Assert.assertEquals(size, size2);

    size = ObjectSizes.getArraySize(8, 1);
    size2 = meter.measureDeep(new byte[8]);
    Assert.assertEquals(size, size2);
}
 

import org.apache.cassandra.utils.ObjectSizes; //导入依赖的package包/类
@Test
public void testMemoryLeak()
{
    Tidier tidier = new Tidier();
    Ref<Object> ref = new Ref(null, tidier);
    long initialSize = ObjectSizes.measureDeep(ref);
    for (int i = 0 ; i < 1000 ; i++)
        ref.ref().release();
    long finalSize = ObjectSizes.measureDeep(ref);
    if (finalSize > initialSize * 2)
        throw new AssertionError();
    ref.release();
}