Index

A

• ActionBlock object
  • using / ActionBlock
• Active column, Threads window / Using the Threads window
• Affinity Mask column, Threads window / Using the Threads window
• Amdahl's law
  • about / Amdahl's law
• APPDomain column, Tasks window / Using the Tasks window
• application
  • about / OS scheduler operations
  • creating, with threads / Creating an application with threads, How to do it, How it works
  • debugging / Debugging an entire application, How to do it, How it works
  • designing, with Pipeline design pattern / Pipeline design pattern, How to do it, How it works
  • designing, with producer-consumer design pattern / Producer-consumer design pattern, How to do it, How it works
• Arithmetic and Logic Unit (ALU)
  • about / Doing a tiny bit of each task
• asymmetrical multiprocessing (AMP or ASMP) / Multiprocessor systems – many warriors to win a battle
• AsyncCallback delegate method
  • using / Using an AsyncCallback delegate method, How to do it, How it works
• asynchronous execution / How does it work without blocking the UI?
• Asynchronous Programming Model (APM)
  • implementing / Introduction to the Asynchronous Programming Model, How to do it, How it works
• async keyword
  • demonstrating / The async and await keywords, How to do it, How it works
• AsyncState column, Tasks window / Using the Tasks window
• AutoResetEvent class
  • used, for handling signals between threads / Using the AutoResetEvent class to handle signals between threads
• await keyword
  • demonstrating / The async and await keywords, How to do it, How it works

B

• BackgroundWorker component
  • overview / Getting started with the BackgroundWorker component
  • about / Showing progress
• BackgroundWorker thread
  • cancelling / Canceling a BackgroundWorker thread, How to do it, How does it work?
• BufferBlock object
  • using / BufferBlock

C

• callbacks / Showing progress
• cancellation tokens / Canceling a task
• Category column, Threads window / Using the Threads window
• color compositions, pixel
  • about / Understanding the pixels' color compositions
• components, Color (System.Drawing.Color) instance
  • hue / Understanding the pixels' color compositions
  • saturation / Understanding the pixels' color compositions
  • brightness / Understanding the pixels' color compositions
• concurrency
  • designing for / Designing for concurrency
• concurrent collections
  • about / Concurrent collections, How to do it, How it works
• concurrent UI feedback / Have a go hero – concurrent UI feedback
• cooperative cancellation
  • about / How to do it
• coordination costs
  • factors / Estimating performance improvements
• core
  • about / Mono-processor systems – the old gladiators
• CPU-Z
  • about / Examining our hardware
  • URL / Examining our hardware
• critical operations
  • about / Single core – only one warrior to fight against everybody

D

• data
  • sharing, between threads / Sharing data between threads, How to do it, How it works
• data parallelism, on collections
  • with Parallel.ForEach command / Data parallelism on collections using Parallel.ForEach, How to do it, How it works
• delegate
  • about / Delegates and lambda expressions

E

• encryption program / Let's get started with an encryption program
• error handling
  • threads, using / Error handling with threads, How to do it, How it works
• event wait handles / Using the AutoResetEvent class to handle signals between threads
• example
  • without BackgroundWorker object / Simple example without a BackgroundWorker object, How to do it, How does it work?
• examples
  • exploring / Exploring other examples
• exceptions
  • handling, in parallel loops / Handling exceptions in parallel loops, How to do it, How it works
• Exclusive OR (XOR) operations / How it works
• execution cores
  • about / Taking advantage of multiple execution cores

F

• faulted task
  • about / Task exception handling
• Filter Image function / Designing for concurrency
• Find All References function / Using the Parallel Stacks window
• Flag column, Threads window / Using the Threads window
• Flags column, Tasks window / Using the Tasks window
• Floating Point Unit (FPU)
  • about / Doing a tiny bit of each task
• ForEach overloads
  • ForEach<TSource, TLocal>* TSource datatype / Using thread-local variables in parallel loops
  • IEnumerable<TSource> collection / Using thread-local variables in parallel loops
  • Func<TLocal> function / Using thread-local variables in parallel loops
  • Func<TSource, ParallelLoopState, TLocal, TLocal> function / Using thread-local variables in parallel loops
  • Action<TLocal> function / Using thread-local variables in parallel loops
• Front Side Bus (FSB)
  • about / Taking advantage of multiple execution cores

G

• GetBrightness() method / Understanding the pixels' color compositions
• GetHue() method / Understanding the pixels' color compositions
• GetSaturation() method / Understanding the pixels' color compositions
• Gustafson's law
  • about / Gustafson's law

H

• hardware
  • examining / Examining our hardware
• hardware thread
  • about / Multiple core processors and hyperthreading
• hardware threads
  • about / Examining our hardware
• heavyweight concurrency / How it works
• hyperthreading
  • about / Multiple core processors and hyperthreading

I

• Icons column, Tasks window / Using the Tasks window
• ID column, Tasks window / Using the Tasks window
• ID column, Threads window / Using the Threads window
• image processing application
  • used, for pipelining / Explaining pipelining using an image processing application, How to do it, How it works
• input-processing-output (IPO)
  • about / Mono-processor systems – the old gladiators
• inter-processor bus
  • about / Estimating performance improvements
• IsAlive method / Pausing and restarting threads
• IsBusy() function / Exploring other examples

L

• lambda expressions / Delegates and lambda expressions
• Load Image function / Designing for concurrency
• Location column, Tasks window / Using the Tasks window
• Location column, Threads window / Using the Threads window

M

• machine cycle
  • about / OS scheduler operations
• Managed ID column, Threads window / Using the Threads window
• managed thread
  • about / Using the Threads window
• merging, in PLINQ / Merging in PLINQ, How to do it, How it works
• message blocks
  • examining / Explaining message blocks
• mono-processor systems
  • about / Mono-processor systems – the old gladiators
  • single processing core / Single core – only one warrior to fight against everybody
• multicore
  • about / Taking advantage of multiple execution cores
• multiple BackgroundWorker components
  • working with / Working with multiple BackgroundWorker components, How does it work?, How does it work?
• multiple core processors
  • about / Multiple core processors and hyperthreading
• multiple execution cores
  • advantage, taking of / Taking advantage of multiple execution cores
• multiple processors
  • analyzing, factors / Estimating performance improvements
• multiple tasks completion
  • waiting for / Waiting for multiple tasks to complete, How to do it, How it works
• multiplexing
  • about / Single core – only one warrior to fight against everybody, Doing a tiny bit of each task
• multiprocessor systems
  • about / Multiprocessor systems – many warriors to win a battle
• multithreaded applications
  • considerations, for debugging / Considerations for debugging multithreaded applications
• multiuser systems
  • about / Doing a tiny bit of each task

N

• n-way symmetrical multiprocessing
  • about / Multiprocessor systems – many warriors to win a battle
• Name column, Threads window / Using the Threads window
• NASA’s Spitzer Space Telescope
  • URL / How to do it

O

• ordering, in PLINQ / Ordering in PLINQ, How to do it, How it works
• OS scheduler operations / OS scheduler operations
• overclocking
  • about / Taking advantage of multiple execution cores

P

• Parallel.ForEach command
  • used, for data parallelism on collections / Data parallelism on collections using Parallel.ForEach, How to do it, How it works
• Parallel.ForEach method / Introducing the Parallel class
• parallel class
  • about / Introducing the Parallel class, How to do it, How it works
• Parallel LINQ (PLINQ)
  • about / Task Parallel Library
• parallel loops
  • processing / Parallel loop processing, How to do it, How it works
  • canceling / Canceling a parallel loop, How to do it
  • exceptions, handling in / Handling exceptions in parallel loops, How to do it, How it works
  • thread-local variables, using in / Using thread-local variables in parallel loops, How to do it, How it works
• parallel pipeline design
  • diagrammatic representation / Designing for concurrency
• Parallel Stacks window
  • using / Using the Parallel Stacks window
• Parallel Watch window
  • using / Using the Parallel Watch window
• parameters
  • passing, to threads / Passing parameters to threads, How to do it, How it works
• Parent column, Tasks window / Using the Tasks window
• performance improvements
  • estimating / Estimating performance improvements
• performance improvements, PLINQ / Understanding performance improvements in PLINQ
• performance increment
  • factors / Estimating performance improvements
• physical CPUs, logical cores
  • about / Multiple core processors and hyperthreading
• Pipeline design pattern
  • application, designing with / Pipeline design pattern, How to do it, How it works
• pipelining
  • about / Pipelining
  • image processing application, using / Explaining pipelining using an image processing application, How to do it, How it works
  • pixels’color compositions / Understanding the pixels' color compositions
• PLINQ
  • executing / Executing a PLINQ, How to do it, How it works
  • ordering concept / Ordering in PLINQ, How to do it, How it works
  • merging concept / Merging in PLINQ, How to do it, How it works
  • canceling / Canceling a PLINQ, How to do it, How it works
  • performance, improving / Understanding performance improvements in PLINQ
• Priority column, Threads window / Using the Threads window
• procedures, for distributing tasks
  • symmetrical multiprocessing (SMP) / Multiprocessor systems – many warriors to win a battle
  • asymmetrical multiprocessing (AMP or ASMP) / Multiprocessor systems – many warriors to win a battle
• processes
  • about / OS scheduler operations
• Process Explorer
  • URL, for downloading / Exploring other examples
• processing cores
  • about / Taking advantage of multiple execution cores
• Process Name column, Threads window / Using the Threads window
• producer-consumer design pattern
  • application, designing with / Producer-consumer design pattern, How to do it, How it works
• producer-consumer model
  • about / Designing for concurrency
• progress
  • displaying / Showing progress, How to do it, How does it work?

R

• refactoring / How does it work?
• resources
  • locking, for ensuring thread-safe data / Locking resources to ensure thread-safe data, How to do it, How it works
• response time
  • approaches, for avoiding / Multiprocessor systems – many warriors to win a battle
• return values
  • tasks with / Tasks with return values, How to do it, How it works

S

• Scale Image function / Designing for concurrency
• scheduler
  • about / OS scheduler operations
• sequential operation
  • diagrammatic representation / Designing for concurrency
• service
  • about / OS scheduler operations
• signals, between threads
  • handling / Signals between threads, How to do it
  • working / How it works
  • handling, with AutoResetEvent class / Using the AutoResetEvent class to handle signals between threads
  • checking, with WaitHandle class / Using the WaitHandle class to check for signals
• single core
  • about / Single core – only one warrior to fight against everybody
• single instruction, single data (SISD)
  • about / Mono-processor systems – the old gladiators
• software application
  • about / OS scheduler operations
• software process
  • about / OS scheduler operations
• Status column, Tasks window
  • Active / Using the Tasks window
  • Deadlocked / Using the Tasks window
  • Waiting / Using the Tasks window
  • Scheduled / Using the Tasks window
  • Completed / Using the Tasks window
• Suspended Count column, Threads window / Using the Threads window
• symmetrical multiprocessing (SMP) / Multiprocessor systems – many warriors to win a battle
• synchronization mechanisms / How it works
• System.Collections.Concurrent / Concurrent collections

T

• task
  • canceling / Canceling a task, How to do it, How it works
• task completion
  • waiting for / Waiting for a task to complete, How to do it, How it works
• task exception handling
  • about / Task exception handling
• TaskFactory class
  • exploring / Exploring the TaskFactory class, How to do it, How it works
• Task Parallel Library (TPL) / How does it work?
• tasks
  • exploring / Exploring tasks, How to do it, How it works
  • with return values / Tasks with return values, How to do it, How it works
• task scheduler
  • about / Task schedulers
• Tasks window
  • using / Using the Tasks window
  • Flags column / Using the Tasks window
  • Icons column / Using the Tasks window
  • ID column / Using the Tasks window
  • Status column / Using the Tasks window
  • Location column / Using the Tasks window
  • Parent column / Using the Tasks window
  • Thread Assignment column / Using the Tasks window
  • APPDomain column / Using the Tasks window
  • AsyncState column / Using the Tasks window
• thread-local variables
  • using, in parallel loops / Using thread-local variables in parallel loops, How to do it, How it works
• Thread Assignment column, Tasks window / Using the Tasks window
• Thread class
  • threads, creating with / Creating threads with the Thread class, How to do it, How it works
• ThreadPool
  • URL / Task schedulers
• threads
  • about / OS scheduler operations
  • creating, with Thread class / Creating threads with the Thread class, How to do it, How it works
  • application, creating with / Creating an application with threads, How to do it, How it works
  • data, sharing between / Sharing data between threads, How to do it, How it works
  • parameters, passing to / How to do it, How it works
  • pausing / Pausing and restarting threads, How to do it, How it works
  • restarting / Pausing and restarting threads, How to do it, How it works
  • joining / Joining threads, How to do it
  • used, for error handling / Error handling with threads, How to do it, How it works
• thread safety types / How it works
• Threads window
  • using / Using the Threads window
  • Flag column / Using the Threads window
  • Active column / Using the Threads window
  • ID column / Using the Threads window
  • Managed ID column / Using the Threads window
  • Category column / Using the Threads window
  • Name column / Using the Threads window
  • Location column / Using the Threads window
  • Priority column / Using the Threads window
  • Affinity Mask column / Using the Threads window
  • Suspended Count column / Using the Threads window
  • Process Name column / Using the Threads window
• TPL
  • about / Task Parallel Library

V

• von Neumann's bottleneck
  • about / Doing a tiny bit of each task
• von Neumann machines
  • about / Mono-processor systems – the old gladiators

W

• W5 / Explaining pipelining using an image processing application
• WaitAll method / Using the WaitHandle class to check for signals
• WaitHandle class
  • used, for checking signals between threads / Using the WaitHandle class to check for signals
• Windows Presentation Foundation (WPF) / Getting started with the BackgroundWorker component, Explaining pipelining using an image processing application, Parallel loop processing, How to do it
• WPF example
  • with asynchronous BackgroundWorker / WPF example with an asynchronous BackgroundWorker, How to do it, How does it work without blocking the UI?, How does it work?
  • with synchronous BackgroundWorker / WPF example with a synchronous BackgroundWorker