@Test
    void testBigLoadForPerfTesting() {

        MapNamFunc mapNamFunc = this::buildMapNameWithoutRefStreamDef;

//        setPurgeAgeProperty("1d");
        int refStreamDefCount = 5;
        int keyValueMapCount = 2;
        int rangeValueMapCount = 2;
        int entryCount = 50;
        int totalKeyValueEntryCount = refStreamDefCount * keyValueMapCount * entryCount;
        int totalRangeValueEntryCount = refStreamDefCount * rangeValueMapCount * entryCount;
        int totalValueEntryCount = (totalKeyValueEntryCount + totalRangeValueEntryCount) / refStreamDefCount;

        LOGGER.info("-------------------------load starts here--------------------------------------");
        final List<RefStreamDefinition> refStreamDefs1 = loadBulkData(
                refStreamDefCount, keyValueMapCount, rangeValueMapCount, entryCount, 0, mapNamFunc);

        assertDbCounts(
                refStreamDefCount,
                totalKeyValueEntryCount,
                totalRangeValueEntryCount);

        // here to aid debugging problems at low volumes
        if (entryCount < 10) {
            refDataStore.logAllContents(LOGGER::info);
        }


        LOGGER.info("-----------------------second-load starts here----------------------------------");

        List<RefStreamDefinition> refStreamDefs2 = loadBulkData(
                refStreamDefCount, keyValueMapCount, rangeValueMapCount, entryCount, refStreamDefCount, mapNamFunc);

        assertDbCounts(
                refStreamDefCount * 2,
                totalKeyValueEntryCount * 2,
                totalRangeValueEntryCount * 2);

        LOGGER.info("-------------------------gets start here---------------------------------------");

        Random random = new Random();
        // for each ref stream def & map def, have N goes at picking a random key and getting the value for it
        Stream.concat(refStreamDefs1.stream(), refStreamDefs2.stream()).forEach(refStreamDef -> {
            Instant startTime = Instant.now();
            Stream.of(KV_TYPE, RANGE_TYPE).forEach(valueType -> {
                for (int i = 0; i < entryCount; i++) {

                    String mapName = mapNamFunc.buildMapName(refStreamDef, valueType, random.nextInt(keyValueMapCount));
                    MapDefinition mapDefinition = new MapDefinition(refStreamDef, mapName);
                    int entryIdx = random.nextInt(entryCount);

                    String queryKey;
                    String expectedValue;
                    if (valueType.equals(KV_TYPE)) {
                        queryKey = buildKey(entryIdx);
                        expectedValue = buildKeyStoreValue(mapName, entryIdx, queryKey);
                    } else {
                        Range<Long> range = buildRangeKey(entryIdx);
                        // in the DB teh keys are ranges so we need to pick a value in that range
                        queryKey = Long.toString(random.nextInt(range.size().intValue()) + range.getFrom());
                        expectedValue = buildRangeStoreValue(mapName, entryIdx, range);
                    }

                    // get the proxy then get the value
                    RefDataValueProxy valueProxy = refDataStore.getValueProxy(mapDefinition, queryKey);
                    Optional<RefDataValue> optRefDataValue = valueProxy.supplyValue();

                    assertThat(optRefDataValue).isNotEmpty();
                    String value = ((StringValue) (optRefDataValue.get())).getValue();
                    assertThat(value)
                            .isEqualTo(expectedValue);

                    //now do it in one hit
                    optRefDataValue = refDataStore.getValue(mapDefinition, queryKey);
                    assertThat(optRefDataValue).isNotEmpty();
                    value = ((StringValue) (optRefDataValue.get())).getValue();
                    assertThat(value)
                            .isEqualTo(expectedValue);
                }
            });
            LOGGER.info("Done {} queries in {} for {}",
                    entryCount * 2, Duration.between(startTime, Instant.now()).toString(), refStreamDef);
        });
    }
Make entryCount very big for manual performance testing or profiling
stroom-pipeline/src/test/java/stroom/pipeline/refdata/store/onheapstore/TestRefDataOnHeapStore.java