On the Complexity of Buffer Allocation in Message

On the Complexity of Buffer Allocation in Message Passing Systems Alex Brodsky Joint work with Jan B. Pedersen & Alan Wagner University of British Columbia

Outline Motivation Definitions Buffer Allocation Problem Buffer Sufficiency Problem Nonblocking Buffer Allocation Problem Other Models and Related Problems Conclusion

Motivation

What is the Problem? send(p 2, . . . ) recv(p 2, . . . ) send(p 1, . . . ) recv(p 1, . . . ) Unless there is somewhere to put the message the senders will deadlock. So. .

What is the Problem? send(p 2, . . . ) recv(p 2, . . . ) Unless there is somewhere to put the message the senders will deadlock. So, buffers are used. send(p 1, . . . ) recv(p 1, . . . )

What is the Problem? send(p 2, . . . ) recv(p 2, . . . ) send(p 1, . . . ) recv(p 1, . . . )

Problem Statement Not all systems have unrestricted amounts of buffers. e. g. , clusters that offload message passing functionality to the network interface card (NIC). Hence, we must determine the number of buffers needed for a safe program execution. This is the Buffer Allocation Problem (BAP). Question: What is the complexity of BAP?

Assumptions

Assumptions Processes are asynchronous.

Assumptions Processes are asynchronous. The communication pattern is static. i. e. , doesn't change from execution to execution.

Assumptions Processes are asynchronous. The communication pattern is static. i. e. , doesn't change from execution to execution. Send/recv calls are explicitly matched. send(p 2, . . . ) recv(p 1, . . . )

Assumptions Processes are asynchronous. The communication pattern is static. i. e. , doesn't change from execution to execution. Send/recv calls are explicitly matched. Buffers are allocated on the receiver.

Assumptions Processes are asynchronous. The communication pattern is static. i. e. , doesn't change from execution to execution. Send/recv calls are explicitly matched. Buffers are allocated on the receiver. Sends block if no buffers are available & receiver is not ready.

Problem Input

Problem Input What is the invariant across executions of a program?

Problem Input What is the invariant across executions of a program? The static communication pattern

Problem Input What is the invariant across executions of a program? The static communication pattern. Use communication graphs to represent communication patterns. The communication graph becomes the problem input.

Communication Graph P 0 P 1 P 2 P 3 P 4 P 5 Process component Time Processes are denoted by vertical process arcs (up to down).

Communication Graph P 0 P 1 start Event send recv end Events (start, end, send, receive) are denoted by vertices.

Communication Graph P 0 P 1 nd se Communication arcs denote sends from one process to another.

Communication Graph P 0 P 1 P 2 P 3 P 4 Examples of communication graphs. P 5

Arrival != Receipt P 0 P 1 P 2 P 3 Arrival interval Receive event occurs when message is received.

Arrival != Receipt P 0 P 1 P 2 P 3 Arrival interval Messages can arrive before receive events.

Dependencies P 0 P 1 All events depend on start events.

Dependencies P 0 P 1 Receive events depend on send events.

Dependencies P 0 P 1 If there are NO buffers, send events depend on receive events.

Dependencies P 2 P 3 A send event depends on the preceding event.

Dependencies P 2 P 3 The arrival interval is defined by a receive event and its dependency within the same process.

Circular Dependency & Deadlock P 4 P 5 With no buffers, the send/receive events depend on each other.

Circular Dependency & Deadlock P 4 P 5 A circular dependency (with no buffers) represents deadlock.

The t-ring P 0 P 1 P 2 P 3 P 4 P 5 We call such a circular dependency a t-ring, e. g. , t=6.

Solving Deadlock P 0 0 P 1 1 P 2 0 P 3 2 P 4 0 To solve deadlock, we use buffers. P 5 0

Buffer Assignment P 0 0 P 1 1 P 2 0 P 3 2 P 4 0 Each process is assigned 0 or more buffers. P 5 0

Solving Deadlock P 0 0 P 1 1 Initially, neither process can complete a send.

Solving Deadlock P 0 0 P 1 1 Message from process 0 is buffered by process 1.

Solving Deadlock P 0 0 P 1 1 Process 0 can proceed to receive from process 1.

Solving Deadlock P 0 0 P 1 1 Finally, process 1 receives from process 0.

Solving Deadlock P 2 0 P 3 2 Initially, none of the sends can complete. P 4 0 P 5 0

Solving Deadlock P 2 0 P 3 2 P 4 0 P 5 0 Since message arrival is nondeterministic, 2 buffers are needed.

Solving Deadlock P 2 0 P 3 2 P 4 0 Process P 4 can complete its receives. P 5 0

Solving Deadlock P 2 0 P 3 2 P 4 0 Process P 3 can complete its receives. P 5 0

Safety A program is k-safe if k buffers are sufficient to guarantee deadlock free execution.

Buffer Allocation Problem (BAP) Informal Question: How many buffers does a program need to avoid deadlock? Formal Question: Given a communication graph, how many buffers are needed to avoid deadlock in the corresponding program? Decision Question (BAP): Given a communication graph and integer k, is the corresponding program k-safe?

Thm: BAP is NP-hard Proof by reduction from 3 SAT Decision Problem: Does the formula of the form ∧i (ai ∨ bi ∨ ci) have a satisfying assignment where each ai, bi, ci, is a either a variable xj or its negation, (n variables). Idea: For any 3 SAT formula we show to construct a corresponding communication graph to test n-safety (requires n buffers). 2 widgets: fix assignment and check clauses

The Construction x 0 ~x 0 x 1 ~x 1 x 2 ~x 2 x 3 ~x 3 For a formula over n variables create a graph with 2 n processes.

Fixing the assignment x 0 ~x 0 x 1 ~x 1 x 2 ~x 2 x 3 ~x 3 The 2 -rings are used to fix a variable assignment.

Fixing the assignment x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 0 ~x 3 1 A buffer assignment fixes the variables, e. g. , ~x 0, x 1, x 2, ~x 3. No more than n buffers may be selected, (testing for n-safety).

Use a 3 -ring for each Clause x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 0 ~x 3 1 (x 0+x 1+x 3) (x 0+~x 2+x 3) Each clause is represented by a 3 -ring. Which will not deadlock only if one of the processes has a buffer.

Unsatisfied Clauses and 3 -rings x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 0 ~x 3 1 (x 0+x 1+x 3) (x 0+~x 2+x 3) This first 3 -ring does not deadlock. The 3 -ring corresponds to a satisfied clause.

Unsatisfied Clauses and 3 -rings x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 0 ~x 3 1 (x 0+x 1+x 3) (x 0+~x 2+x 3) For this buffer assignment the second 3 -ring will deadlock. The program is n-safe if none of the 3 -rings deadlock.

A Better Buffer Assignment x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 1 ~x 3 0 (x 0+x 1+x 3) (x 0+~x 2+x 3) Buffer assignments of size n that prevent deadlock correspond to satisfying assignments for the formula.

Thus, BAP is NP-Hard! x 0 0 ~x 0 1 x 1 1 ~x 1 0 x 2 1 ~x 2 0 x 3 1 ~x 3 0 (x 0+x 1+x 3) (x 0+~x 2+x 3)

Buffer Sufficiency Problem (BSP) How about something easier? To solve BAP we need to verify that a buffer assignment is safe, this is also HARD! Decision Problem: Given a communication graph and a buffer assignment, does the buffer assignment yield a safe execution?

Thm: BSP is co. NP-complete Proof by reduction from Tautology Given a DNF formula, is it true for all assignments? Construct a communication graph that corresponds to a given formula. Play a colouring game on the graph which simulates the execution of a program. There exists a simulation that deadlocks iff the formula is not a tautology.

Buffer Stealing P 2 1 P 3 0 P 4 0 P 2 is blocked on a receive Which process blocks, P 3 or P 4 ? Either execution is possible.

Buffer Stealing P 2 1 P 3 0 P 4 0 P 2 is blocked on a receive The process whose message arrives first steals the buffer.

Fixing an Assignment P 2 1 xi 0 ~xi 0 A buffer stealing widget used to fix an assignment.

Fixing an Assignment P 2 1 xi 0 ~xi 0 Fixing an assignment corresponds to an execution.

Terms of a DNF T 0 1 T 1 1 T 2 1 T 3 1 T 4 1 When does this system deadlock? T 5 1

Terms of a DNF T 0 1 T 1 1 T 2 1 T 3 1 T 4 1 Message arrival corresponds to a term being false. T 5 1

Terms of a DNF T 0 1 T 1 1 T 2 1 T 3 1 T 4 1 T 5 1 If message arrival steals all buffers, the t-ring will deadlock.

Sketch of proof A buffer stealing widget forces an execution which corresponds to a variable assignment. The simulation deadlocks on the sum widget only if the formula is false on the assignment. Also uses the buffer stealing mechanism. Hence, a simulation can deadlock iff the corresponding formula is not a tautology.

How does this help us? While these results are interesting, they don't help us solve our problem! How to determine the number of buffers our program needs.

How does this help us? While these results are interesting, they don't help us solve our problem! How to determine the number of buffers our program needs. Suppose, we added an additional restriction: the program should not block (or deadlock) due to lack of buffers!

How does this help us? While these results are interesting, they don't help us solve our problem! How to determine the number of buffers our program needs. Suppose, we added an additional restriction: the program should not block (or deadlock) due to lack of buffers! Amazingly, this makes our problem tractable!

The Nonblocking Buffer Allocation Problem (NBAP) Informal Question: How many buffers does a program need to execute without blocking on a send? Decision Question: Given a communication graph and an integer k, are all executions of the corresponding program send block free? Upper bound: # of receives in each process.

When is a buffer needed? P 0 P 1 P 2 P 3 P 4 Arrival interval A buffer is needed only during the arrival interval. P 5

How Long is the Interval? P 0 P 1 P 2 P 3 P 4 P 5 Arrival interval The interval extends to preceding dependency in the same process.

Each interval requires a buffer P 0 P 1 P 2 P 3 2 buffers, no overlap P 4 P 5

Each interval requires a buffer P 0 P 1 P 2 P 3 3 buffers, 1 overlap P 4 P 5

Each interval requires a buffer P 0 P 1 P 2 P 3 P 4 P 5 5 buffers, 3 overlaps of size 2, 1 overlap of size 3

The Algorithm P 0 0 P 1 0 P 2 3 P 3 2 P 4 0 Compute the maximum per process overlap. P 5 0

The Algorithm 5 = P 0 0 + P 1 0 + P 2 3 + P 3 2 + Sum the per process buffers. P 4 0 + P 5 0

Implementation First: detect dependencies to minimize arrival intervals. Arrival interval Use depth first search and dynamic programming.

Implementation First: detect dependencies to minimize arrival intervals. Second: Compute max overlap for each process. Sort arrival intervals of each process. Find maximum overlap. 1 Arrival interval Use depth first search and dynamic programming. 0

Other Models We considered a model where the buffer is allocated on the receive side.

Other Models We considered a model where the buffer is allocated on the receive side. Other models include: Send side buffers

Other Models We considered a model where the buffer is allocated on the receive side. Other models include: Send side buffers Send / recv side buffers

Results We considered a model where the buffer is allocated on the receive side. Other models include: Send side buffers Send / recv side buffers For these we have the following results: Problem BAP BSP NBAP Recv Side NP-hard Co. NP-C P Send Side NP-hard P Send/Recv NP-hard Co. NP-C

Results We considered a model where the buffer is allocated on the receive side. Other models include: Send side buffers Send / recv side buffers For these we have the following results: Problem BAP BSP NBAP Recv Side NP-hard Co. NP-C P Send Side NP-hard P P Send/Recv NP-hard Co. NP-C NP-hard

Conclusions Solving the buffer allocation problem for programs with static communication patterns and simple communication primitives is NPhard. Even verifying a solution to the buffer allocation problem is hard (co. NP-complete). Fortunately, if programs are required to be block free, as well as deadlock free, then the problem becomes tractable!

Thank you

Solving Deadlock P 0 0 P 1 1 Message from process 0 is buffered by process 1.

Solving Deadlock P 0 0 P 1 1 P 2 0 P 3 2 P 4 0 P 5 0 Finally, process 1 receives buffered message from process 0.

Solving Deadlock P 0 0 P 1 1 P 2 0 P 3 2 P 4 0 Process 0 can then receive from process 1. P 5 0

The Algorithm P 0 0 P 1 0 P 2 3 P 3 2 P 4 0 Compute the maximum per process overlap. P 5 0

The Algorithm 5 = P 0 0 + P 1 0 + P 2 3 + P 3 2 + P 4 0 Sum the per process buffers. + P 5 0

Implementation First: detect dependencies To minimize arrival intervals Arrival interval