Function bodies 231 total

    public byte[] serializeDouble() {
        return codec.serialize(2.718281828, noFlags);
    }

    public byte[] serializeShort() {
        return codec.serialize((short) 100, noFlags);
    }

    public byte[] serializeBigDecimal() {
        return codec.serialize(new BigDecimal("12345.6789"), noFlags);
    }

    public byte[] serializeBoolean() {
        return codec.serialize(true, noFlags);
    }

    public byte[] serializeLocalDateTime() {
        return codec.serialize(LocalDateTime.of(2024, 6, 15, 9, 30), noFlags);
    }

    public byte[] serializeAsString() {
        return codec.serialize(42, stringFlags);
    }

    public Object deserializeString() {
        return codec.deserialize(stringBytes, String.class, noFlags);
    }

    public Object deserializeInteger() {
        return codec.deserialize(intBytes, Integer.class, noFlags);
    }

    public Object deserializeLong() {
        return codec.deserialize(longBytes, Long.class, noFlags);
    }

    public Object deserializeFloat() {
        return codec.deserialize(floatBytes, Float.class, noFlags);
    }

    public Object deserializeDouble() {
        return codec.deserialize(doubleBytes, Double.class, noFlags);
    }

    public Object deserializeShort() {
        return codec.deserialize(shortBytes, Short.class, noFlags);
    }

    public Object deserializeBigDecimal() {
        return codec.deserialize(bigDecimalBytes, BigDecimal.class, noFlags);
    }

    public Object deserializeBoolean() {
        return codec.deserialize(booleanBytes, Boolean.class, noFlags);
    }

    public Object deserializeLocalDateTime() {
        return codec.deserialize(localDateTimeBytes, LocalDateTime.class, noFlags);
    }

    public Object deserializeAsString() {
        return codec.deserialize(stringFlagBytes, Integer.class, stringFlags);
    }

    public boolean canDeserializeString() {
        return codec.canDeserialize(String.class);
    }

    public Put citizenFullWriteAsPut() {
        return citizenMapper.writeAsPut(citizenFull);
    }

    public Put citizenMinimalWriteAsPut() {
        return citizenMapper.writeAsPut(citizenMinimal);
    }

    public Put employeeWriteAsPut() {
        return employeeMapper.writeAsPut(employee);
    }

    public Put crawlWriteAsPut() {
        return crawlMapper.writeAsPut(crawl);
    }

    public Citizen citizenFullReadFromResult() {
        return citizenMapper.readFromResult(citizenFullResult);
    }

    public Citizen citizenMinimalReadFromResult() {
        return citizenMapper.readFromResult(citizenMinimalResult);
    }

    public Employee employeeReadFromResult() {
        return employeeMapper.readFromResult(employeeResult);
    }

    public Crawl crawlReadFromResult() {
        return crawlMapper.readFromResult(crawlResult);
    }

    public Citizen citizenFullReadFromPut() {
        return citizenMapper.readFromPut(citizenFullPut);
    }

    public Employee employeeReadFromPut() {
        return employeeMapper.readFromPut(employeePut);
    }

    public Crawl crawlReadFromPut() {
        return crawlMapper.readFromPut(crawlPut);
    }

    public Result citizenFullWriteAsResult() {
        return citizenMapper.writeAsResult(citizenFull);
    }

    public Result employeeWriteAsResult() {
        return employeeMapper.writeAsResult(employee);
    }

    public byte[] citizenComposeRowKey() {
        return citizenMapper.composeRowKey(citizen);
    }

    public byte[] employeeComposeRowKey() {
        return employeeMapper.composeRowKey(employee);
    }

    public byte[] crawlComposeRowKey() {
        return crawlMapper.composeRowKey(crawl);
    }

    public Citizen citizenParseRowKey() {
        Citizen c = new Citizen();
        citizenMapper.parseRowKey(citizenRowKeyBytes, c);
        return c;
    }

    public Employee employeeParseRowKey() {
        Employee e = new Employee();
        employeeMapper.parseRowKey(employeeRowKeyBytes, e);
        return e;
    }

    public Crawl crawlParseRowKey() {
        Crawl c = new Crawl();
        crawlMapper.parseRowKey(crawlRowKeyBytes, c);
        return c;
    }

    public String citizenGetRowKey() {
        return citizenMapper.getRowKey(citizen);
    }

    public Long employeeGetRowKey() {
        return employeeMapper.getRowKey(employee);
    }

    public String crawlGetRowKey() {
        return crawlMapper.getRowKey(crawl);
    }

class AsyncDAOPerfTest extends HBasePerfTestBase {

    @BeforeAll
    static void init() {
        PerfResultReporter.clear();
    }

    @AfterAll
    static void report() throws Exception {
        PerfResultReporter.writeReport(Path.of(System.getProperty("project.dir")));
    }

    @Test
    @Order(1)
    void singlePutGetLatency() {
        BenchmarkResult result = PerfResultReporter.run("async.single.put_get", 50, 1000, () -> {
            try {
                Citizen c = new Citizen("APERF", 1, "AsyncSingle");
                c.setAge((short) 25);
                asyncCitizenDAO.persist(c).get(10, TimeUnit.SECONDS);
                Citizen fetched = asyncCitizenDAO.get("APERF#1").get(10, TimeUnit.SECONDS);
                assertNotNull(fetched);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(result);
    }

    @ParameterizedTest
    @ValueSource(ints = {10, 100, 1000})
    @Order(2)
    v

    static void init() {
        PerfResultReporter.clear();
    }

    static void report() throws Exception {
        PerfResultReporter.writeReport(Path.of(System.getProperty("project.dir")));
    }

    void singlePutGetLatency() {
        BenchmarkResult result = PerfResultReporter.run("async.single.put_get", 50, 1000, () -> {
            try {
                Citizen c = new Citizen("APERF", 1, "AsyncSingle");
                c.setAge((short) 25);
                asyncCitizenDAO.persist(c).get(10, TimeUnit.SECONDS);
                Citizen fetched = asyncCitizenDAO.get("APERF#1").get(10, TimeUnit.SECONDS);
                assertNotNull(fetched);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(result);
    }

    void bulkPutThroughput(int batchSize) {
        List<Citizen> batch = new ArrayList<>(batchSize);
        for (int i = 0; i < batchSize; i++) {
            Citizen c = new Citizen("ABULK", i, "Citizen-" + i);
            c.setAge((short) (20 + i % 50));
            batch.add(c);
        }

        BenchmarkResult result = PerfResultReporter.run(
                "async.bulk_put.batch_" + batchSize, 3, 20, () -> {
                    try {
                        asyncCitizenDAO.persistAll(batch).get(30, TimeUnit.SECONDS);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                });
        System.out.println(result);
    }

    void bulkGetThroughput(int batchSize) throws Exception {
        // Seed data
        List<Citizen> batch = new ArrayList<>(batchSize);
        List<String> keys = new ArrayList<>(batchSize);
        for (int i = 0; i < batchSize; i++) {
            Citizen c = new Citizen("ABGET", i, "Citizen-" + i);
            batch.add(c);
            keys.add("ABGET#" + i);
        }
        asyncCitizenDAO.persistAll(batch).get(30, TimeUnit.SECONDS);

        BenchmarkResult result = PerfResultReporter.run(
                "async.bulk_get.batch_" + batchSize, 3, 20, () -> {
                    try {
                        asyncCitizenDAO.getAll(keys).get(30, TimeUnit.SECONDS);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                });
        System.out.println(result);
    }

    void concurrentBulkPut() {
        BenchmarkResult result = PerfResultReporter.run("async.concurrent_bulk_put.1000", 2, 10, () -> {
            try {
                List<CompletableFuture<String>> futures = new ArrayList<>(1000);
                for (int i = 0; i < 1000; i++) {
                    Citizen c = new Citizen("CONC", i, "Concurrent-" + i);
                    futures.add(asyncCitizenDAO.persist(c));
                }
                CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).get(60, TimeUnit.SECONDS);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(result);
    }

    void prefixScanThroughput(int resultSize) throws Exception {
        // Seed data
        String prefix = "ASCAN" + resultSize;
        List<Citizen> batch = new ArrayList<>(resultSize);
        for (int i = 0; i < resultSize; i++) {
            batch.add(new Citizen(prefix, i, "Citizen-" + i));
        }
        asyncCitizenDAO.persistAll(batch).get(30, TimeUnit.SECONDS);

        BenchmarkResult result = PerfResultReporter.run(
                "async.prefix_scan.size_" + resultSize, 3, 20, () -> {
                    try {
                        asyncCitizenDAO.getByPrefix(Bytes.toBytes(prefix + "#")).get(30, TimeUnit.SECONDS);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                });
        System.out.println(result);
    }

    void executorComparison() {
        // Seed data for scan
        try {
            List<Citizen> batch = new ArrayList<>(100);
            for (int i = 0; i < 100; i++) {
                batch.add(new Citizen("EXEC", i, "Citizen-" + i));
            }
            asyncCitizenDAO.persistAll(batch).get(30, TimeUnit.SECONDS);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        Scan scan = new Scan();
        scan.setRowPrefixFilter(Bytes.toBytes("EXEC#"));

        // Default executor (null — inline)
        AsyncHBaseDAO<String, Citizen> defaultDAO = asyncCitizenDAO;
        BenchmarkResult defaultResult = PerfResultReporter.run("async.executor.default", 3, 30, () -> {
            try {
                defaultDAO.scanAll(scan).get(30, TimeUnit.SECONDS);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(defaultResult);

        // Fixed-4 executor
        Ex

    void multiVersionWriteRead() {
        BenchmarkResult result = PerfResultReporter.run("async.multi_version.write_read", 5, 50, () -> {
            try {
                Crawl crawl = new Crawl("async-mv-" + System.nanoTime());
                for (int v = 0; v < 10; v++) {
                    crawl.addF1((long) (v + 1) * 1000, v * 1.1);
                }
                asyncCrawlDAO.persist(crawl).get(10, TimeUnit.SECONDS);
                Crawl fetched = asyncCrawlDAO.get(crawl.getKey(), 10).get(10, TimeUnit.SECONDS);
                assertNotNull(fetched);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(result);
    }

public abstract class HBasePerfTestBase {

    protected static final int ZK_PORT = 2181;
    protected static final int MASTER_PORT = 16000;
    protected static final int RS_PORT = 16020;
    protected static final int MASTER_UI_PORT = 16010;

    protected static GenericContainer<?> hbaseContainer;
    protected static Connection syncConnection;
    protected static AsyncConnection asyncConnection;

    protected static BestSuitCodec codec;
    protected static HBaseDAO<String, Citizen> citizenDAO;
    protected static HBaseDAO<Long, Employee> employeeDAO;
    protected static HBaseDAO<String, Crawl> crawlDAO;
    protected static AsyncHBaseDAO<String, Citizen> asyncCitizenDAO;
    protected static AsyncHBaseDAO<Long, Employee> asyncEmployeeDAO;
    protected static AsyncHBaseDAO<String, Crawl> asyncCrawlDAO;

    @BeforeAll
    @SuppressWarnings("resource")
    static void setUpHBase() throws Exception {
        Path dockerDir = Path.of(System.getProperty("project.dir"), "docker");