Software Testing

Use Thread Pools Correctly: Keep Tasks Short and Nonblocking Use Thread Pools Correctly: Keep Tasks Short and Nonblocking- A thread pool hides a lot of details, but to use it effectively some awareness of some things a pool does under the c… Break Up and Interleave Work to Keep Threads Responsive Break Up and Interleave Work to Keep Threads Responsive- Breaking up is hard to do, but interleaving can be even subtler. Avoid Exposing Concurrency: Hide It Inside Synchronous Methods Avoid Exposing Concurrency: Hide It Inside Synchronous Methods- Explains where to start when trying to add concurrency to a mass of existing code. Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic Prefer Structured Lifetimes: Local, Nested, Bounded, Deterministic- What's good for the function and the object is also good for the thread, the task, and the lock. Practical Lock-Free Buffers Practical Lock-Free Buffers- Looks at how lock-free programming avoids system failure by tolerating individual process failures. Prefer Futures to Baked-In "Async APIs" Prefer Futures to Baked-In "Async APIs"- Explains that it's important to separate "what" from "how" when designing concurrent APIs. Use Threads Correctly = Isolation + Asynchronous Messages Use Threads Correctly = Isolation + Asynchronous Messages- Motivates and illustrate best practices for using threads - techniques that will make concurrent code easier to write co… It's Not Always Nice To Share It's Not Always Nice To Share- It isn't just languages that have poor support for thread local storage, but operating systems too Introduction to Priority Inversion Introduction to Priority Inversion- Gives an introduction to priority inversion and shows a pair of techniques to avoid them. Fundamental Concepts of Parallel Programming Fundamental Concepts of Parallel Programming- Explains fundamental concepts for moving from a linear to a parallel programming model Real-world Concurrency Real-world Concurrency- Describes some key principles that will help mastering the "black art" of writing multithreaded code. Lock-Free Code: A False Sense of Security Lock-Free Code: A False Sense of Security- Writing lock-free code can confound anyone-even expert programmers, as Herb shows in this article. Sharing Is the Root of All Contention Sharing Is the Root of All Contention- Sharing requires waiting and overhead, and is a natural enemy of scalability. This article focuses on one important case, namely mutable (wr… Multithreaded File I/O Multithreaded File I/O- So far multithreaded file I/O is a under-researched field. Although its simple to measure, there is not much common knowledge about it. The measurements pr… Measuring Parallel Performance: Optimizing a Concurrent Queue Measuring Parallel Performance: Optimizing a Concurrent Queue- Shows different ways of how to write a fast, internally synchronized queue, one that callers can use without any exp… Lock Options Lock Options- Presents a solution to races and deadlocks based on a well-known deadlock-avoidance protocol and shows how it can be enforced by the compiler. It can be applied to p… Understanding Parallel Performance Understanding Parallel Performance- Explains how to accurately analyze the real performance of parallel code and lists some basic considerations and common costs. What's New in Boost Threads? What's New in Boost Threads?- The Boost.Thread library, which enables the use of multiple threads of execution with shared data in portable C++ code, has undergone some major chan… Writing Lock-Free Code: A Corrected Queue Writing Lock-Free Code: A Corrected Queue- Explores lock-free code by focusing on creating a lock-free queue. The Many Faces of Deadlock The Many Faces of Deadlock- Explains that deadlock can happen whenever there is a blocking (or waiting) cycle among concurrent tasks. Maximize Locality, Minimize Contention Maximize Locality, Minimize Contention- Explains why in the concurrent world, locality is a first-order issue that trumps most other performance considerations. Now locality is no… volatile - Multithreaded Programmer's Best Friend volatile - Multithreaded Programmer's Best Friend- Discusses the usage of the volatile keyword in multithreaded C++ programs. Multi-threaded Debugging Techniques Multi-threaded Debugging Techniques- Describes a number of general purpose debugging techniques for multi-threaded applications. The Pillars of Concurrency The Pillars of Concurrency- This article makes the case that a consistent mental model is needed to talk about concurrency. Lock-free Interprocess Communication Lock-free Interprocess Communication- Interprocess communication is an essential component of modern software engineering. Often, lock-free IPC is accomplished via special process… Application-Level Abstractions for Lock-Free Data Sharing Application-Level Abstractions for Lock-Free Data Sharing- Describes lock-free data sharing, otherwise known as "wait-free data sharing" as an alternative to the use of locks. Use Lock Hierarchies to Avoid Deadlock Use Lock Hierarchies to Avoid Deadlock- Explains how to use lock hierarchies to avoid deadlock by assigning each shared resource a level that corresponds to its architectural laye… Apply Critical Sections Consistently Apply Critical Sections Consistently- Critical sections are the One True Tool for guaranteeing mutual exclusion on shared variables. Like most tools, these must be applied consist… Protothreads Protothreads- Very lightweight stackless threads; give linear code execution for event-driven systems, designed to use little memory; library is pure C, no platform-specific Assem… RT++ RT++- Higher order threads for C++; tutorial and reference manual.