Futures: Parallel Computing

Futures

• A future serves as a placeholder object representing a result that may be computed in parallel
• One can envision ordering food; your order number acts as future, allowing other activities while awaiting fulfillment.
• You can perform tasks while waiting for computation results, and then check if they are ready.
• A blocking call waits for the result if it is not immediately available.
• Submit a task to an executor, which returns a future.
• Check if the result is ready by a non-blocking call, to see if the computation is complete.
• Retrieve results using a blocking call that waits until ready.
• Futures enable asynchronous programming, improving responsiveness and utilizing parallelism.
• Challenges include complexity in managing tasks/results, error handling during computation, and overhead for short tasks.

Parallelism vs. Concurrency

• Concurrency manages multiple tasks seemingly simultaneously, focusing on shared resource access.
• Parallelism executes multiple tasks at the same time to speed up computations, requires multiple cores/machines.
• Concurrency focuses on managing access to shared resources
• Implementation of concurrence achieved using threads, locks, and concurrent data structures.
• Parallelism focuses on speeding up computation.
• Implementation of parallelism requires multiple processing cores or machines.
• Concurrency analogy: a chef juggling orders; parallelism analogy: multiple chefs working together.
• A single-core processor gives only the illusion of parallelism, but manages multiple threads concurrently.

"Mental Picture" of Shared Objects

• Shared objects are accessed and modified concurrently by multiple threads.
• Examples include variables, data structures, files, and network connections
• Shared objects: a central data store accessible to all threads.
• Concurrent access can lead to race conditions and data corruption.
• Crucial to use synchronization mechanisms to protect shared objects.
• Locks provide exclusive access.
• Atomic variables provide atomic operations.
• Concurrent data structures ensure thread safety.

Amdahl's Law

• Theoretical speedup in task execution latency based on resource improvement.
• The formula illustrates how the sequential portion of code limits speedup from parallelization
• $Speedup = \frac{1}{(1 - P) + \frac{P}{N}}$
  • $P$ is the proportion of the code that can be parallelized.
  • $N$ is the number of processors.
• Speedup is limited by the sequential code portion, even with infinite processors.
• It's important to optimize sequential bottlenecks.
• Example: if 85% of code is parallelizable, max speedup is 6.66.
• Graphs show that speedup plateaus with increased processors due to sequential limits.
• Optimize sequential bottlenecks, estimate potential speedup.