Libuv Mastery

Building High-Performance Asynchronous Applications in C

Introduction

1. What You Will Learn
2. Who This Book Is For
3. How This Book Is Structured
4. A Note on Code Examples

Chapter 1: The World of Asynchronous I/O

1. The C10K Problem and Beyond
2. Concurrency Models Compared
3. What libuv Is and Where It Lives
4. Design Goals of libuv
5. How to Read This Book

Chapter 2: Getting Started with libuv

1. Obtaining libuv
2. Building Your First Project with CMake
3. The Minimal Event Loop Program
4. Understanding the Build Output
5. Verifying Your Installation

Chapter 3: Architecture of libuv

1. The Platform Abstraction Layer
2. Handles vs Requests
3. The Event Loop Internals
4. Memory Allocation in libuv
5. Thread Safety Rules

Chapter 4: The Event Loop

1. Anatomy of uv_run()
2. Loop Lifecycle
3. Custom Event Loops
4. Embedding Loops
5. Common Pitfalls

Chapter 5: Asynchronous I/O Fundamentals

1. The Callback Pattern
2. Error Handling in libuv
3. Handles Lifecycle
4. The Stream Abstraction
5. Resource Cleanup Patterns

Chapter 6: Timers and Periodic Operations

1. One-Shot Timers with uv_timer_t
2. Repeating Timers
3. Periodic Handles: Prepare and Check
4. Time Management in libuv
5. Building a Task Scheduler

Chapter 7: File System Operations

1. Synchronous vs Asynchronous File I/O
2. Reading and Writing Files
3. Directory Operations
4. The Thread Pool Behind fs Operations
5. File Descriptors and Ownership

Chapter 8: TCP Networking

1. TCP Servers
2. TCP Clients
3. Stream Operations on TCP
4. Advanced Socket Options
5. Building a Concurrent Echo Server

Chapter 9: UDP and DNS Resolution

1. UDP Sockets
2. Multicast Support
3. Async DNS with getaddrinfo
4. Reverse DNS and Hostname Resolution
5. Building a Simple UDP Chat Server

Chapter 10: Pipes, Streams, and TTY

1. Unix Domain Sockets and Named Pipes
2. The Unified Stream Interface
3. Duplex Streams
4. TTY Support
5. Building an IPC Bridge

Chapter 11: Process Management and Signals

1. Spawning Processes
2. Stdio Inheritance Patterns
3. Process Events
4. Signal Handling
5. Building a Process Supervisor

Chapter 12: Threading and Synchronization

1. The Thread Pool
2. Creating Custom Threads
3. Mutexes and Locks
4. Condition Variables
5. Atomic Operations and Thread-Local Storage

Chapter 13: Polling and Custom File Descriptors

1. The Poll Handle
2. Event Types and Their Meanings
3. Integrating External Libraries
4. File Descriptor Ownership
5. Building a Hybrid Reactor

Chapter 14: Error Handling, Debugging, and Testing

1. Systematic Error Handling
2. Debugging libuv Applications
3. Memory Leak Detection
4. Testing Asynchronous Code
5. Core Dumps and Post-Mortem Analysis

Chapter 15: Performance Optimization

1. Reducing Latency
2. Throughput Optimization
3. CPU Affinity and Multiple Loops
4. Profiling libuv Applications
5. Tuning for Production

Chapter 16: Portability Across Operating Systems

1. Platform Detection in libuv
2. Linux-Specific Behavior
3. macOS and BSD Considerations
4. Windows Portability
5. Writing Truly Portable Code

Chapter 17: Embedding libuv and Integration

1. Embedding libuv in Existing Applications
2. Integrating with SSL/TLS Libraries
3. Building on Top of libuv
4. Interfacing with C++ and Other Languages
5. Microservice Architecture with libuv

Chapter 18: Real-World Applications

1. Building an HTTP Server from Scratch
2. A WebSocket Implementation
3. A Load Balancer
4. Deployment Considerations

Conclusion: The Art of Event-Driven Programming

1. Patterns That Scale
2. When NOT to Use libuv
3. The Future of Async C
4. Continuing Your Journey

References