!include once #1027304 // Eclipse Collections

sclass ManagedIntObjects64_Collector implements IManagedObjectCollector64 {

  ManagedIntObjects64 mem;

  CompactTreeSet<LongRange> objects = new(longRangeComparatorByStart());

  new LongHashSet pointers;

  new CompactHashSet<LongRange> pointerRanges;

  new LongLongHashMap relocationMap;

  long[] newMem;

  new Map<Long, IVF1<Long>> relocationCallbacks;

  bool discardFreeListEarly; // saves memory, but ironically makes original memory unusable when compacting fails because of OOM

  bool verbose = true;

  *(ManagedIntObjects64 *mem) {}

  // notify collector that there is an object in a location

  public void noteObject(long start, long size, IVF1<Long> updateAddress default null) {

    objects.add(longRange(start, start+size));

    if (updateAddress != null)

      relocationCallbacks.put(start, updateAddress);

  }

  // notify collector that there is a pointer in a location

  public void notePointer(long addr) {

    if (addr != 0)

      pointers.add(addr);

  }

  // notify collector that there is a pointer array in a location

  public void notePointerArray(long start) {

    if (start == 0) ret;

    long n = mem.get(start);

    noteObject(start, n+1);

    notePointerRange(LongRange(start+1, start+1+n));

  }

  void notePointerRange(LongRange r) {

    pointerRanges.add(r);

  }

  int sizeNeeded() {

    ret toInt(mem.reservedSpaceAtBeginning()+totalLongRangesLength(objects));

  }

  void collectAndCompact() {

    int sizeNeeded = sizeNeeded();

    if (mem.size() == sizeNeeded) ret;

    if (discardFreeListEarly) mem.freeList.clear();

    // reserve new memory

    print("Reserving " + toM(sizeNeeded*(long) mem.wordSizeInBytes()) + " MB");

    newMem = new long[sizeNeeded];

    // copy all the objects, fill relocationMap

    print("Copying " + nObjects(objects) + " (" + n2(relocationCallbacks, "callback") + ")");

    long freePtr = mem.reservedSpaceAtBeginning();

    for (LongRange r : objects) {

      long oldPtr = r.start, newPtr = freePtr;

      if (oldPtr != newPtr) {

        relocationMap.put(oldPtr, newPtr);

        callF(relocationCallbacks.get(oldPtr), freePtr);

      }

      arraycopy(mem.mem, r.start, newMem, freePtr, r.length());

      freePtr += r.length();

    }

    relocationCallbacks.clear();

    // update the pointers

    print("Updating " + n2(pointers.size(), "pointer"));

    LongIterator itPointers = pointers.longIterator();

    while (itPointers.hasNext())

      movePointer(itPointers.next());

    print("Updating " + n2(pointerRanges.size(), "pointer range"));

    for (LongRange r : pointerRanges) {

      for (long i = r.start; i < r.end; i++)

        movePointer(i);

    }

    print("Managed GC done");

    mem.mem = newMem;

    if (!discardFreeListEarly) mem.freeList.clear();

  }

  // call after collectAndCompact to get new location of objects

  public long getNewLocation(long addr) {

    ret relocationMap.getIfAbsent(addr, addr);

  }

  void movePointer(long pointerAddr) {

    // find enclosing object

    LongRange obj = objects.floor(LongRange(pointerAddr, pointerAddr));

    if (obj == null) ret with print("Pointer without object");

    long newObjAddr = relocationMap.getIfAbsent(obj.start, obj.start);

    long newPointerAddr = newObjAddr-obj.start+pointerAddr;

    // find target, update pointer

    long target = mem.get(pointerAddr);

    if (target == 0) ret;

    long newTarget = relocationMap.getIfAbsent(target, -1);

    if (newTarget >= 0)

      newMem[newPointerAddr] = newTarget;

  }

}