How to use

release

method

in

org.apache.ignite.internal.util.offheap.unsafe.GridUnsafeMemory

/**
 * @param page Page.
 */
private void deallocate(Page page) {
  assert page != null;
  mem.release(page.ptr, page.size);
}

/**
 * Releases allocated table.
 */
void destruct() {
  lock.writeLock().lock();
  try {
    if (tblAddr == 0)
      return;
    for (long binAddr = tblAddr, tblEnd = (tblAddr + memCap); binAddr < tblEnd; binAddr += 8) {
      long entryAddr = Bin.first(binAddr, mem);
      if (entryAddr == 0)
        continue;
      while (true) {
        long next = Entry.nextAddress(entryAddr, mem);
        mem.release(entryAddr, Entry.size(entryAddr, mem));
        if (next == 0)
          break;
        else
          entryAddr = next;
      }
    }
    mem.releaseSystem(tblAddr, memCap);
  }
  finally {
    tblAddr = 0;
    lock.writeLock().unlock();
  }
}

/**
 * Releases off-heap memory allocated by {@link #putOffHeap} method.
 *
 * @param ptr Optional pointer returned by {@link #putOffHeap}.
 */
public void removeOffHeap(long ptr) {
  if (ptr != 0)
    release(ptr, readInt(ptr) + 5);
}

/** {@inheritDoc} */
@Override public void close() {
  super.close();
  mem.release(heads, HEADS_SIZE);
}

/**
 * Deferred delete.
 */
synchronized void deferredDelete() {
  if (!deleted.get() || hasRefs())
    return;
  assert refCnt.get() == 0;
  for (int i = 0; i < buffers.idx; i++)
    dir.memory().release(buffers.arr[i], BUFFER_SIZE);
  buffers = null;
}

/**
 * Stores value to the specified memory location. If specified pointer is {@code 0}, then will
 * allocate required space. If size of allocated space is not enough to hold given values, will
 * reallocate memory.
 *
 * @param ptr Optional pointer to allocated memory. First 4 bytes in allocated region must contain
 *      size of allocated chunk.
 * @param val Value to store.
 * @param type Value type.
 * @return Pointer.
 */
public long putOffHeap(long ptr, byte[] val, byte type) {
  int size = val.length;
  assert size != 0;
  int allocated = ptr == 0 ? 0 : readInt(ptr);
  if (allocated != size) {
    if (ptr != 0)
      release(ptr, allocated + 5);
    ptr = allocate(size + 5);
    writeInt(ptr, size);
  }
  writeByte(ptr + 4, type);
  writeBytes(ptr + 5, val);
  return ptr;
}

/**
 * @throws Exception If failed.
 */
@Test
public void testBytes() throws Exception {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  String s = "123";
  byte[] bytes = s.getBytes();
  int size = bytes.length * 2;
  long addr = mem.allocate(size);
  try {
    mem.writeBytes(addr, bytes);
    byte[] read = mem.readBytes(addr, bytes.length);
    assert Arrays.equals(bytes, read);
  }
  finally {
    mem.release(addr, size);
  }
}

/**
 * @param s String.
 * @throws Exception If failed.
 */
public void checkCompare(String s) throws Exception {
  byte[] bytes = s.getBytes();
  int size = bytes.length + 8;
  GridUnsafeMemory mem = new GridUnsafeMemory(size);
  for (int i = 0; i < 8; i++) {
    long addr = mem.allocate(size);
    long ptr = addr + i;
    try {
      mem.writeBytes(ptr, bytes);
      assert mem.compare(ptr, bytes);
      byte[] read = mem.readBytes(ptr, bytes.length);
      assert Arrays.equals(bytes, read);
    }
    finally {
      mem.release(addr, size);
    }
  }
}

mem.release(addr, size);

/**
 *
 */
@Test
public void testDouble() {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 32;
  long addr = mem.allocate(size);
  try {
    double d1 = 0.2323423;
    mem.writeDouble(addr, d1);
    assertEquals(d1, mem.readDouble(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

mem.release(addr, block);

/**
 *
 */
@Test
public void testFloat() {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 32;
  long addr = mem.allocate(size);
  try {
    float f1 = 0.23223f;
    mem.writeFloat(addr, f1);
    assertEquals(f1, mem.readFloat(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

/**
 * @throws Exception If failed.
 */
@Test
public void testShort() throws Exception {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 16;
  long addr = mem.allocate(size);
  try {
    short s1 = (short)56777;
    mem.writeShort(addr, s1);
    assertEquals(s1, mem.readShort(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

mem.release(relAddr, relSize);

/**
 * @throws Exception If failed.
 */
@Test
public void testByte() throws Exception {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 32;
  long addr = mem.allocate(size);
  try {
    byte b1 = 123;
    mem.writeByte(addr, b1);
    byte b2 = mem.readByte(addr);
    assertEquals(b1, b2);
    byte b3 = 11;
    mem.writeByteVolatile(addr, b3);
    assertEquals(b3, mem.readByteVolatile(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

mem.release(relAddr, relSize);

/**
 * @throws Exception If failed.
 */
@Test
public void testLong() throws Exception {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 32;
  long addr = mem.allocate(size);
  try {
    long l1 = 123456;
    mem.writeLong(addr, l1);
    long l2 = mem.readLong(addr);
    assertEquals(l1, l2);
    long l3 = 654321;
    mem.writeLongVolatile(addr, l3);
    long l4 = 666666;
    assertTrue(mem.casLong(addr, l3, l4));
    assertFalse(mem.casLong(addr, l3, 0));
    assertEquals(l4, mem.readLongVolatile(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

/**
 * @throws Exception If failed.
 */
@Test
public void testInt() throws Exception {
  GridUnsafeMemory mem = new GridUnsafeMemory(64);
  int size = 32;
  long addr = mem.allocate(size);
  try {
    int i1 = 123;
    mem.writeInt(addr, i1);
    int i2 = mem.readInt(addr);
    assertEquals(i1, i2);
    int i3 = 321;
    mem.writeIntVolatile(addr, i3);
    int i4 = 222;
    assertTrue(mem.casInt(addr, i3, i4));
    assertFalse(mem.casInt(addr, i3, 0));
    assertEquals(i4, mem.readIntVolatile(addr));
  }
  finally {
    mem.release(addr, size);
  }
}

mem.release(relAddr, relSize);

/**
 * Deferred delete.
 */
synchronized void deferredDelete() {
  if (!deleted.get() || hasRefs())
    return;
  assert refCnt.get() == 0;
  for (int i = 0; i < buffers.idx; i++)
    dir.memory().release(buffers.arr[i], BUFFER_SIZE);
  buffers = null;
}