Allocators for Compressed Pages - In-depth Comparison with z3fold
Explore compressed page allocators, focusing on z3fold's performance, compression ratios, and ongoing improvements. Gain insights into zswap, zram, and efficient memory management techniques.
The Kernel Concurrency Sanitizer - Detecting Concurrency Bugs in Linux
Explore Linux kernel concurrency, LKMM, and KCSAN with Marco Elver. Learn to detect and prevent concurrency bugs in kernel code using practical examples and advanced techniques.
A New Proposal for Protecting Kernel Data Memory
Propuesta para proteger la memoria de datos del kernel mediante segmentación del espacio de direcciones vmalloc y codificación de propiedades, reduciendo la sobrecarga de verificación y allanando el camino para el endurecimiento de las tablas de páginas.
Programming Distributed Systems
Exploring innovative programming language designs to simplify distributed systems development, enhancing performance and correctness while reducing common errors in large-scale applications.
Explaining Different Coroutine Flavors Using Scala Native
Explore coroutines in modern languages, their types, and implementation. Learn about stackless and stackfull variants, LLVM backend optimizations, and green threads in operating systems.
Producer-Consumer Problem - Why Process Synchronization? - Race Condition - Operating System
Explore process synchronization, race conditions, and the producer-consumer problem in operating systems. Learn key concepts for efficient multi-process management and coordination.
Making Unprivileged Containers More Usable
Explore unprivileged containers, their limitations, and solutions for enhanced usability. Learn about syscalls, seccomp, kernel policies, and security considerations in container management.
LoLKV - Logless, Linearizable, RDMA-based Key-Value Storage System
Innovative key-value storage system using lock-free design for concurrent updates, achieving higher throughput and lower latency than state-of-the-art alternatives.
Beyond Ctrl-C: The Dark Corners of Unix Signal Handling - RustConf 2023
Explore the intricacies of Unix signal handling beyond basic interrupts, delving into advanced techniques and potential pitfalls in Rust programming.
Mastering Argo Workflows at Scale - A Practical Guide to Scalability Excellence
Practical strategies for scaling Argo Workflows, covering infrastructure optimization, resource management, workflow design, and observability. Learn from real-world experience handling 18,000+ pods per workflow.
Instruction-Level BPF Memory Model
Explore the intricacies of instruction-level BPF memory models with expert Paul E. McKenney in this comprehensive Linux Foundation presentation.
Reclamation Interactions with RCU
Explore reclamation interactions with RCU, a crucial concept in Linux kernel development, presented by expert Paul E. McKenney.
No Tears Atomics and LBS
Explore atomic operations and load balancing strategies in Linux systems, enhancing performance and reliability in complex computing environments.
Enhancements to RCU-protected VMA Walks
Explore advanced techniques for optimizing RCU-protected VMA walks in Linux kernel development, enhancing system performance and efficiency.
Ticket Spinlocks in Zephyr RTOS - What, Where and Why
Explore ticket spinlocks in Zephyr RTOS, their advantages over traditional spinlocks, and their impact on SMP systems. Learn about lock fairness and potential challenges in hardware and simulator targets.
The Miracle of Generators - Exploring ECMAScript 2015 Iterators and Coroutines
Explore ECMAScript 2015 generators: from simple iterators to powerful coroutines. Learn how they simplify asynchronous programming and uncover a fundamental computer science concept.
Avoiding Rigor Mortis in Software Development - Pragmatic Approaches
Explore strategies to avoid software rigidity with Pragmatic Dave Thomas. Learn functional programming, concurrency, and pattern matching techniques to keep your code flexible and maintainable.
Optimal Reads-From Consistency Checking for C11-Style Memory Models
Explore optimal consistency checking algorithms for C11-style memory models, improving efficiency in concurrency testing and model checking for various C/C++ variants.
Sound Dynamic Deadlock Prediction in Linear Time
Explore a novel approach to dynamic deadlock prediction in concurrent systems, introducing sync-preserving deadlocks and efficient algorithms for sound, linear-time detection.
Memento: A Framework for Detectable Recoverability in Persistent Memory
Explore Memento, a high-performance framework for detectable recoverability in persistent memory. Learn about its timestamp-based recovery strategy and implementation in various data structures.
Putting Weak Memory in Order via a Promising Intermediate Representation
Explore an in-order shared-memory concurrency model for C/C++, supporting non-atomic accesses and compiler optimizations while maintaining soundness between source and intermediate representation.