Multicore Application Programming For Windows, Linux, and Oracle Solaris

Subject : Multicore Application Programming For Windows,

Linux, and Oracle Solaris
Chapter 1 Hardware and Processes and Threads
1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)

Chapter 2 Coding for Performance

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
 12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)

Chapter 3 Identifying Opportunities for Parallelism

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)

Chapter 4 Synchronization and Data Sharing

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)

Chapter 5 Using POSIX Threads

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)

Chapter 6 Windows Threading

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
 68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)
86. Creating Native Windows Threads - Answer (click here)
87. Terminating Threads - Answer (click here)
88. Creating and Resuming Suspended Threads - Answer (click here)
89. Using Handles to Kernel Resources - Answer (click here)
90. Methods of Synchronization and Resource Sharing - Answer (click here)
91. An Example of Requiring Synchronization Between Threads - Answer
(click here)
92. Protecting Access to Code with Critical Sections - Answer (click here)
93. Protecting Regions of Code with Mutexes - Answer (click here)
94. Slim Reader/Writer Locks - Answer (click here)
95. Signaling Event Completion to Other Threads or Processes - Answer (click
here)
96. Wide String Handling in Windows - Answer (click here)
97. Creating Processes - Answer (click here)
98. Sharing Memory Between Processes - Answer (click here)
99. Inheriting Handles in Child Processes - Answer (click here)
100. Naming Mutexes and Sharing Them Between Processes - Answer (click
here)
101. Communicating with Pipes - Answer (click here)
102. Communicating Using Sockets - Answer (click here)
103. Atomic Updates of Variables - Answer (click here)
104. Allocating Thread-Local Storage - Answer (click here)
105. Setting Thread Priority - Answer (click here)
Chapter 7 Using Automatic Parallelization and OpenMP
1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
 69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)
86. Creating Native Windows Threads - Answer (click here)
87. Terminating Threads - Answer (click here)
88. Creating and Resuming Suspended Threads - Answer (click here)
89. Using Handles to Kernel Resources - Answer (click here)
90. Methods of Synchronization and Resource Sharing - Answer (click here)
91. An Example of Requiring Synchronization Between Threads - Answer
(click here)
92. Protecting Access to Code with Critical Sections - Answer (click here)
93. Protecting Regions of Code with Mutexes - Answer (click here)
94. Slim Reader/Writer Locks - Answer (click here)
95. Signaling Event Completion to Other Threads or Processes - Answer (click
here)
96. Wide String Handling in Windows - Answer (click here)
97. Creating Processes - Answer (click here)
98. Sharing Memory Between Processes - Answer (click here)
99. Inheriting Handles in Child Processes - Answer (click here)
100. Naming Mutexes and Sharing Them Between Processes - Answer (click
here)
101. Communicating with Pipes - Answer (click here)
102. Communicating Using Sockets - Answer (click here)
103. Atomic Updates of Variables - Answer (click here)
104. Allocating Thread-Local Storage - Answer (click here)
105. Setting Thread Priority - Answer (click here)
106. Using Automatic Parallelization and OpenMP - Answer (click here)
107. Using Automatic Parallelization to Produce a Parallel Application -
Answer (click here)
108. Identifying and Parallelizing Reductions - Answer (click here)
109. Automatic Parallelization of Codes Containing Calls - Answer (click here)
110. Assisting Compiler in Automatically Parallelizing Code - Answer (click
here)
111. Using OpenMP to Produce a Parallel Application - Answer (click here)
112. Using OpenMP to Parallelize Loops - Answer (click here)
113. Runtime Behavior of an OpenMP Application - Answer (click here)
114. Variable Scoping Inside OpenMP Parallel Regions - Answer (click here)
115. Parallelizing Reductions Using OpenMP - Answer (click here)
116. Accessing Private Data Outside the Parallel Region - Answer (click here)
117. Improving Work Distribution Using Scheduling - Answer (click here)
118. Using Parallel Sections to Perform Independent Work - Answer (click here)
119. Nested Parallelism - Answer (click here)
120. Using OpenMP for Dynamically Defined Parallel Tasks - Answer (click
here)
121. Keeping Data Private to Threads - Answer (click here)
122. Controlling the OpenMP Runtime Environment - Answer (click here)
123. Waiting for Work to Complete - Answer (click here)
124. Restricting the Threads That Execute a Region of Code - Answer (click
here)
125. Ensuring That Code in a Parallel Region Is Executed in Order - Answer
(click here)
126. Collapsing Loops to Improve Workload Balance - Answer (click here)
127. Enforcing Memory Consistency - Answer (click here)
128. An Example of Parallelization - Answer (click here)

Chapter 8 Hand Coded Synchronization and Sharing

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
 83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)
86. Creating Native Windows Threads - Answer (click here)
87. Terminating Threads - Answer (click here)
88. Creating and Resuming Suspended Threads - Answer (click here)
89. Using Handles to Kernel Resources - Answer (click here)
90. Methods of Synchronization and Resource Sharing - Answer (click here)
91. An Example of Requiring Synchronization Between Threads - Answer
(click here)
92. Protecting Access to Code with Critical Sections - Answer (click here)
93. Protecting Regions of Code with Mutexes - Answer (click here)
94. Slim Reader/Writer Locks - Answer (click here)
95. Signaling Event Completion to Other Threads or Processes - Answer (click
here)
96. Wide String Handling in Windows - Answer (click here)
97. Creating Processes - Answer (click here)
98. Sharing Memory Between Processes - Answer (click here)
99. Inheriting Handles in Child Processes - Answer (click here)
100. Naming Mutexes and Sharing Them Between Processes - Answer (click
here)
101. Communicating with Pipes - Answer (click here)
102. Communicating Using Sockets - Answer (click here)
103. Atomic Updates of Variables - Answer (click here)
104. Allocating Thread-Local Storage - Answer (click here)
105. Setting Thread Priority - Answer (click here)
106. Using Automatic Parallelization and OpenMP - Answer (click here)
107. Using Automatic Parallelization to Produce a Parallel Application -
Answer (click here)
108. Identifying and Parallelizing Reductions - Answer (click here)
109. Automatic Parallelization of Codes Containing Calls - Answer (click here)
110. Assisting Compiler in Automatically Parallelizing Code - Answer (click
here)
111. Using OpenMP to Produce a Parallel Application - Answer (click here)
112. Using OpenMP to Parallelize Loops - Answer (click here)
113. Runtime Behavior of an OpenMP Application - Answer (click here)
114. Variable Scoping Inside OpenMP Parallel Regions - Answer (click here)
115. Parallelizing Reductions Using OpenMP - Answer (click here)
116. Accessing Private Data Outside the Parallel Region - Answer (click here)
117. Improving Work Distribution Using Scheduling - Answer (click here)
118. Using Parallel Sections to Perform Independent Work - Answer (click here)
119. Nested Parallelism - Answer (click here)
120. Using OpenMP for Dynamically Defined Parallel Tasks - Answer (click
here)
121. Keeping Data Private to Threads - Answer (click here)
122. Controlling the OpenMP Runtime Environment - Answer (click here)
123. Waiting for Work to Complete - Answer (click here)
124. Restricting the Threads That Execute a Region of Code - Answer (click
here)
125. Ensuring That Code in a Parallel Region Is Executed in Order - Answer
(click here)
126. Collapsing Loops to Improve Workload Balance - Answer (click here)
127. Enforcing Memory Consistency - Answer (click here)
128. An Example of Parallelization - Answer (click here)
129. Hand-Coded Synchronization and Sharing - Answer (click here)
130. Atomic Operations - Answer (click here)
131. Using Compare and Swap Instructions to Form More Complex Atomic
Operations - Answer (click here)
132. Enforcing Memory Ordering to Ensure Correct Operation - Answer (click
here)
133. Compiler Support of Memory-Ordering Directives - Answer (click here)
134. Reordering of Operations by the Compiler - Answer (click here)
135. Volatile Variables - Answer (click here)
136. Operating System–Provided Atomics - Answer (click here)
137. Lockless Algorithms - Answer (click here)
138. Dekker’s Algorithm - Answer (click here)
139. Producer-Consumer with a Circular Buffer - Answer (click here)
140. Scaling to Multiple Consumers or Producers - Answer (click here)
141. Scaling the Producer-Consumer to Multiple Threads - Answer (click here)
142. Modifying the Producer-Consumer Code to Use Atomics - Answer (click
here)
143. The ABA Problem - Answer (click here)

Chapter 9 Scaling with Multicore Processors

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
 8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
 79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)
86. Creating Native Windows Threads - Answer (click here)
87. Terminating Threads - Answer (click here)
88. Creating and Resuming Suspended Threads - Answer (click here)
89. Using Handles to Kernel Resources - Answer (click here)
90. Methods of Synchronization and Resource Sharing - Answer (click here)
91. An Example of Requiring Synchronization Between Threads - Answer
(click here)
92. Protecting Access to Code with Critical Sections - Answer (click here)
93. Protecting Regions of Code with Mutexes - Answer (click here)
94. Slim Reader/Writer Locks - Answer (click here)
95. Signaling Event Completion to Other Threads or Processes - Answer (click
here)
96. Wide String Handling in Windows - Answer (click here)
97. Creating Processes - Answer (click here)
98. Sharing Memory Between Processes - Answer (click here)
99. Inheriting Handles in Child Processes - Answer (click here)
100. Naming Mutexes and Sharing Them Between Processes - Answer (click
here)
101. Communicating with Pipes - Answer (click here)
102. Communicating Using Sockets - Answer (click here)
103. Atomic Updates of Variables - Answer (click here)
104. Allocating Thread-Local Storage - Answer (click here)
105. Setting Thread Priority - Answer (click here)
106. Using Automatic Parallelization and OpenMP - Answer (click here)
107. Using Automatic Parallelization to Produce a Parallel Application -
Answer (click here)
108. Identifying and Parallelizing Reductions - Answer (click here)
109. Automatic Parallelization of Codes Containing Calls - Answer (click here)
110. Assisting Compiler in Automatically Parallelizing Code - Answer (click
here)
111. Using OpenMP to Produce a Parallel Application - Answer (click here)
112. Using OpenMP to Parallelize Loops - Answer (click here)
113. Runtime Behavior of an OpenMP Application - Answer (click here)
114. Variable Scoping Inside OpenMP Parallel Regions - Answer (click here)
115. Parallelizing Reductions Using OpenMP - Answer (click here)
116. Accessing Private Data Outside the Parallel Region - Answer (click here)
117. Improving Work Distribution Using Scheduling - Answer (click here)
118. Using Parallel Sections to Perform Independent Work - Answer (click here)
119. Nested Parallelism - Answer (click here)
120. Using OpenMP for Dynamically Defined Parallel Tasks - Answer (click
here)
121. Keeping Data Private to Threads - Answer (click here)
122. Controlling the OpenMP Runtime Environment - Answer (click here)
123. Waiting for Work to Complete - Answer (click here)
124. Restricting the Threads That Execute a Region of Code - Answer (click
here)
125. Ensuring That Code in a Parallel Region Is Executed in Order - Answer
(click here)
126. Collapsing Loops to Improve Workload Balance - Answer (click here)
127. Enforcing Memory Consistency - Answer (click here)
128. An Example of Parallelization - Answer (click here)
129. Hand-Coded Synchronization and Sharing - Answer (click here)
130. Atomic Operations - Answer (click here)
131. Using Compare and Swap Instructions to Form More Complex Atomic
Operations - Answer (click here)
132. Enforcing Memory Ordering to Ensure Correct Operation - Answer (click
here)
133. Compiler Support of Memory-Ordering Directives - Answer (click here)
134. Reordering of Operations by the Compiler - Answer (click here)
135. Volatile Variables - Answer (click here)
136. Operating System–Provided Atomics - Answer (click here)
137. Lockless Algorithms - Answer (click here)
138. Dekker’s Algorithm - Answer (click here)
139. Producer-Consumer with a Circular Buffer - Answer (click here)
140. Scaling to Multiple Consumers or Producers - Answer (click here)
141. Scaling the Producer-Consumer to Multiple Threads - Answer (click here)
142. Modifying the Producer-Consumer Code to Use Atomics - Answer (click
here)
143. The ABA Problem - Answer (click here)
144. Scaling with Multicore Processors - Answer (click here)
145. Constraints to Application Scaling - Answer (click here)
146. Hardware Constraints to Scaling - Answer (click here)
147. Bandwidth Sharing Between Cores - Answer (click here)
148. False Sharing - Answer (click here)
149. Cache Conflict and Capacity - Answer (click here)
150. Pipeline Resource Starvation - Answer (click here)
151. Operating System Constraints to Scaling - Answer (click here)
152. Multicore Processors and Scaling - Answer (click here)

Chapter 10 Other Parallelization Technologies

1. Hardware, Processes, and Threads - Answer (click here)
2. Examining the Insides of a Computer - Answer (click here)
3. The Motivation for Multicore Processors - Answer (click here)
4. Supporting Multiple Threads on a Single Chip - Answer (click here)
5. Increasing Instruction Issue Rate with Pipelined Processor Cores -
Answer (click here)
6. Using Caches to Hold Recently Used Data - Answer (click here)
7. Using Virtual Memory to Store Data - Answer (click here)
8. Translating from Virtual Addresses to Physical Addresses - Answer (click
here)
9. The Characteristics of Multiprocessor Systems - Answer (click here)
10. How Latency and Bandwidth Impact Performance - Answer (click here)
11. The Translation of Source Code to Assembly Language - Answer (click
here)
12. The Performance of 32-Bit versus 64-Bit Code - Answer (click here)
13. Ensuring the Correct Order of Memory Operations - Answer (click here)
14. The Differences Between Processes and Threads - Answer (click here)
15. Coding for Performance - Answer (click here)
16. Defining Performance - Answer (click here)
17. Understanding Algorithmic Complexity - Answer (click here)
18. Why Algorithmic Complexity Is Important - Answer (click here)
19. Using Algorithmic Complexity with Care - Answer (click here)
20. How Structure Impacts Performance - Answer (click here)
21. Performance and Convenience Trade-Offs in Source Code and Build
Structures - Answer (click here)
22. Using Libraries to Structure Applications - Answer (click here)
23. The Impact of Data Structures on Performance - Answer (click here)
24. The Role of the Compiler - Answer (click here)
25. The Two Types of Compiler Optimization - Answer (click here)
26. Selecting Appropriate Compiler Options - Answer (click here)
27. How Cross-File Optimization Can Be Used to Improve Performance -
Answer (click here)
28. Using Profile Feedback - Answer (click here)
29. How Potential Pointer Aliasing Can Inhibit Compiler Optimizations -
Answer (click here)
30. Identifying Where Time Is Spent Using Profiling - Answer (click here)
31. Commonly Available Profiling Tools - Answer (click here)
32. How Not to Optimize - Answer (click here)
33. Performance by Design - Answer (click here)
34. Identifying Opportunities for Parallelism - Answer (click here)
35. Using Multiple Processes to Improve System Productivity - Answer (click
here)
36. Multiple Users Utilizing a Single System - Answer (click here)
37. Improving Machine Efficiency Through Consolidation - Answer (click here)
38. Using Containers to Isolate Applications Sharing a Single System -
Answer (click here)
39. Hosting Multiple Operating Systems Using Hypervisors - Answer (click
here)
40. Using Parallelism to Improve the Performance of a Single Task - Answer
(click here)
41. One Approach to Visualizing Parallel Applications - Answer (click here)
42. How Parallelism Can Change the Choice of Algorithms - Answer (click
here)
43. Amdahl’s Law - Answer (click here)
44. Determining the Maximum Practical Threads - Answer (click here)
45. How Synchronization Costs Reduce Scaling - Answer (click here)
46. Parallelization Patterns - Answer (click here)
47. Data Parallelism Using SIMD Instructions - Answer (click here)
48. Parallelization Using Processes or Threads - Answer (click here)
49. Multiple Independent Tasks - Answer (click here)
50. Multiple Loosely Coupled Tasks - Answer (click here)
51. Multiple Copies of the Same Task - Answer (click here)
52. Single Task Split Over Multiple Threads - Answer (click here)
53. Using a Pipeline of Tasks to Work on a Single Item - Answer (click here)
54. Division of Work into a Client and a Server - Answer (click here)
55. Splitting Responsibility into a Producer and a Consumer - Answer (click
here)
56. Combining Parallelization Strategies - Answer (click here)
57. How Dependencies Influence the Ability Run Code in Parallel - Answer
(click here)
58. Antidependencies and Output Dependencies - Answer (click here)
59. Using Speculation to Break Dependencies - Answer (click here)
60. Critical Paths - Answer (click here)
61. Identifying Parallelization Opportunities - Answer (click here)
62. Synchronization and Data Sharing - Answer (click here)
63. Data Races - Answer (click here)
64. Using Tools to Detect Data Races - Answer (click here)
65. Avoiding Data Races - Answer (click here)
 66. Synchronization Primitives - Answer (click here)
67. Mutexes and Critical Regions - Answer (click here)
68. Spin Locks - Answer (click here)
69. Semaphores - Answer (click here)
70. Readers-Writer Locks - Answer (click here)
71. Barriers - Answer (click here)
72. Atomic Operations and Lock-Free Code - Answer (click here)
73. Deadlocks and Livelocks - Answer (click here)
74. Communication Between Threads and Processes - Answer (click here)
75. Storing Thread-Private Data - Answer (click here)
76. Using POSIX Threads - Answer (click here)
77. Creating Threads - Answer (click here)
78. Compiling Multithreaded Code - Answer (click here)
79. Process Termination - Answer (click here)
80. Sharing Data Between Threads - Answer (click here)
81. Variables and Memory - Answer (click here)
82. Multiprocess Programming - Answer (click here)
83. Sockets - Answer (click here)
84. Reentrant Code and Compiler Flags - Answer (click here)
85. Windows Threading - Answer (click here)
86. Creating Native Windows Threads - Answer (click here)
87. Terminating Threads - Answer (click here)
88. Creating and Resuming Suspended Threads - Answer (click here)
89. Using Handles to Kernel Resources - Answer (click here)
90. Methods of Synchronization and Resource Sharing - Answer (click here)
91. An Example of Requiring Synchronization Between Threads - Answer
(click here)
92. Protecting Access to Code with Critical Sections - Answer (click here)
93. Protecting Regions of Code with Mutexes - Answer (click here)
94. Slim Reader/Writer Locks - Answer (click here)
95. Signaling Event Completion to Other Threads or Processes - Answer (click
here)
96. Wide String Handling in Windows - Answer (click here)
97. Creating Processes - Answer (click here)
98. Sharing Memory Between Processes - Answer (click here)
99. Inheriting Handles in Child Processes - Answer (click here)
100. Naming Mutexes and Sharing Them Between Processes - Answer (click
here)
101. Communicating with Pipes - Answer (click here)
102. Communicating Using Sockets - Answer (click here)
103. Atomic Updates of Variables - Answer (click here)
104. Allocating Thread-Local Storage - Answer (click here)
105. Setting Thread Priority - Answer (click here)
106. Using Automatic Parallelization and OpenMP - Answer (click here)
107. Using Automatic Parallelization to Produce a Parallel Application -
Answer (click here)
108. Identifying and Parallelizing Reductions - Answer (click here)
109. Automatic Parallelization of Codes Containing Calls - Answer (click here)
110. Assisting Compiler in Automatically Parallelizing Code - Answer (click
here)
111. Using OpenMP to Produce a Parallel Application - Answer (click here)
112. Using OpenMP to Parallelize Loops - Answer (click here)
113. Runtime Behavior of an OpenMP Application - Answer (click here)
114. Variable Scoping Inside OpenMP Parallel Regions - Answer (click here)
115. Parallelizing Reductions Using OpenMP - Answer (click here)
116. Accessing Private Data Outside the Parallel Region - Answer (click here)
117. Improving Work Distribution Using Scheduling - Answer (click here)
118. Using Parallel Sections to Perform Independent Work - Answer (click here)
119. Nested Parallelism - Answer (click here)
120. Using OpenMP for Dynamically Defined Parallel Tasks - Answer (click
here)
121. Keeping Data Private to Threads - Answer (click here)
122. Controlling the OpenMP Runtime Environment - Answer (click here)
123. Waiting for Work to Complete - Answer (click here)
124. Restricting the Threads That Execute a Region of Code - Answer (click
here)
125. Ensuring That Code in a Parallel Region Is Executed in Order - Answer
(click here)
126. Collapsing Loops to Improve Workload Balance - Answer (click here)
127. Enforcing Memory Consistency - Answer (click here)
128. An Example of Parallelization - Answer (click here)
129. Hand-Coded Synchronization and Sharing - Answer (click here)
130. Atomic Operations - Answer (click here)
131. Using Compare and Swap Instructions to Form More Complex Atomic
Operations - Answer (click here)
132. Enforcing Memory Ordering to Ensure Correct Operation - Answer (click
here)
133. Compiler Support of Memory-Ordering Directives - Answer (click here)
134. Reordering of Operations by the Compiler - Answer (click here)
135. Volatile Variables - Answer (click here)
136. Operating System–Provided Atomics - Answer (click here)
137. Lockless Algorithms - Answer (click here)
138. Dekker’s Algorithm - Answer (click here)
139. Producer-Consumer with a Circular Buffer - Answer (click here)
140. Scaling to Multiple Consumers or Producers - Answer (click here)
141. Scaling the Producer-Consumer to Multiple Threads - Answer (click here)
142. Modifying the Producer-Consumer Code to Use Atomics - Answer (click
here)
143. The ABA Problem - Answer (click here)
144. Scaling with Multicore Processors - Answer (click here)
145. Constraints to Application Scaling - Answer (click here)
146. Hardware Constraints to Scaling - Answer (click here)
147. Bandwidth Sharing Between Cores - Answer (click here)
148. False Sharing - Answer (click here)
149. Cache Conflict and Capacity - Answer (click here)
150. Pipeline Resource Starvation - Answer (click here)
151. Operating System Constraints to Scaling - Answer (click here)
152. Multicore Processors and Scaling - Answer (click here)
153. Other Parallelization Technologies - Answer (click here)
154. GPU-Based Computing - Answer (click here)
155. Language Extensions - Answer (click here)
156. Alternative Languages - Answer (click here)
157. Clustering Technologies - Answer (click here)
158. Transactional Memory - Answer (click here)
159. Vectorization - Answer (click here)