C++ HFT Systems Engineering

Write a constrained function template using a C++20 concept and interpret a failed constraint.

Select an STL container from complexity, iterator-stability, allocation, and locality requirements.

Diagnose a compilation or linking failure involving declarations, definitions, templates, inline entities, or the One Definition Rule.

Replace an allocation-heavy temporary-data path with std::span and non-owning views.

Implement closed-set polymorphism with std::variant and std::visit, and identify when virtual dispatch would be preferable.

Use std::pmr with a suitable memory resource to control allocation for a scoped workload.

Inspect type size, alignment, padding, object representation, triviality, and standard-layout properties relevant to binary data.

Use compiler warnings, AddressSanitizer, and UndefinedBehaviorSanitizer to diagnose a faulty C++ program.

Trace the lifecycle and cost of a Linux system call across the user-kernel boundary.

Explain how processes, threads, file descriptors, and inherited resources relate after fork and exec.

Interpret a process virtual-memory map containing code, data, heap, stack, shared libraries, and mappings.

Predict the effects of page faults, copy-on-write, huge pages, and TLB pressure on a workload.

Use mmap correctly for file-backed or anonymous memory and distinguish it from buffered file I/O.

Relate scheduler states, context switches, CPU affinity, and oversubscription to latency.

Compare blocking I/O, readiness notification, and asynchronous I/O for a specified workload.

Use strace and procfs to diagnose a Linux process performing unexpected system calls or I/O.

Relate out-of-order execution, instruction dependencies, execution ports, and instruction-level parallelism to CPU throughput.

Predict cache-line traffic for sequential, strided, and pointer-chasing memory access patterns.

Reorganize data between array-of-structures and structure-of-arrays layouts to improve locality.

Diagnose false sharing and coherence traffic in a multithreaded data structure.

Predict the performance impact of branch prediction for a given control-flow pattern.

Calculate L1 and L2 data-TLB coverage for a working set and explain the overhead of a hardware page-table walk.

Inspect optimized x86-64 assembly to identify loads, branches, vectorization, and eliminated work.

Use perf stat counters to test a hypothesis about cycles, instructions, cache misses, or branch misses.

Manage std::thread or std::jthread lifetime without leaks, detached work, or premature destruction.

Identify data races, race conditions, deadlocks, livelocks, and starvation in concurrent code.

Protect a shared invariant with a mutex while minimizing the critical section.

Use a condition variable with a predicate that remains correct under spurious wakeups.

Select a mutex, semaphore, latch, barrier, or condition variable for a synchronization requirement.

Implement a bounded blocking queue with shutdown semantics.

Implement a fixed-worker task executor using a provided queue abstraction and signal task completion safely.

Use ThreadSanitizer and stress testing to reproduce and diagnose a concurrency defect.

Construct a happens-before graph for a C++ program containing threads, mutexes, and atomics.

Distinguish atomic load, store, exchange, fetch, and compare-exchange semantics in a state transition.

Evaluate a memory-ordering litmus test and list its permitted outcomes under sequentially consistent, acquire-release, and relaxed ordering.

Choose sequentially consistent, acquire-release, or relaxed ordering for a small concurrent algorithm.

Implement publication of immutable data using release and acquire operations.

Implement a bounded single-producer single-consumer ring buffer with atomics.

Explain the ABA problem in a compare-exchange-based data structure.

Compare epoch-based reclamation, hazard pointers, and reference counting for reclaiming concurrent objects.

Audit and repair a microbenchmark for dead-code elimination, setup contamination, input predictability, and environmental noise.

Validate a TSC-based cycle timer by choosing an ordering strategy and calibrating it against a monotonic clock.

Summarize a latency distribution using percentiles, outliers, warm-up behavior, and confidence intervals.

Use perf recording and flame graphs to locate a CPU bottleneck in a C++ program.

Benchmark general-purpose allocation, a PMR arena, and a bounded pool for a hot-path workload, then select one from latency and lifetime requirements.

Refactor one hot path to reduce measured cache misses or branch mispredictions.

Evaluate compiler optimization, link-time optimization, and profile-guided optimization using controlled evidence.

Write a reproducible performance report that distinguishes observations, hypotheses, experiments, and conclusions.

Trace an application message through sockets, TCP or UDP, IP, Ethernet, and the reverse receive path.

Trace TCP connection establishment, state transitions, teardown, and TIME_WAIT handling.

Explain TCP sliding-window flow control, retransmission mechanisms, and congestion-control dynamics.

Implement a blocking TCP client and server that handle partial reads, partial writes, and disconnects.

Design message framing for a byte-stream protocol and reject malformed frames safely.

Implement a nonblocking connection state machine using epoll.

Use tcpdump or Wireshark to diagnose a handshake, retransmission, reset, or packet-loss scenario.

Measure throughput and tail latency for a socket-based service under controlled load.

Explain how interrupts, NAPI polling, socket buffers, and scheduling contribute to Linux network latency.

Configure and justify TCP options such as TCP_NODELAY and socket-buffer sizes for a latency-sensitive flow.

Implement a UDP multicast receiver that selects an interface, manages group membership, and preserves datagram boundaries.

Decode an endian-aware binary market-data message without undefined behavior or unnecessary allocation.

Implement sequence tracking that classifies duplicates, reordering, and sequence gaps in a market-data stream.

Maintain a price-level order book from add, modify, and cancel events.

Relate NIC queues, RSS, CPU affinity, and NUMA placement to packet-processing locality.

Compare busy polling, user-space networking, DPDK-style kernel bypass, and RDMA at an architectural level.

Define latency, throughput, correctness, recovery, and resource constraints for a market-data pipeline.

Design pipeline stages and bounded handoff queues with explicit ownership and backpressure policies.

Assemble ingress and decoding stages from the previously built socket and decoder components using an ownership-safe bounded handoff.

Integrate sequence tracking and order-book updates into a deterministic event-processing core.

Create deterministic capture-and-replay support for debugging and regression tests.

Add low-overhead metrics for rates, queue occupancy, errors, and latency percentiles.

Test the pipeline under packet gaps, malformed input, slow consumers, and shutdown races.

Benchmark end-to-end latency and present an evidence-based defense of the pipeline’s ownership, concurrency, networking, and performance trade-offs.

Solve Trapping Rain Water and justify the invariant behind the two-pointer solution.

Solve Minimum Window Substring and justify the validity conditions of the sliding window.

Solve Median of Two Sorted Arrays using logarithmic partition-based binary search.

Solve Reverse Nodes in k-Group while preserving list connectivity and constant auxiliary space.

Solve Largest Rectangle in Histogram using a monotonic stack.

Implement Find Median from Data Stream using two heaps and prove the balancing invariant.

Solve The Skyline Problem using an event sweep and an ordered active set.

Implement an LFU Cache with constant-time average get and put operations.

Solve Binary Tree Maximum Path Sum using a postorder recurrence.

Solve Word Search II using trie-guided graph search and pruning.

Solve Word Ladder II by constructing only edges that belong to shortest transformation paths.

Solve N-Queens using backtracking with constant-time conflict checks.

Solve Burst Balloons using interval dynamic programming.

Solve Regular Expression Matching using dynamic programming over string and pattern prefixes.

Solve Candy by deriving and combining directional greedy constraints.

Solve Minimum One Bit Operations to Make Integers Zero by deriving its recursive bit structure.