Home * Search * Parallel Search * ABDADA

Hannah Höch - Da Dandy [1]

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) [2] [3] and αβ* (Vincent David 1993) [4] . 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) [5] 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 [6] , 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 [7] . 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 [8] .

# 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:
1. The eldest son is analyzed, regardless of the activities of other processors
2. Next, all other sons not currently being analyzed by other processors are analyzed
3. 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;

/* generate moves while waiting for the answer ... */
GenerateMoves(position);
/* 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 [9], as well inside an Othello program called BUGS [10] .

## Smash

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