Lecture 5: Search Algorithms for Discrete Optimization Problems

Transcription

1 Lecture 5: Search Algorithms for Discrete Optimization Problems

2 Definitions Discrete optimization problem (DOP): tuple (S, f), S finite set of feasible solutions, f : S R, cost function. Objective: find x opt => f(x opt ) f(x) for all x in S Examples of DOP: Scheduling Optimal layout of VLSI chips Robot motion planning Test-pattern generation for digital circuits DOP are NP-hard problems Need heuristic algorithms => suboptimal solutions

3 Example: 0/1 Integer-linear Programming A mxn, b mx1, c nx1 Objective: min f(x) = min c T x where x is a vector with elements in {0,1} subject to: Ax b S is the set of vectors x satisfying Ax b

4 Example: The 8-puzzle problem S: set of all sequences of moves from the initial to the final configuration Objective: find the shortest sequence of moves from the initial to the final configuration

5 Example: 0/1 Integer-linear Programming 5x 1 + 2x 2 + x 3 + 2x 4 8 x 1 - x 2 -x 3 + 2x 4 2 3x 1 + x 2 + x 3 + 3x 4 5 f(x) = 2x 1 + x 2 -x 3-2x 4 State space graph => Check: \sum {xj free} max{a[i,j], 0} + \sum {xj fixed} A[i,j]x j b i for i = 1,..,m Solution x = (1, 0, 1, 1)

6 Admissible Heuristic Heuristic estimate: the estimate of the cost to reach the goal state from an intermediate state h(x) heuristic estimate of reaching the goal state from x g(x) cost of reaching state x from s h is admissible if h(x) is a lower bound on the cost of reaching the goal state from x, for all x If h(x) admissible => l(x) = g(x) + h(x) is the lower bound on the cost of reaching the goal state from the initial state. Example: Manhattan distance is an admissible heuristic for the 8-puzzle M(i,j) = i - k + j l The sum of the M distances between the initial and final positions of all tiles is an estimate of the number of moves to reach the final positions.

7 Unfolding a State Graph into a Tree

8 Depth-First Search Algorithms solve DOP formulated as trees in each step expand the most recently generated node. If no successor node then backtrack. Simple backtracking: DFS that terminates after finding the first solution. DFS Branch-and-Bound: exhaustively searches the state space for optimal solutions it discards the inferior partial solutions

9 Depth-First Search: The 8-puzzle Successors are ordered as: up, down, left, and right.

10 Depth-First Search Algorithms Iterative Deepening DFS (ID-DFS): a bound is imposed on the depth to which DF searches if the node to be expanded is beyond the depth bound, the node is not expanded and the algorithm backtracks if solution is not found => search again with a larger depth bound Iterative Deepening A* (IDA*): uses l-values of the nodes to bound the depth => performs cost-bounded searches finds the optimal solution if the heuristic function is admissible

11 Representing a DFS Tree Search tree is represented as a stack. The storage cost is O(md) where m is storage for one state and d is the max. depth. Two variants: Untried alternatives only Untried alternatives along with their parent (useful for checking duplicate states)

12 Best-First Search Algorithms solve DOP formulated as both trees and graphs use heuristics to direct the search to portions of the search space likely to produce a solution maintains two lists: open and closed at each step the most promising node from the open list is expanded successors of the newly open node are placed in the open list if: 1) the successor is not in one of the lists 2) the successor is already in one of the lists but has a lower heuristic value. A* algorithm: uses l as a heuristic evaluation function A* finds an optimal solution if l is admissible

13 Best-First Search: the 8-puzzle

14 Best-First Search: the 8-puzzle

15 Search Overhead Factor Sources of overhead in parallel search: Communication overhead Idle time due to load imbalances Contention for shared data structures The amount of work done by the parallel algorithm (W p ) if often different from the that done by the sequential algorithm (W) Search overhead factor = W p /W Upper bound on the speedup: p (W/W p ) Superlinear speedup is possible!

16 Parallel Depth-First Search How to distribute the search space among the processors? Static distribution => load imbalance Solution?

17 Parallel Depth-First Search Dynamic load balancing: when a processor runs out of work it gets more work from another processor that has work. Parallel DFS with dynamic load balancing: Each processor performs DFS on a disjoint part of the search space. When a processor finishes searching its part, it requests an unsearched part from other processors. When goal state is found => terminate (broadcast a message to all processes to terminate). If no solution => processors run out of work and terminate (needs a termination detection algorithm) At the beginning only one processor contains the whole state space. The space is distributed as the processors requests work. Donor and recipient processors. Problems: How to split the work? => work splitting strategies How to determine the donor? => load-balancing schemes

18 Parallel Depth-First Search

19 Work-Splitting Strategies Donor s stack is split into two stacks and one stack is sent to the recipient. If two little work is sent => recipient quickly becomes idle If two much work is sent => donor quickly becomes idle Ideal: split the stack into equal parts => half-split Nodes at the bottom of the stack => roots of bigger subtrees Nodes at the top of the stack => roots of smaller subtrees Nodes beyond a cutoff depth are not sent => Avoids sending to little work Strategies: 1. Send nodes near the bottom of the stack 2. Send nodes near the cutoff depth 3. Send half the nodes between the bottom of the stack and the cutoff depth. 1. and 3. work well for uniform strategy spaces 3. works well for irregular strategy spaces

20 Work-Splitting Strategies Splitting using strategy 3

21 Load-Balancing Schemes Asynchronous Round Robin (ARR): Donor is specified by target variable. When a processor runs out of work it attempts to get work from the processor whose label is target. target = target + 1, each time a request is made. Initially: target = ((label+1) mod p) Global Round Robin (GRR): target is a global variable (stored at P 0 ) Drawback: contention for access target. Random Polling (RP): When a processor becomes idle it randomly selects a donor.

22 Analysis of Parallel DFS Compute the overhead T o Overhead in load balancing: communication (sending and requesting work) idle time (waiting for work) termination detection contention for shared resources Analysis assumes that search overhead factor W p /W = 1 Communication time subsumes the idle time. Communication overhead is dominant.

23 Analysis of Parallel DFS Assumptions: the work at any processor can be partitioned into independent pieces if size > ε a reasonable work-splitting mechanism exist => α-splitting mechanism Work w can be partitioned into ψw and (1- ψ)w, 0 <= ψ <= 1 There exists α (0 < α <= 0.5) such that ψw > αw and (1- ψ)w > αw => both partitions have at least αw work.

24 Analysis of Parallel DFS Donor has w i work => after splitting: w j > αw i and w k > αw i, α < 0.5 After a work transfer, the donor and the recipient have work (1- α)w i Assume there are p pieces of work: w 0,w 1,, w p-1,and the largest piece is of size w. After splitting => 2p pieces: ψ 0 w 0, ψ 1 w 1,, ψ p-1 w p-1, (1- ψ 0 )w 0, (1- ψ 1 )w 1,, (1- ψ p-1 )w p-1 => the size of the largest piece is (1- α)w After V(p) work requests a processor receives at least one request => V(p) p Initially P 0 has W units of work After V(p) work requests => max work remaining at any processor < (1- α)w After 2V(p) => (1- α) 2 W After (log 1/(1- α) (W/ε))V(p) => max work < ε => Total number of requests O(V(p) log W) assuming α=0.5 ε = 1.

25 Analysis of Parallel DFS Assume that amount of data associated with a work transfer is constant T o = t comm V(p) log W E = 1/(1 + T o /W) = 1/(1 + t comm V(p) log W)/W Efficiency depends on: The architecture ( t comm ) Load balancing scheme ( V(p) )

26 Computation of V(p) Asynchronous Round Robin (ARR): Worst case when P p-1 has all the work and local counters of all other processors are 0 P p-1 receives a request after one processor issues (p-1) requests and the other (p-2) processors issue (p-2) requests => V(p) = (p-1) + (p-2)(p-2) = O(p 2 ) Global Round Robin (GRR): After p requests each processor has received one request => O(p) Random Polling (RP); Worst-case => unbounded Average case => O(p log p)

27 Analysis of Load Balancing Schemes T o = O(V(p) log W) Asynchronous Round Robin (ARR): T o = O(p 2 log W) W=O(p 2 log W) = O(p 2 log (p 2 log W))= O(p 2 log p + O(p 2 log log W)) => Isoefficiency function O(p 2 log p) Global Round Robin (GRR): T o = O(p log W) W = O(p log W) = O(p log (p log W)) = O(p log p + O(p log log W)) => Isoefficiency due to communication O(p log p) The number of time the shared variable is accessed O(p log W) If the processors are used efficiently => execution time = O(W/p) W/p = O(p log W) => Isoefficiency due to contention O(p 2 log p) => overall isoefficiency O(p 2 log p) Random Polling (RP): T o = O(p log p log W) => Isoefficiency due to communication O(p log 2 p)

28 Dijkstra s Token Termination Detection Algorithm The ring algorithm: When idle P 0 sends a token to P 1 When idle P i-1 sends a token to P i When P 0 receives the token back all processors are idle. => Cannot be applied to parallel DFS (After becoming idle a processor my receive more work.)

29 Dijkstra s Token Termination Detection Algorithm Processors can be in two states: black or white. Initially all processors are white. The modified ring algorithm: When idle P 0 initiates the termination detection algorithm P 0 =white and P 0 w P 1 If P j sends work to P i and j > i => P j = black If P i has the token and is idle then it passes the token to P i+1. If P i == black => color of token = black before sending to P i+1 If P i == white pass token unchanged. After P i passes the token to P i+1 => P i = white The algorithm terminates when P 0 receives a white token and is itself idle. T = O(p)

30 Tree-Based Termination Detection Initially P 0 has all the work. Weights are associated with each processor When the weight of P 0 becomes 1 terminate Drawback: computers have finite precision and weight at P 0 may not become 1. Solution: use inverse of weight.

31 Parallel Depth-First Branch-and- Bound Search (DFBB) DFS Branch-and-Bound: exhaustively searches the state space for optimal solutions it discards the inferior partial solutions Parallel version of DFBB: modified parallel DFS => all processors are informed of the current best solution path Shared memory: store the best solution path and cost in the global memory. each time a processor finds a solution => compare its cost with the current cost if lower => replace the current best path with the current one. Message-passing: when a solution is found the processor broadcasts it => all processors update their current best cost. Small overhead added => similar performance as the parallel DFS

32 Parallel IDA* IDA* explores the search tree iteratively by increasing the cost bounds. Parallel IDA*: Executes each IDA* iteration by using parallel DFS. All processors use the same bound and searches its own space. Each processor stores the bound locally. After each iteration a selected processor computes the new bound for the next iteration. When the goal state is found the processor informs all processors. Performance similar to parallel DFS.

33 Parallel Best-First Search BFS: maintains two lists: open and closed at each step the most promising node (according to the l- value) from the open list is expanded Newly generated nodes are added to the open list. Parallel BFS: different processors concurrently expand different nodes form open list How to manage the open list? Centralized strategy: Each processor gets work from a single global open list.

34 Parallel Best-First Search (centralized strategy) Problems: Needs termination detection: check if the other nodes have found a better solution. Contention for the open list => limits the speedup

35 Parallel Best-First Search Avoid congestion due to global open list => Distribute the open list: each processor has its own local open list Initially the search space is statically distributed among processors by expanding some nodes Processors expand nodes concurrently No communication: some processors may explore unnecessary nodes => poor speedup Processors must communicate to increase efficiency. How much communication?

36 Parallel Best-First Search Communication strategies for Tree BFS: Communication allows nodes to be exchanged between open lists Goal: ensure that nodes with good l-values are distributed evenly. Random communication strategy: A processor periodically send some of its best nodes to a randomly selected processor If a processor stores a good part of the space => the others will get part of it If the communication cost is low => communicate after each node expansion

37 Parallel Best-First Search Ring communication strategy: Processors are mapped into a virtual ring Each processor periodically exchanges some of its best nodes with its neighbors Drawback: it takes a long time to distributed good nodes if the state space is not uniform

38 Parallel Best-First Search Blackboard communication strategy: After selecting the best node from its local open list a processor expands the node only if its l-value is within a tolerable limit of the best node on the blackboard If selected node is better than the best node on BB it sends some of its best nodes to BB before expanding it If selected node is worse that the processor retrieves some nodes from BB and selects one for expansion Drawback: suitable for shared memory only.

39 Parallel Best-First Search Communication strategies for Graph BFS: When searching graphs => must check for node duplication Idea: whenever a node is generated it is mapped to the same processor, which checks for replication Use a hash function h(node) = proc. label Algorithm: When a new node is generated => compute the hash => label Send the node to the processor indicate by label When the node is received the processor checks if it already exists in the local open or closed list. If not => insert into open list If yes and has better cost => replace it. Ensures an even distribution of nodes with good l- values.

40 Speedup Anomalies in Parallel Search Algorithms Acceleration anomalies => supralinear speedup

41 Speedup Anomalies in Parallel Search Algorithms Deceleration anomalies => sublinear speedup