Each {@code perCommand} arm performs both lookups, matching what one Redis command does: + * {@code agentCrashingCommands} via {@code LettuceClientDecorator.onCommand}, and {@code + * nonInstrumentingCommands} via {@code expectsResponse}. Ordinary commands ({@code GET}, {@code + * SET}, {@code HGETALL}, {@code INCR}) are in neither set, so the {@code _miss} arms cover the + * common path and the {@code _hit} arms the administrative commands the sets contain. + * + *
All three candidates are declared {@code static final}, as production declares its sets, so + * the comparison reflects the structures rather than static-versus-instance field access. Keys are + * produced the way {@code getCommandName} produces them ({@code getType().toString().trim()}), + * which keeps the interned-constant identity fast path in {@code String.equals} intact. + * + *
{@code nonInstrumentingCommands} declares four entries, of which two are reachable through + * lettuce's built-in commands: {@code CommandType} (174 constants in lettuce 5.0.0) defines {@code + * SHUTDOWN} and {@code DEBUG} but neither {@code OOM} nor {@code SEGFAULT}, and {@code SEGFAULT} is + * a {@code CommandKeyword} rather than a command type. {@code getType()} returns a {@code + * ProtocolKeyword} though, and a custom implementation may report either name, so these entries are + * unreachable via {@code CommandType} rather than unreachable outright. Both arrays are benchmarked + * as declared. + * + *
Results (JDK 17.0.18, Apple M4 Max, {@code @Fork(3)}, {@code @Threads(1)}; ns/op, lower is + * better), with allocation from a separate {@code -Pjmh.profilers=gc} run: + * + *
{@code
+ * Benchmark ns/op alloc B/op
+ * hashSet_perCommand_miss 1.715 +- 0.071 ~0
+ * stringIndexEmbedded_perCommand_miss 1.881 +- 0.295 ~0
+ * stringIndexInstance_perCommand_miss 2.687 +- 0.151 ~0
+ * hashSet_perCommand_hit 1.938 +- 0.158
+ * stringIndexEmbedded_perCommand_hit 1.890 +- 0.117
+ * stringIndexInstance_perCommand_hit 2.286 +- 0.100
+ * }
+ *
+ * Miss-path scores over six runs, since a single run understates the run-to-run spread: + * + *
{@code
+ * run scores mean spread
+ * hashSet 1.708 1.706 1.736 1.707 1.744 1.715 1.719 0.038
+ * stringIndexEmbedded 1.699 1.668 1.698 1.796 1.680 1.881 1.737 0.213
+ * stringIndexInstance 2.667 2.665 2.635 2.682 2.773 2.687 2.685 0.138
+ * }
+ *
+ * Footprint is deterministic, so unlike a throughput benchmark this is safe to run under load. + * + *
Measured at the declared sizes, 4 and 6 entries. {@code capacityFor} rounds to a power of two, + * putting those on 8- and 16-slot tables at the default 0.5 load factor, while {@code new + * HashSet<>(Collection)} floors its table at 16 slots for both. + * + *
All candidates hold the same interned {@code String} instances, so the strings cancel out and + * the comparable figure is overhead above a plain {@code String[]} of the same names. + * + *
Both sets are {@code static final}, built once per classloader the helper is injected into + * ({@code HelperInjector} keys injection by classloader), not per command. Per-lookup allocation is + * zero for all three structures; see {@code LettuceCommandClassificationBenchmark} under {@code + * -Pjmh.profilers=gc}. + * + *
Measured retained bytes (JDK 17.0.18, JOL estimate mode: ordering reliable, exact bytes + * approximate). The combined row measures both structures as simultaneous roots, since the two sets + * share the interned {@code "DEBUG"} instance and summing separate measurements would count it + * twice: + * + *
{@code
+ * set n array hashSet siInstance siEmbedded
+ * nonInstrumentingCommands 4 224 480 312 288
+ * overhead above array (256) (88) (64)
+ * agentCrashingCommands 6 328 640 472 448
+ * overhead above array (312) (144) (120)
+ * TOTAL both sets 1120 784 736
+ * saving vs hashSet 336 384
+ * }
+ *
+ * Both {@code StringIndex} modes undercut {@code HashSet}: structural overhead is 568 B against + * 232 B for the instance and 184 B for the embedded arrays. + */ +class LettuceCommandSetFootprintTest { + + @BeforeAll + static void assumeNotJ9Jvm() { + // JOL's GraphLayout relies on HotSpot-specific Unsafe internals and throws on J9-based JVMs + // (IBM/Semeru) -- same guard as StringIndexFootprintTest. + assumeFalse(JavaVirtualMachine.isJ9()); + } + + static long bytes(final Object... roots) { + return GraphLayout.parseInstance(roots).totalSize(); + } + + @Test + void footprintComparison() { + final String[] nonInstrumenting = LettuceInstrumentationUtil.NON_INSTRUMENTING_COMMAND_WORDS; + final String[] agentCrashing = LettuceInstrumentationUtil.AGENT_CRASHING_COMMANDS_WORDS; + + System.out.printf( + "%-28s %6s %10s %10s %10s %10s%n", + "set", "n", "array", "hashSet", "siInstance", "siEmbedded"); + + for (final String[] words : new String[][] {nonInstrumenting, agentCrashing}) { + final String name = + words == nonInstrumenting ? "nonInstrumentingCommands" : "agentCrashingCommands"; + + final long array = bytes((Object) words); + final long hashSet = bytes(new HashSet<>(Arrays.asList(words))); + final long siInstance = bytes(StringIndex.of(words)); + final StringIndex.Data data = StringIndex.EmbeddingSupport.create(words); + final long siEmbedded = bytes(data.hashes, data.names); + + System.out.printf( + "%-28s %6d %10d %10d %10d %10d%n", + name, words.length, array, hashSet, siInstance, siEmbedded); + System.out.printf( + "%-28s %6s %10s %10d %10d %10d (overhead above array)%n", + "", "", "", hashSet - array, siInstance - array, siEmbedded - array); + + assertTrue( + siInstance < hashSet, + "StringIndex instance should retain fewer bytes than HashSet for " + name); + assertTrue( + siEmbedded < hashSet, + "StringIndex embedded arrays should retain fewer bytes than HashSet for " + name); + } + + // Both structures are measured as simultaneous roots. The two sets share the interned "DEBUG" + // instance, so measuring them separately and adding the results counts that object twice. + final long bothArrays = bytes(nonInstrumenting, agentCrashing); + final long bothHashSets = + bytes( + new HashSet<>(Arrays.asList(nonInstrumenting)), + new HashSet<>(Arrays.asList(agentCrashing))); + final long bothInstances = + bytes(StringIndex.of(nonInstrumenting), StringIndex.of(agentCrashing)); + final StringIndex.Data niData = StringIndex.EmbeddingSupport.create(nonInstrumenting); + final StringIndex.Data acData = StringIndex.EmbeddingSupport.create(agentCrashing); + final long bothEmbedded = bytes(niData.hashes, niData.names, acData.hashes, acData.names); + + System.out.printf( + "%n%-28s %6s %10d %10d %10d %10d%n", + "BOTH SETS (combined graph)", "", bothArrays, bothHashSets, bothInstances, bothEmbedded); + System.out.printf( + "%-28s %6s %10s %10s %10d %10d (saving vs hashSet, per classloader)%n", + "", "", "", "", bothHashSets - bothInstances, bothHashSets - bothEmbedded); + } +}