Examples with LongList org.eclipse.collections.api.list.primitive.LongList used on opensource projects

Example 21 with LongList

use of org.eclipse.collections.api.list.primitive.LongList in project neo4j by neo4j.

the class ParallelNodeCursorTransactionStateTestBase method shouldScanAllNodesFromRandomlySizedWorkers.

@Test
void shouldScanAllNodesFromRandomlySizedWorkers() throws InterruptedException, TransactionFailureException, InvalidTransactionTypeKernelException {
    // given
    ExecutorService service = Executors.newFixedThreadPool(4);
    int size = 128;
    LongArrayList ids = new LongArrayList();
    try (KernelTransaction tx = beginTransaction()) {
        Write write = tx.dataWrite();
        for (int i = 0; i < size; i++) {
            ids.add(write.nodeCreate());
        }
        Read read = tx.dataRead();
        Scan<NodeCursor> scan = read.allNodesScan();
        CursorFactory cursors = testSupport.kernelToTest().cursors();
        // when
        List<Future<LongList>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            futures.add(service.submit(randomBatchWorker(scan, () -> cursors.allocateNodeCursor(NULL), NODE_GET)));
        }
        // then
        List<LongList> lists = futures.stream().map(TestUtils::unsafeGet).collect(Collectors.toList());
        TestUtils.assertDistinct(lists);
        LongList concat = TestUtils.concat(lists);
        assertEquals(ids.toSortedList(), concat.toSortedList());
        tx.rollback();
    } finally {
        service.shutdown();
        service.awaitTermination(1, TimeUnit.MINUTES);
    }
}

Example 22 with LongList

use of org.eclipse.collections.api.list.primitive.LongList in project neo4j by neo4j.

the class ParallelNodeLabelScanTestBase method shouldScanAllNodesFromMultipleThreads.

@Test
void shouldScanAllNodesFromMultipleThreads() throws InterruptedException, ExecutionException {
    // given
    ExecutorService service = Executors.newFixedThreadPool(4);
    Scan<NodeLabelIndexCursor> scan = read.nodeLabelScan(BAR_LABEL);
    CursorFactory cursors = testSupport.kernelToTest().cursors();
    try {
        // when
        Supplier<NodeLabelIndexCursor> allocateCursor = () -> cursors.allocateNodeLabelIndexCursor(NULL);
        Future<LongList> future1 = service.submit(singleBatchWorker(scan, allocateCursor, NODE_GET, NUMBER_OF_NODES));
        Future<LongList> future2 = service.submit(singleBatchWorker(scan, allocateCursor, NODE_GET, NUMBER_OF_NODES));
        Future<LongList> future3 = service.submit(singleBatchWorker(scan, allocateCursor, NODE_GET, NUMBER_OF_NODES));
        Future<LongList> future4 = service.submit(singleBatchWorker(scan, allocateCursor, NODE_GET, NUMBER_OF_NODES));
        // then
        LongList ids1 = future1.get();
        LongList ids2 = future2.get();
        LongList ids3 = future3.get();
        LongList ids4 = future4.get();
        assertDistinct(ids1, ids2, ids3, ids4);
        assertEquals(BAR_NODES, LongSets.immutable.withAll(concat(ids1, ids2, ids3, ids4)));
    } finally {
        service.shutdown();
        service.awaitTermination(1, TimeUnit.MINUTES);
    }
}

Example 23 with LongList

use of org.eclipse.collections.api.list.primitive.LongList in project neo4j by neo4j.

the class ParallelNodeLabelScanTransactionStateTestBase method shouldScanAllNodesFromRandomlySizedWorkers.

@Test
void shouldScanAllNodesFromRandomlySizedWorkers() throws InterruptedException, KernelException {
    // given
    ExecutorService service = Executors.newFixedThreadPool(4);
    int size = 2000;
    try (KernelTransaction tx = beginTransaction()) {
        int label = tx.tokenWrite().labelGetOrCreateForName("L");
        LongList ids = createNodesWithLabel(tx.dataWrite(), label, size);
        Read read = tx.dataRead();
        Scan<NodeLabelIndexCursor> scan = read.nodeLabelScan(label);
        CursorFactory cursors = testSupport.kernelToTest().cursors();
        // when
        List<Future<LongList>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            futures.add(service.submit(randomBatchWorker(scan, () -> cursors.allocateNodeLabelIndexCursor(tx.cursorContext()), NODE_GET)));
        }
        // then
        List<LongList> lists = futures.stream().map(TestUtils::unsafeGet).collect(Collectors.toList());
        assertDistinct(lists);
        assertEquals(ids.toSortedList(), concat(lists).toSortedList());
        tx.rollback();
    } finally {
        service.shutdown();
        service.awaitTermination(1, TimeUnit.MINUTES);
    }
}

Example 24 with LongList

use of org.eclipse.collections.api.list.primitive.LongList in project neo4j by neo4j.

the class ParallelNodeLabelScanTransactionStateTestBase method parallelTxStateScanStressTest.

@Test
void parallelTxStateScanStressTest() throws KernelException, InterruptedException {
    int label = label("L");
    MutableLongSet existingNodes = LongSets.mutable.withAll(createNodesWithLabel(label, 1000));
    int workers = Runtime.getRuntime().availableProcessors();
    ExecutorService threadPool = Executors.newFixedThreadPool(workers);
    CursorFactory cursors = testSupport.kernelToTest().cursors();
    ThreadLocalRandom random = ThreadLocalRandom.current();
    try {
        for (int i = 0; i < 1000; i++) {
            MutableLongSet allNodes = LongSets.mutable.withAll(existingNodes);
            try (KernelTransaction tx = beginTransaction()) {
                int nodeInTx = random.nextInt(1000);
                allNodes.addAll(createNodesWithLabel(tx.dataWrite(), label, nodeInTx));
                Scan<NodeLabelIndexCursor> scan = tx.dataRead().nodeLabelScan(label);
                List<Future<LongList>> futures = new ArrayList<>(workers);
                for (int j = 0; j < workers; j++) {
                    futures.add(threadPool.submit(randomBatchWorker(scan, () -> cursors.allocateNodeLabelIndexCursor(tx.cursorContext()), NODE_GET)));
                }
                List<LongList> lists = futures.stream().map(TestUtils::unsafeGet).collect(Collectors.toList());
                assertDistinct(lists);
                LongList concat = concat(lists);
                assertEquals(allNodes, LongSets.immutable.withAll(concat), format("nodes=%d, seen=%d, all=%d", nodeInTx, concat.size(), allNodes.size()));
                assertEquals(allNodes.size(), concat.size(), format("nodes=%d", nodeInTx));
                tx.rollback();
            }
        }
    } finally {
        threadPool.shutdown();
        threadPool.awaitTermination(1, TimeUnit.MINUTES);
    }
}

Example 25 with LongList

use of org.eclipse.collections.api.list.primitive.LongList in project neo4j by neo4j.

the class IndexedIdGeneratorTest method shouldConcurrentlyAllocateAllIdsAroundReservedIds.

@Test
void shouldConcurrentlyAllocateAllIdsAroundReservedIds() throws IOException {
    // given
    idGenerator.start(NO_FREE_IDS, NULL);
    long startingId = IdValidator.INTEGER_MINUS_ONE - 100;
    idGenerator.setHighId(startingId);
    idGenerator.markHighestWrittenAtHighId();
    // when
    Race race = new Race();
    int threads = 8;
    int allocationsPerThread = 32;
    LongList[] allocatedIds = new LongList[threads];
    for (int i = 0; i < 8; i++) {
        LongArrayList list = new LongArrayList(32);
        allocatedIds[i] = list;
        race.addContestant(() -> {
            for (int j = 0; j < allocationsPerThread; j++) {
                list.add(idGenerator.nextId(NULL));
            }
        }, 1);
    }
    race.goUnchecked();
    // then
    MutableLongList allIds = new LongArrayList(allocationsPerThread * threads);
    Stream.of(allocatedIds).forEach(allIds::addAll);
    allIds = allIds.sortThis();
    assertEquals(allocationsPerThread * threads, allIds.size());
    MutableLongIterator allIdsIterator = allIds.longIterator();
    long nextExpected = startingId;
    while (allIdsIterator.hasNext()) {
        assertEquals(nextExpected, allIdsIterator.next());
        do {
            nextExpected++;
        } while (IdValidator.isReservedId(nextExpected));
    }
}