#include <search.h>

Public Attributes
Board	board [1]

SquareList	empties [BOARD_SIZE+2]

SquareList *	x_to_empties [BOARD_SIZE+2]

int	n_empties

int	player

int	id

HashTable	hash_table [1]

HashTable	pv_table [1]

HashTable	shallow_table [1]

Eval	eval [1]

Random	random [1]

struct TaskStack *	tasks

struct Task *	task

SpinLock	spin

struct Search *	parent

struct Search *	child [MAX_THREADS]

struct Search *	master

volatile int	n_child

int	depth

int	selectivity

int	probcut_level

unsigned int	parity

int	depth_pv_extension

volatile Stop	stop

bool	allow_node_splitting

struct {
long long extra

volatile long long spent

bool extended

bool can_update

long long mini

long long maxi

}	time

MoveList	movelist [1]

int	height

NodeType	node_type [GAME_SIZE]

Bound	stability_bound

struct {
int depth

int selectivity

long long time

bool time_per_move

int verbosity

bool keep_date

const char * header

const char * separator

bool guess_pv

int multipv_depth

int hash_size

}	options

Result *	result

void(*	observer )(Result *)

volatile unsigned long long	n_nodes

volatile unsigned long long	child_nodes

Detailed Description

search stare

Member Data Documentation

◆ allow_node_splitting

bool Search::allow_node_splitting

allow parallelism

◆ board

Board Search::board[1]

othello board

◆ can_update

bool Search::can_update

flag allowing to extend time

◆ child

struct Search* Search::child[MAX_THREADS]

child search

◆ child_nodes

volatile unsigned long long Search::child_nodes

node counter

◆ depth

int Search::depth

depth level

depth

◆ depth_pv_extension

int Search::depth_pv_extension

depth for pv_extension

◆ empties

SquareList Search::empties[BOARD_SIZE+2]

list of empty squares

◆ eval

Eval Search::eval[1]

eval

◆ extended

bool Search::extended

flag to extend time only once

◆ extra

long long Search::extra

extra alloted time

◆ guess_pv

bool Search::guess_pv

guess PV (in cassio mode only)

◆ hash_size

int Search::hash_size

hashtable size

◆ hash_table

HashTable Search::hash_table[1]

hashtable

◆ header

const char* Search::header

header for search output

◆ height

int Search::height

search height from root

◆ id

int Search::id

search id

◆ keep_date

bool Search::keep_date

keep date

◆ master

struct Search* Search::master

master search (parent of all searches)

◆ maxi

long long Search::maxi

maximal alloted time

◆ mini

long long Search::mini

minimal alloted time

◆ movelist

MoveList Search::movelist[1]

list of moves

◆ multipv_depth

int Search::multipv_depth

multi PV depth

◆ n_child

volatile int Search::n_child

search child number

◆ n_empties

int Search::n_empties

number of empty squares

◆ n_nodes

volatile unsigned long long Search::n_nodes

node counter

◆ node_type

NodeType Search::node_type[GAME_SIZE]

node type (pv node, cut node, all node)

◆ observer

void(* Search::observer) (Result *)

call back function to print search result

◆ options

struct { ... } Search::options

local (threadable) options.

◆ parent

struct Search* Search::parent

parent search

◆ parity

unsigned int Search::parity

parity

◆ player

int Search::player

player color

◆ probcut_level

int Search::probcut_level

probcut recursivity level

◆ pv_table

HashTable Search::pv_table[1]

hashtable for the pv

◆ random

Random Search::random[1]

random generator

◆ result

Result* Search::result

shared result

◆ selectivity

int Search::selectivity

selectivity level

final selectivity

◆ separator

const char* Search::separator

separator for search output

◆ shallow_table

HashTable Search::shallow_table[1]

hashtable for short search

◆ spent

volatile long long Search::spent

time spent thinking

◆ spin

SpinLock Search::spin

search lock

◆ stability_bound

Bound Search::stability_bound

score bounds according to stable squares

◆ stop

volatile Stop Search::stop

thinking status

◆ task

struct Task* Search::task

search task

◆ tasks

struct TaskStack* Search::tasks

available task queue

◆ time [1/2]

struct { ... } Search::time

time

◆ time [2/2]

long long Search::time

time in sec.

◆ time_per_move

bool Search::time_per_move

time_per_move or per game ?

◆ verbosity

int Search::verbosity

verbosity level

◆ x_to_empties

SquareList* Search::x_to_empties[BOARD_SIZE+2]

link position to the list

The documentation for this struct was generated from the following file:

search.h

Public Attributes