Leveraging the OS CPU Scheduler to Write Real-Time Multithreaded Applications
Learn to leverage Linux's kernel scheduler for writing soft real-time multithreaded applications in C, covering scheduling policies, thread-level control, and RTOS capabilities.
Faster Ray Tracing with Multithreading - Ray Tracing Series
Explore multithreading techniques to optimize ray tracing performance. Learn how to implement parallel processing for faster rendering and improved efficiency in C++ ray tracing algorithms.
Finding and Fixing Slow Code - Ray Tracing Series
Optimize ray tracing performance through multithreading and code analysis. Learn techniques to identify bottlenecks and improve efficiency in C++ implementations for faster rendering.
Emulating NT Synchronization Primitives in Wine
Explore a proposed kernel driver solution to enhance Wine's performance by emulating NT synchronization primitives, potentially doubling speed for multithreaded applications like modern games.
Improving CPU Isolation with Per-CPU Spinlocks - Performance Cost and Analysis
Explore CPU isolation improvements using per-CPU spinlocks. Analyze performance costs, cache coherence, and contention. Compare with current solutions and discuss strategies for optimizing time-sensitive task execution.
Flow Based Programming Applied to IoT Development
Explore Flow Based Programming for IoT, addressing dynamic environments and concurrent I/O. Learn how this approach simplifies development and scales to microcontrollers using Soletta Project.
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.
How State Machines Create Robust Software - Deep Dive
Explore XState for robust software development using state machines and actor models. Learn about state charts, AI integration, and practical applications while gaining insights into founding a tech startup.
Pub Crawling in Orleans: Exploring the Actor Model - NDC Porto 2023
Explore the Actor model with Orleans, Microsoft's implementation for creating distributed systems. Learn features and build a scalable pub crawl platform in this demo-heavy session.
Productive Parallel Programming with Dagger.jl - JuliaCon 2024 Workshop
Learn to write fast, parallel Julia code using Dagger.jl. Explore various programming interfaces, build example programs, and gain insights into parallelism through logging and profiling capabilities.
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.
Concurrent Mutation Must Go
Explore concurrent mutation challenges and solutions in programming languages, focusing on innovative approaches to enhance system reliability and performance.
CQS: A Formally-Verified Framework for Fair and Abortable Synchronization
Explore a formally-verified framework for fair and abortable synchronization, enabling efficient implementation of various primitives with modular proofs and improved performance.
Concurrent Immediate Reference Counting
Explore a novel approach to memory management in concurrent programming, combining SMR algorithms with reference counting for efficient and safe automatic memory reclamation in unmanaged languages.
A Proof Recipe for Linearizability in Relaxed Memory Separation Logic
Explore a novel proof recipe for linearizability in relaxed memory, using object modification order to simplify event reordering and enable proof reuse in concurrent libraries.
DisLog: A Separation Logic for Disentanglement
Explore DisLog, a novel separation logic for verifying disentanglement in parallel programs. Learn about its applications, benefits, and case studies in concurrent programming.
What Compilers Desire from Weak Memory Semantics
Explore compiler optimization challenges in concurrent programs, focusing on memory models and safety. Investigate deriving models that retain optimization safety across different consistency levels.
Programmers Love Mind-Bogglingly Complicated Weak Memory Models
Explore mind-boggling complexities of weak memory models in programming, delving into their intricacies and implications for software development.
Designing Wait-free Weak Reference Counting
Explore wait-free weak reference counting design techniques for efficient memory management in concurrent systems.
Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message Passing
Explore LinearActris, a novel logic ensuring deadlock and leak freedom in message-passing concurrency, combining session types and separation logic for higher-order program verification.