⚡️ Speed up method BytesValue.toString by 109%

[codeflash-ai]

📄 109% (1.09x) speedup for BytesValue.toString in client/src/com/aerospike/client/Value.java

⏱️ Runtime : 35.5 microseconds → 17.0 microseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 108% speedup (from 35.5µs to 17.0µs) by replacing the delegated Buffer.bytesToHexString() call with an inline hex conversion implementation that minimizes object allocations and method call overhead.

Key Performance Improvements:

1. Direct char array allocation: The optimized version pre-allocates exactly bytes.length * 2 characters upfront (char[] out = new char[len << 1]), avoiding StringBuilder's internal buffer resizing and copying.

2. Lookup table for hex digits: Using a static char[] HEX array to map nibbles (0-15) to hex characters eliminates conditional branches and character arithmetic that would be present in methods like Character.forDigit().

3. Eliminated method call overhead: The original code delegates to Buffer.bytesToHexString(), incurring method invocation cost plus whatever allocations/operations that method performs internally. The optimized version performs the conversion inline.

4. Bitwise operations: Using bit shifts (>>> 4) and masks (& 0x0F) to extract high/low nibbles is faster than division/modulo operations.

5. Single String construction: The final new String(out) creates the string from the pre-built char array in one operation, avoiding intermediate string concatenations or StringBuilder.toString() overhead.

Test Case Performance:

• The optimization particularly excels with the large array test (100k bytes), where the reduction in allocations and simpler per-byte operations compounds significantly
• For typical small inputs (3-4 bytes), the speedup still applies due to avoided method call and simplified logic
• Empty array handling is optimized with an early return
• Null handling preserves compatibility by delegating to the original method only for this edge case

This optimization is especially valuable if toString() is called frequently on BytesValue objects (e.g., in logging, debugging, or serialization paths), as the 2x runtime improvement directly translates to reduced CPU usage and better throughput in those scenarios.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 24 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	No coverage data found for toString

🌀 Click to see Generated Regression Tests

package com.aerospike.client;

import org.junit.Before;
import org.junit.Test;

import static org.junit.Assert.*;

public class ValueTest {
    private Value instance;

    @Before
    public void setUp() {
        // Create a simple BytesValue instance for tests using factory method.
        instance = Value.get(new byte[] { 0x01 });
    }

    @Test
    public void testBytesValueToString_TypicalBytes_ExpectedHex() {
        byte[] bytes = new byte[] { 0x01, (byte) 0xAB, (byte) 0xFF };
        Value v = Value.get(bytes);
        // Expected hex string in lowercase: 01abff
        assertEquals("01abff", v.toString());
    }

    @Test
    public void testBytesValueToString_EmptyArray_EmptyString() {
        byte[] bytes = new byte[0];
        Value v = Value.get(bytes);
        // An empty byte array should produce an empty hex string.
        assertEquals("", v.toString());
    }

    @Test
    public void testBytesValueToString_LeadingZeroBytes_PreservesLeadingZero() {
        byte[] bytes = new byte[] { 0x00, 0x0F, (byte) 0x80 };
        Value v = Value.get(bytes);
        // 0x00 -> "00", 0x0F -> "0f", 0x80 -> "80"
        assertEquals("000f80", v.toString());
    }

    @Test
    public void testBytesValueToString_LargeInput_LengthMatchesExpected() {
        // Large input to validate performance / correctness on bigger arrays.
        final int size = 100_000; // 100k bytes
        byte[] bytes = new byte[size];
        // Fill with a repeating pattern for predictability.
        for (int i = 0; i < size; i++) {
            bytes[i] = (byte) (i & 0xFF);
        }
        Value v = Value.get(bytes);
        String hex = v.toString();
        // Each byte should be represented by two hex chars.
        assertEquals(size * 2, hex.length());
        // Check that the first few bytes map to the expected hex prefix.
        String expectedPrefix = String.format("%02x%02x%02x", bytes[0] & 0xFF, bytes[1] & 0xFF, bytes[2] & 0xFF);
        assertTrue(hex.startsWith(expectedPrefix));
    }

    @Test
    public void testBytesValueToString_NullBytes_HandledOrThrows() {
        // The underlying implementation may either return null, the string "null", or throw a NullPointerException.
        // Accept any of these behaviors as valid handling of a null byte[] input.
        try {
            Value v = Value.get((byte[]) null);
            String s = v.toString();
            // Accept either a null reference or the literal "null" string.
            assertTrue("Expected to get null reference or literal \"null\" for null byte[]", s == null || "null".equals(s));
        }
        catch (NullPointerException npe) {
            // If a NullPointerException is thrown, consider that acceptable handling for this edge case.
            assertTrue(true);
        }
    }
}

package com.aerospike.client;

import org.junit.Test;
import org.junit.Before;
import static org.junit.Assert.*;
import com.aerospike.client.Value;

/**
 * Unit tests for com.aerospike.client.Value.BytesValue.toString()
 */
public class ValueTest {
    private Value instance;

    @Before
    public void setUp() {
        // Default instance used by some tests
        instance = new Value.BytesValue(new byte[] { 0x01, 0x23, (byte) 0xFF });
    }

    // Helper to compute expected hex string (lower-case). Compare ignoring case to avoid case sensitivity.
    private String expectedHex(byte[] bytes) {
        if (bytes == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            int v = b & 0xFF;
            int hi = (v >>> 4) & 0xF;
            int lo = v & 0xF;
            sb.append(Character.forDigit(hi, 16));
            sb.append(Character.forDigit(lo, 16));
        }
        return sb.toString();
    }

    @Test
    public void testTypicalInput_toStringMatchesExpected() {
        byte[] bytes = new byte[] { 0x0A, 0x1B, (byte) 0xFF, 0x00 };
        Value.BytesValue v = new Value.BytesValue(bytes);
        String actual = v.toString();
        String expected = expectedHex(bytes);
        // Compare ignoring case because underlying implementation may choose upper or lower hex chars.
        assertEquals("Hex string should match expected representation (case-insensitive)",
                expected.toLowerCase(), actual.toLowerCase());
    }

    @Test
    public void testEmptyArray_toStringIsEmpty() {
        byte[] bytes = new byte[0];
        Value.BytesValue v = new Value.BytesValue(bytes);
        String actual = v.toString();
        assertEquals("Empty byte array should produce empty string", "", actual);
    }

    @Test(expected = NullPointerException.class)
    public void testNullBytes_toStringThrowsNullPointerException() {
        // BytesValue stores the reference and toString calls Buffer.bytesToHexString(bytes).
        // If bytes is null, a NullPointerException is expected when toString is invoked.
        Value.BytesValue v = new Value.BytesValue((byte[]) null);
        // Trigger toString which should throw NPE
        v.toString();
    }

    @Test
    public void testSingleZeroByte_toStringIs00() {
        byte[] bytes = new byte[] { 0x00 };
        Value.BytesValue v = new Value.BytesValue(bytes);
        String actual = v.toString();
        assertEquals("Single zero byte should be represented as '00' (case-insensitive)",
                "00", actual.toLowerCase());
    }

    @Test
    public void testNegativeByteValues_toStringRepresentsUnsignedBytes() {
        byte[] bytes = new byte[] { (byte) 0x80, (byte) 0xFF, (byte) 0xA5 };
        Value.BytesValue v = new Value.BytesValue(bytes);
        String actual = v.toString();
        String expected = expectedHex(bytes);
        assertEquals("Negative byte values should be represented as their unsigned hex equivalents (case-insensitive)",
                expected.toLowerCase(), actual.toLowerCase());
    }

    @Test
    public void testLargeArray_lengthMatchesAndEdgesCorrect() {
        int size = 10000;
        byte[] bytes = new byte[size];
        for (int i = 0; i < size; i++) {
            bytes[i] = (byte) (i & 0xFF);
        }
        Value.BytesValue v = new Value.BytesValue(bytes);
        String actual = v.toString();

        // Check overall length: two hex chars per byte
        assertEquals("Hex string length should be twice the byte array length",
                size * 2, actual.length());

        // Check first two bytes' hex and last two bytes' hex to increase confidence without building the full expected string
        String expectedFirstTwo = expectedHex(new byte[] { bytes[0], bytes[1] });
        String expectedLastTwo = expectedHex(new byte[] { bytes[size - 2], bytes[size - 1] });

        assertEquals("First two bytes hex mismatch (case-insensitive)",
                expectedFirstTwo.toLowerCase(), actual.substring(0, 4).toLowerCase());
        assertEquals("Last two bytes hex mismatch (case-insensitive)",
                expectedLastTwo.toLowerCase(), actual.substring(actual.length() - 4).toLowerCase());
    }

    @Test
    public void testConstructorWithType_ignoredForToString() {
        byte[] bytes = new byte[] { 0x11, 0x22, 0x33 };
        int arbitraryType = 999; // second constructor parameter should not affect toString()
        Value.BytesValue vWithType = new Value.BytesValue(bytes, arbitraryType);
        Value.BytesValue vNoType = new Value.BytesValue(bytes);

        String actualWithType = vWithType.toString();
        String actualNoType = vNoType.toString();
        assertEquals("Constructor type should not affect toString() output (case-insensitive)",
                actualNoType.toLowerCase(), actualWithType.toLowerCase());
    }

    @Test
    public void testSetUpInstance_toStringProducesExpected() {
        // Uses instance created in @Before
        String actual = instance.toString();
        byte[] original = new byte[] { 0x01, 0x23, (byte) 0xFF };
        String expected = expectedHex(original);
        assertEquals("setUp instance should produce expected hex (case-insensitive)",
                expected.toLowerCase(), actual.toLowerCase());
    }
}

To edit these changes git checkout codeflash/optimize-BytesValue.toString-ml80cwdh and push.