[RESP] Optimize command parsing with SIMD fast path and O(1) hash table lookup

[badrishc]

Description of Change

Replaces the two legacy command parsing methods (FastParseArrayCommand ~950 lines of nested switch/if chains, SlowParseCommand ~815 lines of sequential SequenceEqual comparisons) with a tiered architecture:

1. SIMD Vector128 fast path — matches ~18 hot commands (GET, SET, DEL, PING, INCR, etc.) by comparing the full RESP encoding in a single 16-byte vector comparison. Cost: 3 ops per candidate.
2. MRU cache — 2-slot per-session cache catches repeated commands (HSET, LPUSH, ZADD) at the same 3-op cost as SIMD.
3. Scalar ulong fast path — handles hot commands too long for SIMD (PUBLISH, SETRANGE, GETRANGE) and variable-arg commands (EXPIRE, SETEXNX, GETEX, PEXPIRE).
4. CRC32 hash table (RespCommandHashLookup) — O(1) lookup for all 400 built-in commands. 512-entry table (16KB, L1-resident) with linear probing and per-parent subcommand tables.

Also unifies BITOP subcommand handling, adds debug assertions, hardens the hash table against edge cases (empty names, oversized names), and adds ValidatePrimaryTable() for startup integrity checks.

Key files:

• RespCommand.cs — Refactored FastParseCommand (SIMD + scalar + MRU), removed FastParseArrayCommand and SlowParseCommand
• RespCommandHashLookup.cs — New: Hash table engine (lookup, insert, validate, subcommand dispatch)
• RespCommandHashLookupData.cs — New: Command registration (PopulatePrimaryTable, subcommand arrays)
• RespCommandSimdPatterns.cs — New: SIMD Vector128 patterns and RespPattern() helper
• CommandParsingBenchmark.cs — New: BDN benchmark covering all parser tiers

CommandParsingBenchmark Results (Params=None, batch of 100):

Command	Tier	dev (μs)	PR (μs)	Delta
ParsePING	SIMD	1.576	1.427	−9.5%
ParseGET	SIMD	2.145	1.847	−13.9%
ParseSET	SIMD	2.823	2.453	−13.1%
ParseINCR	SIMD	2.152	2.034	−5.5%
ParseEXISTS	SIMD	8.891	2.319	−73.9%
ParseSETEX	SIMD	3.376	3.469	+2.8%
ParsePUBLISH	Scalar	—	3.469	new
ParseEXPIRE	Scalar	3.076	3.505	+13.9%
ParseHSET	Hash+MRU	10.035	3.867	−61.5%
ParseLPUSH	Hash+MRU	8.981	3.176	−64.6%
ParseZADD	Hash+MRU	9.599	3.843	−60.0%
ParseZRANGEBYSCORE	Hash	12.455	8.539	−31.4%
ParseZREMRANGEBYSCORE	Hash	13.983	9.289	−33.6%
ParseHINCRBYFLOAT	Hash	11.104	9.311	−16.1%
ParseSUBSCRIBE	Hash	9.649	7.196	−25.4%
ParseGEORADIUS	Hash	20.397	10.478	−48.6%
ParseSETIFMATCH	Hash	28.701	8.230	−71.3%

ParseCommand [AggressiveInlining]
│
├── FastParseCommand [AggressiveInlining]
│   │
│   │   // On SIMD hardware (Vector128.IsHardwareAccelerated && remainingBytes >= 16):
│   ├── SIMD pattern matching
│   │   Matches ~18 hot commands by comparing the full RESP encoding
│   │   (*N\r\n$L\r\nCMD\r\n) as a single 16-byte vector.
│   │   Cost: 1 load + 1 AND + 1 EqualsAll per candidate.
│   │   Hit → return immediately (readHead advanced past command header + name).
│   │
│   ├── MRU cache (2-slot, Vector128-based)
│   │   Catches repeated commands not in the SIMD table (e.g., HSET, LPUSH, ZADD).
│   │   Populated by ParseCommand after ArrayParseCommand resolves a command.
│   │   Slot 1 promoted to slot 0 on hit (LRU).
│   │   Hit → return immediately.
│   │
│   │   // Always (SIMD or not), if buffer starts with *N\r\n$L\r\n:
│   ├── Scalar path (ulong comparisons)
│   │   Three sections:
│   │   (1) Same fixed-arg hot commands as SIMD — fallback when remainingBytes < 16
│   │   (2) Hot commands too long for SIMD (name > 6 chars: PUBLISH, SETRANGE, etc.)
│   │   (3) Hot variable-arg commands (SETEXNX, GETEX, EXPIRE, PEXPIRE)
│   │   Hit → return immediately.
│   │
│   │   // If buffer does NOT start with *N\r\n$L\r\n:
│   └── Inline command check (FastParseInlineCommand)
│       Matches PING\r\n and QUIT\r\n (no array framing).
│       Hit → return immediately.
│
│   // FastParseCommand returned NONE — command not matched by any fast path
│
├── ArrayParseCommand [NoInlining]
│   │
│   ├── MakeUpperCase + retry FastParseCommand
│   │   If the command was lowercase, uppercases in-place and retries
│   │   FastParseCommand. Catches lowercase get, set, ping, etc.
│   │   Hit → return immediately.
│   │
│   ├── Parse RESP array header (*N\r\n)
│   │   Reads the array length. If buffer doesn't start with '*',
│   │   treats as malformed inline command and returns INVALID.
│   │
│   └── HashLookupCommand [NoInlining]
│       │
│       ├── Extract and uppercase command name ($len\r\nNAME\r\n)
│       │
│       ├── Hash table lookup (RespCommandHashLookup.Lookup)
│       │   CRC32 hash, 512-entry table (~16KB, L1-resident), linear probing.
│       │   Covers all ~400 built-in commands. O(1).
│       │
│       ├── If hash miss → TryParseCustomCommand
│       │   Runtime-registered commands (CustomTxn, CustomProcedure, etc.).
│       │   If miss → return INVALID.
│       │
│       └── If has subcommands → HandleSubcommandLookup [NoInlining]
│           Extract and uppercase subcommand name, look up in per-parent
│           hash table (CLUSTER, CLIENT, ACL, CONFIG, COMMAND, BITOP, etc.).
│           If miss → return INVALID with command-specific error message.
│
├── Update MRU cache (on SIMD hardware, if ArrayParseCommand resolved a
│   non-custom command — captures the 16-byte RESP pattern so
│   FastParseCommand's MRU check matches it on subsequent calls)
│
├── Parse arguments (parseState.Read for each remaining token)
│
└── Return command + argument count

[Copilot]

Pull request overview

This PR upgrades Garnet’s RESP command parsing pipeline by introducing SIMD-accelerated matching for the hottest commands, plus a cache-friendly hash table (with subcommand tables) to replace the previous deep switch/linear-scan parsing logic. It also adds benchmark coverage and updates contributor documentation to reflect the new recommended parsing extension points.

Changes:

• Added RespCommandHashLookup (primary + subcommand hash tables) and integrated it into ArrayParseCommand.
• Reworked FastParseCommand to add SIMD Vector128 pattern matching and a per-session 2-slot MRU cache.
• Added a dedicated BenchmarkDotNet benchmark for parser-only throughput and updated docs/guides for adding commands.

Reviewed changes

Copilot reviewed 5 out of 6 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
website/docs/dev/fast-parsing-plan.md	Adds a detailed parsing optimization/design document.
libs/server/Resp/Parser/RespCommandHashLookup.cs	New static hash-table-based command/subcommand lookup implementation.
libs/server/Resp/Parser/RespCommand.cs	Integrates SIMD fast path + MRU cache + hash lookup parsing; removes legacy slow parsing paths.
benchmark/BDN.benchmark/Operations/CommandParsingBenchmark.cs	Adds parsing-only microbenchmarks across tiers.
.github/skills/add-garnet-command/SKILL.md	Updates contributor guidance to use the new hash lookup path.
.github/copilot-instructions.md	Updates “add parsing logic” instructions to reference the new hash lookup table.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[kevin-montrose]

Static initializers can cause the JIT to inject checks around static methods, since this is so hot let's use a module initializer instead.

Small example of code check diff:

WithStaticInit.Bar:

L0000	push	rbx
L0001	sub	rsp, 0x20
L0005	mov	ebx, ecx
L0007	mov	rcx, 0x7ffe7cccccc8
L0011	mov	edx, 2
L0016	call	0x00007ffedade5e20
L001b	mov	rcx, 0x7ffe7cccccc8
L0025	mov	edx, 2
L002a	call	0x00007ffedae04ef0
L002f	mov	eax, [rax+8]
L0032	cdq	
L0033	idiv	ebx
L0035	mov	eax, edx
L0037	add	rsp, 0x20
L003b	pop	rbx
L003c	ret	

WithModuleInit.Bar

L0000	push	rbx
L0001	sub	rsp, 0x20
L0005	mov	ebx, ecx
L0007	mov	rcx, 0x7ffe7cccccc8
L0011	mov	edx, 3
L0016	call	0x00007ffedae04ef0
L001b	mov	eax, [rax+8]
L001e	cdq	
L001f	idiv	ebx
L0021	mov	eax, edx
L0023	add	rsp, 0x20
L0027	pop	rbx
L0028	ret	

.NET 8, x64

[kevin-montrose]

nit: there's a mix of explicit local types and var in here - let's prefer var everywhere in this change.

[kevin-montrose]

These three .AsByte() calls are superfluous.