Public Attributes | List of all members
Search Struct Reference

#include <search.h>

Public Attributes

Board board [1]
 
SquareList empties [BOARD_SIZE+2]
 
SquareListx_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 TaskStacktasks
 
struct Tasktask
 
SpinLock spin
 
struct Searchparent
 
struct Searchchild [MAX_THREADS]
 
struct Searchmaster
 
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
 
Resultresult
 
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: