/** * @param meta Meta pointer. * @param collision Collision pointer. */ protected void collision(long meta, long collision) { assert meta != collision : meta; mem.writeLong(meta + 24, collision); }
/** * @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); } }
/** * Writes next entry address. * * @param ptr Pointer. * @param addr Address. * @param mem Memory. */ static void nextAddress(long ptr, long addr, GridUnsafeMemory mem) { mem.writeLong(ptr + HEADER_NEXT_ADDR_OFF, addr); }
/** * Writes address of entry. * * @param qAddr Queue node address. * @param addr Address of entry. */ private void entry(long qAddr, long addr) { mem.writeLong(qAddr + 27, addr); }
/** * @param meta Meta pointer. * @param val Value pointer. */ protected void value(long meta, long val) { mem.writeLong(meta + 16, val); }
/** * Writes address of next queue node. * * @param qAddr Queue node address. * @param next Address of next node. */ private void next(long qAddr, long next) { mem.writeLong(qAddr + 19, next); }
/** * @param meta Meta pointer. * @param valPtr Last visited value pointer. */ private void lastVisitedValue(long meta, long valPtr) { mem.writeLong(meta + 16, valPtr); }
/** * @param meta Meta pointer. * @param level Level. * @param nextMeta Next meta. */ private void nextMeta(long meta, int level, long nextMeta) { assert meta != 0; mem.writeLong(meta + 24 + 8 * level, nextMeta); }
/** * @param ptr Pointer. * @param qAddr Queue address. * @param mem Memory. */ static void queueAddress(long ptr, long qAddr, GridUnsafeMemory mem) { mem.writeLong(ptr + HEADER_QUEUE_ADDR_OFF, qAddr); }
/** * @param meta Meta pointer. * @param valPtr Last visited value pointer. */ private void lastVisitedValue(long meta, long valPtr) { mem.writeLong(meta + 32, valPtr); }
/** * @param meta Meta pointer. * @param key Key pointer. */ private void key(long meta, long key) { mem.writeLong(meta, key); }
/** * @param binAddr Bin address location. * @param mem Memory. */ static void clear(long binAddr, GridUnsafeMemory mem) { mem.writeLong(binAddr, 0L); // Clear pointer. }
/** * @param valPtr Value page pointer. * @param nextValPtr Next value page pointer. */ protected void nextValue(long valPtr, long nextValPtr) { mem.writeLong(valPtr, nextValPtr); }
/** * Writes first entry address. * * @param binAddr Pointer. * @param entryAddr Address. * @param mem Memory. */ static void first(long binAddr, long entryAddr, GridUnsafeMemory mem) { mem.writeLong(binAddr, entryAddr); }
/** * Writes address of previous queue node. * * @param qAddr Queue node address. * @param prev Address of previous node. */ private void previous(long qAddr, long prev) { mem.writeLong(qAddr + 11, prev); }
/** {@inheritDoc} */ @Override public void writeLong(long v) { mem.writeLong(move(8), v); }
/** * @param keyHash Key hash. * @param keySize Key size. * @param keyPtr Key pointer. * @param valPtr Value page pointer. * @param collisionPtr Pointer to meta with hash collision. * @param lastVisitedVal Last visited value pointer. * @return Created meta page pointer. */ private long createMeta(int keyHash, int keySize, long keyPtr, long valPtr, long collisionPtr, long lastVisitedVal) { long meta = allocate(40); mem.writeInt(meta, keyHash); mem.writeInt(meta + 4, keySize); mem.writeLong(meta + 8, keyPtr); mem.writeLong(meta + 16, valPtr); mem.writeLong(meta + 24, collisionPtr); mem.writeLong(meta + 32, lastVisitedVal); return meta; }
/** * @param keyHash Key hash. * @param keySize Key size. * @param keyPtr Key pointer. * @param valPtr Value page pointer. * @param collisionPtr Pointer to meta with hash collision. * @return Created meta page pointer. */ private long createMeta(int keyHash, int keySize, long keyPtr, long valPtr, long collisionPtr) { long meta = allocate(32); mem.writeInt(meta, keyHash); mem.writeInt(meta + 4, keySize); mem.writeLong(meta + 8, keyPtr); mem.writeLong(meta + 16, valPtr); mem.writeLong(meta + 24, collisionPtr); return meta; }
/** * @param key Key. * @param val Value. * @param level Level. * @return Meta pointer. */ private long createMeta(long key, long val, int level) { int size = 32 + 8 * level; long meta = allocate(size); key(meta, key); value(meta, val); lastVisitedValue(meta, 0L); for (int i = 32; i < size; i += 8) // Fill with 0. mem.writeLong(meta + i, 0L); return meta; }
/** * Writes next entry address. * * @param ptr Pointer. * @param addr Address. * @param mem Memory. */ static void nextAddress(long ptr, long addr, GridUnsafeMemory mem) { mem.writeLong(ptr + HEADER_NEXT_ADDR_OFF, addr); }