Atomic's Memory Orders, What For?
Demystifying C++11 Memory Model: Explore atomic variables, memory orders, and their impact on multithreading. Gain insights into compiler optimizations, CPU execution, and efficient inter-thread communication.
Lock-Free Programming with Modern C++
Comprehensive introduction to lock-free programming using modern C++, covering std::atomic, memory models, and practical implementations of thread-safe data structures for low-latency applications.
There Is a Better Future
Explore advanced concurrency concepts, including improved futures and CSP channels, for creating efficient parallel task graphs and addressing limitations in std::future.
Finally Executors for C++
Explore C++ executors for asynchronous and parallel programming, covering motivation, requirements, interfaces, and practical examples. Learn about recent proposal developments and interactions with coroutines.
Parallel Design Patterns and Stream Parallelism
Explore parallel design patterns and stream parallelism using GrPPI, an experimental library for expressing parallelism through patterns, with focus on composability and multiple back-end support.
Heterogeneous Programming in C++ Today
Explore the evolving landscape of heterogeneous parallelism in C++, including standards, specifications, and future applications in IoT, self-driving cars, and machine learning.
Here's My Number; Call Me, Maybe - Callbacks in a Multithreaded World
Explore techniques for managing callbacks in multithreaded applications, focusing on clarity, object lifetime management, and preventing dangling references in C++ programming.
An Adventure in Race Conditions
Explore high-level abstractions for concurrent programming, avoiding common traps with locks and atomics. Learn strategies to prevent and detect race conditions in C++ development.
Concurrency in C++20 and Beyond
Explore new C++20 concurrency features and future proposals, including std::jthread, std::stop_token, std::latch, std::barrier, and std::counting_semaphore. Learn to write efficient concurrent code.
Threads Considered Harmful
Explore a new paradigm for multithreaded programming using tasks and dependencies, eliminating locks and improving composability, determinism, and performance in concurrent software development.
std::jthread - I Told You Concurrency Is Tricky
Explore the intricacies of C++20's std::jthread, uncovering concurrency challenges and design considerations. Gain insights into implementing robust threading mechanisms with expert guidance.
A Lock-Free std::atomic std::shared_ptr
Explore lock-free implementation of std::atomic std::shared_ptr in C++20, its motivation, history, and strategies. Learn about a new portable, lock-free solution for low-latency applications.
Structured Concurrency
Explore structured concurrency in C++ using senders/receivers for application-wide design. Learn to eliminate traditional concurrency pains and improve concurrent code experience.
An Introduction to Multithreading in C++20
Explore C++20's multithreading tools for safe and efficient concurrent programming. Learn key concepts and best practices for developing robust multithreaded applications.
Introduction to Epoch-Based Memory Reclamation - What to Do When No Thread is Watching
Explore epoch-based memory reclamation in concurrent programming, comparing it to hazard pointers and discussing its characteristics, benefits, and potential drawbacks for efficient memory management.
Multi Threading Model in Paradox Games - Past, Present and Future
Explore the evolution of multi-threading models in Paradox grand strategy games, from past implementations to current systems and future possibilities for improved performance and complexity.
Designing for C++ Concurrency Using Message Passing
Explore message passing in C++ concurrency design, covering frameworks, examples, and practical implementation to reduce synchronization errors and enhance system efficiency.
A Journey to Performance - Using Rust in Mercurial
Explore Rust's impact on Mercurial's performance, focusing on 'hg status' optimization. Learn about interoperability, data structures, and version control internals for significant speed improvements.
Gprofng - The Next Generation GNU Profiling Tool
Explore gprofng, a next-gen Linux profiling tool for C, C++, Java, and Scala. Learn its features, architecture, and advantages over gprof through practical examples and future development plans.
Rethinking Web UI's with WebGL
Explore Makepad, an experimental livecoding environment using WebGL for UI rendering. Learn about its architecture, GPU-compiled JS, and innovative approaches to styling and data visualization.
Reinventing the Web Browser for Modern Computers
Explore the future of web browsing with Mozilla's Mark Mayo as he discusses performance optimization, memory management, and API innovations for a better browsing experience.