Package org.neo4j.gds.core.utils.paged

Class HugeIntArray

  • All Implemented Interfaces:
    org.neo4j.gds.collections.cursor.HugeCursorSupport<int[]>
    public abstract class HugeIntArray
extends HugeArray<int[],​java.lang.Integer,​HugeIntArray>
    A long-indexable version of a primitive int array (int[]) that can contain more than 2 bn. elements.

    It is implemented by paging of smaller int-arrays (int[][]) to support approx. 32k bn. elements. If the provided size is small enough, an optimized view of a single int[] might be used.

    • The array is of a fixed size and cannot grow or shrink dynamically.
    • The array is not optimized for sparseness and has a large memory overhead if the values written to it are very sparse (see HugeSparseIntArray for a different implementation that can profit from sparse data).
    • The array does not support default values and returns the same default for unset values that a regular int[] does (0).

    Basic Usage

     
 AllocationTracker allocationTracker = ...;
 long arraySize = 42L;
 HugeIntArray array = HugeIntArray.newArray(arraySize, allocationTracker);
 array.set(13L, 37);
 int value = array.get(13L);
 // value = 37

    • Constructor Summary

      Constructors 
      Constructor Description
      HugeIntArray()  

    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      abstract void addTo​(long index, int value)
      Adds (+) the existing value and the provided value at the given index and stored the result into the given index.
      abstract int and​(long index, int value)
      Computes the bit-wise AND (&) of the existing value and the provided value at the given index.
      LongNodePropertyValues asNodeProperties()  
      HugeIntArray copyOf​(long newLength)
      Creates a copy of the given array.
      abstract void copyTo​(HugeIntArray dest, long length)
      Copies the content of this array into the target array.
      abstract void fill​(int value)
      Assigns the specified int value to each element.
      abstract int get​(long index)  
      abstract int getAndAdd​(long index, int delta)  
      static long memoryEstimation​(long size)  
      static HugeIntArray newArray​(long size)
      Creates a new array of the given size.
      abstract org.neo4j.gds.collections.cursor.HugeCursor<int[]> newCursor()
      static HugeIntArray of​(int... values)  
      abstract void or​(long index, int value)
      Computes the bit-wise OR (|) of the existing value and the provided value at the given index.
      abstract long release()
      Destroys the data, allowing the underlying storage arrays to be collected as garbage.
      abstract void set​(long index, int value)
      Sets the int value at the given index to the given value.
      abstract void setAll​(java.util.function.LongToIntFunction gen)
      Set all elements using the provided generator function to compute each element.
      abstract long size()
      Returns the length of this array.
      abstract long sizeOf()
      int[] toArray()

      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

      • Methods inherited from interface org.neo4j.gds.collections.cursor.HugeCursorSupport

        initCursor, initCursor

    • Constructor Detail

      • HugeIntArray

        public HugeIntArray()

    • Method Detail

      • get

        public abstract int get​(long index)
        Returns:
        the int value at the given index
        Throws:
        java.lang.ArrayIndexOutOfBoundsException - if the index is not within size()

      • getAndAdd

        public abstract int getAndAdd​(long index,
                              int delta)

      • set

        public abstract void set​(long index,
                         int value)
        Sets the int value at the given index to the given value.
        Throws:
        java.lang.ArrayIndexOutOfBoundsException - if the index is not within size()

      • or

        public abstract void or​(long index,
                        int value)
        Computes the bit-wise OR (|) of the existing value and the provided value at the given index. If there was no previous value, the final result is set to the provided value (x | 0 == x).
        Throws:
        java.lang.ArrayIndexOutOfBoundsException - if the index is not within size()

      • and

        public abstract int and​(long index,
                        int value)
        Computes the bit-wise AND (&) of the existing value and the provided value at the given index. If there was no previous value, the final result is set to the 0 (x & 0 == 0).
        Returns:
        the now current value after the operation
        Throws:
        java.lang.ArrayIndexOutOfBoundsException - if the index is not within size()

      • addTo

        public abstract void addTo​(long index,
                           int value)
        Adds (+) the existing value and the provided value at the given index and stored the result into the given index. If there was no previous value, the final result is set to the provided value (x + 0 == x).
        Throws:
        java.lang.ArrayIndexOutOfBoundsException - if the index is not within size()

      • setAll

        public abstract void setAll​(java.util.function.LongToIntFunction gen)
        Set all elements using the provided generator function to compute each element.

        The behavior is identical to Arrays.setAll(int[], java.util.function.IntUnaryOperator).

      • fill

        public abstract void fill​(int value)
        Assigns the specified int value to each element.

        The behavior is identical to Arrays.fill(int[], int).

      • size

        public abstract long size()
        Returns the length of this array.

        If the size is greater than zero, the highest supported index is size() - 1

        The behavior is identical to calling array.length on primitive arrays.

        Specified by:
        size in interface org.neo4j.gds.collections.cursor.HugeCursorSupport<int[]>
        Specified by:
        size in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>

      • sizeOf

        public abstract long sizeOf()
        Specified by:
        sizeOf in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>
        Returns:
        the amount of memory used by the instance of this array, in bytes. This should be the same as returned from HugeArray.release() without actually releasing the array.

      • release

        public abstract long release()
        Destroys the data, allowing the underlying storage arrays to be collected as garbage. The array is unusable after calling this method and will throw NullPointerExceptions on virtually every method invocation.

        Note that the data might not immediately collectible if there are still cursors alive that reference this array. You have to HugeCursor.close() every cursor instance as well.

        Specified by:
        release in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>
        Returns:
        the amount of memory freed, in bytes.

      • newCursor

        public abstract org.neo4j.gds.collections.cursor.HugeCursor<int[]> newCursor()

      • copyTo

        public abstract void copyTo​(HugeIntArray dest,
                            long length)
        Copies the content of this array into the target array.

        The behavior is identical to System.arraycopy(Object, int, Object, int, int).

        Specified by:
        copyTo in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>

      • copyOf

        public final HugeIntArray copyOf​(long newLength)
        Creates a copy of the given array. The behavior is identical to Arrays.copyOf(int[], int).
        Specified by:
        copyOf in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>

      • toArray

        public int[] toArray()
        Specified by:
        toArray in class HugeArray<int[],​java.lang.Integer,​HugeIntArray>
        Returns:
        the contents of this array as a flat java primitive array. The returned array might be shared and changes would then be reflected and visible in this array.

      • newArray

        public static HugeIntArray newArray​(long size)
        Creates a new array of the given size.

      • memoryEstimation

        public static long memoryEstimation​(long size)