PKMS

Quant

4 min read

Home

Conf videos on youtube

HRT

IMC

IMC Lauchpad Program: https://www.imc.com/in/careers/students-graduates/programs/launchpad

Meetup:

Books

Research Papers/Articles:

Basics GK

Data are of two types Quantitative and Qualitative

  • Quantitative ⇒ you can measure ⇒ Finance is all about numbers ⇒ Quant Finance ⇒ Data-driven, analytical, model-based Important considering factor for Venture capitals, Investors etc.
  • Qualitative ⇒ subjective factors like management quality, brand value, regulatory risks, and macroeconomic trends Important considering factor for Private equity, Risk management, HFT, asset pricing etc.

Foundation (CPU/Hardware)

  1. CPU cache hierarchy (L1/L2/L3)
  2. Cache lines and alignment
  3. Cache coherency (MESI/MOESI)
  4. False sharing
  5. True sharing and cache bouncing
  6. Memory barriers and fences
  7. Store buffers and load buffers
  8. Write-combining
  9. Branch prediction (static/dynamic)
  10. Instruction pipelining
  11. Out-of-order execution
  12. Speculative execution
  13. SIMD basics (SSE, AVX, NEON)
  14. Prefetching (hardware/software)
  15. TLB (Translation Lookaside Buffer)
  16. Page faults and memory paging
  17. NUMA topology and awareness
  18. CPU affinity and core pinning
  19. Hyper-threading effects

Memory & Data Structures

  1. Memory layout and padding
  2. Struct packing and alignment
  3. Pointer aliasing
  4. Temporal/spatial locality
  5. Working set size
  6. Cache line coloring
  7. Ring buffers
  8. Circular queues
  9. Lock-free queues (MPMC, SPSC)
  10. Skip lists (lock-free variants)
  11. Hash tables (concurrent)
  12. Memory pools and pre-allocation
  13. Object reuse patterns
  14. Disruptor pattern
  15. Bounded queues vs unbounded

Synchronization & Concurrency

  1. Atomics (compare-and-swap, load/store)
  2. Memory ordering (acquire/release/relaxed)
  3. Spinlocks vs mutexes
  4. Reader-writer locks
  5. Condition variables
  6. Semaphores
  7. Lock-free vs wait-free
  8. ABA problem
  9. Acquire/release semantics
  10. Sequential consistency
  11. Double-checked locking
  12. Seqlock pattern

Threading & Scheduling

  1. Thread creation overhead
  2. Thread pooling
  3. Work stealing
  4. Thread affinity pinning
  5. NUMA-aware scheduling
  6. Real-time scheduling (SCHED_FIFO/SCHED_RR)
  7. CPU isolation (isolcpus)
  8. Context switching costs
  9. Jitter sources
  10. Priority inversion
  11. Busy-wait loops
  12. Backpressure strategies

I/O & Networking

  1. Polling vs interrupts
  2. Interrupt coalescing
  3. Socket options (TCP_NODELAY, SO_REUSEADDR)
  4. UDP vs TCP tradeoffs
  5. Non-blocking I/O
  6. epoll/kqueue/IOCP
  7. Event-driven architecture
  8. Reactor pattern
  9. Proactor pattern
  10. Zero-copy (sendfile, mmap, io_uring)
  11. RX/TX ring buffers (NIC level)
  12. DPDK basics
  13. Kernel bypass
  14. Packet filtering/XDP

System Calls & OS Interaction

  1. Syscall overhead
  2. Avoiding syscalls
  3. Batch syscalls
  4. vDSO (virtual dynamic shared object)
  5. Read/write/mmap syscalls
  6. mlock/mlockall
  7. Process vs thread creation
  8. Signal handling in low-latency code

Profiling & Analysis Tools

  1. perf (Linux performance counters)
  2. Flamegraphs
  3. VTune (Intel)
  4. Cachegrind/Callgrind
  5. Strace syscall tracing
  6. ltrace library tracing
  7. GDB debugging
  8. Valgrind/Helgrind
  9. ThreadSanitizer
  10. CPU cycle counting (RDTSC)
  11. Microbenchmarking frameworks
  12. Statistical significance in benchmarks
  13. Variance and tail latency analysis
  14. Load testing tools

C++ Specific

  1. Move semantics and RVO
  2. RAII and scope guards
  3. Smart pointers (unique/shared)
  4. Noexcept and exception safety
  5. Constexpr and compile-time computation
  6. Templates and specialization
  7. SFINAE and concepts
  8. Variadic templates
  9. Inline assembly (asm)
  10. Compiler intrinsics (_builtin*)
  11. Volatile and compiler barriers
  12. Undefined behavior pitfalls
  13. Aliasing rules
  14. Link-time optimization (LTO)
  15. Profile-guided optimization (PGO)

Rust Specific

  1. Ownership and borrowing semantics
  2. Send/Sync traits
  3. Interior mutability (Cell/RefCell/Atomic)
  4. Async/await for systems
  5. Tokio/async-std runtimes
  6. Crossbeam (threading/concurrency)
  7. Parking lot mutexes
  8. Unsafe code and correctness
  9. Inline assembly in Rust
  10. SIMD in Rust (packed_simd, std::simd)

Design Patterns & Architecture

  1. Ring buffer patterns
  2. Event sourcing
  3. Command pattern
  4. Observer pattern
  5. Pub-sub architectures
  6. Pipeline patterns
  7. Batching for throughput
  8. Backpressure handling
  9. Graceful degradation
  10. Circuit breakers
  11. Rate limiting

Benchmarking & Validation

  1. Microbenchmarking methodology
  2. Cold vs warm cache testing
  3. Variance measurement
  4. Reproducibility
  5. Tail latency percentiles
  6. Throughput vs latency tradeoffs
  7. Load generation
  8. Stress testing
  9. Long-running stability tests
  10. Regression testing

Real-world HFT/Low-Latency Specifics

  1. Order matching engines
  2. Market data processing
  3. Serialization formats (FIX, protobuf, flatbuffers)
  4. Time synchronization (NTP, PTP)
  5. Latency budgets
  6. Jitter quantification
  7. Tick-to-trade timing
  8. Colocation considerations
  9. Network latency measurement
  10. Hardware clocking

Build & Deployment

  1. CMake/Bazel build optimization
  2. Compiler flags for performance
  3. Static vs dynamic linking
  4. Code generation options (-O3, -march, etc)
  5. Stripping/dead code elimination
  6. Docker for reproducibility
  7. Linux container tuning
  8. Kernel parameters (sysctl)

3 items under this folder.