ABDADA

Home * Search * Parallel Search * ABDADA



ABDADA, (Alpha-Bêta Distribué avec Droit d'Aînesse = Distributed Alpha-Beta Search with Eldest Son Right) a loosely synchronized, distributed search algorithm developed by Jean-Christophe Weill. The ABDADA search algorithm is based on Young Brothers Wait Concept (YBWC) (Rainer Feldmann et al. 1986, 1993) and αβ* (Vincent David 1993). From YBWC it retains the basic concept to allow parallel search only if the eldest son has been fully evaluated. From αβ* as well as Steve Otto and Ed Felten's algorithm (1988) which both rely on a Shared Hash Table and all processors start the search simultaneously at the root, ABDADA retains the simple recursive control structure similar to a serial algorithm. With the help of additional transposition table information, i.e. the number of processors searching this node, it is possible to control speculative parallelism.

=Recursion= While YBWC is difficult to implement recursively, ABDADA is not. In YBWC, when a processor receives an evaluation answer from one of its slaves, it must be able to produce a jump in the search depth if this evaluation produces a pruning of the current master node. So the values of alpha and beta must at least be kept in arrays indexed by ply distance from root, and special arrangements must be made to counteract the disruption that might occur from confusing depths. Therefor YBWC needs a hugely modified iterative search algorithm. In his paper, Weill states that using ABDADA within a recursive NegaScout framework was 30% faster than a none-recursive search, which was observed independently by Mark Brockington in 1994. It can be explained by the fact that within high-level languages and their compilers for certain target platforms, the use of procedure stacks is much more optimized than the use of indexed arrays, also observed by Niklaus Wirth concerning the Quicksort algorithm.

=Algorithm= The ABDADA algorithm is described in five steps:
 * 1) A TT-Entry has a field entry.nproc containing the number of processors currently searching the associated node
 * 2) All processors start the search simultaneously at the root of the search tree
 * 3) When a processor enters a node, it increments entry.nproc
 * 4) When a processor leaves a node, it decrements entry.nproc
 * 5) The analysis of a position is done in three phases:
 * 6) The eldest son is analyzed, regardless of the activities of other processors
 * 7) Next, all other sons not currently being analyzed by other processors are analyzed
 * 8) In the final phase, any remaining sons not yet analyzed are searched, i.e. the corresponding entry in the TT indicates this node and its siblings have not been searched to the required depth

=Pseudo Code= The C-like pseudo code below (adopted from the Pascal like pseudo code from Weill's paper), demonstrates the mentioned three phases controlled by an iteration counter. The boolean parameter exclusiveP indicates whether the node should be searched exclusively and is passed to the TT-probing code via the procedure retrieveAsk. A new value outside the usual value range need to be defined (ON_EVALUATION), and retrieveAsk returns this score if probed in exclusive move, and other processors evaluating this node. int abdada(const CNode &position, int α, int β, int depth, bool exclusiveP) { if (depth == 0) return evaluate( position ); int best = -oo;

retrieveAsk(position, α, β, depth, exclusiveP); /* generate moves while waiting for the answer ... */  GenerateMoves(position); retrieveAnswer(&α, &β, &best); /* The current move is not searched if causing a cutoff or */ /* in exclusive mode and another processor is currently searching it */ if ( α >= β || best == ON_EVALUATION ) return best; /* entry.nproc not incremented */

bool alldone = false; for ( int iteration = 0; iteration < 2 && α < β && !alldone; iteration++) { alldone = true; Move m = firstMove( position ); while ( (m != 0) && (α < β) ) { exclusive = (iteration == 0) && !isFirstMove( m ); /* On the first iteration, only one processor should search young sons exclusively */ value = -abdada( position * m, -β, -max(α, best), depth-1, exclusive ); if ( value == -ON_EVALUATION) { alldone = false; } else if ( value > best ) { best = value; if ( best > β ) goto endsearch; }        m = nextMove( position ); }  } endsearch: storeHash( position, α, β, depth, best ); return best; }

=Implementations=

Frenchess
ABDADA was implemented in Frenchess on a Cray T3D with 128 DEC Alpha 21064 processors. Frenchess participated at the WCCC 1995 finishing fourth, tied with Deep Blue Prototype, as well inside an Othello program called BUGS.

Smash
The GPL open source chess engine Smash by Maurizio Sambati demonstrates an ABDADA implementation in C++.

=See also=
 * Dynamic Tree Splitting
 * Jamboree
 * Lazy SMP
 * Parallel Alpha-Beta in Cilk
 * Shared Hash Table
 * Young Brothers Wait Concept

=Publications=
 * Jean-Christophe Weill (1995). Programmes d'Échecs de Championnat: Architecture Logicielle Synthèse de Fonctions d'Évaluations, Parallélisme de Recherche. Ph.D. Thesis. Université Paris 8, Saint-Denis, zipped ps (French)
 * Marc-François Baudot, Jean-Christophe Weill, Jean-Luc Seret, Michel Gondran (1995). Frenchess: A Cray T3D at the 8th World Computer Chess Championship. First European Cray-T3D Workshop, Citeseex
 * Jean-Christophe Weill (1996). The ABDADA Distributed Minimax Search Agorithm. Proceedings of the 1996 ACM Computer Science Conference, pp. 131-138. ACM, New York, N.Y, reprinted ICCA Journal, Vol. 19, No. 1, zipped postscript

=Forum Posts=

1997 ...

 * Parallel searching by Andrew Tridgell, rgcc, March 22, 1997
 * Re:Parallel searching by Mark Brockington, rgcc, March 22, 1997

2000 ...

 * tip for "simulating" an MP computer & performance of ABDADA by Tom Kerrigan, CCC, May 28, 2000
 * A couple of Questions re ABDADA by Steve Maughan, CCC, May 29, 2000
 * Parallel algorithms in chess programming by Dieter Bürßner, CCC, April 16, 2001

2010 ...

 * Parallelization questions, ABDADA or DTS? by Benjamin Rosseaux, CCC, March 23, 2012
 * ABDADA speedup results by Daniel Shawul, CCC, May 01, 2013
 * IID and move sorting by Daniel Shawul, CCC, May 09, 2013 » Internal Iterative Deepening
 * Possible improvement to ABDADA -- checking for cutoffs by Tom Kerrigan, CCC, July 10, 2015
 * Actual speedups from YBWC and ABDADA on 8+ core machines? by Tom Kerrigan, CCC, July 10, 2015
 * Good parallel speedup with ABDADA and cutoff checks by Tom Kerrigan, CCC, February 03, 2017
 * Approximate ABDADA by Peter Österlund, CCC, August 23, 2017 » Lazy SMP - Lazy Cluster
 * "How To" guide to parallel-izing an engine by Tom Kerrigan, CCC, August 27, 2017
 * "Simplified ABDADA" updated by Tom Kerrigan, CCC, August 29, 2017

=External Links=

Algorithm

 * Simplified ABDADA from Parallel Search by Tom Kerrigan
 * Cutoff Checks from Parallel Search by Tom Kerrigan

Misc

 * AB from Wikipedia
 * ab - Wiktionary
 * ab initio - Wiktionary
 * بد - Wiktionary
 * Dada from Wikipedia
 * Jean-Luc Ponty - Final Truth (Part 2), Montreal Jazz Festival, 1982, YouTube Video
 * feat. Allan Zavod, Jamie Glaser, Rayford Griffin and Keith Jones

=References=

Up one level