Continuous Packet Offloading with Update Rule in DPDK
Discover how to implement atomic updates in DPDK rte_flow rules using the new actions_update() API, ensuring zero packet loss during rule modifications and steering operations.
LRSCwait: Enabling Scalable and Efficient Synchronization in Manycore Systems
Explore scalable synchronization in manycore systems with LRSCwait. Learn about polling-free and retry-free operations for improved throughput and energy efficiency in shared-memory architectures.
Introduction to Lock/Wait Free Algorithms - Defining and Understanding the Terms
Explore lock/wait-free algorithms: understand definitions, motivations, and applications in concurrent programming. Gain insights into hardware design and synchronization challenges.
C++ Memory Model: From C++11 to C++23
Explore C++ memory model evolution from C++11 to C++23. Learn CPU and compiler optimizations, threading tools, and best practices for robust, thread-safe code development.
Real-time Confessions in C++ - The Most Common Sins in Real-Time Code
Explore common misconceptions and errors in real-time C++ audio development. Learn to avoid pitfalls and write efficient, reliable code for audio applications.
A Lock-Free Atomic Shared_Ptr
Explore lock-free atomic shared_ptr implementation for C++, covering motivation, existing strategies, and a new portable solution for low-latency and real-time applications.
Lock-free Atomic Shared Pointers Without a Split Reference Count - Implementation Strategies
Explore lock-free atomic shared pointers implementation without split reference count. Learn an elegant solution using hazard pointers for improved performance in concurrent C++ programming.
A Lock-Free Atomic Shared Pointer in Modern C++
Explore lock-free atomic shared pointers in C++20, their implementation challenges, and a new portable solution for low-latency applications. Gain insights into modern C++ concurrency.
C++11 to C++23 in the C++ Memory Model - Lecture
Explore C++ memory model evolution from C++11 to C++23, covering threading, optimization, and best practices for robust, thread-safe code development.