Generating Chess Moves using PVM

Transcription

1 Generating Chess Moves using PVM Areef Reza Department of Electrical and Computer Engineering University Of Waterloo Waterloo, Ontario, Canada, N2L 3G1 Abstract Game playing is one of the oldest areas of endeavors in artificial intelligence. A chess playing computer is an existence proof of a machine doing something thought to require intelligence. Chess programs have three major components: move generation, search and evaluation. The speed of a chess program depends on the quality of the mechanisms used to prune search of unprofitable continuations. The most reliable pruning method in popular use is the alpha-beta algorithm. This paper presents a parallel alpha-beta searching algorithm and examines the performance of its implementation. 1 Introduction The problem of playing chess can be defined as a problem of moving around in a state space where each state corresponds to a legal position of the board. The goal state is any board position in which the opponent does not have a legal move and his king is under attack. Chess has an average branching factor of about 35 and games often go to 5 moves by each player, so the search tree has about 35 1 nodes. Exploring each of the node in this huge search tree is not at all feasible. However it is possible to cut off some of the subtrees using a method called alpha-beta pruning. This paper develops a parallel alpha-beta search algorithm. Section 2 discusses the concepts of game playing. Section 3 develops the parallel alpha-beta searching algorithm. Section 4 focuses on the implementation of the parallel algorithm. Section 5 examines the performance of the parallel solution. Section 6 provides a summary and directions for further research. 2 Background Most of the search procedures are essentially generate-and-test procedures in which the testing is done after varying amounts of work by the generator. At one extreme, the generator generates the entire proposed solutions, which the tester then evaluates. At the other extreme, generator generates individual moves in the search space, each of which is then evaluated by the tester and the most promising one is chosen. To improve the effectiveness of a search based problem-solving program, the generate procedures should be improved so that only good moves (paths) are generated and also the test procedures should be improved so that the best moves(paths) will be recognized and explored first. In gameplaying programs, it is particularly important that both these things be done. So two important knowledge based components of a good game playing program are: a good move-generator and a good static evaluation function. They must both incorporate a great deal of knowledge about the particular game being played. But unless these functions are perfect, we also need a search procedure that makes it possible to look ahead as many moves as possible to see what may occur. Alpha-beta search algorithm is one such procedure. 2.1 Sequential Alpha-beta Search Alpha-beta search algorithm is just a variation of the minimax search procedure. The minimax search procedure is a depth first, depth-limited search procedure. The idea is to start at the current position and use the move generator to generate the set of possible successor positions. Now we can apply the static evaluation function to those positions and simply choose the best one. After doing so we can back up the value up to the starting position to represent our evaluation of it. The starting position is exactly as good for us as

2 the position generated by the best move we can make next. If we assume that that the static evaluation function returns large values to indicate good situations for us, our goal is to maximize the value of the static evaluation function of the next board position, whereas the opponent s goal is to minimize it. The alpha-beta search procedure requires the maintenance of two threshold values, one representing a lower bound on the value that a maximizing node may ultimately be assigned(alpha) and another representing an upper bound on the value that a minimizing node may be assigned(beta). At maximizing level we can rule out a move early if it becomes clear that its value will be less than the current threshold, while at minimizing levels, search will be terminated if values that are greater than the current threshold are discovered. Figure 1 shows the sequential alpha-beta algorithm. Algorithm AB(board, move, alpha, beta, depth) board: boardtype; move: movetype; alpha, beta, depth: integer; Var merit, j, value: integer; posn : ARRAY[1..MAXWIDTH] OF position; BEGIN applymove(board, move); IF depth = MAX_DEPTH THEN posn = Generate(p); IF empty(posn) THEN merit := -MAXINT; FOR j := 1 TO sizeof(posn) DO BEGIN value := -AB(posn[j], -beta, -max(alpha,merit), depth+1); IF (value > merit) THEN merit := value; IF (merit >= beta) THEN { cutoff? GOTO done; done: Return(merit); Figure 1: Sequential Alpha-beta Search 3 Parallel Alpha-beta Search Algorithm Implementation of parallel alpha-beta search suffers primarily from the synchronization and search overheads of parallelization. This section describes a parallel alpha-beta search algorithm that achieves high performance through the use of three different types of processes: Interface, Employer and Employees. Synchronization overhead is reduced by having all Employees apply the parallel algorithm on the subtree they search and having an Employer process re-assigning idle processes to help out busy ones. 3.1 Principal Variation Splitting Search One sequential alpha-beta algorithm, the Principal Variation Splitting(PVS) search has been shown to be effective on well ordered game trees. The essence of the PVS method is to assume that the leftmost path examined is the best, and to use the value of that path to form tight bounds on the search of the remaining subtrees in a quick attempt to prove their inferiority. This algorithm has been parallelized in this project. Figure 2 shows the PVS algorithm. Algorithm PVS(board, move, alpha, beta, depth) board: boardtype; move: movetype; alpha, beta, depth: integer; Var merit, j, value: integer; posn : ARRAY[1..MAXWIDTH] OF position; BEGIN applymove(board, move); IF depth = MAX_DEPTH THEN posn = Generate(p); IF empty(posn) THEN merit := -PVS(posn[1], -beta, -alpha, depth+1); FOR j := 2 TO sizeof(posn) DO BEGIN value := -PVS(posn[j], -beta, -max(alpha,merit), depth+1); IF (value > merit) THEN merit := value; IF (merit >= beta) THEN { cutoff? GOTO done; done: Return(merit); Figure 2: Principal Variation Search 3.2 Process Description Two special types of task, Employer and Employee have been defined for the parallel algorithm. The Employer assigns a subtree to each Employee. The Employee applies principal variation splitting algorithm on its subtree. Whenever an Employee becomes idle it reports to the Employer. A busy Employee can ask for more Employees from the Employer to assist it. Another task, Interface has been defined for the man machine interface. Consider the process diagram shown in Figure 3. The Interface sends a MOVE_SEND message along with a board description to the Employer. It waits for a MOVE_ACK message from the Employer accompanied by the best move. The Employer selects an Employee and sends it a MOVE_SEND message with the current board description. The Employer also sends it a DO_U_NEED_HELP

3 Interface MOVE_SEND MOVE_ACK TERMINATE EMP_SEND EMP_SEND_ACK Employer MOVE_SEND MOVE_ACK TERMINATE EMP_AVAILABLE DO_U_NEED_HELP TERMINATE message to all Employees and terminates itself. Employees also terminate after receiving this message. The parallel algorithms are shown in Figure 4 and Figure 5. MOVE_SEND Employee 1 Employee Employee n 2... MOVE_ACK STOP_COMPUTING Figure 3: Process Diagram message. The active Employee applies PVS algorithm on the given problem. Whenever it needs help (at the point of tree decomposition) it checks whether there is any DO_U_NEED_HELP message in the message queue. If the message is found it sends an EMP_SEND message to the Employer along with the number or required Employees. The Employer sends back the possible number of idle Employees with an EMP_SEND_ACK message. The Employee then sends MOVE_SEND message to each of the received Employees along with a node of the search tree. Whenever an Employee needs to cut off the search, it sends STOP_COMPUTING message to all other Employees that were assisting it. It then sends back the result to the requester. Interface initboard; while(game is not over) { send MOVE_SEND to employer; receive MOVE_ACK from employer; updateboard; get move from user; updateboard; send TERMINATE to employer; Employer while(1) { receive any msg; switch(type of msg){ case MOVE_SEND: hire an employee; case MOVE_ACK: send result; case EMP_SEND: send employees; update emp info; case TERMINATE: terminate all employees; exit; Employee while(1) { receive any msg; myparent = myparent(); switch(type of msg) { case MOVE_SEND: call PAB; if result is UNDEFINED send nothing; otherwise send result to myparent; case TERMINATE: exit; Figure 4: Interface, Employer and Employee If an Employee receives a STOP_COMPUTING message it stops computing and becomes idle. Whenever an Employee becomes idle it sends EMP_AVAILABLE message to the Employer. On receiving this message the Employer sends DO_U_NEED_HELP to all other active Employees. The Employer maintains the list of all active and idle Employees. On receiving TERMINATE message from the Interface, the Employer sends Algorithm PAB(board, move, usethresh, passthresh, depth) board : boardtype; move : movetype; passthresh, usethresh, depth : integer; 1. applymove(board, move) 2. IF depth = MAX_DEPTH return evaluate(board) 3. nextmoves = getnextmoves(board) IF empty(nextmoves) return evaluate(board) 4. merit = -PAB(board, nextmvoes[1], -passthresh, -usethresh, depth+1) 5. IF merit > passthresh passthresh = merit 6. index = 2 7. WHILE index <= sizeof(nextmoves) DO i) IF search tree has at least MIN_WORK_DEPTH IF nrecv(do_u_need_help,employer) asstnts = recv(emp_send, sizeof(nextmoves)-index+1, Employer) IF not empty(asstnts) FOR i=1 to sizeof(asstnts) send(move_send,board, nextmoves[i],asstnts[i]) index = index+sizeof(asstnts) ii) IF index > sizeof(nextmoves) goto 8 iii) merit=-ab(board,nextmoves[index], -passthresh,-usethresh,depth+1) iv) IF nrecv(stop_computing, myparent) send STOP_COMPUTING to all asstnts stop further computing return UNDEFINED v) IF merit > passthresh passthresh = merit vi) IF passthresh >= usethresh send STOP_COMPUTING to all asstnts return passthresh vii) FOR i=1 to sizeof(asstnts) IF nrecv(move_ack,result,asstnts[i]) delete ith member from asstnts IF result>passthresh passthresh = result IF passthresh >= usethresh send STOP_COMPUTING to all asstnts return passthresh viii) index = index FOR i = 1 to sizeof(asstnts) recv(move_ack,result,asstnts[i]) IF result > passthresh passthres = result IF passthresh >= usethresh send STOP_COMPUTING to all asstnts return passthresh 9. IF nrecv(stop_computing,myparent) return UNDEFINED otherwise return passthersh Figure 5: Parallel Alpha Beta Algorithm 3.3 Processor Tree Employer and Employees maintain a tree like structure. This tree structure changes dynamically as search progresses. As shown in figure 6, whenever an Employee becomes idle, it is used to help out another active Employee.

4 Employer Employer Employer e 1 e 1 e 1 e 2 e 3 e 4 e 2 e3 e 2 idle idle e4 e 3 e 4 e i = Employee i Figure 6: Processor Tree 4.4 Parallel alpha-beta search PVM routines were used to spawn tasks, send messages and receive messages. Both blocking receive (recv) and non blocking receive (nrecv) primitives were used to synchronize processes. Beyond a certain size or granularity of work it does not make sense to parallelize. The smallest unit of work that can be assigned to a processor was a 3 ply search. 4 Implementation 5 Results The implementation was done using PVM message passing library for a distributed computer system. A brief overview of PVM is discussed in this section with other implementation details. 4.1 Parallel Virtual Machine(PVM) This tool enables a collection of heterogeneous computer systems to be viewed as a single parallel virtual machine. The unit of parallelism in PVM is a task. Multiple tasks may execute on a single processor. The tasks communicate with each other through explicit message passing. 4.2 Move Generator A legal move generator was used in the implementation. It generates all possible moves generated by each piece. 4.3 Static Evaluation Function An evaluation function was used in the implementation considering the following points: Mobility: It is the summation of the square roots of the number of moves that the queen, rooks, bishops and knights can make. Piece Safety: For the rooks, bishops and knights 1 point is added if the piece is defended once, and 1.5 points are added if it is defended at least twice. Pawn Credit:.3 points are awarded for each pawn defended by one or more non-pawns. Material Value: Each piece is given a material value according to its importance. The material values are: pawn=1, knight=3, bishop=4, rook=5, queen=1 and king=1. Experiments were performed using a network of SparcStation 1s running SunOS Some test chess board were used for comparing performance of the sequential and parallel chess programs. This section discusses how effective the parallel algorithm searches game tree using the above described methods. Results for speedup, workload, search overhead and time overhead are presented. 5.1 Speedup Speedup is the ratio between the time needed for the most efficient sequential algorithm to perform a computation and the time needed to perform the same computation on a machine incorporating parallelism. Figure 7 shows the speedup obtained. The sublinear speedup observed can be attributed to search overhead and communication overhead Number of Processors Figure 7: Speedup 5.2 Time Overhead Speed up Ideal Speedup Time overhead is the percentage loss in speedup when using N processors compared to the ideal speedup. This can be expressed as: TO = Time using N CPUs * N Time using 1 CPU - 1

5 TO is a simple quantitative measure of the total overhead. An interpretation of it is that for every 1 seconds of useful computing(as defined by the sequential program), TO seconds are wasted because of parallelization. The major causes for this loss in performance are communication overhead(co), search overhead(so), and synchronization overhead(sy). These overheads are related by TO = CO + SO + SY Figure 8 shows the time overhead obtained for a 4 ply search. TO increases as the number of processor is increased Number of Processors Figure 8: Time Overhead 5.3 Search Overhead Time Overhead In the sequential environment, all information is readily available for making decisions. In a distributed environment, that information may be dispersed over several machines or not to be available at all. Making the available information accessible to everyone may dramatically increase communication. On the otherhand, not having enough information may result in parts of the tree being explored unnecessarily. This possible increase in the size of the search tree incurred by the parallelism is called information deficiency or search overhead. This loss can be approximated by using the observation that the size of the tree built is proportional to the time spent searching. SO can then be estimated by, SO = Nodes search for N CPUs Nodes searched for 1 CPU - 1 Figure 9 shows the search overhead obtained. The search overhead for this test case peaks at depth 3 as this is the smallest amount of work that can be assigned to a process Depth Figure 9: Search Overhead 5.4 Load Distribution Search Overhead Figure 1 shows the number of nodes generated by each Employee. This experiment was carried out with 5 Employees. This graph gives a rough idea of how well the load was distributed assuming the load is proportional to the number of nodes generated during search (x1 3 ) Depth (x1 3 ) (x1 4 ) (x1 5 ) Figure 1: Load Distribution 6 Conclusions Emp 1 Emp 2 Emp 3 Emp 4 Emp 5 A parallel alpha-beta algorithm has been developed. The sequential and parallel implementations were compared and a sublinear speedup was obtained. A very simple chess program was developed using the proposed algorithm which could play chess with some intelligence.

6 Alpha-beta search has a number of opportunities for parallel execution. One approach is to parallelize move generation and position evaluation. However the speedup that can be achieved with this approach is limited by the parallelism inherent in these activities. Further improvement is possible by adding speculative computing to the search, using several Scout processes to speculatively search for interesting features in the tree. Scouts are stripped down versions of Employees. They are designed to be as fast as possible scouting ahead in the tree looking for wins and losses of materials at a depth beyond what an alpha-beta program could usually search. References [1] A. Geist, A. Beguelin, J. Dongarra, W. Jiang, R. Manchek, and V. Sunderam, PVM: Parallel Virtual Machine - A Users Guide and Tutorial for Networked Parallel Computing, The MIT Press, [2] D. Levy, All About Chess and Computer, Computer Science Press, [3] E. Rich and K. Knight, Artificial Intelligence, McGraw-Hill, Inc., [4] J. Schaeffer, Experiments In Distributed Game-Tree Searching, Technical Report TR87-2, January [5] M. J. Quinn, Parallel Computing, Theory and Practice, McGraw-Hill, Inc., [6] T. A. Marsland, Searching for Chess, Technical Report TR87-6, May 1987.