Stockfish 9

Official release version of Stockfish 9

Bench 5023629

.travis.yml

@@ -0,0 +1,73 @@
+language: cpp
+sudo: required
+dist: trusty
+
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6', 'g++-6-multilib', 'g++-multilib', 'valgrind', 'expect']
+      env:
+        - COMPILER=g++-6
+        - COMP=gcc
+
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['clang', 'g++-multilib', 'valgrind', 'expect']
+      env:
+        - COMPILER=clang++
+        - COMP=clang
+
+    - os: osx
+      compiler: gcc
+      env:
+        - COMPILER=g++
+        - COMP=gcc
+
+    - os: osx
+      compiler: clang
+      env:
+        - COMPILER=clang++ V='Apple LLVM 6.0' # Apple LLVM version 6.0 (clang-600.0.54) (based on LLVM 3.5svn)
+        - COMP=clang
+
+branches:
+  only:
+   - master
+
+before_script:
+  - cd src
+
+script:
+  # Obtain bench reference from git log
+  - git log HEAD | grep "\b[Bb]ench[ :]\+[0-9]\{7\}" | head -n 1 | sed "s/[^0-9]*\([0-9][0-9]*\)/\1/g" > git_sig
+  - export benchref=$(cat git_sig)
+  - echo "Reference bench:" $benchref
+  #
+  # Verify bench number against various builds
+  - export CXXFLAGS=-Werror
+  - make clean && make -j2 ARCH=x86-64 optimize=no debug=yes build && ../tests/signature.sh $benchref
+  - make clean && make -j2 ARCH=x86-32 optimize=no debug=yes build && ../tests/signature.sh $benchref
+  - make clean && make -j2 ARCH=x86-32 build && ../tests/signature.sh $benchref
+  - make clean && make -j2 ARCH=x86-64 build && ../tests/signature.sh $benchref
+  #
+  # Check perft and reproducible search
+  - ../tests/perft.sh
+  - ../tests/reprosearch.sh
+  #
+  # Valgrind
+  #
+  - export CXXFLAGS=-O1
+  - if [ -x "$(command -v valgrind )" ]; then make clean && make -j2 ARCH=x86-64 debug=yes optimize=no build > /dev/null && ../tests/instrumented.sh --valgrind; fi
+  - if [ -x "$(command -v valgrind )" ]; then ../tests/instrumented.sh --valgrind-thread; fi
+  #
+  # Sanitizer
+  #
+  # Use g++-6 as a proxy for having sanitizers, might need revision as they become available for more recent versions of clang/gcc
+  - if [[ "$COMPILER" == "g++-6" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=undefined optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-undefined; fi
+  - if [[ "$COMPILER" == "g++-6" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=thread    optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-thread; fi

AUTHORS

@@ -0,0 +1,98 @@
+# Generated with 'git shortlog -sn | cut -c8-', which sorts by commits, manually ordered the first four authors, merged duplicates
+
+Tord Romstad
+Marco Costalba (mcostalba)
+Joona Kiiski (zamar)
+Gary Linscott (glinscott)
+Lucas Braesch (lucasart)
+Bill Henry (VoyagerOne)
+mstembera
+Stéphane Nicolet (Stephane Nicolet, snicolet)
+Stefan Geschwentner
+Alain SAVARD (Rocky640)
+Jörg Oster (Joerg Oster, joergoster)
+Reuven Peleg
+Chris Caino (Chris Cain, ceebo)
+Jean-Francois Romang
+homoSapiensSapiens
+Leonid Pechenik
+Stefano Cardanobile (Stefano80)
+Arjun Temurnikar
+Uri Blass (uriblass)
+jundery
+Ajith (ajithcj)
+hxim
+Ralph Stößer (Ralph Stoesser)
+Guenther Demetz
+Jonathan Calovski (Mysseno)
+Tom Vijlbrief
+mbootsector
+Daylen Yang
+ElbertoOne
+Henri Wiechers
+loco-loco
+Joost VandeVondele (Joost Vandevondele)
+Ronald de Man (syzygy)
+DU-jdto
+David Zar
+Eelco de Groot
+Jerry Donald
+NicklasPersson
+Ryan Schmitt
+Alexander Kure
+Dan Schmidt
+H. Felix Wittmann
+Jacques
+Joseph R. Prostko
+Justin Blanchard
+Linus Arver
+Luca Brivio
+Lyudmil Antonov
+Rodrigo Exterckötter Tjäder
+Ron Britvich
+RyanTaker
+Vince Negri
+erbsenzaehler
+Joseph Hellis (jhellis3)
+shane31
+Andrew Grant
+Andy Duplain
+Auguste Pop
+Balint Pfliegel
+Dariusz Orzechowski
+DiscanX
+Ernesto Gatti
+Gregor Cramer
+Hiraoka Takuya (HiraokaTakuya)
+Hongzhi Cheng
+IIvec
+Kelly Wilson
+Ken T Takusagawa
+Kojirion
+Krgp
+Matt Sullivan
+Matthew Lai
+Matthew Sullivan
+Michel Van den Bergh
+Niklas Fiekas
+Oskar Werkelin Ahlin
+Pablo Vazquez
+Pascal Romaret
+Raminder Singh
+Richard Lloyd
+Ryan Takker
+Thanar2
+absimaldata
+atumanian
+braich
+fanon
+gamander
+gguliash
+kinderchocolate
+pellanda
+ppigazzini
+renouve
+sf-x
+thaspel
+unknown
+

Readme.md

@@ -0,0 +1,123 @@
+### Overview
+
+[![Build Status](https://travis-ci.org/official-stockfish/Stockfish.svg?branch=master)](https://travis-ci.org/official-stockfish/Stockfish)
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/official-stockfish/Stockfish?svg=true)](https://ci.appveyor.com/project/mcostalba/stockfish)
+
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program and requires some UCI-compatible GUI
+(e.g. XBoard with PolyGlot, eboard, Arena, Sigma Chess, Shredder, Chess
+Partner or Fritz) in order to be used comfortably. Read the
+documentation for your GUI of choice for information about how to use
+Stockfish with it.
+
+This version of Stockfish supports up to 512 cores. The engine defaults
+to one search thread, so it is therefore recommended to inspect the value of
+the *Threads* UCI parameter, and to make sure it equals the number of CPU
+cores on your computer.
+
+This version of Stockfish has support for Syzygybases.
+
+
+### Files
+
+This distribution of Stockfish consists of the following files:
+
+  * Readme.md, the file you are currently reading.
+
+  * Copying.txt, a text file containing the GNU General Public License.
+
+  * src, a subdirectory containing the full source code, including a Makefile
+    that can be used to compile Stockfish on Unix-like systems.
+
+
+### Syzygybases
+
+**Configuration**
+
+Syzygybases are configured using the UCI options "SyzygyPath",
+"SyzygyProbeDepth", "Syzygy50MoveRule" and "SyzygyProbeLimit".
+
+The option "SyzygyPath" should be set to the directory or directories that
+contain the .rtbw and .rtbz files. Multiple directories should be
+separated by ";" on Windows and by ":" on Unix-based operating systems.
+**Do not use spaces around the ";" or ":".**
+
+Example: `C:\tablebases\wdl345;C:\tablebases\wdl6;D:\tablebases\dtz345;D:\tablebases\dtz6`
+
+It is recommended to store .rtbw files on an SSD. There is no loss in
+storing the .rtbz files on a regular HD.
+
+Increasing the "SyzygyProbeDepth" option lets the engine probe less
+aggressively. Set this option to a higher value if you experience too much
+slowdown (in terms of nps) due to TB probing.
+
+Set the "Syzygy50MoveRule" option to false if you want tablebase positions
+that are drawn by the 50-move rule to count as win or loss. This may be useful
+for correspondence games (because of tablebase adjudication).
+
+The "SyzygyProbeLimit" option should normally be left at its default value.
+
+**What to expect**
+If the engine is searching a position that is not in the tablebases (e.g.
+a position with 7 pieces), it will access the tablebases during the search.
+If the engine reports a very large score (typically 123.xx), this means
+that it has found a winning line into a tablebase position.
+
+If the engine is given a position to search that is in the tablebases, it
+will use the tablebases at the beginning of the search to preselect all
+good moves, i.e. all moves that preserve the win or preserve the draw while
+taking into account the 50-move rule.
+It will then perform a search only on those moves. **The engine will not move
+immediately**, unless there is only a single good move. **The engine likely
+will not report a mate score even if the position is known to be won.**
+
+It is therefore clear that behaviour is not identical to what one might
+be used to with Nalimov tablebases. There are technical reasons for this
+difference, the main technical reason being that Nalimov tablebases use the
+DTM metric (distance-to-mate), while Syzygybases use a variation of the
+DTZ metric (distance-to-zero, zero meaning any move that resets the 50-move
+counter). This special metric is one of the reasons that Syzygybases are
+more compact than Nalimov tablebases, while still storing all information
+needed for optimal play and in addition being able to take into account
+the 50-move rule.
+
+
+### Compiling it yourself
+
+On Unix-like systems, it should be possible to compile Stockfish
+directly from the source code with the included Makefile.
+
+Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT
+instruction, big-endian machines such as Power PC, and other platforms.
+
+In general it is recommended to run `make help` to see a list of make
+targets with corresponding descriptions. When not using the Makefile to
+compile (for instance with Microsoft MSVC) you need to manually
+set/unset some switches in the compiler command line; see file *types.h*
+for a quick reference.
+
+### Resource For Understanding the Code Base
+
+* [Chessprogramingwiki](https://chessprogramming.wikispaces.com) has good overall chess engines explanations 
+(techniques used here are well explained like hash maps etc), it was 
+also recommended by the [support at stockfish.](http://support.stockfishchess.org/discussions/questions/1132-how-to-understand-stockfish-sources)
+
+* [Here](https://chessprogramming.wikispaces.com/Stockfish) you can find a set of features and techniques used by stockfish and each of them is explained at the wiki, however, it's a generic way rather than focusing on stockfish's own implementation, but it will still help you. 
+
+
+### Terms of use
+
+Stockfish is free, and distributed under the **GNU General Public License**
+(GPL). Essentially, this means that you are free to do almost exactly
+what you want with the program, including distributing it among your
+friends, making it available for download from your web site, selling
+it (either by itself or as part of some bigger software package), or
+using it as the starting point for a software project of your own.
+
+The only real limitation is that whenever you distribute Stockfish in
+some way, you must always include the full source code, or a pointer
+to where the source code can be found. If you make any changes to the
+source code, these changes must also be made available under the GPL.
+
+For full details, read the copy of the GPL found in the file named
+*Copying.txt*.

Readme.txt

@@ -1,79 +0,0 @@
-1. Introduction
----------------
-
-Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is not a
-complete chess program, but requires some UCI compatible GUI (like XBoard
-with PolyGlot, eboard, Arena, Sigma Chess, Shredder, Chess Partner or Fritz)
-in order to be used comfortably. Read the documentation for your GUI of choice
-for information about how to use Stockfish with your GUI.
-
-This version of Stockfish supports up to 32 CPUs, but has not been tested
-thoroughly with more than 4.  The program tries to detect the number of
-CPUs on your computer and set the number of search threads accordingly, but
-please be aware that the detection is not always correct. It is therefore
-recommended to inspect the value of the "Threads" UCI parameter, and to
-make sure it equals the number of CPU cores on your computer. If you are
-using more than eight threads, it is recommended to raise the value of
-"Min Split Depth" UCI parameter to 7.
-
-
-2. Files
---------
-
-This distribution of Stockfish consists of the following files:
-
-  * Readme.txt, the file you are currently reading.
-
-  * Copying.txt, a text file containing the GNU General Public
-    License.
-
-  * src/, a subdirectory containing the full source code, including a
-    Makefile that can be used to compile Stockfish on Unix-like systems.
-    For further information about how to compile Stockfish yourself
-    read section 4 below.
-
-  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
-    adapter.
-
-
-3. Opening books
-----------------
-
-This version of Stockfish has support for PolyGlot opening books.
-For information about how to create such books, consult the PolyGlot
-documentation.  The book file can be selected by setting the UCI
-parameter "Book File".
-
-
-4. Compiling it yourself
-------------------------
-
-On Unix-like systems, it should usually be possible to compile Stockfish
-directly from the source code with the included Makefile.
-
-Stockfish has support for 32 or 64 bits CPUS, big-endian machines, like
-Power PC, hardware POPCNT instruction and other platforms.
-
-In general is recommended to run 'make help' to see a list of make targets
-with corresponding descriptions. When not using Makefile to compile, for
-instance with Microsoft MSVC, you need to manually set/unset in the compiler
-command line some swicthes, see file types.h for a quick reference.
-
-
-5. Terms of use
----------------
-
-Stockfish is free, and distributed under the GNU General Public License
-(GPL). Essentially, this means that you are free to do almost exactly
-what you want with the program, including distributing it among your
-friends, making it available for download from your web site, selling
-it (either by itself or as part of some bigger software package), or
-using it as the starting point for a software project of your own.
-
-The only real limitation is that whenever you distribute Stockfish in
-some way, you must always include the full source code, or a pointer
-to where the source code can be found. If you make any changes to the
-source code, these changes must also be made available under the GPL.
-
-For full details, read the copy of the GPL found in the file named
-Copying.txt.

Top CPU Contributors.txt

@@ -0,0 +1,132 @@
+Contributors with >10,000 CPU hours as of January 23, 2018
+Thank you!
+
+Username         CPU Hours    Games played 
+mibere           518300       41835669    
+crunchy          375564       29121434    
+cw               371664       28748719    
+fastgm           299773       20765374    
+JojoM            220590       15299913    
+glinscott        204517       13932027    
+bking_US         187568       12233168    
+ctoks            169342       13475495    
+spams            149531       10940322    
+Thanar           137015       11714855    
+velislav         127305       10047749    
+vdbergh          121741       9056874     
+malala           117291       8126488     
+vdv              117218       8289983     
+leszek           114825       8331897     
+dsmith           114010       7622414     
+CSU_Dynasty      113516       9582758     
+sqrt2            112407       8782694     
+marrco           111143       8222921     
+drabel           108168       9061580     
+BrunoBanani      104938       7448565     
+Data             94621        8433010     
+CoffeeOne        90394        3964243     
+BRAVONE          80811        5341681     
+psk              77195        6156031     
+brabos           70284        5685893     
+Fisherman        66650        5572406     
+nssy             64587        5369140     
+Pking_cda        64499        5704075     
+sterni1971       63488        5070004     
+mgrabiak         62385        5420812     
+tvijlbrief       58957        4154234     
+jromang          58854        4704502     
+dv8silencer      57421        3961325     
+sunu             56620        4609155     
+tinker           56039        4204914     
+biffhero         55743        4810039     
+teddybaer        52982        4740444     
+bcross           50548        5071599     
+renouve          50318        3544864     
+Freja            50296        3805120     
+robnjr           47504        4131742     
+eva42            46542        4044694     
+davar            46538        4030604     
+finfish          46244        3481661     
+rap              46201        3219490     
+ttruscott        45037        3645430     
+solarlight       44155        4074841     
+TueRens          41372        3891510     
+ElbertoOne       41321        3920894     
+Antihistamine    39218        2792761     
+mhunt            38991        2697512     
+bigpen0r         37820        3149955     
+homyur           35569        3009637     
+VoyagerOne       35137        3302650     
+mhoram           34770        2684128     
+racerschmacer    33022        3231055     
+speedycpu        32043        2531964     
+EthanOConnor     31638        2143255     
+oryx             29574        2767730     
+Pyafue           28885        1986098     
+jkiiski          28014        1923255     
+Garf             27579        2770144     
+slakovv          27017        2031279     
+Bobo1239         27000        2488707     
+pb00067          26817        2306694     
+robal            26337        2316795     
+hyperbolic.tom   26248        2200777     
+rkl              24898        2236013     
+SC               23988        2126825     
+nabildanial      23524        1586321     
+achambord        23495        1942546     
+Sharaf_DG        22975        1790697     
+chriswk          22876        1947731     
+anst             22568        2013953     
+Patrick_G        22435        1682293     
+cuistot          22201        1383031     
+gri              21901        1820968     
+Prcuvu           21182        1890546     
+Zirie            21171        1493227     
+JanErik          20596        1791991     
+Isidor           20560        1730290     
+xor12            20535        1819280     
+team-oh          20364        1653708     
+nesoneg          20264        1493435     
+rstoesser        19802        1335177     
+grandphish2      19402        1834196     
+sg4032           18427        1671742     
+dew              18263        1423326     
+ianh2105         18133        1668562     
+MazeOfGalious    18022        1644593     
+ville            17900        1539130     
+j3corre          17607        975954      
+eudhan           17502        1424648     
+iisiraider       17175        1118788     
+jundery          17172        1115855     
+SFTUser          16635        1363975     
+purplefishies    16621        1106850     
+DragonLord       16599        1252348     
+chris            15274        1575333     
+xoto             14900        1486261     
+dju              14861        901552      
+dex              14647        1228763     
+nordlandia       14551        1369718     
+ronaldjerum      14361        1210607     
+OssumOpossum     14149        1029265     
+IgorLeMasson     13844        1228391     
+enedene          13762        935618      
+ako027ako        13442        1250249     
+AdrianSA         13324        924980      
+bpfliegel        13318        886523      
+ncfish1          13056        932344      
+wei              12863        1369596     
+jpulman          12776        854815      
+horst.prack      12436        1151505     
+joster           12424        986622      
+cisco2015        12265        1205019     
+fatmurphy        12015        901134      
+modolief         11228        926456      
+Dark_wizzie      11214        1017910     
+mschmidt         10973        818594      
+eastorwest       10970        1117836     
+infinity         10762        746397      
+SapphireBrand    10692        1024604     
+Thomas A.        10553        736094      
+pgontarz         10294        878746      
+Andrew Grant     10195        922933      
+stocky           10083        718114      

appveyor.yml

@@ -0,0 +1,71 @@
+version: 1.0.{build}
+clone_depth: 50
+
+branches:
+  only:
+    - master
+    - appveyor
+
+# Operating system (build VM template)
+os: Visual Studio 2015
+
+# Build platform, i.e. x86, x64, AnyCPU. This setting is optional.
+platform:
+  - x86
+  - x64
+
+# build Configuration, i.e. Debug, Release, etc.
+configuration:
+  - Debug
+  - Release
+
+matrix:
+  # The build fail immediately once one of the job fails
+  fast_finish: true
+
+# Scripts that are called at very beginning, before repo cloning
+init:
+  - cmake --version
+  - msbuild /version
+
+before_build:
+  - ps: |
+      # Get sources
+      $src = get-childitem -Path *.cpp -Recurse | select -ExpandProperty FullName
+      $src = $src -join ' '
+      $src = $src.Replace("\", "/")
+
+      # Build CMakeLists.txt
+      $t = 'cmake_minimum_required(VERSION 3.8)',
+           'project(Stockfish)',
+           'set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/src)',
+           'set(source_files', $src, ')',
+           'add_executable(stockfish ${source_files})'
+
+      # Write CMakeLists.txt withouth BOM
+      $MyPath = (Get-Item -Path "." -Verbose).FullName + '\CMakeLists.txt'
+      $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False
+      [System.IO.File]::WriteAllLines($MyPath, $t, $Utf8NoBomEncoding)
+
+      # Obtain bench reference from git log
+      $b = git log HEAD | sls "\b[Bb]ench[ :]+[0-9]{7}" | select -first 1
+      $bench = $b -match '\D+(\d+)' | % { $matches[1] }
+      Write-Host "Reference bench:" $bench
+      $g = "Visual Studio 14 2015"
+      If (${env:PLATFORM} -eq 'x64') { $g = $g + ' Win64' }
+      cmake -G "${g}" .
+      Write-Host "Generated files for: " $g
+
+build_script:
+  - cmake --build . --config %CONFIGURATION% -- /verbosity:minimal
+
+before_test:
+  - cd src/%CONFIGURATION%
+  - ps: |
+      # Verify bench number
+      ./stockfish bench 2> out.txt 1> null
+      $s = (gc "./out.txt" | out-string)
+      $r = ($s -match 'Nodes searched \D+(\d+)' | % { $matches[1] })
+      Write-Host "Engine bench:" $r
+      Write-Host "Reference bench:" $bench
+      If ($r -ne $bench) { exit 1 }

polyglot.ini

@@ -1,43 +0,0 @@
-
-[PolyGlot]
-
-EngineDir = .
-EngineCommand = ./stockfish
-
-Book = false
-BookFile = book.bin
-
-Log = false
-LogFile = stockfish.log
-
-Resign = true
-ResignScore = 600
-
-[Engine]
-
-Use Search Log = false
-Search Log Filename = SearchLog.txt
-Book File = book.bin
-Best Book Move = false
-Mobility (Middle Game) = 100
-Mobility (Endgame) = 100
-Passed Pawns (Middle Game) = 100
-Passed Pawns (Endgame) = 100
-Space = 100
-Aggressiveness = 100
-Cowardice = 100
-Min Split Depth = 4
-Max Threads per Split Point = 5
-Threads = 1
-Use Sleeping Threads = false
-Hash = 128
-Ponder = true
-OwnBook = false
-MultiPV = 1
-Skill Level = 20
-Emergency Move Horizon = 40
-Emergency Base Time = 200
-Emergency Move Time = 70
-Minimum Thinking Time = 20
-UCI_Chess960 = false
-UCI_AnalyseMode = false

src/Makefile

@@ -1,6 +1,7 @@
 # Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-# Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+# Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+# Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 #
 # Stockfish is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -20,6 +21,12 @@
 ### Section 1. General Configuration
 ### ==========================================================================
 
+### Establish the operating system name
+KERNEL = $(shell uname -s)
+ifeq ($(KERNEL),Linux)
+	OS = $(shell uname -o)
+endif
+
 ### Executable name
 EXE = stockfish
 
@@ -28,12 +35,12 @@ PREFIX = /usr/local
 BINDIR = $(PREFIX)/bin
 
 ### Built-in benchmark for pgo-builds
-PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+PGOBENCH = ./$(EXE) bench
 
 ### Object files
-OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
+OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \
-	material.o misc.o move.o movegen.o movepick.o pawns.o position.o \
+	material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \
-	search.o thread.o timeman.o tt.o uci.o ucioption.o
+	search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o
 
 ### ==========================================================================
 ### Section 2. High-level Configuration
@@ -43,147 +50,88 @@ OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
 # ----------------------------------------------------------------------------
 #
 # debug = yes/no      --- -DNDEBUG         --- Enable/Disable debug mode
+# sanitize = undefined/thread/no (-fsanitize )
+#                     --- ( undefined )    --- enable undefined behavior checks
+#                     --- ( thread    )    --- enable threading error  checks
 # optimize = yes/no   --- (-O3/-fast etc.) --- Enable/Disable optimizations
 # arch = (name)       --- (-arch)          --- Target architecture
-# os = (name)         ---                  --- Target operating system
 # bits = 64/32        --- -DIS_64BIT       --- 64-/32-bit operating system
-# bigendian = yes/no  --- -DBIGENDIAN      --- big/little-endian byte order
+# prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch asm-instruction
-# prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch x86 asm-instruction
+# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt asm-instruction
-# bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
+# sse = yes/no        --- -msse            --- Use Intel Streaming SIMD Extensions
-#                                              with GCC and ICC 64-bit)
+# pext = yes/no       --- -DUSE_PEXT       --- Use pext x86_64 asm-instruction
-# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
 #
 # Note that Makefile is space sensitive, so when adding new architectures
 # or modifying existing flags, you have to make sure there are no extra spaces
 # at the end of the line for flag values.
 
-### 2.1. General
+### 2.1. General and architecture defaults
-debug = no
 optimize = yes
+debug = no
+sanitize = no
+bits = 32
+prefetch = no
+popcnt = no
+sse = no
+pext = no
 
 ### 2.2 Architecture specific
 
-# General-section
-ifeq ($(ARCH),general-64)
-	arch = any
-	os = any
-	bits = 64
-	bigendian = no
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
 ifeq ($(ARCH),general-32)
 	arch = any
-	os = any
-	bits = 32
-	bigendian = no
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),bigendian-64)
-	arch = any
-	os = any
-	bits = 64
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),bigendian-32)
-	arch = any
-	os = any
-	bits = 32
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-# x86-section
-ifeq ($(ARCH),x86-64)
-	arch = x86_64
-	os = any
-	bits = 64
-	bigendian = no
-	prefetch = yes
-	bsfq = yes
-	popcnt = no
-endif
-
-ifeq ($(ARCH),x86-64-modern)
-	arch = x86_64
-	os = any
-	bits = 64
-	bigendian = no
-	prefetch = yes
-	bsfq = yes
-	popcnt = yes
-endif
-
-ifeq ($(ARCH),x86-32)
-	arch = i386
-	os = any
-	bits = 32
-	bigendian = no
-	prefetch = yes
-	bsfq = no
-	popcnt = no
 endif
 
 ifeq ($(ARCH),x86-32-old)
 	arch = i386
-	os = any
-	bits = 32
-	bigendian = no
-	prefetch = no
-	bsfq = no
-	popcnt = no
 endif
 
-# osx-section
+ifeq ($(ARCH),x86-32)
-ifeq ($(ARCH),osx-ppc-64)
-	arch = ppc64
-	os = osx
-	bits = 64
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),osx-ppc-32)
-	arch = ppc
-	os = osx
-	bits = 32
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),osx-x86-64)
-	arch = x86_64
-	os = osx
-	bits = 64
-	bigendian = no
-	prefetch = yes
-	bsfq = yes
-	popcnt = no
-endif
-
-ifeq ($(ARCH),osx-x86-32)
 	arch = i386
-	os = osx
-	bits = 32
-	bigendian = no
 	prefetch = yes
-	bsfq = no
+	sse = yes
-	popcnt = no
+endif
+
+ifeq ($(ARCH),general-64)
+	arch = any
+	bits = 64
+endif
+
+ifeq ($(ARCH),x86-64)
+	arch = x86_64
+	bits = 64
+	prefetch = yes
+	sse = yes
+endif
+
+ifeq ($(ARCH),x86-64-modern)
+	arch = x86_64
+	bits = 64
+	prefetch = yes
+	popcnt = yes
+	sse = yes
+endif
+
+ifeq ($(ARCH),x86-64-bmi2)
+	arch = x86_64
+	bits = 64
+	prefetch = yes
+	popcnt = yes
+	sse = yes
+	pext = yes
+endif
+
+ifeq ($(ARCH),armv7)
+	arch = armv7
+	prefetch = yes
+endif
+
+ifeq ($(ARCH),ppc-32)
+	arch = ppc
+endif
+
+ifeq ($(ARCH),ppc-64)
+	arch = ppc64
+	bits = 64
 endif
 
 
@@ -192,75 +140,170 @@ endif
 ### ==========================================================================
 
 ### 3.1 Selecting compiler (default = gcc)
+
+CXXFLAGS += -Wall -Wcast-qual -fno-exceptions -std=c++11 $(EXTRACXXFLAGS)
+DEPENDFLAGS += -std=c++11
+LDFLAGS += $(EXTRALDFLAGS)
+
 ifeq ($(COMP),)
 	COMP=gcc
 endif
 
-ifeq ($(COMP),mingw)
-	comp=mingw
-	CXX=g++
-	profile_prepare = gcc-profile-prepare
-	profile_make = gcc-profile-make
-	profile_use = gcc-profile-use
-	profile_clean = gcc-profile-clean
-endif
-
 ifeq ($(COMP),gcc)
 	comp=gcc
 	CXX=g++
-	profile_prepare = gcc-profile-prepare
+	CXXFLAGS += -pedantic -Wextra -Wshadow
-	profile_make = gcc-profile-make
+
-	profile_use = gcc-profile-use
+	ifeq ($(ARCH),armv7)
-	profile_clean = gcc-profile-clean
+		ifeq ($(OS),Android)
+			CXXFLAGS += -m$(bits)
+			LDFLAGS += -m$(bits)
+		endif
+	else
+		CXXFLAGS += -m$(bits)
+		LDFLAGS += -m$(bits)
+	endif
+
+	ifneq ($(KERNEL),Darwin)
+	   LDFLAGS += -Wl,--no-as-needed
+	endif
+endif
+
+ifeq ($(COMP),mingw)
+	comp=mingw
+
+	ifeq ($(KERNEL),Linux)
+		ifeq ($(bits),64)
+			ifeq ($(shell which x86_64-w64-mingw32-c++-posix),)
+				CXX=x86_64-w64-mingw32-c++
+			else
+				CXX=x86_64-w64-mingw32-c++-posix
+			endif
+		else
+			ifeq ($(shell which i686-w64-mingw32-c++-posix),)
+				CXX=i686-w64-mingw32-c++
+			else
+				CXX=i686-w64-mingw32-c++-posix
+			endif
+		endif
+	else
+		CXX=g++
+	endif
+
+	CXXFLAGS += -Wextra -Wshadow
+	LDFLAGS += -static
 endif
 
 ifeq ($(COMP),icc)
 	comp=icc
 	CXX=icpc
-	profile_prepare = icc-profile-prepare
+	CXXFLAGS += -diag-disable 1476,10120 -Wcheck -Wabi -Wdeprecated -strict-ansi
-	profile_make = icc-profile-make
-	profile_use = icc-profile-use
-	profile_clean = icc-profile-clean
 endif
 
-### 3.2 General compiler settings
+ifeq ($(COMP),clang)
-CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+	comp=clang
-
+	CXX=clang++
-ifeq ($(comp),gcc)
+	CXXFLAGS += -pedantic -Wextra -Wshadow
-	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
+ifneq ($(KERNEL),Darwin)
+ifneq ($(KERNEL),OpenBSD)
+	LDFLAGS += -latomic
+endif
 endif
 
-ifeq ($(comp),mingw)
+	ifeq ($(ARCH),armv7)
-	CXXFLAGS += -Wextra -Wshadow
+		ifeq ($(OS),Android)
+			CXXFLAGS += -m$(bits)
+			LDFLAGS += -m$(bits)
+		endif
+	else
+		CXXFLAGS += -m$(bits)
+		LDFLAGS += -m$(bits)
+	endif
 endif
 
 ifeq ($(comp),icc)
-	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+	profile_make = icc-profile-make
+	profile_use = icc-profile-use
+else
+ifeq ($(comp),clang)
+	profile_make = clang-profile-make
+	profile_use = clang-profile-use
+else
+	profile_make = gcc-profile-make
+	profile_use = gcc-profile-use
+endif
 endif
 
-ifeq ($(os),osx)
+ifeq ($(KERNEL),Darwin)
-	CXXFLAGS += -arch $(arch)
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.9
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.9
 endif
 
-### 3.3 General linker settings
+### Travis CI script uses COMPILER to overwrite CXX
-LDFLAGS = -lpthread $(EXTRALDFLAGS)
+ifdef COMPILER
-
+	COMPCXX=$(COMPILER)
-ifeq ($(os),osx)
-	LDFLAGS += -arch $(arch)
 endif
 
-### 3.4 Debugging
+### Allow overwriting CXX from command line
+ifdef COMPCXX
+	CXX=$(COMPCXX)
+endif
+
+### On mingw use Windows threads, otherwise POSIX
+ifneq ($(comp),mingw)
+	# On Android Bionic's C library comes with its own pthread implementation bundled in
+	ifneq ($(OS),Android)
+		# Haiku has pthreads in its libroot, so only link it in on other platforms
+		ifneq ($(KERNEL),Haiku)
+			LDFLAGS += -lpthread
+		endif
+	endif
+endif
+
+### 3.2.1 Debugging
 ifeq ($(debug),no)
 	CXXFLAGS += -DNDEBUG
+else
+	CXXFLAGS += -g
 endif
 
-### 3.5 Optimization
+### 3.2.2 Debugging with undefined behavior sanitizers
+ifneq ($(sanitize),no)
+        CXXFLAGS += -g3 -fsanitize=$(sanitize) -fuse-ld=gold
+        LDFLAGS += -fsanitize=$(sanitize) -fuse-ld=gold
+endif
+
+### 3.3 Optimization
 ifeq ($(optimize),yes)
 
-	ifeq ($(comp),gcc)
 	CXXFLAGS += -O3
 
-		ifeq ($(os),osx)
+	ifeq ($(comp),gcc)
+
+		ifeq ($(KERNEL),Darwin)
+			ifeq ($(arch),i386)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+			ifeq ($(arch),x86_64)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+		endif
+
+		ifeq ($(OS), Android)
+			CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
+		endif
+	endif
+
+	ifeq ($(comp),icc)
+		ifeq ($(KERNEL),Darwin)
+			CXXFLAGS += -mdynamic-no-pic
+		endif
+	endif
+
+	ifeq ($(comp),clang)
+		ifeq ($(KERNEL),Darwin)
+				CXXFLAGS += -flto
+				LDFLAGS += $(CXXFLAGS)
 			ifeq ($(arch),i386)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
@@ -269,59 +312,70 @@ ifeq ($(optimize),yes)
 			endif
 		endif
 	endif
-
-	ifeq ($(comp),mingw)
-		CXXFLAGS += -O3
 endif
 
-	ifeq ($(comp),icc)
+### 3.4 Bits
-		ifeq ($(os),osx)
-			CXXFLAGS += -fast -mdynamic-no-pic
-		else
-			CXXFLAGS += -O3
-		endif
-	endif
-endif
-
-### 3.6. Bits
 ifeq ($(bits),64)
 	CXXFLAGS += -DIS_64BIT
 endif
 
-### 3.7 Endianess
+### 3.5 prefetch
-ifeq ($(bigendian),yes)
-	CXXFLAGS += -DBIGENDIAN
-endif
-
-### 3.8 prefetch
 ifeq ($(prefetch),yes)
+	ifeq ($(sse),yes)
 		CXXFLAGS += -msse
 		DEPENDFLAGS += -msse
+	endif
 else
 	CXXFLAGS += -DNO_PREFETCH
 endif
 
-### 3.9 bsfq
+### 3.6 popcnt
-ifeq ($(bsfq),yes)
-	CXXFLAGS += -DUSE_BSFQ
-endif
-
-### 3.10 popcnt
 ifeq ($(popcnt),yes)
+	ifeq ($(comp),icc)
 		CXXFLAGS += -msse3 -DUSE_POPCNT
+	else
+		CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT
+	endif
 endif
 
-### 3.11 Link Time Optimization, it works since gcc 4.5 but not on mingw.
+### 3.7 pext
+ifeq ($(pext),yes)
+	CXXFLAGS += -DUSE_PEXT
+	ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+		CXXFLAGS += -mbmi2
+	endif
+endif
+
+### 3.8 Link Time Optimization, it works since gcc 4.5 but not on mingw under Windows.
 ### This is a mix of compile and link time options because the lto link phase
 ### needs access to the optimization flags.
 ifeq ($(comp),gcc)
-	GCC_MAJOR := `gcc -dumpversion | cut -f1 -d.`
+	ifeq ($(optimize),yes)
-	GCC_MINOR := `gcc -dumpversion | cut -f2 -d.`
+	ifeq ($(debug),no)
-	ifeq (1,$(shell expr \( $(GCC_MAJOR) \> 4 \) \| \( $(GCC_MAJOR) \= 4 \& $(GCC_MINOR) \>= 5 \)))
 		CXXFLAGS += -flto
 		LDFLAGS += $(CXXFLAGS)
 	endif
 	endif
+endif
+
+ifeq ($(comp),mingw)
+	ifeq ($(KERNEL),Linux)
+	ifeq ($(optimize),yes)
+	ifeq ($(debug),no)
+		CXXFLAGS += -flto
+		LDFLAGS += $(CXXFLAGS)
+	endif
+	endif
+	endif
+endif
+
+### 3.9 Android 5 can only run position independent executables. Note that this
+### breaks Android 4.0 and earlier.
+ifeq ($(OS), Android)
+	CXXFLAGS += -fPIE
+	LDFLAGS += -fPIE -pie
+endif
+
 
 ### ==========================================================================
 ### Section 4. Public targets
@@ -331,100 +385,69 @@ help:
 	@echo ""
 	@echo "To compile stockfish, type: "
 	@echo ""
-	@echo "make target ARCH=arch [COMP=comp]"
+	@echo "make target ARCH=arch [COMP=compiler] [COMPCXX=cxx]"
 	@echo ""
 	@echo "Supported targets:"
 	@echo ""
-	@echo "build                > Build unoptimized version"
+	@echo "build                   > Standard build"
-	@echo "profile-build        > Build PGO-optimized version"
+	@echo "profile-build           > PGO build"
-	@echo "double-profile-build > Build PGO-optimized version with and without popcnt support"
 	@echo "strip                   > Strip executable"
 	@echo "install                 > Install executable"
 	@echo "clean                   > Clean up"
-	@echo "testrun              > Make sample run"
 	@echo ""
 	@echo "Supported archs:"
 	@echo ""
 	@echo "x86-64                  > x86 64-bit"
-	@echo "x86-64-modern        > x86 64-bit with runtime support for popcnt instruction"
+	@echo "x86-64-modern           > x86 64-bit with popcnt support"
-	@echo "x86-32               > x86 32-bit excluding very old hardware without SSE-support"
+	@echo "x86-64-bmi2             > x86 64-bit with pext support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
+	@echo "x86-32                  > x86 32-bit with SSE support"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
+	@echo "ppc-64                  > PPC 64-bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
+	@echo "ppc-32                  > PPC 32-bit"
-	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
+	@echo "armv7                   > ARMv7 32-bit"
 	@echo "general-64              > unspecified 64-bit"
 	@echo "general-32              > unspecified 32-bit"
-	@echo "bigendian-64         > unspecified 64-bit with bigendian byte order"
-	@echo "bigendian-32         > unspecified 32-bit with bigendian byte order"
 	@echo ""
-	@echo "Supported comps:"
+	@echo "Supported compilers:"
 	@echo ""
 	@echo "gcc                     > Gnu compiler (default)"
-	@echo "icc                  > Intel compiler"
 	@echo "mingw                   > Gnu compiler with MinGW under Windows"
+	@echo "clang                   > LLVM Clang compiler"
+	@echo "icc                     > Intel compiler"
 	@echo ""
-	@echo "Non-standard targets:"
+	@echo "Simple examples. If you don't know what to do, you likely want to run: "
 	@echo ""
-	@echo "make hpux           >  Compile for HP-UX. Compiler = aCC"
+	@echo "make build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make build ARCH=x86-32    (This is for 32-bit systems)"
 	@echo ""
-	@echo "Examples. If you don't know what to do, you likely want to run: "
+	@echo "Advanced examples, for experienced users: "
 	@echo ""
-	@echo "make profile-build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make build ARCH=x86-64 COMP=clang"
-	@echo "make profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo "make profile-build ARCH=x86-64-modern COMP=gcc COMPCXX=g++-4.8"
 	@echo ""
 
-build:
+
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+.PHONY: help build profile-build strip install clean objclean profileclean help \
+        config-sanity icc-profile-use icc-profile-make gcc-profile-use gcc-profile-make \
+        clang-profile-use clang-profile-make
+
+build: config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
 
-profile-build:
+profile-build: config-sanity objclean profileclean
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
 	@echo ""
-	@echo "Step 0/4. Preparing for profile build."
+	@echo "Step 1/4. Building instrumented executable ..."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
-	@echo ""
-	@echo "Step 1/4. Building executable for benchmark ..."
-	@touch *.cpp *.h
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
 	@echo ""
 	@echo "Step 2/4. Running benchmark for pgo-build ..."
-	@$(PGOBENCH) > /dev/null
+	$(PGOBENCH) > /dev/null
 	@echo ""
-	@echo "Step 3/4. Building final executable ..."
+	@echo "Step 3/4. Building optimized executable ..."
-	@touch *.cpp
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) objclean
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
 	@echo ""
 	@echo "Step 4/4. Deleting profile data ..."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) profileclean
-
-double-profile-build:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
-	@echo ""
-	@echo "Step 0/6. Preparing for profile build."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
-	@echo ""
-	@echo "Step 1/6. Building executable for benchmark (popcnt disabled)..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=x86-64 COMP=$(COMP) $(profile_make)
-	@echo ""
-	@echo "Step 2/6. Running benchmark for pgo-build (popcnt disabled)..."
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 3/6. Building executable for benchmark (popcnt enabled)..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=x86-64-modern COMP=$(COMP) $(profile_make)
-	@echo ""
-	@echo "Step 4/6. Running benchmark for pgo-build (popcnt enabled)..."
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 5/6. Building final executable ..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
-	@echo ""
-	@echo "Step 6/6. Deleting profile data ..."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
-	@echo ""
 
 strip:
 	strip $(EXE)
@@ -434,11 +457,19 @@ install:
 	-cp $(EXE) $(BINDIR)
 	-strip $(BINDIR)/$(EXE)
 
-clean:
+#clean all
-	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
+clean: objclean profileclean
+	@rm -f .depend *~ core
 
-testrun:
+# clean binaries and objects
-	@$(PGOBENCH)
+objclean:
+	@rm -f $(EXE) $(EXE).exe *.o ./syzygy/*.o
+
+# clean auxiliary profiling files
+profileclean:
+	@rm -rf profdir
+	@rm -f bench.txt *.gcda ./syzygy/*.gcda *.gcno ./syzygy/*.gcno
+	@rm -f stockfish.profdata *.profraw
 
 default:
 	help
@@ -453,14 +484,16 @@ config-sanity:
 	@echo ""
 	@echo "Config:"
 	@echo "debug: '$(debug)'"
+	@echo "sanitize: '$(sanitize)'"
 	@echo "optimize: '$(optimize)'"
 	@echo "arch: '$(arch)'"
-	@echo "os: '$(os)'"
 	@echo "bits: '$(bits)'"
-	@echo "bigendian: '$(bigendian)'"
+	@echo "kernel: '$(KERNEL)'"
+	@echo "os: '$(OS)'"
 	@echo "prefetch: '$(prefetch)'"
-	@echo "bsfq: '$(bsfq)'"
 	@echo "popcnt: '$(popcnt)'"
+	@echo "sse: '$(sse)'"
+	@echo "pext: '$(pext)'"
 	@echo ""
 	@echo "Flags:"
 	@echo "CXX: $(CXX)"
@@ -470,22 +503,32 @@ config-sanity:
 	@echo "Testing config sanity. If this fails, try 'make help' ..."
 	@echo ""
 	@test "$(debug)" = "yes" || test "$(debug)" = "no"
+	@test "$(sanitize)" = "undefined" || test "$(sanitize)" = "thread" || test "$(sanitize)" = "no"
 	@test "$(optimize)" = "yes" || test "$(optimize)" = "no"
 	@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
-	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc"
+	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
-	@test "$(os)" = "any" || test "$(os)" = "osx"
 	@test "$(bits)" = "32" || test "$(bits)" = "64"
-	@test "$(bigendian)" = "yes" || test "$(bigendian)" = "no"
 	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
-	@test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
 	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
-	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw"
+	@test "$(sse)" = "yes" || test "$(sse)" = "no"
+	@test "$(pext)" = "yes" || test "$(pext)" = "no"
+	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang"
 
 $(EXE): $(OBJS)
 	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
 
-gcc-profile-prepare:
+clang-profile-make:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) gcc-profile-clean
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-instr-generate ' \
+	EXTRALDFLAGS=' -fprofile-instr-generate' \
+	all
+
+clang-profile-use:
+	llvm-profdata merge -output=stockfish.profdata *.profraw
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-instr-use=stockfish.profdata' \
+	EXTRALDFLAGS='-fprofile-use ' \
+	all
 
 gcc-profile-make:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
@@ -495,18 +538,12 @@ gcc-profile-make:
 
 gcc-profile-use:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
-	EXTRACXXFLAGS='-fprofile-use' \
+	EXTRACXXFLAGS='-fprofile-use -fno-peel-loops -fno-tracer' \
 	EXTRALDFLAGS='-lgcov' \
 	all
 
-gcc-profile-clean:
-	@rm -rf *.gcda *.gcno bench.txt
-
-icc-profile-prepare:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) icc-profile-clean
-	@mkdir profdir
-
 icc-profile-make:
+	@mkdir -p profdir
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
 	EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
 	all
@@ -516,23 +553,8 @@ icc-profile-use:
 	EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
 	all
 
-icc-profile-clean:
-	@rm -rf profdir bench.txt
-
 .depend:
 	-@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null
 
 -include .depend
 
-
-### ==========================================================================
-### Section 6. Non-standard targets
-### ==========================================================================
-
-hpux:
-	$(MAKE) \
-	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG -DNO_PREFETCH' \
-	CXXFLAGS="" \
-	LDFLAGS="" \
-	all
-

src/benchmark.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -19,24 +20,23 @@
 
 #include <fstream>
 #include <iostream>
+#include <istream>
 #include <vector>
 
-#include "misc.h"
 #include "position.h"
-#include "search.h"
-#include "thread.h"
-#include "ucioption.h"
 
 using namespace std;
-using namespace Search;
 
-static const char* Defaults[] = {
+namespace {
+
+const vector<string> Defaults = {
+  "setoption name UCI_Chess960 value false",
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
   "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10",
   "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
-  "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14",
+  "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14 moves d4e6",
-  "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14",
+  "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14 moves g2g4",
   "r3r1k1/2p2ppp/p1p1bn2/8/1q2P3/2NPQN2/PPP3PP/R4RK1 b - - 2 15",
   "r1bbk1nr/pp3p1p/2n5/1N4p1/2Np1B2/8/PPP2PPP/2KR1B1R w kq - 0 13",
   "r1bq1rk1/ppp1nppp/4n3/3p3Q/3P4/1BP1B3/PP1N2PP/R4RK1 w - - 1 16",
@@ -46,49 +46,85 @@ static const char* Defaults[] = {
   "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
   "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
   "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
-  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
+  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26",
+  "6k1/6p1/6Pp/ppp5/3pn2P/1P3K2/1PP2P2/3N4 b - - 0 1",
+  "3b4/5kp1/1p1p1p1p/pP1PpP1P/P1P1P3/3KN3/8/8 w - - 0 1",
+  "2K5/p7/7P/5pR1/8/5k2/r7/8 w - - 0 1 moves g5g6 f3e3 g6g5 e3f3",
+  "8/6pk/1p6/8/PP3p1p/5P2/4KP1q/3Q4 w - - 0 1",
+  "7k/3p2pp/4q3/8/4Q3/5Kp1/P6b/8 w - - 0 1",
+  "8/2p5/8/2kPKp1p/2p4P/2P5/3P4/8 w - - 0 1",
+  "8/1p3pp1/7p/5P1P/2k3P1/8/2K2P2/8 w - - 0 1",
+  "8/pp2r1k1/2p1p3/3pP2p/1P1P1P1P/P5KR/8/8 w - - 0 1",
+  "8/3p4/p1bk3p/Pp6/1Kp1PpPp/2P2P1P/2P5/5B2 b - - 0 1",
+  "5k2/7R/4P2p/5K2/p1r2P1p/8/8/8 b - - 0 1",
+  "6k1/6p1/P6p/r1N5/5p2/7P/1b3PP1/4R1K1 w - - 0 1",
+  "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1",
+  "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1",
+  "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1",
+
+  // 5-man positions
+  "8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1",     // Kc2 - mate
+  "8/8/8/5N2/8/p7/8/2NK3k w - - 0 1",      // Na2 - mate
+  "8/3k4/8/8/8/4B3/4KB2/2B5 w - - 0 1",    // draw
+
+  // 6-man positions
+  "8/8/1P6/5pr1/8/4R3/7k/2K5 w - - 0 1",   // Re5 - mate
+  "8/2p4P/8/kr6/6R1/8/8/1K6 w - - 0 1",    // Ka2 - mate
+  "8/8/3P3k/8/1p6/8/1P6/1K3n2 b - - 0 1",  // Nd2 - draw
+
+  // 7-man positions
+  "8/R7/2q5/8/6k1/8/1P5p/K6R w - - 0 124", // Draw
+
+  // Mate and stalemate positions
+  "6k1/3b3r/1p1p4/p1n2p2/1PPNpP1q/P3Q1p1/1R1RB1P1/5K2 b - - 0 1",
+  "r2r1n2/pp2bk2/2p1p2p/3q4/3PN1QP/2P3R1/P4PP1/5RK1 w - - 0 1",
+  "8/8/8/8/8/6k1/6p1/6K1 w - -",
+  "7k/7P/6K1/8/3B4/8/8/8 b - -",
+
+  // Chess 960
+  "setoption name UCI_Chess960 value true",
+  "bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1 moves g2g3 d7d5 d2d4 c8h3 c1g5 e8d6 g5e7 f7f6",
+  "setoption name UCI_Chess960 value false"
 };
 
+} // namespace
 
-/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
+/// setup_bench() builds a list of UCI commands to be run by bench. There
-/// of positions for a given limit each. There are five parameters; the
+/// are five parameters: TT size in MB, number of search threads that
-/// transposition table size, the number of search threads that should
+/// should be used, the limit value spent for each position, a file name
-/// be used, the limit value spent for each position (optional, default is
+/// where to look for positions in FEN format and the type of the limit:
-/// depth 12), an optional file name where to look for positions in fen
+/// depth, perft, nodes and movetime (in millisecs).
-/// format (defaults are the positions defined above) and the type of the
+///
-/// limit value: depth (default), time in secs or number of nodes.
+/// bench -> search default positions up to depth 13
+/// bench 64 1 15 -> search default positions up to depth 15 (TT = 64MB)
+/// bench 64 4 5000 current movetime -> search current position with 4 threads for 5 sec
+/// bench 64 1 100000 default nodes -> search default positions for 100K nodes each
+/// bench 16 1 5 default perft -> run a perft 5 on default positions
 
-void benchmark(int argc, char* argv[]) {
+vector<string> setup_bench(const Position& current, istream& is) {
 
-  vector<string> fens;
+  vector<string> fens, list;
-  LimitsType limits;
+  string go, token;
-  int time;
-  int64_t nodes = 0;
 
   // Assign default values to missing arguments
-  string ttSize  = argc > 2 ? argv[2] : "128";
+  string ttSize    = (is >> token) ? token : "16";
-  string threads = argc > 3 ? argv[3] : "1";
+  string threads   = (is >> token) ? token : "1";
-  string valStr  = argc > 4 ? argv[4] : "12";
+  string limit     = (is >> token) ? token : "13";
-  string fenFile = argc > 5 ? argv[5] : "default";
+  string fenFile   = (is >> token) ? token : "default";
-  string valType = argc > 6 ? argv[6] : "depth";
+  string limitType = (is >> token) ? token : "depth";
 
-  Options["Hash"]    = ttSize;
+  go = "go " + limitType + " " + limit;
-  Options["Threads"] = threads;
-  Options["OwnBook"] = false;
 
-  if (valType == "time")
+  if (fenFile == "default")
-      limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
+      fens = Defaults;
 
-  else if (valType == "nodes")
+  else if (fenFile == "current")
-      limits.maxNodes = atoi(valStr.c_str());
+      fens.push_back(current.fen());
 
   else
-      limits.maxDepth = atoi(valStr.c_str());
-
-  if (fenFile != "default")
   {
       string fen;
-      ifstream file(fenFile.c_str());
+      ifstream file(fenFile);
 
       if (!file.is_open())
       {
@@ -102,34 +138,19 @@ void benchmark(int argc, char* argv[]) {
 
       file.close();
   }
-  else
-      fens.assign(Defaults, Defaults + 16);
 
-  time = system_time();
+  list.emplace_back("ucinewgame");
+  list.emplace_back("setoption name Threads value " + threads);
+  list.emplace_back("setoption name Hash value " + ttSize);
 
-  for (size_t i = 0; i < fens.size(); i++)
+  for (const string& fen : fens)
-  {
+      if (fen.find("setoption") != string::npos)
-      Position pos(fens[i], false, 0);
+          list.emplace_back(fen);
-
-      cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
-
-      if (valType == "perft")
-      {
-          int64_t cnt = perft(pos, limits.maxDepth * ONE_PLY);
-          cerr << "\nPerft " << limits.maxDepth  << " leaf nodes: " << cnt << endl;
-          nodes += cnt;
-      }
       else
       {
-          Threads.start_thinking(pos, limits, vector<Move>(), false);
+          list.emplace_back("position fen " + fen);
-          nodes += RootPosition.nodes_searched();
+          list.emplace_back(go);
-      }
       }
 
-  time = system_time() - time;
+  return list;
-
-  cerr << "\n==========================="
-       << "\nTotal time (ms) : " << time
-       << "\nNodes searched  : " << nodes
-       << "\nNodes/second    : " << int(nodes / (time / 1000.0)) << endl;
 }

src/bitbase.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,255 +18,163 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
 #include <cassert>
+#include <numeric>
+#include <vector>
 
 #include "bitboard.h"
 #include "types.h"
 
 namespace {
 
-  enum Result {
+  // There are 24 possible pawn squares: the first 4 files and ranks from 2 to 7
-    RESULT_UNKNOWN,
+  const unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608
-    RESULT_INVALID,
-    RESULT_WIN,
-    RESULT_DRAW
-  };
-
-  struct KPKPosition {
-    Result classify_knowns(int index);
-    Result classify(int index, Result db[]);
-
-  private:
-    void from_index(int index);
-    Result classify_white(const Result db[]);
-    Result classify_black(const Result db[]);
-    Bitboard wk_attacks()   const { return StepAttacksBB[W_KING][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttacksBB[B_KING][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttacksBB[W_PAWN][pawnSquare]; }
-
-    Square whiteKingSquare, blackKingSquare, pawnSquare;
-    Color sideToMove;
-  };
-
-  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
-  const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq = 196608
 
   // Each uint32_t stores results of 32 positions, one per bit
-  uint32_t KPKBitbase[IndexMax / 32];
+  uint32_t KPKBitbase[MAX_INDEX / 32];
 
-  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
+  // A KPK bitbase index is an integer in [0, IndexMax] range
+  //
+  // Information is mapped in a way that minimizes the number of iterations:
+  //
+  // bit  0- 5: white king square (from SQ_A1 to SQ_H8)
+  // bit  6-11: black king square (from SQ_A1 to SQ_H8)
+  // bit    12: side to move (WHITE or BLACK)
+  // bit 13-14: white pawn file (from FILE_A to FILE_D)
+  // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+  unsigned index(Color us, Square bksq, Square wksq, Square psq) {
+    return wksq | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15);
+  }
+
+  enum Result {
+    INVALID = 0,
+    UNKNOWN = 1,
+    DRAW    = 2,
+    WIN     = 4
+  };
+
+  Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+
+  struct KPKPosition {
+    KPKPosition() = default;
+    explicit KPKPosition(unsigned idx);
+    operator Result() const { return result; }
+    Result classify(const std::vector<KPKPosition>& db)
+    { return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }
+
+    template<Color Us> Result classify(const std::vector<KPKPosition>& db);
+
+    Color us;
+    Square ksq[COLOR_NB], psq;
+    Result result;
+  };
+
+} // namespace
+
+
+bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color us) {
+
+  assert(file_of(wpsq) <= FILE_D);
+
+  unsigned idx = index(us, bksq, wksq, wpsq);
+  return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));
 }
 
 
-uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
+void Bitbases::init() {
 
-  int index = compute_index(wksq, bksq, wpsq, stm);
+  std::vector<KPKPosition> db(MAX_INDEX);
+  unsigned idx, repeat = 1;
 
-  return KPKBitbase[index / 32] & (1 << (index & 31));
+  // Initialize db with known win / draw positions
-}
+  for (idx = 0; idx < MAX_INDEX; ++idx)
+      db[idx] = KPKPosition(idx);
 
-
+  // Iterate through the positions until none of the unknown positions can be
-void kpk_bitbase_init() {
+  // changed to either wins or draws (15 cycles needed).
-
-  Result db[IndexMax];
-  KPKPosition pos;
-  int index, bit, repeat = 1;
-
-  // Initialize table
-  for (index = 0; index < IndexMax; index++)
-      db[index] = pos.classify_knowns(index);
-
-  // Iterate until all positions are classified (30 cycles needed)
   while (repeat)
-      for (repeat = index = 0; index < IndexMax; index++)
+      for (repeat = idx = 0; idx < MAX_INDEX; ++idx)
-          if (   db[index] == RESULT_UNKNOWN
+          repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);
-              && pos.classify(index, db) != RESULT_UNKNOWN)
-              repeat = 1;
 
-  // Map 32 position results into one KPKBitbase[] entry
+  // Map 32 results into one KPKBitbase[] entry
-  for (index = 0; index < IndexMax / 32; index++)
+  for (idx = 0; idx < MAX_INDEX; ++idx)
-      for (bit = 0; bit < 32; bit++)
+      if (db[idx] == WIN)
-          if (db[32 * index + bit] == RESULT_WIN)
+          KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
-              KPKBitbase[index] |= (1 << bit);
 }
 
 
 namespace {
 
-  // A KPK bitbase index is an integer in [0, IndexMax] range
+  KPKPosition::KPKPosition(unsigned idx) {
+
+    ksq[WHITE] = Square((idx >>  0) & 0x3F);
+    ksq[BLACK] = Square((idx >>  6) & 0x3F);
+    us         = Color ((idx >> 12) & 0x01);
+    psq        = make_square(File((idx >> 13) & 0x3), Rank(RANK_7 - ((idx >> 15) & 0x7)));
+
+    // Check if two pieces are on the same square or if a king can be captured
+    if (   distance(ksq[WHITE], ksq[BLACK]) <= 1
+        || ksq[WHITE] == psq
+        || ksq[BLACK] == psq
+        || (us == WHITE && (PawnAttacks[WHITE][psq] & ksq[BLACK])))
+        result = INVALID;
+
+    // Immediate win if a pawn can be promoted without getting captured
+    else if (   us == WHITE
+             && rank_of(psq) == RANK_7
+             && ksq[us] != psq + NORTH
+             && (    distance(ksq[~us], psq + NORTH) > 1
+                 || (PseudoAttacks[KING][ksq[us]] & (psq + NORTH))))
+        result = WIN;
+
+    // Immediate draw if it is a stalemate or a king captures undefended pawn
+    else if (   us == BLACK
+             && (  !(PseudoAttacks[KING][ksq[us]] & ~(PseudoAttacks[KING][ksq[~us]] | PawnAttacks[~us][psq]))
+                 || (PseudoAttacks[KING][ksq[us]] & psq & ~PseudoAttacks[KING][ksq[~us]])))
+        result = DRAW;
+
+    // Position will be classified later
+    else
+        result = UNKNOWN;
+  }
+
+  template<Color Us>
+  Result KPKPosition::classify(const std::vector<KPKPosition>& db) {
+
+    // White to move: If one move leads to a position classified as WIN, the result
+    // of the current position is WIN. If all moves lead to positions classified
+    // as DRAW, the current position is classified as DRAW, otherwise the current
+    // position is classified as UNKNOWN.
     //
-  // Information is mapped in this way
+    // Black to move: If one move leads to a position classified as DRAW, the result
-  //
+    // of the current position is DRAW. If all moves lead to positions classified
-  // bit     0: side to move (WHITE or BLACK)
+    // as WIN, the position is classified as WIN, otherwise the current position is
-  // bit  1- 6: black king square (from SQ_A1 to SQ_H8)
+    // classified as UNKNOWN.
-  // bit  7-12: white king square (from SQ_A1 to SQ_H8)
-  // bit 13-14: white pawn file (from FILE_A to FILE_D)
-  // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
 
-  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) {
+    const Color  Them = (Us == WHITE ? BLACK : WHITE);
+    const Result Good = (Us == WHITE ? WIN   : DRAW);
+    const Result Bad  = (Us == WHITE ? DRAW  : WIN);
 
-    assert(file_of(wpsq) <= FILE_D);
+    Result r = INVALID;
+    Bitboard b = PseudoAttacks[KING][ksq[Us]];
 
-    int p = file_of(wpsq) + 4 * (rank_of(wpsq) - 1);
-    int r = stm + 2 * bksq + 128 * wksq + 8192 * p;
-
-    assert(r >= 0 && r < IndexMax);
-
-    return r;
-  }
-
-  void KPKPosition::from_index(int index) {
-
-    int s = index >> 13;
-    sideToMove = Color(index & 1);
-    blackKingSquare = Square((index >> 1) & 63);
-    whiteKingSquare = Square((index >> 7) & 63);
-    pawnSquare = make_square(File(s & 3), Rank((s >> 2) + 1));
-  }
-
-  Result KPKPosition::classify_knowns(int index) {
-
-    from_index(index);
-
-    // Check if two pieces are on the same square
-    if (   whiteKingSquare == pawnSquare
-        || whiteKingSquare == blackKingSquare
-        || blackKingSquare == pawnSquare)
-        return RESULT_INVALID;
-
-    // Check if a king can be captured
-    if (    bit_is_set(wk_attacks(), blackKingSquare)
-        || (bit_is_set(pawn_attacks(), blackKingSquare) && sideToMove == WHITE))
-        return RESULT_INVALID;
-
-    // The position is an immediate win if it is white to move and the
-    // white pawn can be promoted without getting captured.
-    if (   rank_of(pawnSquare) == RANK_7
-        && sideToMove == WHITE
-        && whiteKingSquare != pawnSquare + DELTA_N
-        && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
-            || bit_is_set(wk_attacks(), pawnSquare + DELTA_N)))
-        return RESULT_WIN;
-
-    // Check for known draw positions
-    //
-    // Case 1: Stalemate
-    if (   sideToMove == BLACK
-        && !(bk_attacks() & ~(wk_attacks() | pawn_attacks())))
-        return RESULT_DRAW;
-
-    // Case 2: King can capture pawn
-    if (   sideToMove == BLACK
-        && bit_is_set(bk_attacks(), pawnSquare) && !bit_is_set(wk_attacks(), pawnSquare))
-        return RESULT_DRAW;
-
-    // Case 3: Black king in front of white pawn
-    if (   blackKingSquare == pawnSquare + DELTA_N
-        && rank_of(pawnSquare) < RANK_7)
-        return RESULT_DRAW;
-
-    //  Case 4: White king in front of pawn and black has opposition
-    if (   whiteKingSquare == pawnSquare + DELTA_N
-        && blackKingSquare == pawnSquare + DELTA_N + DELTA_N + DELTA_N
-        && rank_of(pawnSquare) < RANK_5
-        && sideToMove == WHITE)
-        return RESULT_DRAW;
-
-    // Case 5: Stalemate with rook pawn
-    if (   blackKingSquare == SQ_A8
-        && file_of(pawnSquare) == FILE_A)
-        return RESULT_DRAW;
-
-    return RESULT_UNKNOWN;
-  }
-
-  Result KPKPosition::classify(int index, Result db[]) {
-
-    from_index(index);
-    db[index] = (sideToMove == WHITE ? classify_white(db) : classify_black(db));
-    return db[index];
-  }
-
-  Result KPKPosition::classify_white(const Result db[]) {
-
-    // If one move leads to a position classified as RESULT_WIN, the result
-    // of the current position is RESULT_WIN. If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
-    // otherwise the current position is classified as RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = wk_attacks();
     while (b)
+        r |= Us == WHITE ? db[index(Them, ksq[Them]  , pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), ksq[Them]  , psq)];
+
+    if (Us == WHITE)
     {
-        s = pop_1st_bit(&b);
+        if (rank_of(psq) < RANK_7)      // Single push
-        r = db[compute_index(s, blackKingSquare, pawnSquare, BLACK)];
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH)];
 
-        if (r == RESULT_WIN)
+        if (   rank_of(psq) == RANK_2   // Double push
-            return RESULT_WIN;
+            && psq + NORTH != ksq[Us]
-
+            && psq + NORTH != ksq[Them])
-        if (r == RESULT_UNKNOWN)
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH + NORTH)];
-            unknownFound = true;
     }
 
-    // Pawn moves
+    return result = r & Good  ? Good  : r & UNKNOWN ? UNKNOWN : Bad;
-    if (rank_of(pawnSquare) < RANK_7)
-    {
-        s = pawnSquare + DELTA_N;
-        r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
-
-        if (r == RESULT_WIN)
-            return RESULT_WIN;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-
-        // Double pawn push
-        if (rank_of(s) == RANK_3 && r != RESULT_INVALID)
-        {
-            s += DELTA_N;
-            r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
-
-            if (r == RESULT_WIN)
-                return RESULT_WIN;
-
-            if (r == RESULT_UNKNOWN)
-                unknownFound = true;
-        }
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
   }
 
-  Result KPKPosition::classify_black(const Result db[]) {
+} // namespace
-
-    // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW. If all moves lead to positions
-    // classified as RESULT_WIN, the position is classified as RESULT_WIN.
-    // Otherwise, the current position is classified as RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = bk_attacks();
-    while (b)
-    {
-        s = pop_1st_bit(&b);
-        r = db[compute_index(whiteKingSquare, s, pawnSquare, WHITE)];
-
-        if (r == RESULT_DRAW)
-            return RESULT_DRAW;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_WIN;
-  }
-
-}

src/bitboard.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,299 +19,246 @@
 */
 
 #include <algorithm>
-#include <cstring>
-#include <iostream>
 
 #include "bitboard.h"
-#include "bitcount.h"
+#include "misc.h"
-#include "rkiss.h"
 
-Bitboard RMasks[64];
+uint8_t PopCnt16[1 << 16];
-Bitboard RMagics[64];
+int SquareDistance[SQUARE_NB][SQUARE_NB];
-Bitboard* RAttacks[64];
-int RShifts[64];
 
-Bitboard BMasks[64];
+Bitboard SquareBB[SQUARE_NB];
-Bitboard BMagics[64];
+Bitboard FileBB[FILE_NB];
-Bitboard* BAttacks[64];
+Bitboard RankBB[RANK_NB];
-int BShifts[64];
+Bitboard AdjacentFilesBB[FILE_NB];
+Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+Bitboard LineBB[SQUARE_NB][SQUARE_NB];
+Bitboard DistanceRingBB[SQUARE_NB][8];
+Bitboard ForwardFileBB[COLOR_NB][SQUARE_NB];
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
 
-Bitboard SetMaskBB[65];
+Magic RookMagics[SQUARE_NB];
-Bitboard ClearMaskBB[65];
+Magic BishopMagics[SQUARE_NB];
-
-Bitboard FileBB[8];
-Bitboard RankBB[8];
-Bitboard NeighboringFilesBB[8];
-Bitboard ThisAndNeighboringFilesBB[8];
-Bitboard InFrontBB[2][8];
-Bitboard StepAttacksBB[16][64];
-Bitboard BetweenBB[64][64];
-Bitboard SquaresInFrontMask[2][64];
-Bitboard PassedPawnMask[2][64];
-Bitboard AttackSpanMask[2][64];
-
-Bitboard BishopPseudoAttacks[64];
-Bitboard RookPseudoAttacks[64];
-Bitboard QueenPseudoAttacks[64];
-
-uint8_t BitCount8Bit[256];
-int SquareDistance[64][64];
 
 namespace {
 
-  CACHE_LINE_ALIGNMENT
+  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
+  const uint64_t DeBruijn64 = 0x3F79D71B4CB0A89ULL;
+  const uint32_t DeBruijn32 = 0x783A9B23;
 
-  int BSFTable[64];
+  int MSBTable[256];            // To implement software msb()
-  Bitboard RookTable[0x19000];  // Storage space for rook attacks
+  Square BSFTable[SQUARE_NB];   // To implement software bitscan
-  Bitboard BishopTable[0x1480]; // Storage space for bishop attacks
+  Bitboard RookTable[0x19000];  // To store rook attacks
+  Bitboard BishopTable[0x1480]; // To store bishop attacks
 
-  void init_magic_bitboards(PieceType pt, Bitboard* attacks[], Bitboard magics[],
+  void init_magics(Bitboard table[], Magic magics[], Direction directions[]);
-                            Bitboard masks[], int shifts[]);
-}
 
+  // bsf_index() returns the index into BSFTable[] to look up the bitscan. Uses
+  // Matt Taylor's folding for 32 bit case, extended to 64 bit by Kim Walisch.
 
-/// print_bitboard() prints a bitboard in an easily readable format to the
+  unsigned bsf_index(Bitboard b) {
-/// standard output. This is sometimes useful for debugging.
-
-void print_bitboard(Bitboard b) {
-
-  for (Rank r = RANK_8; r >= RANK_1; r--)
-  {
-      std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
-      for (File f = FILE_A; f <= FILE_H; f++)
-          std::cout << "| " << (bit_is_set(b, make_square(f, r)) ? "X " : "  ");
-
-      std::cout << "|\n";
-  }
-  std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
-}
-
-
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
-#if defined(IS_64BIT) && !defined(USE_BSFQ)
-
-Square first_1(Bitboard b) {
-  return Square(BSFTable[((b & -b) * 0x218A392CD3D5DBFULL) >> 58]);
-}
-
-Square pop_1st_bit(Bitboard* b) {
-  Bitboard bb = *b;
-  *b &= (*b - 1);
-  return Square(BSFTable[((bb & -bb) * 0x218A392CD3D5DBFULL) >> 58]);
-}
-
-#elif !defined(USE_BSFQ)
-
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = unsigned(b) ^ unsigned(b >> 32);
-  return Square(BSFTable[(fold * 0x783A9B23) >> 26]);
-}
-
-// Use type-punning
-union b_union {
-
-    Bitboard b;
-    struct {
-#if defined (BIGENDIAN)
-        uint32_t h;
-        uint32_t l;
-#else
-        uint32_t l;
-        uint32_t h;
-#endif
-    } dw;
-};
-
-Square pop_1st_bit(Bitboard* bb) {
-
-   b_union u;
-   Square ret;
-
-   u.b = *bb;
-
-   if (u.dw.l)
-   {
-       ret = Square(BSFTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783A9B23) >> 26]);
-       u.dw.l &= (u.dw.l - 1);
-       *bb = u.b;
-       return ret;
-   }
-   ret = Square(BSFTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783A9B23) >> 26]);
-   u.dw.h &= (u.dw.h - 1);
-   *bb = u.b;
-   return ret;
-}
-
-#endif // !defined(USE_BSFQ)
-
-
-/// bitboards_init() initializes various bitboard arrays. It is called during
-/// program initialization.
-
-void bitboards_init() {
-
-  for (Bitboard b = 0; b < 256; b++)
-      BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
-
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
-  {
-      SetMaskBB[s] = 1ULL << s;
-      ClearMaskBB[s] = ~SetMaskBB[s];
-  }
-
-  ClearMaskBB[SQ_NONE] = ~0ULL;
-
-  FileBB[FILE_A] = FileABB;
-  RankBB[RANK_1] = Rank1BB;
-
-  for (int f = FILE_B; f <= FILE_H; f++)
-  {
-      FileBB[f] = FileBB[f - 1] << 1;
-      RankBB[f] = RankBB[f - 1] << 8;
-  }
-
-  for (int f = FILE_A; f <= FILE_H; f++)
-  {
-      NeighboringFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
-      ThisAndNeighboringFilesBB[f] = FileBB[f] | NeighboringFilesBB[f];
-  }
-
-  for (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
-  {
-      InFrontBB[WHITE][rw] = InFrontBB[WHITE][rw + 1] | RankBB[rw + 1];
-      InFrontBB[BLACK][rb] = InFrontBB[BLACK][rb - 1] | RankBB[rb - 1];
-  }
-
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (Square s = SQ_A1; s <= SQ_H8; s++)
-      {
-          SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
-          PassedPawnMask[c][s]     = in_front_bb(c, s) & this_and_neighboring_files_bb(file_of(s));
-          AttackSpanMask[c][s]     = in_front_bb(c, s) & neighboring_files_bb(file_of(s));
-      }
-
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
-
-  for (int i = 0; i < 64; i++)
-      if (!Is64Bit) // Matt Taylor's folding trick for 32 bit systems
-      {
-          Bitboard b = 1ULL << i;
     b ^= b - 1;
-          b ^= b >> 32;
+    return Is64Bit ? (b * DeBruijn64) >> 58
-          BSFTable[uint32_t(b * 0x783A9B23) >> 26] = i;
+                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn32) >> 26;
   }
+
+
+  // popcount16() counts the non-zero bits using SWAR-Popcount algorithm
+
+  unsigned popcount16(unsigned u) {
+    u -= (u >> 1) & 0x5555U;
+    u = ((u >> 2) & 0x3333U) + (u & 0x3333U);
+    u = ((u >> 4) + u) & 0x0F0FU;
+    return (u * 0x0101U) >> 8;
+  }
+}
+
+#ifdef NO_BSF
+
+/// Software fall-back of lsb() and msb() for CPU lacking hardware support
+
+Square lsb(Bitboard b) {
+  assert(b);
+  return BSFTable[bsf_index(b)];
+}
+
+Square msb(Bitboard b) {
+
+  assert(b);
+  unsigned b32;
+  int result = 0;
+
+  if (b > 0xFFFFFFFF)
+  {
+      b >>= 32;
+      result = 32;
+  }
+
+  b32 = unsigned(b);
+
+  if (b32 > 0xFFFF)
+  {
+      b32 >>= 16;
+      result += 16;
+  }
+
+  if (b32 > 0xFF)
+  {
+      b32 >>= 8;
+      result += 8;
+  }
+
+  return Square(result + MSBTable[b32]);
+}
+
+#endif // ifdef NO_BSF
+
+
+/// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
+/// to be printed to standard output. Useful for debugging.
+
+const std::string Bitboards::pretty(Bitboard b) {
+
+  std::string s = "+---+---+---+---+---+---+---+---+\n";
+
+  for (Rank r = RANK_8; r >= RANK_1; --r)
+  {
+      for (File f = FILE_A; f <= FILE_H; ++f)
+          s += b & make_square(f, r) ? "| X " : "|   ";
+
+      s += "|\n+---+---+---+---+---+---+---+---+\n";
+  }
+
+  return s;
+}
+
+
+/// Bitboards::init() initializes various bitboard tables. It is called at
+/// startup and relies on global objects to be already zero-initialized.
+
+void Bitboards::init() {
+
+  for (unsigned i = 0; i < (1 << 16); ++i)
+      PopCnt16[i] = (uint8_t) popcount16(i);
+
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
+  {
+      SquareBB[s] = 1ULL << s;
+      BSFTable[bsf_index(SquareBB[s])] = s;
+  }
+
+  for (Bitboard b = 2; b < 256; ++b)
+      MSBTable[b] = MSBTable[b - 1] + !more_than_one(b);
+
+  for (File f = FILE_A; f <= FILE_H; ++f)
+      FileBB[f] = f > FILE_A ? FileBB[f - 1] << 1 : FileABB;
+
+  for (Rank r = RANK_1; r <= RANK_8; ++r)
+      RankBB[r] = r > RANK_1 ? RankBB[r - 1] << 8 : Rank1BB;
+
+  for (File f = FILE_A; f <= FILE_H; ++f)
+      AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+
+  for (Rank r = RANK_1; r < RANK_8; ++r)
+      ForwardRanksBB[WHITE][r] = ~(ForwardRanksBB[BLACK][r + 1] = ForwardRanksBB[BLACK][r] | RankBB[r]);
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      {
+          ForwardFileBB [c][s] = ForwardRanksBB[c][rank_of(s)] & FileBB[file_of(s)];
+          PawnAttackSpan[c][s] = ForwardRanksBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+          PassedPawnMask[c][s] = ForwardFileBB [c][s] | PawnAttackSpan[c][s];
+      }
+
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+          if (s1 != s2)
+          {
+              SquareDistance[s1][s2] = std::max(distance<File>(s1, s2), distance<Rank>(s1, s2));
+              DistanceRingBB[s1][SquareDistance[s1][s2] - 1] |= s2;
+          }
+
+  int steps[][5] = { {}, { 7, 9 }, { 6, 10, 15, 17 }, {}, {}, {}, { 1, 7, 8, 9 } };
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt : { PAWN, KNIGHT, KING })
+          for (Square s = SQ_A1; s <= SQ_H8; ++s)
+              for (int i = 0; steps[pt][i]; ++i)
+              {
+                  Square to = s + Direction(c == WHITE ? steps[pt][i] : -steps[pt][i]);
+
+                  if (is_ok(to) && distance(s, to) < 3)
+                  {
+                      if (pt == PAWN)
+                          PawnAttacks[c][s] |= to;
                       else
-          BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i;
+                          PseudoAttacks[pt][s] |= to;
-
+                  }
-  int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
-                     {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
-
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (PieceType pt = PAWN; pt <= KING; pt++)
-          for (Square s = SQ_A1; s <= SQ_H8; s++)
-              for (int k = 0; steps[pt][k]; k++)
-              {
-                  Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
-
-                  if (square_is_ok(to) && square_distance(s, to) < 3)
-                      set_bit(&StepAttacksBB[make_piece(c, pt)][s], to);
               }
 
-  init_magic_bitboards(ROOK, RAttacks, RMagics, RMasks, RShifts);
+  Direction RookDirections[] = { NORTH,  EAST,  SOUTH,  WEST };
-  init_magic_bitboards(BISHOP, BAttacks, BMagics, BMasks, BShifts);
+  Direction BishopDirections[] = { NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST };
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  init_magics(RookTable, RookMagics, RookDirections);
+  init_magics(BishopTable, BishopMagics, BishopDirections);
+
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
   {
-      BishopPseudoAttacks[s] = bishop_attacks_bb(s, 0);
+      PseudoAttacks[QUEEN][s1]  = PseudoAttacks[BISHOP][s1] = attacks_bb<BISHOP>(s1, 0);
-      RookPseudoAttacks[s]   = rook_attacks_bb(s, 0);
+      PseudoAttacks[QUEEN][s1] |= PseudoAttacks[  ROOK][s1] = attacks_bb<  ROOK>(s1, 0);
-      QueenPseudoAttacks[s]  = queen_attacks_bb(s, 0);
+
+      for (PieceType pt : { BISHOP, ROOK })
+          for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+          {
+              if (!(PseudoAttacks[pt][s1] & s2))
+                  continue;
+
+              LineBB[s1][s2] = (attacks_bb(pt, s1, 0) & attacks_bb(pt, s2, 0)) | s1 | s2;
+              BetweenBB[s1][s2] = attacks_bb(pt, s1, SquareBB[s2]) & attacks_bb(pt, s2, SquareBB[s1]);
           }
-
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          if (bit_is_set(QueenPseudoAttacks[s1], s2))
-          {
-              Square delta = (s2 - s1) / square_distance(s1, s2);
-
-              for (Square s = s1 + delta; s != s2; s += delta)
-                  set_bit(&BetweenBB[s1][s2], s);
   }
 }
 
 
 namespace {
 
-  Bitboard sliding_attacks(PieceType pt, Square sq, Bitboard occupied) {
+  Bitboard sliding_attack(Direction directions[], Square sq, Bitboard occupied) {
 
-    Square deltas[][4] = { { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  },
+    Bitboard attack = 0;
-                           { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW } };
-    Bitboard attacks = 0;
-    Square* delta = (pt == ROOK ? deltas[0] : deltas[1]);
 
-    for (int i = 0; i < 4; i++)
+    for (int i = 0; i < 4; ++i)
+        for (Square s = sq + directions[i];
+             is_ok(s) && distance(s, s - directions[i]) == 1;
+             s += directions[i])
         {
-        Square s = sq + delta[i];
+            attack |= s;
 
-        while (square_is_ok(s) && square_distance(s, s - delta[i]) == 1)
+            if (occupied & s)
-        {
-            set_bit(&attacks, s);
-
-            if (bit_is_set(occupied, s))
                 break;
+        }
 
-            s += delta[i];
+    return attack;
-        }
-    }
-    return attacks;
   }
 
 
-  Bitboard pick_random(Bitboard mask, RKISS& rk, int booster) {
+  // init_magics() computes all rook and bishop attacks at startup. Magic
-
+  // bitboards are used to look up attacks of sliding pieces. As a reference see
-    Bitboard magic;
+  // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
-
-    // Values s1 and s2 are used to rotate the candidate magic of a
-    // quantity known to be the optimal to quickly find the magics.
-    int s1 = booster & 63, s2 = (booster >> 6) & 63;
-
-    while (true)
-    {
-        magic = rk.rand<Bitboard>();
-        magic = (magic >> s1) | (magic << (64 - s1));
-        magic &= rk.rand<Bitboard>();
-        magic = (magic >> s2) | (magic << (64 - s2));
-        magic &= rk.rand<Bitboard>();
-
-        if (BitCount8Bit[(mask * magic) >> 56] >= 6)
-            return magic;
-    }
-  }
-
-
-  // init_magic_bitboards() computes all rook and bishop magics at startup.
-  // Magic bitboards are used to look up attacks of sliding pieces. As reference
-  // see chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
   // use the so called "fancy" approach.
 
-  void init_magic_bitboards(PieceType pt, Bitboard* attacks[], Bitboard magics[],
+  void init_magics(Bitboard table[], Magic magics[], Direction directions[]) {
-                            Bitboard masks[], int shifts[]) {
+
+    // Optimal PRNG seeds to pick the correct magics in the shortest time
+    int seeds[][RANK_NB] = { { 8977, 44560, 54343, 38998,  5731, 95205, 104912, 17020 },
+                             {  728, 10316, 55013, 32803, 12281, 15100,  16645,   255 } };
 
-    int MagicBoosters[][8] = { { 3191, 2184, 1310, 3618, 2091, 1308, 2452, 3996 },
-                               { 1059, 3608,  605, 3234, 3326,   38, 2029, 3043 } };
-    RKISS rk;
     Bitboard occupancy[4096], reference[4096], edges, b;
-    int i, size, index, booster;
+    int epoch[4096] = {}, cnt = 0, size = 0;
 
-    // attacks[s] is a pointer to the beginning of the attacks table for square 's'
+    for (Square s = SQ_A1; s <= SQ_H8; ++s)
-    attacks[SQ_A1] = (pt == ROOK ? RookTable : BishopTable);
-
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
     {
         // Board edges are not considered in the relevant occupancies
         edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
@@ -320,47 +268,59 @@ namespace {
         // all the attacks for each possible subset of the mask and so is 2 power
         // the number of 1s of the mask. Hence we deduce the size of the shift to
         // apply to the 64 or 32 bits word to get the index.
-        masks[s]  = sliding_attacks(pt, s, 0) & ~edges;
+        Magic& m = magics[s];
-        shifts[s] = (Is64Bit ? 64 : 32) - popcount<Max15>(masks[s]);
+        m.mask  = sliding_attack(directions, s, 0) & ~edges;
+        m.shift = (Is64Bit ? 64 : 32) - popcount(m.mask);
+
+        // Set the offset for the attacks table of the square. We have individual
+        // table sizes for each square with "Fancy Magic Bitboards".
+        m.attacks = s == SQ_A1 ? table : magics[s - 1].attacks + size;
 
         // Use Carry-Rippler trick to enumerate all subsets of masks[s] and
-        // store the corresponding sliding attacks bitboard in reference[].
+        // store the corresponding sliding attack bitboard in reference[].
         b = size = 0;
         do {
             occupancy[size] = b;
-            reference[size++] = sliding_attacks(pt, s, b);
+            reference[size] = sliding_attack(directions, s, b);
-            b = (b - masks[s]) & masks[s];
+
+            if (HasPext)
+                m.attacks[pext(b, m.mask)] = reference[size];
+
+            size++;
+            b = (b - m.mask) & m.mask;
         } while (b);
 
-        // Set the offset for the table of the next square. We have individual
+        if (HasPext)
-        // table sizes for each square with "Fancy Magic Bitboards".
+            continue;
-        if (s < SQ_H8)
-            attacks[s + 1] = attacks[s] + size;
 
-        booster = MagicBoosters[Is64Bit][rank_of(s)];
+        PRNG rng(seeds[Is64Bit][rank_of(s)]);
 
         // Find a magic for square 's' picking up an (almost) random number
         // until we find the one that passes the verification test.
-        do {
+        for (int i = 0; i < size; )
-            magics[s] = pick_random(masks[s], rk, booster);
+        {
-            memset(attacks[s], 0, size * sizeof(Bitboard));
+            for (m.magic = 0; popcount((m.magic * m.mask) >> 56) < 6; )
+                m.magic = rng.sparse_rand<Bitboard>();
 
             // A good magic must map every possible occupancy to an index that
             // looks up the correct sliding attack in the attacks[s] database.
             // Note that we build up the database for square 's' as a side
-            // effect of verifying the magic.
+            // effect of verifying the magic. Keep track of the attempt count
-            for (i = 0; i < size; i++)
+            // and save it in epoch[], little speed-up trick to avoid resetting
+            // m.attacks[] after every failed attempt.
+            for (++cnt, i = 0; i < size; ++i)
             {
-                index = (pt == ROOK ? rook_index(s, occupancy[i])
+                unsigned idx = m.index(occupancy[i]);
-                                    : bishop_index(s, occupancy[i]));
 
-                if (!attacks[s][index])
+                if (epoch[idx] < cnt)
-                    attacks[s][index] = reference[i];
+                {
-
+                    epoch[idx] = cnt;
-                else if (attacks[s][index] != reference[i])
+                    m.attacks[idx] = reference[i];
+                }
+                else if (m.attacks[idx] != reference[i])
                     break;
             }
-        } while (i != size);
+        }
     }
   }
 }

src/bitboard.h

@@ -1,14 +1,14 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-
   Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -18,74 +18,120 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(BITBOARD_H_INCLUDED)
+#ifndef BITBOARD_H_INCLUDED
 #define BITBOARD_H_INCLUDED
 
+#include <string>
+
 #include "types.h"
 
-extern Bitboard FileBB[8];
+namespace Bitbases {
-extern Bitboard NeighboringFilesBB[8];
-extern Bitboard ThisAndNeighboringFilesBB[8];
-extern Bitboard RankBB[8];
-extern Bitboard InFrontBB[2][8];
 
-extern Bitboard SetMaskBB[65];
+void init();
-extern Bitboard ClearMaskBB[65];
+bool probe(Square wksq, Square wpsq, Square bksq, Color us);
 
-extern Bitboard StepAttacksBB[16][64];
-extern Bitboard BetweenBB[64][64];
-
-extern Bitboard SquaresInFrontMask[2][64];
-extern Bitboard PassedPawnMask[2][64];
-extern Bitboard AttackSpanMask[2][64];
-
-extern uint64_t RMagics[64];
-extern int RShifts[64];
-extern Bitboard RMasks[64];
-extern Bitboard* RAttacks[64];
-
-extern uint64_t BMagics[64];
-extern int BShifts[64];
-extern Bitboard BMasks[64];
-extern Bitboard* BAttacks[64];
-
-extern Bitboard BishopPseudoAttacks[64];
-extern Bitboard RookPseudoAttacks[64];
-extern Bitboard QueenPseudoAttacks[64];
-
-extern uint8_t BitCount8Bit[256];
-
-
-/// Functions for testing whether a given bit is set in a bitboard, and for
-/// setting and clearing bits.
-
-inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & SetMaskBB[s];
 }
 
-inline void set_bit(Bitboard* b, Square s) {
+namespace Bitboards {
-  *b |= SetMaskBB[s];
+
+void init();
+const std::string pretty(Bitboard b);
+
 }
 
-inline void clear_bit(Bitboard* b, Square s) {
+const Bitboard AllSquares = ~Bitboard(0);
-  *b &= ClearMaskBB[s];
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
+
+const Bitboard FileABB = 0x0101010101010101ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
+
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
+
+extern int SquareDistance[SQUARE_NB][SQUARE_NB];
+
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard FileBB[FILE_NB];
+extern Bitboard RankBB[RANK_NB];
+extern Bitboard AdjacentFilesBB[FILE_NB];
+extern Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard LineBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard DistanceRingBB[SQUARE_NB][8];
+extern Bitboard ForwardFileBB[COLOR_NB][SQUARE_NB];
+extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+extern Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
+
+
+/// Magic holds all magic bitboards relevant data for a single square
+struct Magic {
+  Bitboard  mask;
+  Bitboard  magic;
+  Bitboard* attacks;
+  unsigned  shift;
+
+  // Compute the attack's index using the 'magic bitboards' approach
+  unsigned index(Bitboard occupied) const {
+
+    if (HasPext)
+        return unsigned(pext(occupied, mask));
+
+    if (Is64Bit)
+        return unsigned(((occupied & mask) * magic) >> shift);
+
+    unsigned lo = unsigned(occupied) & unsigned(mask);
+    unsigned hi = unsigned(occupied >> 32) & unsigned(mask >> 32);
+    return (lo * unsigned(magic) ^ hi * unsigned(magic >> 32)) >> shift;
+  }
+};
+
+extern Magic RookMagics[SQUARE_NB];
+extern Magic BishopMagics[SQUARE_NB];
+
+
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
+
+inline Bitboard operator&(Bitboard b, Square s) {
+  return b & SquareBB[s];
 }
 
-
+inline Bitboard operator|(Bitboard b, Square s) {
-/// Functions used to update a bitboard after a move. This is faster
+  return b | SquareBB[s];
-/// then calling a sequence of clear_bit() + set_bit()
-
-inline Bitboard make_move_bb(Square from, Square to) {
-  return SetMaskBB[from] | SetMaskBB[to];
 }
 
-inline void do_move_bb(Bitboard* b, Bitboard move_bb) {
+inline Bitboard operator^(Bitboard b, Square s) {
-  *b ^= move_bb;
+  return b ^ SquareBB[s];
 }
 
+inline Bitboard& operator|=(Bitboard& b, Square s) {
+  return b |= SquareBB[s];
+}
 
-/// rank_bb() and file_bb() take a file or a square as input and return
+inline Bitboard& operator^=(Bitboard& b, Square s) {
-/// a bitboard representing all squares on the given file or rank.
+  return b ^= SquareBB[s];
+}
+
+constexpr bool more_than_one(Bitboard b) {
+  return b & (b - 1);
+}
+
+/// rank_bb() and file_bb() return a bitboard representing all the squares on
+/// the given file or rank.
 
 inline Bitboard rank_bb(Rank r) {
   return RankBB[r];
@@ -104,173 +150,190 @@ inline Bitboard file_bb(Square s) {
 }
 
 
-/// neighboring_files_bb takes a file as input and returns a bitboard representing
+/// shift() moves a bitboard one step along direction D. Mainly for pawns
-/// all squares on the neighboring files.
 
-inline Bitboard neighboring_files_bb(File f) {
+template<Direction D>
-  return NeighboringFilesBB[f];
+constexpr Bitboard shift(Bitboard b) {
+  return  D == NORTH      ?  b             << 8 : D == SOUTH      ?  b             >> 8
+        : D == NORTH_EAST ? (b & ~FileHBB) << 9 : D == SOUTH_EAST ? (b & ~FileHBB) >> 7
+        : D == NORTH_WEST ? (b & ~FileABB) << 7 : D == SOUTH_WEST ? (b & ~FileABB) >> 9
+        : 0;
 }
 
 
-/// this_and_neighboring_files_bb takes a file as input and returns a bitboard
+/// adjacent_files_bb() returns a bitboard representing all the squares on the
-/// representing all squares on the given and neighboring files.
+/// adjacent files of the given one.
 
-inline Bitboard this_and_neighboring_files_bb(File f) {
+inline Bitboard adjacent_files_bb(File f) {
-  return ThisAndNeighboringFilesBB[f];
+  return AdjacentFilesBB[f];
 }
 
 
-/// in_front_bb() takes a color and a rank or square as input, and returns a
+/// between_bb() returns a bitboard representing all the squares between the two
-/// bitboard representing all the squares on all ranks in front of the rank
+/// given ones. For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with
-/// (or square), from the given color's point of view.  For instance,
+/// the bits for square d5 and e6 set. If s1 and s2 are not on the same rank, file
-/// in_front_bb(WHITE, RANK_5) will give all squares on ranks 6, 7 and 8, while
+/// or diagonal, 0 is returned.
-/// in_front_bb(BLACK, SQ_D3) will give all squares on ranks 1 and 2.
 
-inline Bitboard in_front_bb(Color c, Rank r) {
+inline Bitboard between_bb(Square s1, Square s2) {
-  return InFrontBB[c][r];
-}
-
-inline Bitboard in_front_bb(Color c, Square s) {
-  return InFrontBB[c][rank_of(s)];
-}
-
-
-/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
-/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
-/// bitboard of occupied squares as input, and return a bitboard representing
-/// all squares attacked by a rook, bishop or queen on the given square.
-
-#if defined(IS_64BIT)
-
-FORCE_INLINE unsigned rook_index(Square s, Bitboard occ) {
-  return unsigned(((occ & RMasks[s]) * RMagics[s]) >> RShifts[s]);
-}
-
-FORCE_INLINE unsigned bishop_index(Square s, Bitboard occ) {
-  return unsigned(((occ & BMasks[s]) * BMagics[s]) >> BShifts[s]);
-}
-
-#else // if !defined(IS_64BIT)
-
-FORCE_INLINE unsigned rook_index(Square s, Bitboard occ) {
-  Bitboard b = occ & RMasks[s];
-  return unsigned(int(b) * int(RMagics[s]) ^ int(b >> 32) * int(RMagics[s] >> 32)) >> RShifts[s];
-}
-
-FORCE_INLINE unsigned bishop_index(Square s, Bitboard occ) {
-  Bitboard b = occ & BMasks[s];
-  return unsigned(int(b) * int(BMagics[s]) ^ int(b >> 32) * int(BMagics[s] >> 32)) >> BShifts[s];
-}
-#endif
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard occ) {
-  return RAttacks[s][rook_index(s, occ)];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard occ) {
-  return BAttacks[s][bishop_index(s, occ)];
-}
-
-inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
-  return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
-}
-
-
-/// squares_between returns a bitboard representing all squares between
-/// two squares.  For instance, squares_between(SQ_C4, SQ_F7) returns a
-/// bitboard with the bits for square d5 and e6 set.  If s1 and s2 are not
-/// on the same line, file or diagonal, EmptyBoardBB is returned.
-
-inline Bitboard squares_between(Square s1, Square s2) {
   return BetweenBB[s1][s2];
 }
 
 
-/// squares_in_front_of takes a color and a square as input, and returns a
+/// forward_ranks_bb() returns a bitboard representing all the squares on all the ranks
-/// bitboard representing all squares along the line in front of the square,
+/// in front of the given one, from the point of view of the given color. For
-/// from the point of view of the given color. Definition of the table is:
+/// instance, forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2.
-/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
 
-inline Bitboard squares_in_front_of(Color c, Square s) {
+inline Bitboard forward_ranks_bb(Color c, Square s) {
-  return SquaresInFrontMask[c][s];
+  return ForwardRanksBB[c][rank_of(s)];
 }
 
 
-/// passed_pawn_mask takes a color and a square as input, and returns a
+/// forward_file_bb() returns a bitboard representing all the squares along the line
-/// bitboard mask which can be used to test if a pawn of the given color on
+/// in front of the given one, from the point of view of the given color:
-/// the given square is a passed pawn. Definition of the table is:
+///      ForwardFileBB[c][s] = forward_ranks_bb(c, s) & file_bb(s)
-/// PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s)
+
+inline Bitboard forward_file_bb(Color c, Square s) {
+  return ForwardFileBB[c][s];
+}
+
+
+/// pawn_attack_span() returns a bitboard representing all the squares that can be
+/// attacked by a pawn of the given color when it moves along its file, starting
+/// from the given square:
+///      PawnAttackSpan[c][s] = forward_ranks_bb(c, s) & adjacent_files_bb(file_of(s));
+
+inline Bitboard pawn_attack_span(Color c, Square s) {
+  return PawnAttackSpan[c][s];
+}
+
+
+/// passed_pawn_mask() returns a bitboard mask which can be used to test if a
+/// pawn of the given color and on the given square is a passed pawn:
+///      PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_file_bb(c, s)
 
 inline Bitboard passed_pawn_mask(Color c, Square s) {
   return PassedPawnMask[c][s];
 }
 
 
-/// attack_span_mask takes a color and a square as input, and returns a bitboard
+/// aligned() returns true if the squares s1, s2 and s3 are aligned either on a
-/// representing all squares that can be attacked by a pawn of the given color
+/// straight or on a diagonal line.
-/// when it moves along its file starting from the given square. Definition is:
-/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
 
-inline Bitboard attack_span_mask(Color c, Square s) {
+inline bool aligned(Square s1, Square s2, Square s3) {
-  return AttackSpanMask[c][s];
+  return LineBB[s1][s2] & s3;
 }
 
 
-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// distance() functions return the distance between x and y, defined as the
-/// either on a straight or on a diagonal line.
+/// number of steps for a king in x to reach y. Works with squares, ranks, files.
 
-inline bool squares_aligned(Square s1, Square s2, Square s3) {
+template<typename T> inline int distance(T x, T y) { return x < y ? y - x : x - y; }
-  return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
+template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; }
-        & (    SetMaskBB[s1] |     SetMaskBB[s2] |     SetMaskBB[s3]);
+
+template<typename T1, typename T2> inline int distance(T2 x, T2 y);
+template<> inline int distance<File>(Square x, Square y) { return distance(file_of(x), file_of(y)); }
+template<> inline int distance<Rank>(Square x, Square y) { return distance(rank_of(x), rank_of(y)); }
+
+
+/// attacks_bb() returns a bitboard representing all the squares attacked by a
+/// piece of type Pt (bishop or rook) placed on 's'.
+
+template<PieceType Pt>
+inline Bitboard attacks_bb(Square s, Bitboard occupied) {
+
+  const Magic& m = Pt == ROOK ? RookMagics[s] : BishopMagics[s];
+  return m.attacks[m.index(occupied)];
+}
+
+inline Bitboard attacks_bb(PieceType pt, Square s, Bitboard occupied) {
+
+  assert(pt != PAWN);
+
+  switch (pt)
+  {
+  case BISHOP: return attacks_bb<BISHOP>(s, occupied);
+  case ROOK  : return attacks_bb<  ROOK>(s, occupied);
+  case QUEEN : return attacks_bb<BISHOP>(s, occupied) | attacks_bb<ROOK>(s, occupied);
+  default    : return PseudoAttacks[pt][s];
+  }
 }
 
 
-/// same_color_squares() returns a bitboard representing all squares with
+/// popcount() counts the number of non-zero bits in a bitboard
-/// the same color of the given square.
 
-inline Bitboard same_color_squares(Square s) {
+inline int popcount(Bitboard b) {
-  return bit_is_set(0xAA55AA55AA55AA55ULL, s) ?  0xAA55AA55AA55AA55ULL
+
-                                              : ~0xAA55AA55AA55AA55ULL;
+#ifndef USE_POPCNT
+
+  extern uint8_t PopCnt16[1 << 16];
+  union { Bitboard bb; uint16_t u[4]; } v = { b };
+  return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]];
+
+#elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+
+  return (int)_mm_popcnt_u64(b);
+
+#else // Assumed gcc or compatible compiler
+
+  return __builtin_popcountll(b);
+
+#endif
 }
 
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
 
-#if defined(USE_BSFQ)
+#if defined(__GNUC__)
 
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+inline Square lsb(Bitboard b) {
-
+  assert(b);
-FORCE_INLINE Square first_1(Bitboard b) {
+  return Square(__builtin_ctzll(b));
-   unsigned long index;
-   _BitScanForward64(&index, b);
-   return (Square) index;
 }
+
+inline Square msb(Bitboard b) {
+  assert(b);
+  return Square(63 ^ __builtin_clzll(b));
+}
+
+#elif defined(_WIN64) && defined(_MSC_VER)
+
+inline Square lsb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+  _BitScanForward64(&idx, b);
+  return (Square) idx;
+}
+
+inline Square msb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+  _BitScanReverse64(&idx, b);
+  return (Square) idx;
+}
+
 #else
 
-FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
+#define NO_BSF // Fallback on software implementation for other cases
-  Bitboard dummy;
+
-  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
+Square lsb(Bitboard b);
-  return (Square) dummy;
+Square msb(Bitboard b);
-}
+
 #endif
 
-FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
+
-  const Square s = first_1(*b);
+/// pop_lsb() finds and clears the least significant bit in a non-zero bitboard
-  *b &= ~(1ULL<<s);
+
+inline Square pop_lsb(Bitboard* b) {
+  const Square s = lsb(*b);
+  *b &= *b - 1;
   return s;
 }
 
-#else // if !defined(USE_BSFQ)
 
-extern Square first_1(Bitboard b);
+/// frontmost_sq() and backmost_sq() return the square corresponding to the
-extern Square pop_1st_bit(Bitboard* b);
+/// most/least advanced bit relative to the given color.
 
-#endif
+inline Square frontmost_sq(Color c, Bitboard b) { return c == WHITE ? msb(b) : lsb(b); }
+inline Square  backmost_sq(Color c, Bitboard b) { return c == WHITE ? lsb(b) : msb(b); }
 
-
+#endif // #ifndef BITBOARD_H_INCLUDED
-extern void print_bitboard(Bitboard b);
-extern void bitboards_init();
-
-#endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -1,112 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(BITCOUNT_H_INCLUDED)
-#define BITCOUNT_H_INCLUDED
-
-#include <cassert>
-#include "types.h"
-
-enum BitCountType {
-  CNT_64,
-  CNT_64_MAX15,
-  CNT_32,
-  CNT_32_MAX15,
-  CNT_HW_POPCNT
-};
-
-/// Determine at compile time the best popcount<> specialization according if
-/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count or
-/// use hardware popcnt instruction when available.
-const BitCountType Full  = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64 : CNT_32;
-const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;
-
-
-/// popcount() counts the number of nonzero bits in a bitboard
-template<BitCountType> inline int popcount(Bitboard);
-
-template<>
-inline int popcount<CNT_64>(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
-}
-
-template<>
-inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
-}
-
-template<>
-inline int popcount<CNT_32>(Bitboard b) {
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
-  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
-  v *= 0x01010101; // mul is fast on amd procs
-  return int(v >> 24);
-}
-
-template<>
-inline int popcount<CNT_32_MAX15>(Bitboard b) {
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v += w; // 0-8 in 4 bits
-  v *= 0x11111111;
-  return int(v >> 28);
-}
-
-template<>
-inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
-
-#if !defined(USE_POPCNT)
-
-  assert(false);
-  return int(b != 0); // Avoid 'b not used' warning
-
-#elif defined(_MSC_VER) && defined(__INTEL_COMPILER)
-
-  return _mm_popcnt_u64(b);
-
-#elif defined(_MSC_VER)
-
-  return (int)__popcnt64(b);
-
-#else
-
-  unsigned long ret;
-  __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b));
-  return ret;
-
-#endif
-}
-
-#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,530 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-/*
-  The code in this file is based on the opening book code in PolyGlot
-  by Fabien Letouzey. PolyGlot is available under the GNU General
-  Public License, and can be downloaded from http://wbec-ridderkerk.nl
-*/
-
-#include <cassert>
-#include <iostream>
-
-#include "book.h"
-#include "misc.h"
-#include "movegen.h"
-
-using namespace std;
-
-namespace {
-
-  // Random numbers from PolyGlot, used to compute book hash keys
-  const Key PolyGlotRandoms[781] = {
-    0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
-    0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
-    0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL,
-    0x1A083822CEAFE02DULL, 0x9605D5F0E25EC3B0ULL, 0xD021FF5CD13A2ED5ULL,
-    0x40BDF15D4A672E32ULL, 0x011355146FD56395ULL, 0x5DB4832046F3D9E5ULL,
-    0x239F8B2D7FF719CCULL, 0x05D1A1AE85B49AA1ULL, 0x679F848F6E8FC971ULL,
-    0x7449BBFF801FED0BULL, 0x7D11CDB1C3B7ADF0ULL, 0x82C7709E781EB7CCULL,
-    0xF3218F1C9510786CULL, 0x331478F3AF51BBE6ULL, 0x4BB38DE5E7219443ULL,
-    0xAA649C6EBCFD50FCULL, 0x8DBD98A352AFD40BULL, 0x87D2074B81D79217ULL,
-    0x19F3C751D3E92AE1ULL, 0xB4AB30F062B19ABFULL, 0x7B0500AC42047AC4ULL,
-    0xC9452CA81A09D85DULL, 0x24AA6C514DA27500ULL, 0x4C9F34427501B447ULL,
-    0x14A68FD73C910841ULL, 0xA71B9B83461CBD93ULL, 0x03488B95B0F1850FULL,
-    0x637B2B34FF93C040ULL, 0x09D1BC9A3DD90A94ULL, 0x3575668334A1DD3BULL,
-    0x735E2B97A4C45A23ULL, 0x18727070F1BD400BULL, 0x1FCBACD259BF02E7ULL,
-    0xD310A7C2CE9B6555ULL, 0xBF983FE0FE5D8244ULL, 0x9F74D14F7454A824ULL,
-    0x51EBDC4AB9BA3035ULL, 0x5C82C505DB9AB0FAULL, 0xFCF7FE8A3430B241ULL,
-    0x3253A729B9BA3DDEULL, 0x8C74C368081B3075ULL, 0xB9BC6C87167C33E7ULL,
-    0x7EF48F2B83024E20ULL, 0x11D505D4C351BD7FULL, 0x6568FCA92C76A243ULL,
-    0x4DE0B0F40F32A7B8ULL, 0x96D693460CC37E5DULL, 0x42E240CB63689F2FULL,
-    0x6D2BDCDAE2919661ULL, 0x42880B0236E4D951ULL, 0x5F0F4A5898171BB6ULL,
-    0x39F890F579F92F88ULL, 0x93C5B5F47356388BULL, 0x63DC359D8D231B78ULL,
-    0xEC16CA8AEA98AD76ULL, 0x5355F900C2A82DC7ULL, 0x07FB9F855A997142ULL,
-    0x5093417AA8A7ED5EULL, 0x7BCBC38DA25A7F3CULL, 0x19FC8A768CF4B6D4ULL,
-    0x637A7780DECFC0D9ULL, 0x8249A47AEE0E41F7ULL, 0x79AD695501E7D1E8ULL,
-    0x14ACBAF4777D5776ULL, 0xF145B6BECCDEA195ULL, 0xDABF2AC8201752FCULL,
-    0x24C3C94DF9C8D3F6ULL, 0xBB6E2924F03912EAULL, 0x0CE26C0B95C980D9ULL,
-    0xA49CD132BFBF7CC4ULL, 0xE99D662AF4243939ULL, 0x27E6AD7891165C3FULL,
-    0x8535F040B9744FF1ULL, 0x54B3F4FA5F40D873ULL, 0x72B12C32127FED2BULL,
-    0xEE954D3C7B411F47ULL, 0x9A85AC909A24EAA1ULL, 0x70AC4CD9F04F21F5ULL,
-    0xF9B89D3E99A075C2ULL, 0x87B3E2B2B5C907B1ULL, 0xA366E5B8C54F48B8ULL,
-    0xAE4A9346CC3F7CF2ULL, 0x1920C04D47267BBDULL, 0x87BF02C6B49E2AE9ULL,
-    0x092237AC237F3859ULL, 0xFF07F64EF8ED14D0ULL, 0x8DE8DCA9F03CC54EULL,
-    0x9C1633264DB49C89ULL, 0xB3F22C3D0B0B38EDULL, 0x390E5FB44D01144BULL,
-    0x5BFEA5B4712768E9ULL, 0x1E1032911FA78984ULL, 0x9A74ACB964E78CB3ULL,
-    0x4F80F7A035DAFB04ULL, 0x6304D09A0B3738C4ULL, 0x2171E64683023A08ULL,
-    0x5B9B63EB9CEFF80CULL, 0x506AACF489889342ULL, 0x1881AFC9A3A701D6ULL,
-    0x6503080440750644ULL, 0xDFD395339CDBF4A7ULL, 0xEF927DBCF00C20F2ULL,
-    0x7B32F7D1E03680ECULL, 0xB9FD7620E7316243ULL, 0x05A7E8A57DB91B77ULL,
-    0xB5889C6E15630A75ULL, 0x4A750A09CE9573F7ULL, 0xCF464CEC899A2F8AULL,
-    0xF538639CE705B824ULL, 0x3C79A0FF5580EF7FULL, 0xEDE6C87F8477609DULL,
-    0x799E81F05BC93F31ULL, 0x86536B8CF3428A8CULL, 0x97D7374C60087B73ULL,
-    0xA246637CFF328532ULL, 0x043FCAE60CC0EBA0ULL, 0x920E449535DD359EULL,
-    0x70EB093B15B290CCULL, 0x73A1921916591CBDULL, 0x56436C9FE1A1AA8DULL,
-    0xEFAC4B70633B8F81ULL, 0xBB215798D45DF7AFULL, 0x45F20042F24F1768ULL,
-    0x930F80F4E8EB7462ULL, 0xFF6712FFCFD75EA1ULL, 0xAE623FD67468AA70ULL,
-    0xDD2C5BC84BC8D8FCULL, 0x7EED120D54CF2DD9ULL, 0x22FE545401165F1CULL,
-    0xC91800E98FB99929ULL, 0x808BD68E6AC10365ULL, 0xDEC468145B7605F6ULL,
-    0x1BEDE3A3AEF53302ULL, 0x43539603D6C55602ULL, 0xAA969B5C691CCB7AULL,
-    0xA87832D392EFEE56ULL, 0x65942C7B3C7E11AEULL, 0xDED2D633CAD004F6ULL,
-    0x21F08570F420E565ULL, 0xB415938D7DA94E3CULL, 0x91B859E59ECB6350ULL,
-    0x10CFF333E0ED804AULL, 0x28AED140BE0BB7DDULL, 0xC5CC1D89724FA456ULL,
-    0x5648F680F11A2741ULL, 0x2D255069F0B7DAB3ULL, 0x9BC5A38EF729ABD4ULL,
-    0xEF2F054308F6A2BCULL, 0xAF2042F5CC5C2858ULL, 0x480412BAB7F5BE2AULL,
-    0xAEF3AF4A563DFE43ULL, 0x19AFE59AE451497FULL, 0x52593803DFF1E840ULL,
-    0xF4F076E65F2CE6F0ULL, 0x11379625747D5AF3ULL, 0xBCE5D2248682C115ULL,
-    0x9DA4243DE836994FULL, 0x066F70B33FE09017ULL, 0x4DC4DE189B671A1CULL,
-    0x51039AB7712457C3ULL, 0xC07A3F80C31FB4B4ULL, 0xB46EE9C5E64A6E7CULL,
-    0xB3819A42ABE61C87ULL, 0x21A007933A522A20ULL, 0x2DF16F761598AA4FULL,
-    0x763C4A1371B368FDULL, 0xF793C46702E086A0ULL, 0xD7288E012AEB8D31ULL,
-    0xDE336A2A4BC1C44BULL, 0x0BF692B38D079F23ULL, 0x2C604A7A177326B3ULL,
-    0x4850E73E03EB6064ULL, 0xCFC447F1E53C8E1BULL, 0xB05CA3F564268D99ULL,
-    0x9AE182C8BC9474E8ULL, 0xA4FC4BD4FC5558CAULL, 0xE755178D58FC4E76ULL,
-    0x69B97DB1A4C03DFEULL, 0xF9B5B7C4ACC67C96ULL, 0xFC6A82D64B8655FBULL,
-    0x9C684CB6C4D24417ULL, 0x8EC97D2917456ED0ULL, 0x6703DF9D2924E97EULL,
-    0xC547F57E42A7444EULL, 0x78E37644E7CAD29EULL, 0xFE9A44E9362F05FAULL,
-    0x08BD35CC38336615ULL, 0x9315E5EB3A129ACEULL, 0x94061B871E04DF75ULL,
-    0xDF1D9F9D784BA010ULL, 0x3BBA57B68871B59DULL, 0xD2B7ADEEDED1F73FULL,
-    0xF7A255D83BC373F8ULL, 0xD7F4F2448C0CEB81ULL, 0xD95BE88CD210FFA7ULL,
-    0x336F52F8FF4728E7ULL, 0xA74049DAC312AC71ULL, 0xA2F61BB6E437FDB5ULL,
-    0x4F2A5CB07F6A35B3ULL, 0x87D380BDA5BF7859ULL, 0x16B9F7E06C453A21ULL,
-    0x7BA2484C8A0FD54EULL, 0xF3A678CAD9A2E38CULL, 0x39B0BF7DDE437BA2ULL,
-    0xFCAF55C1BF8A4424ULL, 0x18FCF680573FA594ULL, 0x4C0563B89F495AC3ULL,
-    0x40E087931A00930DULL, 0x8CFFA9412EB642C1ULL, 0x68CA39053261169FULL,
-    0x7A1EE967D27579E2ULL, 0x9D1D60E5076F5B6FULL, 0x3810E399B6F65BA2ULL,
-    0x32095B6D4AB5F9B1ULL, 0x35CAB62109DD038AULL, 0xA90B24499FCFAFB1ULL,
-    0x77A225A07CC2C6BDULL, 0x513E5E634C70E331ULL, 0x4361C0CA3F692F12ULL,
-    0xD941ACA44B20A45BULL, 0x528F7C8602C5807BULL, 0x52AB92BEB9613989ULL,
-    0x9D1DFA2EFC557F73ULL, 0x722FF175F572C348ULL, 0x1D1260A51107FE97ULL,
-    0x7A249A57EC0C9BA2ULL, 0x04208FE9E8F7F2D6ULL, 0x5A110C6058B920A0ULL,
-    0x0CD9A497658A5698ULL, 0x56FD23C8F9715A4CULL, 0x284C847B9D887AAEULL,
-    0x04FEABFBBDB619CBULL, 0x742E1E651C60BA83ULL, 0x9A9632E65904AD3CULL,
-    0x881B82A13B51B9E2ULL, 0x506E6744CD974924ULL, 0xB0183DB56FFC6A79ULL,
-    0x0ED9B915C66ED37EULL, 0x5E11E86D5873D484ULL, 0xF678647E3519AC6EULL,
-    0x1B85D488D0F20CC5ULL, 0xDAB9FE6525D89021ULL, 0x0D151D86ADB73615ULL,
-    0xA865A54EDCC0F019ULL, 0x93C42566AEF98FFBULL, 0x99E7AFEABE000731ULL,
-    0x48CBFF086DDF285AULL, 0x7F9B6AF1EBF78BAFULL, 0x58627E1A149BBA21ULL,
-    0x2CD16E2ABD791E33ULL, 0xD363EFF5F0977996ULL, 0x0CE2A38C344A6EEDULL,
-    0x1A804AADB9CFA741ULL, 0x907F30421D78C5DEULL, 0x501F65EDB3034D07ULL,
-    0x37624AE5A48FA6E9ULL, 0x957BAF61700CFF4EULL, 0x3A6C27934E31188AULL,
-    0xD49503536ABCA345ULL, 0x088E049589C432E0ULL, 0xF943AEE7FEBF21B8ULL,
-    0x6C3B8E3E336139D3ULL, 0x364F6FFA464EE52EULL, 0xD60F6DCEDC314222ULL,
-    0x56963B0DCA418FC0ULL, 0x16F50EDF91E513AFULL, 0xEF1955914B609F93ULL,
-    0x565601C0364E3228ULL, 0xECB53939887E8175ULL, 0xBAC7A9A18531294BULL,
-    0xB344C470397BBA52ULL, 0x65D34954DAF3CEBDULL, 0xB4B81B3FA97511E2ULL,
-    0xB422061193D6F6A7ULL, 0x071582401C38434DULL, 0x7A13F18BBEDC4FF5ULL,
-    0xBC4097B116C524D2ULL, 0x59B97885E2F2EA28ULL, 0x99170A5DC3115544ULL,
-    0x6F423357E7C6A9F9ULL, 0x325928EE6E6F8794ULL, 0xD0E4366228B03343ULL,
-    0x565C31F7DE89EA27ULL, 0x30F5611484119414ULL, 0xD873DB391292ED4FULL,
-    0x7BD94E1D8E17DEBCULL, 0xC7D9F16864A76E94ULL, 0x947AE053EE56E63CULL,
-    0xC8C93882F9475F5FULL, 0x3A9BF55BA91F81CAULL, 0xD9A11FBB3D9808E4ULL,
-    0x0FD22063EDC29FCAULL, 0xB3F256D8ACA0B0B9ULL, 0xB03031A8B4516E84ULL,
-    0x35DD37D5871448AFULL, 0xE9F6082B05542E4EULL, 0xEBFAFA33D7254B59ULL,
-    0x9255ABB50D532280ULL, 0xB9AB4CE57F2D34F3ULL, 0x693501D628297551ULL,
-    0xC62C58F97DD949BFULL, 0xCD454F8F19C5126AULL, 0xBBE83F4ECC2BDECBULL,
-    0xDC842B7E2819E230ULL, 0xBA89142E007503B8ULL, 0xA3BC941D0A5061CBULL,
-    0xE9F6760E32CD8021ULL, 0x09C7E552BC76492FULL, 0x852F54934DA55CC9ULL,
-    0x8107FCCF064FCF56ULL, 0x098954D51FFF6580ULL, 0x23B70EDB1955C4BFULL,
-    0xC330DE426430F69DULL, 0x4715ED43E8A45C0AULL, 0xA8D7E4DAB780A08DULL,
-    0x0572B974F03CE0BBULL, 0xB57D2E985E1419C7ULL, 0xE8D9ECBE2CF3D73FULL,
-    0x2FE4B17170E59750ULL, 0x11317BA87905E790ULL, 0x7FBF21EC8A1F45ECULL,
-    0x1725CABFCB045B00ULL, 0x964E915CD5E2B207ULL, 0x3E2B8BCBF016D66DULL,
-    0xBE7444E39328A0ACULL, 0xF85B2B4FBCDE44B7ULL, 0x49353FEA39BA63B1ULL,
-    0x1DD01AAFCD53486AULL, 0x1FCA8A92FD719F85ULL, 0xFC7C95D827357AFAULL,
-    0x18A6A990C8B35EBDULL, 0xCCCB7005C6B9C28DULL, 0x3BDBB92C43B17F26ULL,
-    0xAA70B5B4F89695A2ULL, 0xE94C39A54A98307FULL, 0xB7A0B174CFF6F36EULL,
-    0xD4DBA84729AF48ADULL, 0x2E18BC1AD9704A68ULL, 0x2DE0966DAF2F8B1CULL,
-    0xB9C11D5B1E43A07EULL, 0x64972D68DEE33360ULL, 0x94628D38D0C20584ULL,
-    0xDBC0D2B6AB90A559ULL, 0xD2733C4335C6A72FULL, 0x7E75D99D94A70F4DULL,
-    0x6CED1983376FA72BULL, 0x97FCAACBF030BC24ULL, 0x7B77497B32503B12ULL,
-    0x8547EDDFB81CCB94ULL, 0x79999CDFF70902CBULL, 0xCFFE1939438E9B24ULL,
-    0x829626E3892D95D7ULL, 0x92FAE24291F2B3F1ULL, 0x63E22C147B9C3403ULL,
-    0xC678B6D860284A1CULL, 0x5873888850659AE7ULL, 0x0981DCD296A8736DULL,
-    0x9F65789A6509A440ULL, 0x9FF38FED72E9052FULL, 0xE479EE5B9930578CULL,
-    0xE7F28ECD2D49EECDULL, 0x56C074A581EA17FEULL, 0x5544F7D774B14AEFULL,
-    0x7B3F0195FC6F290FULL, 0x12153635B2C0CF57ULL, 0x7F5126DBBA5E0CA7ULL,
-    0x7A76956C3EAFB413ULL, 0x3D5774A11D31AB39ULL, 0x8A1B083821F40CB4ULL,
-    0x7B4A38E32537DF62ULL, 0x950113646D1D6E03ULL, 0x4DA8979A0041E8A9ULL,
-    0x3BC36E078F7515D7ULL, 0x5D0A12F27AD310D1ULL, 0x7F9D1A2E1EBE1327ULL,
-    0xDA3A361B1C5157B1ULL, 0xDCDD7D20903D0C25ULL, 0x36833336D068F707ULL,
-    0xCE68341F79893389ULL, 0xAB9090168DD05F34ULL, 0x43954B3252DC25E5ULL,
-    0xB438C2B67F98E5E9ULL, 0x10DCD78E3851A492ULL, 0xDBC27AB5447822BFULL,
-    0x9B3CDB65F82CA382ULL, 0xB67B7896167B4C84ULL, 0xBFCED1B0048EAC50ULL,
-    0xA9119B60369FFEBDULL, 0x1FFF7AC80904BF45ULL, 0xAC12FB171817EEE7ULL,
-    0xAF08DA9177DDA93DULL, 0x1B0CAB936E65C744ULL, 0xB559EB1D04E5E932ULL,
-    0xC37B45B3F8D6F2BAULL, 0xC3A9DC228CAAC9E9ULL, 0xF3B8B6675A6507FFULL,
-    0x9FC477DE4ED681DAULL, 0x67378D8ECCEF96CBULL, 0x6DD856D94D259236ULL,
-    0xA319CE15B0B4DB31ULL, 0x073973751F12DD5EULL, 0x8A8E849EB32781A5ULL,
-    0xE1925C71285279F5ULL, 0x74C04BF1790C0EFEULL, 0x4DDA48153C94938AULL,
-    0x9D266D6A1CC0542CULL, 0x7440FB816508C4FEULL, 0x13328503DF48229FULL,
-    0xD6BF7BAEE43CAC40ULL, 0x4838D65F6EF6748FULL, 0x1E152328F3318DEAULL,
-    0x8F8419A348F296BFULL, 0x72C8834A5957B511ULL, 0xD7A023A73260B45CULL,
-    0x94EBC8ABCFB56DAEULL, 0x9FC10D0F989993E0ULL, 0xDE68A2355B93CAE6ULL,
-    0xA44CFE79AE538BBEULL, 0x9D1D84FCCE371425ULL, 0x51D2B1AB2DDFB636ULL,
-    0x2FD7E4B9E72CD38CULL, 0x65CA5B96B7552210ULL, 0xDD69A0D8AB3B546DULL,
-    0x604D51B25FBF70E2ULL, 0x73AA8A564FB7AC9EULL, 0x1A8C1E992B941148ULL,
-    0xAAC40A2703D9BEA0ULL, 0x764DBEAE7FA4F3A6ULL, 0x1E99B96E70A9BE8BULL,
-    0x2C5E9DEB57EF4743ULL, 0x3A938FEE32D29981ULL, 0x26E6DB8FFDF5ADFEULL,
-    0x469356C504EC9F9DULL, 0xC8763C5B08D1908CULL, 0x3F6C6AF859D80055ULL,
-    0x7F7CC39420A3A545ULL, 0x9BFB227EBDF4C5CEULL, 0x89039D79D6FC5C5CULL,
-    0x8FE88B57305E2AB6ULL, 0xA09E8C8C35AB96DEULL, 0xFA7E393983325753ULL,
-    0xD6B6D0ECC617C699ULL, 0xDFEA21EA9E7557E3ULL, 0xB67C1FA481680AF8ULL,
-    0xCA1E3785A9E724E5ULL, 0x1CFC8BED0D681639ULL, 0xD18D8549D140CAEAULL,
-    0x4ED0FE7E9DC91335ULL, 0xE4DBF0634473F5D2ULL, 0x1761F93A44D5AEFEULL,
-    0x53898E4C3910DA55ULL, 0x734DE8181F6EC39AULL, 0x2680B122BAA28D97ULL,
-    0x298AF231C85BAFABULL, 0x7983EED3740847D5ULL, 0x66C1A2A1A60CD889ULL,
-    0x9E17E49642A3E4C1ULL, 0xEDB454E7BADC0805ULL, 0x50B704CAB602C329ULL,
-    0x4CC317FB9CDDD023ULL, 0x66B4835D9EAFEA22ULL, 0x219B97E26FFC81BDULL,
-    0x261E4E4C0A333A9DULL, 0x1FE2CCA76517DB90ULL, 0xD7504DFA8816EDBBULL,
-    0xB9571FA04DC089C8ULL, 0x1DDC0325259B27DEULL, 0xCF3F4688801EB9AAULL,
-    0xF4F5D05C10CAB243ULL, 0x38B6525C21A42B0EULL, 0x36F60E2BA4FA6800ULL,
-    0xEB3593803173E0CEULL, 0x9C4CD6257C5A3603ULL, 0xAF0C317D32ADAA8AULL,
-    0x258E5A80C7204C4BULL, 0x8B889D624D44885DULL, 0xF4D14597E660F855ULL,
-    0xD4347F66EC8941C3ULL, 0xE699ED85B0DFB40DULL, 0x2472F6207C2D0484ULL,
-    0xC2A1E7B5B459AEB5ULL, 0xAB4F6451CC1D45ECULL, 0x63767572AE3D6174ULL,
-    0xA59E0BD101731A28ULL, 0x116D0016CB948F09ULL, 0x2CF9C8CA052F6E9FULL,
-    0x0B090A7560A968E3ULL, 0xABEEDDB2DDE06FF1ULL, 0x58EFC10B06A2068DULL,
-    0xC6E57A78FBD986E0ULL, 0x2EAB8CA63CE802D7ULL, 0x14A195640116F336ULL,
-    0x7C0828DD624EC390ULL, 0xD74BBE77E6116AC7ULL, 0x804456AF10F5FB53ULL,
-    0xEBE9EA2ADF4321C7ULL, 0x03219A39EE587A30ULL, 0x49787FEF17AF9924ULL,
-    0xA1E9300CD8520548ULL, 0x5B45E522E4B1B4EFULL, 0xB49C3B3995091A36ULL,
-    0xD4490AD526F14431ULL, 0x12A8F216AF9418C2ULL, 0x001F837CC7350524ULL,
-    0x1877B51E57A764D5ULL, 0xA2853B80F17F58EEULL, 0x993E1DE72D36D310ULL,
-    0xB3598080CE64A656ULL, 0x252F59CF0D9F04BBULL, 0xD23C8E176D113600ULL,
-    0x1BDA0492E7E4586EULL, 0x21E0BD5026C619BFULL, 0x3B097ADAF088F94EULL,
-    0x8D14DEDB30BE846EULL, 0xF95CFFA23AF5F6F4ULL, 0x3871700761B3F743ULL,
-    0xCA672B91E9E4FA16ULL, 0x64C8E531BFF53B55ULL, 0x241260ED4AD1E87DULL,
-    0x106C09B972D2E822ULL, 0x7FBA195410E5CA30ULL, 0x7884D9BC6CB569D8ULL,
-    0x0647DFEDCD894A29ULL, 0x63573FF03E224774ULL, 0x4FC8E9560F91B123ULL,
-    0x1DB956E450275779ULL, 0xB8D91274B9E9D4FBULL, 0xA2EBEE47E2FBFCE1ULL,
-    0xD9F1F30CCD97FB09ULL, 0xEFED53D75FD64E6BULL, 0x2E6D02C36017F67FULL,
-    0xA9AA4D20DB084E9BULL, 0xB64BE8D8B25396C1ULL, 0x70CB6AF7C2D5BCF0ULL,
-    0x98F076A4F7A2322EULL, 0xBF84470805E69B5FULL, 0x94C3251F06F90CF3ULL,
-    0x3E003E616A6591E9ULL, 0xB925A6CD0421AFF3ULL, 0x61BDD1307C66E300ULL,
-    0xBF8D5108E27E0D48ULL, 0x240AB57A8B888B20ULL, 0xFC87614BAF287E07ULL,
-    0xEF02CDD06FFDB432ULL, 0xA1082C0466DF6C0AULL, 0x8215E577001332C8ULL,
-    0xD39BB9C3A48DB6CFULL, 0x2738259634305C14ULL, 0x61CF4F94C97DF93DULL,
-    0x1B6BACA2AE4E125BULL, 0x758F450C88572E0BULL, 0x959F587D507A8359ULL,
-    0xB063E962E045F54DULL, 0x60E8ED72C0DFF5D1ULL, 0x7B64978555326F9FULL,
-    0xFD080D236DA814BAULL, 0x8C90FD9B083F4558ULL, 0x106F72FE81E2C590ULL,
-    0x7976033A39F7D952ULL, 0xA4EC0132764CA04BULL, 0x733EA705FAE4FA77ULL,
-    0xB4D8F77BC3E56167ULL, 0x9E21F4F903B33FD9ULL, 0x9D765E419FB69F6DULL,
-    0xD30C088BA61EA5EFULL, 0x5D94337FBFAF7F5BULL, 0x1A4E4822EB4D7A59ULL,
-    0x6FFE73E81B637FB3ULL, 0xDDF957BC36D8B9CAULL, 0x64D0E29EEA8838B3ULL,
-    0x08DD9BDFD96B9F63ULL, 0x087E79E5A57D1D13ULL, 0xE328E230E3E2B3FBULL,
-    0x1C2559E30F0946BEULL, 0x720BF5F26F4D2EAAULL, 0xB0774D261CC609DBULL,
-    0x443F64EC5A371195ULL, 0x4112CF68649A260EULL, 0xD813F2FAB7F5C5CAULL,
-    0x660D3257380841EEULL, 0x59AC2C7873F910A3ULL, 0xE846963877671A17ULL,
-    0x93B633ABFA3469F8ULL, 0xC0C0F5A60EF4CDCFULL, 0xCAF21ECD4377B28CULL,
-    0x57277707199B8175ULL, 0x506C11B9D90E8B1DULL, 0xD83CC2687A19255FULL,
-    0x4A29C6465A314CD1ULL, 0xED2DF21216235097ULL, 0xB5635C95FF7296E2ULL,
-    0x22AF003AB672E811ULL, 0x52E762596BF68235ULL, 0x9AEBA33AC6ECC6B0ULL,
-    0x944F6DE09134DFB6ULL, 0x6C47BEC883A7DE39ULL, 0x6AD047C430A12104ULL,
-    0xA5B1CFDBA0AB4067ULL, 0x7C45D833AFF07862ULL, 0x5092EF950A16DA0BULL,
-    0x9338E69C052B8E7BULL, 0x455A4B4CFE30E3F5ULL, 0x6B02E63195AD0CF8ULL,
-    0x6B17B224BAD6BF27ULL, 0xD1E0CCD25BB9C169ULL, 0xDE0C89A556B9AE70ULL,
-    0x50065E535A213CF6ULL, 0x9C1169FA2777B874ULL, 0x78EDEFD694AF1EEDULL,
-    0x6DC93D9526A50E68ULL, 0xEE97F453F06791EDULL, 0x32AB0EDB696703D3ULL,
-    0x3A6853C7E70757A7ULL, 0x31865CED6120F37DULL, 0x67FEF95D92607890ULL,
-    0x1F2B1D1F15F6DC9CULL, 0xB69E38A8965C6B65ULL, 0xAA9119FF184CCCF4ULL,
-    0xF43C732873F24C13ULL, 0xFB4A3D794A9A80D2ULL, 0x3550C2321FD6109CULL,
-    0x371F77E76BB8417EULL, 0x6BFA9AAE5EC05779ULL, 0xCD04F3FF001A4778ULL,
-    0xE3273522064480CAULL, 0x9F91508BFFCFC14AULL, 0x049A7F41061A9E60ULL,
-    0xFCB6BE43A9F2FE9BULL, 0x08DE8A1C7797DA9BULL, 0x8F9887E6078735A1ULL,
-    0xB5B4071DBFC73A66ULL, 0x230E343DFBA08D33ULL, 0x43ED7F5A0FAE657DULL,
-    0x3A88A0FBBCB05C63ULL, 0x21874B8B4D2DBC4FULL, 0x1BDEA12E35F6A8C9ULL,
-    0x53C065C6C8E63528ULL, 0xE34A1D250E7A8D6BULL, 0xD6B04D3B7651DD7EULL,
-    0x5E90277E7CB39E2DULL, 0x2C046F22062DC67DULL, 0xB10BB459132D0A26ULL,
-    0x3FA9DDFB67E2F199ULL, 0x0E09B88E1914F7AFULL, 0x10E8B35AF3EEAB37ULL,
-    0x9EEDECA8E272B933ULL, 0xD4C718BC4AE8AE5FULL, 0x81536D601170FC20ULL,
-    0x91B534F885818A06ULL, 0xEC8177F83F900978ULL, 0x190E714FADA5156EULL,
-    0xB592BF39B0364963ULL, 0x89C350C893AE7DC1ULL, 0xAC042E70F8B383F2ULL,
-    0xB49B52E587A1EE60ULL, 0xFB152FE3FF26DA89ULL, 0x3E666E6F69AE2C15ULL,
-    0x3B544EBE544C19F9ULL, 0xE805A1E290CF2456ULL, 0x24B33C9D7ED25117ULL,
-    0xE74733427B72F0C1ULL, 0x0A804D18B7097475ULL, 0x57E3306D881EDB4FULL,
-    0x4AE7D6A36EB5DBCBULL, 0x2D8D5432157064C8ULL, 0xD1E649DE1E7F268BULL,
-    0x8A328A1CEDFE552CULL, 0x07A3AEC79624C7DAULL, 0x84547DDC3E203C94ULL,
-    0x990A98FD5071D263ULL, 0x1A4FF12616EEFC89ULL, 0xF6F7FD1431714200ULL,
-    0x30C05B1BA332F41CULL, 0x8D2636B81555A786ULL, 0x46C9FEB55D120902ULL,
-    0xCCEC0A73B49C9921ULL, 0x4E9D2827355FC492ULL, 0x19EBB029435DCB0FULL,
-    0x4659D2B743848A2CULL, 0x963EF2C96B33BE31ULL, 0x74F85198B05A2E7DULL,
-    0x5A0F544DD2B1FB18ULL, 0x03727073C2E134B1ULL, 0xC7F6AA2DE59AEA61ULL,
-    0x352787BAA0D7C22FULL, 0x9853EAB63B5E0B35ULL, 0xABBDCDD7ED5C0860ULL,
-    0xCF05DAF5AC8D77B0ULL, 0x49CAD48CEBF4A71EULL, 0x7A4C10EC2158C4A6ULL,
-    0xD9E92AA246BF719EULL, 0x13AE978D09FE5557ULL, 0x730499AF921549FFULL,
-    0x4E4B705B92903BA4ULL, 0xFF577222C14F0A3AULL, 0x55B6344CF97AAFAEULL,
-    0xB862225B055B6960ULL, 0xCAC09AFBDDD2CDB4ULL, 0xDAF8E9829FE96B5FULL,
-    0xB5FDFC5D3132C498ULL, 0x310CB380DB6F7503ULL, 0xE87FBB46217A360EULL,
-    0x2102AE466EBB1148ULL, 0xF8549E1A3AA5E00DULL, 0x07A69AFDCC42261AULL,
-    0xC4C118BFE78FEAAEULL, 0xF9F4892ED96BD438ULL, 0x1AF3DBE25D8F45DAULL,
-    0xF5B4B0B0D2DEEEB4ULL, 0x962ACEEFA82E1C84ULL, 0x046E3ECAAF453CE9ULL,
-    0xF05D129681949A4CULL, 0x964781CE734B3C84ULL, 0x9C2ED44081CE5FBDULL,
-    0x522E23F3925E319EULL, 0x177E00F9FC32F791ULL, 0x2BC60A63A6F3B3F2ULL,
-    0x222BBFAE61725606ULL, 0x486289DDCC3D6780ULL, 0x7DC7785B8EFDFC80ULL,
-    0x8AF38731C02BA980ULL, 0x1FAB64EA29A2DDF7ULL, 0xE4D9429322CD065AULL,
-    0x9DA058C67844F20CULL, 0x24C0E332B70019B0ULL, 0x233003B5A6CFE6ADULL,
-    0xD586BD01C5C217F6ULL, 0x5E5637885F29BC2BULL, 0x7EBA726D8C94094BULL,
-    0x0A56A5F0BFE39272ULL, 0xD79476A84EE20D06ULL, 0x9E4C1269BAA4BF37ULL,
-    0x17EFEE45B0DEE640ULL, 0x1D95B0A5FCF90BC6ULL, 0x93CBE0B699C2585DULL,
-    0x65FA4F227A2B6D79ULL, 0xD5F9E858292504D5ULL, 0xC2B5A03F71471A6FULL,
-    0x59300222B4561E00ULL, 0xCE2F8642CA0712DCULL, 0x7CA9723FBB2E8988ULL,
-    0x2785338347F2BA08ULL, 0xC61BB3A141E50E8CULL, 0x150F361DAB9DEC26ULL,
-    0x9F6A419D382595F4ULL, 0x64A53DC924FE7AC9ULL, 0x142DE49FFF7A7C3DULL,
-    0x0C335248857FA9E7ULL, 0x0A9C32D5EAE45305ULL, 0xE6C42178C4BBB92EULL,
-    0x71F1CE2490D20B07ULL, 0xF1BCC3D275AFE51AULL, 0xE728E8C83C334074ULL,
-    0x96FBF83A12884624ULL, 0x81A1549FD6573DA5ULL, 0x5FA7867CAF35E149ULL,
-    0x56986E2EF3ED091BULL, 0x917F1DD5F8886C61ULL, 0xD20D8C88C8FFE65FULL,
-    0x31D71DCE64B2C310ULL, 0xF165B587DF898190ULL, 0xA57E6339DD2CF3A0ULL,
-    0x1EF6E6DBB1961EC9ULL, 0x70CC73D90BC26E24ULL, 0xE21A6B35DF0C3AD7ULL,
-    0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
-    0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
-    0xF8D626AAAF278509ULL
-  };
-
-  // Offsets to the PolyGlotRandoms[] array of zobrist keys
-  const Key* ZobPiece     = PolyGlotRandoms +   0;
-  const Key* ZobCastle    = PolyGlotRandoms + 768;
-  const Key* ZobEnPassant = PolyGlotRandoms + 772;
-  const Key* ZobTurn      = PolyGlotRandoms + 780;
-
-  // Piece offset is calculated as 64 * (PolyPiece ^ 1) where
-  // PolyPiece is: BP = 0, WP = 1, BN = 2, WN = 3 ... BK = 10, WK = 11
-  const int PieceOfs[] = { 0, 64, 192, 320, 448, 576, 704, 0,
-                           0,  0, 128, 256, 384, 512, 640 };
-
-  // book_key() builds up a PolyGlot hash key out of a position
-  uint64_t book_key(const Position& pos) {
-
-    uint64_t result = 0;
-    Bitboard b = pos.occupied_squares();
-
-    while (b)
-    {
-        Square s = pop_1st_bit(&b);
-        result ^= ZobPiece[PieceOfs[pos.piece_on(s)] + s];
-    }
-
-    if (pos.can_castle(WHITE_OO))
-        result ^= ZobCastle[0];
-
-    if (pos.can_castle(WHITE_OOO))
-        result ^= ZobCastle[1];
-
-    if (pos.can_castle(BLACK_OO))
-        result ^= ZobCastle[2];
-
-    if (pos.can_castle(BLACK_OOO))
-        result ^= ZobCastle[3];
-
-    if (pos.ep_square() != SQ_NONE)
-        result ^= ZobEnPassant[file_of(pos.ep_square())];
-
-    if (pos.side_to_move() == WHITE)
-        result ^= ZobTurn[0];
-
-    return result;
-  }
-}
-
-
-/// Book c'tor. Make random number generation less deterministic, for book moves
-Book::Book() : bookSize(0) {
-
-  for (int i = abs(system_time() % 10000); i > 0; i--)
-      RKiss.rand<unsigned>();
-}
-
-
-/// Book destructor. Be sure file is closed before we leave.
-
-Book::~Book() {
-
-  close();
-}
-
-
-/// Book::close() closes the file only if it is open, otherwise the call fails
-/// and the failbit internal state flag is set.
-
-void Book::close() {
-
-  if (bookFile.is_open())
-      bookFile.close();
-
-  bookName = "";
-  bookSize = 0;
-}
-
-
-/// Book::open() opens a book file with a given name
-
-void Book::open(const string& fileName) {
-
-  // Close old file before opening the new
-  close();
-
-  bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary |ios::ate);
-
-  // Silently return when asked to open a non-exsistent file
-  if (!bookFile.is_open())
-      return;
-
-  // Get the book size in number of entries, we are already at the file end
-  bookSize = long(bookFile.tellg()) / sizeof(BookEntry);
-
-  if (!bookFile.good())
-  {
-      cerr << "Failed to open book file " << fileName << endl;
-      exit(EXIT_FAILURE);
-  }
-
-  // Set only if successful
-  bookName = fileName;
-}
-
-
-/// Book::probe() gets a book move for a given position. Returns MOVE_NONE
-/// if no book move is found. If findBest is true then returns always the
-/// highest rated move otherwise chooses randomly based on the move score.
-
-Move Book::probe(const Position& pos, bool findBest) {
-
-  if (!bookSize || !bookFile.is_open())
-      return MOVE_NONE;
-
-  BookEntry entry;
-  unsigned scoresSum = 0, bestScore = 0, bookMove = 0;
-  uint64_t key = book_key(pos);
-  int idx = first_entry(key) - 1;
-
-  // Choose a book move among the possible moves for the given position
-  while (++idx < bookSize && (entry = read_entry(idx), entry.key == key))
-  {
-      scoresSum += entry.count;
-
-      // Choose book move according to its score. If a move has a very
-      // high score it has higher probability to be choosen than a move
-      // with lower score. Note that first entry is always chosen.
-      if (   RKiss.rand<unsigned>() % scoresSum < entry.count
-          || (findBest && entry.count > bestScore))
-          bookMove = entry.move;
-
-      if (entry.count > bestScore)
-          bestScore = entry.count;
-  }
-
-  if (!bookMove)
-      return MOVE_NONE;
-
-  // A PolyGlot book move is encoded as follows:
-  //
-  // bit  0- 5: destination square (from 0 to 63)
-  // bit  6-11: origin square (from 0 to 63)
-  // bit 12-13-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
-  //
-  // Castling moves follow "king captures rook" representation. So in case
-  // book move is a promotion we have to convert to our representation, in
-  // all other cases we can directly compare with a Move after having
-  // masked out special Move's flags that are not supported by PolyGlot.
-  int promotion = (bookMove >> 12) & 7;
-
-  if (promotion)
-      bookMove = make_promotion_move(move_from(Move(bookMove)),
-                                     move_to(Move(bookMove)),
-                                     PieceType(promotion + 1));
-  // Verify the book move is legal
-  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
-      if (unsigned(ml.move() & ~(3 << 14)) == bookMove) // Mask out special flags
-          return ml.move();
-
-  return MOVE_NONE;
-}
-
-
-/// Book::first_entry() takes a book key as input, and does a binary search
-/// through the book file for the given key. The index to the first (leftmost)
-/// book entry with the same key as the input is returned. When the key is not
-/// found in the book file, bookSize is returned.
-
-int Book::first_entry(uint64_t key) {
-
-  int left, right, mid;
-
-  // Binary search (finds the leftmost entry with given key)
-  left = 0;
-  right = bookSize - 1;
-
-  assert(left <= right);
-
-  while (left < right)
-  {
-      mid = (left + right) / 2;
-
-      assert(mid >= left && mid < right);
-
-      if (key <= read_entry(mid).key)
-          right = mid;
-      else
-          left = mid + 1;
-  }
-
-  assert(left == right);
-
-  return read_entry(left).key == key ? left : bookSize;
-}
-
-
-/// Book::operator>>() reads sizeof(T) chars from the file's binary byte
-/// stream and converts them in a number of type T.
-template<typename T>
-Book& Book::operator>>(T& n) {
-
-  n = 0;
-
-  for (size_t i = 0; i < sizeof(T); i++)
-      n = T((n << 8) + bookFile.get());
-
-  return *this;
-}
-
-
-/// Book::read_entry() takes an integer index, and returns the BookEntry
-/// at the given index in the book file.
-
-BookEntry Book::read_entry(int idx) {
-
-  assert(idx >= 0 && idx < bookSize);
-  assert(bookFile.is_open());
-
-  BookEntry e;
-
-  bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg);
-
-  *this >> e.key >> e.move >> e.count >> e.learn;
-
-  if (!bookFile.good())
-  {
-      cerr << "Failed to read book entry at index " << idx << endl;
-      exit(EXIT_FAILURE);
-  }
-  return e;
-}

src/book.h

@@ -1,61 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(BOOK_H_INCLUDED)
-#define BOOK_H_INCLUDED
-
-#include <fstream>
-#include <string>
-
-#include "position.h"
-#include "rkiss.h"
-
-
-/// A Polyglot book is a series of "entries" of 16 bytes. All integers are
-/// stored highest byte first (regardless of size). The entries are ordered
-/// according to key. Lowest key first.
-struct BookEntry {
-  uint64_t key;
-  uint16_t move;
-  uint16_t count;
-  uint32_t learn;
-};
-
-class Book {
-public:
-  Book();
-  ~Book();
-  void open(const std::string& fileName);
-  void close();
-  Move probe(const Position& pos, bool findBestMove);
-  const std::string name() const { return bookName; }
-
-private:
-  template<typename T> Book& operator>>(T& n);
-
-  BookEntry read_entry(int idx);
-  int first_entry(uint64_t key);
-
-  RKISS RKiss;
-  std::ifstream bookFile;
-  std::string bookName;
-  int bookSize;
-};
-
-#endif // !defined(BOOK_H_INCLUDED)

src/endgame.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,104 +18,108 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(ENDGAME_H_INCLUDED)
+#ifndef ENDGAME_H_INCLUDED
 #define ENDGAME_H_INCLUDED
 
 #include <map>
+#include <memory>
 #include <string>
+#include <type_traits>
+#include <utility>
 
 #include "position.h"
 #include "types.h"
 
 
-/// EndgameType lists all supported endgames
+/// EndgameCode lists all supported endgame functions by corresponding codes
 
-enum EndgameType {
+enum EndgameCode {
-
-  // Evaluation functions
 
+  EVALUATION_FUNCTIONS,
+  KNNK,  // KNN vs K
   KXK,   // Generic "mate lone king" eval
   KBNK,  // KBN vs K
   KPK,   // KP vs K
   KRKP,  // KR vs KP
   KRKB,  // KR vs KB
   KRKN,  // KR vs KN
+  KQKP,  // KQ vs KP
   KQKR,  // KQ vs KR
-  KBBKN, // KBB vs KN
-  KNNK,  // KNN vs K
-  KmmKm, // K and two minors vs K and one or two minors
 
-
+  SCALING_FUNCTIONS,
-  // Scaling functions
+  KBPsK,   // KB and pawns vs K
-  SCALE_FUNS,
+  KQKRPs,  // KQ vs KR and pawns
-
-  KBPsK,   // KB+pawns vs K
-  KQKRPs,  // KQ vs KR+pawns
   KRPKR,   // KRP vs KR
+  KRPKB,   // KRP vs KB
   KRPPKRP, // KRPP vs KRP
-  KPsK,    // King and pawns vs king
+  KPsK,    // K and pawns vs K
   KBPKB,   // KBP vs KB
   KBPPKB,  // KBPP vs KB
   KBPKN,   // KBP vs KN
   KNPK,    // KNP vs K
+  KNPKB,   // KNP vs KB
   KPKP     // KP vs KP
 };
 
 
-/// Some magic to detect family type of endgame from its enum value
+/// Endgame functions can be of two types depending on whether they return a
-
+/// Value or a ScaleFactor.
-template<bool> struct bool_to_type { typedef Value type; };
+template<EndgameCode E> using
-template<> struct bool_to_type<true> { typedef ScaleFactor type; };
+eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
-template<EndgameType E> struct eg_family : public bool_to_type<(E > SCALE_FUNS)> {};
 
 
-/// Base and derived templates for endgame evaluation and scaling functions
+/// Base and derived functors for endgame evaluation and scaling functions
 
 template<typename T>
 struct EndgameBase {
 
-  virtual ~EndgameBase() {}
+  explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {}
-  virtual Color color() const = 0;
+  virtual ~EndgameBase() = default;
   virtual T operator()(const Position&) const = 0;
+
+  const Color strongSide, weakSide;
 };
 
 
-template<EndgameType E, typename T = typename eg_family<E>::type>
+template<EndgameCode E, typename T = eg_type<E>>
 struct Endgame : public EndgameBase<T> {
 
-  explicit Endgame(Color c) : strongerSide(c), weakerSide(flip(c)) {}
+  explicit Endgame(Color c) : EndgameBase<T>(c) {}
-  Color color() const { return strongerSide; }
+  T operator()(const Position&) const override;
-  T operator()(const Position&) const;
-
-private:
-  Color strongerSide, weakerSide;
 };
 
 
-/// Endgames class stores in two std::map the pointers to endgame evaluation
+/// The Endgames class stores the pointers to endgame evaluation and scaling
-/// and scaling base objects. Then we use polymorphism to invoke the actual
+/// base objects in two std::map. We use polymorphism to invoke the actual
-/// endgame function calling its operator() method that is virtual.
+/// endgame function by calling its virtual operator().
 
 class Endgames {
 
-  typedef std::map<Key, EndgameBase<Value>*> M1;
+  template<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>;
-  typedef std::map<Key, EndgameBase<ScaleFactor>*> M2;
+  template<typename T> using Map = std::map<Key, Ptr<T>>;
 
-  M1 m1;
+  template<typename T>
-  M2 m2;
+  Map<T>& map() {
+    return std::get<std::is_same<T, ScaleFactor>::value>(maps);
+  }
 
-  M1& map(Value*) { return m1; }
+  template<EndgameCode E, typename T = eg_type<E>, typename P = Ptr<T>>
-  M2& map(ScaleFactor*) { return m2; }
+  void add(const std::string& code) {
 
-  template<EndgameType E> void add(const std::string& code);
+    StateInfo st;
+    map<T>()[Position().set(code, WHITE, &st).material_key()] = P(new Endgame<E>(WHITE));
+    map<T>()[Position().set(code, BLACK, &st).material_key()] = P(new Endgame<E>(BLACK));
+  }
+
+  std::pair<Map<Value>, Map<ScaleFactor>> maps;
 
 public:
   Endgames();
-  ~Endgames();
 
-  template<typename T> EndgameBase<T>* get(Key key) {
+  template<typename T>
-    return map((T*)0).count(key) ? map((T*)0)[key] : NULL;
+  EndgameBase<T>* probe(Key key) {
+    return map<T>().count(key) ? map<T>()[key].get() : nullptr;
   }
 };
 
-#endif // !defined(ENDGAME_H_INCLUDED)
+#endif // #ifndef ENDGAME_H_INCLUDED

src/evaluate.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,15 +18,24 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(EVALUATE_H_INCLUDED)
+#ifndef EVALUATE_H_INCLUDED
 #define EVALUATE_H_INCLUDED
 
+#include <string>
+
 #include "types.h"
 
 class Position;
 
-extern Value evaluate(const Position& pos, Value& margin);
+namespace Eval {
-extern std::string trace_evaluate(const Position& pos);
-extern void read_evaluation_uci_options(Color sideToMove);
 
-#endif // !defined(EVALUATE_H_INCLUDED)
+const Value Tempo = Value(20); // Must be visible to search
+
+extern Score Contempt;
+
+std::string trace(const Position& pos);
+
+Value evaluate(const Position& pos);
+}
+
+#endif // #ifndef EVALUATE_H_INCLUDED

src/history.h

@@ -1,71 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(HISTORY_H_INCLUDED)
-#define HISTORY_H_INCLUDED
-
-#include "types.h"
-#include <cstring>
-#include <algorithm>
-
-/// The History class stores statistics about how often different moves
-/// have been successful or unsuccessful during the current search. These
-/// statistics are used for reduction and move ordering decisions. History
-/// entries are stored according only to moving piece and destination square,
-/// in particular two moves with different origin but same destination and
-/// same piece will be considered identical.
-
-class History {
-
-public:
-  void clear();
-  Value value(Piece p, Square to) const;
-  void add(Piece p, Square to, Value bonus);
-  Value gain(Piece p, Square to) const;
-  void update_gain(Piece p, Square to, Value g);
-
-  static const Value MaxValue = Value(2000);
-
-private:
-  Value history[16][64];  // [piece][to_square]
-  Value maxGains[16][64]; // [piece][to_square]
-};
-
-inline void History::clear() {
-  memset(history,  0, 16 * 64 * sizeof(Value));
-  memset(maxGains, 0, 16 * 64 * sizeof(Value));
-}
-
-inline Value History::value(Piece p, Square to) const {
-  return history[p][to];
-}
-
-inline void History::add(Piece p, Square to, Value bonus) {
-  if (abs(history[p][to] + bonus) < MaxValue) history[p][to] += bonus;
-}
-
-inline Value History::gain(Piece p, Square to) const {
-  return maxGains[p][to];
-}
-
-inline void History::update_gain(Piece p, Square to, Value g) {
-  maxGains[p][to] = std::max(g, maxGains[p][to] - 1);
-}
-
-#endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,85 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(LOCK_H_INCLUDED)
-#define LOCK_H_INCLUDED
-
-#if !defined(_MSC_VER)
-
-#  include <pthread.h>
-
-typedef pthread_mutex_t Lock;
-typedef pthread_cond_t WaitCondition;
-
-#  define lock_init(x) pthread_mutex_init(x, NULL)
-#  define lock_grab(x) pthread_mutex_lock(x)
-#  define lock_release(x) pthread_mutex_unlock(x)
-#  define lock_destroy(x) pthread_mutex_destroy(x)
-#  define cond_destroy(x) pthread_cond_destroy(x)
-#  define cond_init(x) pthread_cond_init(x, NULL)
-#  define cond_signal(x) pthread_cond_signal(x)
-#  define cond_wait(x,y) pthread_cond_wait(x,y)
-#  define cond_timedwait(x,y,z) pthread_cond_timedwait(x,y,z)
-
-#else
-
-#define NOMINMAX // disable macros min() and max()
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#undef NOMINMAX
-
-// Default fast and race free locks and condition variables
-#if !defined(OLD_LOCKS)
-
-typedef SRWLOCK Lock;
-typedef CONDITION_VARIABLE WaitCondition;
-
-#  define lock_init(x) InitializeSRWLock(x)
-#  define lock_grab(x) AcquireSRWLockExclusive(x)
-#  define lock_release(x) ReleaseSRWLockExclusive(x)
-#  define lock_destroy(x) (x)
-#  define cond_destroy(x) (x)
-#  define cond_init(x) InitializeConditionVariable(x)
-#  define cond_signal(x) WakeConditionVariable(x)
-#  define cond_wait(x,y) SleepConditionVariableSRW(x,y,INFINITE,0)
-#  define cond_timedwait(x,y,z) SleepConditionVariableSRW(x,y,z,0)
-
-// Fallback solution to build for Windows XP and older versions, note that
-// cond_wait() is racy between lock_release() and WaitForSingleObject().
-#else
-
-typedef CRITICAL_SECTION Lock;
-typedef HANDLE WaitCondition;
-
-#  define lock_init(x) InitializeCriticalSection(x)
-#  define lock_grab(x) EnterCriticalSection(x)
-#  define lock_release(x) LeaveCriticalSection(x)
-#  define lock_destroy(x) DeleteCriticalSection(x)
-#  define cond_init(x) { *x = CreateEvent(0, FALSE, FALSE, 0); }
-#  define cond_destroy(x) CloseHandle(*x)
-#  define cond_signal(x) SetEvent(*x)
-#  define cond_wait(x,y) { ResetEvent(*x); lock_release(y); WaitForSingleObject(*x, INFINITE); lock_grab(y); }
-#  define cond_timedwait(x,y,z) { ResetEvent(*x); lock_release(y); WaitForSingleObject(*x,z); lock_grab(y); }
-
-#endif
-
-#endif
-
-#endif // !defined(LOCK_H_INCLUDED)

src/main.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,40 +19,37 @@
 */
 
 #include <iostream>
-#include <string>
 
 #include "bitboard.h"
-#include "misc.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
+#include "tt.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
-using namespace std;
+namespace PSQT {
-
+  void init();
-extern void uci_loop();
+}
-extern void benchmark(int argc, char* argv[]);
-extern void kpk_bitbase_init();
 
 int main(int argc, char* argv[]) {
 
-  bitboards_init();
+  std::cout << engine_info() << std::endl;
+
+  UCI::init(Options);
+  PSQT::init();
+  Bitboards::init();
   Position::init();
-  kpk_bitbase_init();
+  Bitbases::init();
   Search::init();
-  Threads.init();
+  Pawns::init();
+  Tablebases::init(Options["SyzygyPath"]);
+  TT.resize(Options["Hash"]);
+  Threads.set(Options["Threads"]);
+  Search::clear(); // After threads are up
 
-  cout << engine_info() << endl;
+  UCI::loop(argc, argv);
 
-  if (argc == 1)
+  Threads.set(0);
-      uci_loop();
+  return 0;
-
-  else if (string(argv[1]) == "bench")
-      benchmark(argc, argv);
-
-  else
-      cerr << "\nUsage: stockfish bench [hash size = 128] [threads = 1] "
-           << "[limit = 12] [fen positions file = default] "
-           << "[limited by depth, time, nodes or perft = depth]" << endl;
-
-  Threads.exit();
 }

src/material.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,40 +18,43 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm> // For std::min
 #include <cassert>
-#include <cstring>
+#include <cstring>   // For std::memset
-#include <algorithm>
 
 #include "material.h"
+#include "thread.h"
 
 using namespace std;
 
 namespace {
 
-  // Values modified by Joona Kiiski
+  // Polynomial material imbalance parameters
-  const Value MidgameLimit = Value(15581);
-  const Value EndgameLimit = Value(3998);
 
-  // Scale factors used when one side has no more pawns
+  const int QuadraticOurs[][PIECE_TYPE_NB] = {
-  const int NoPawnsSF[4] = { 6, 12, 32 };
+    //            OUR PIECES
+    // pair pawn knight bishop rook queen
+    {1667                               }, // Bishop pair
+    {  40,    0                         }, // Pawn
+    {  32,  255,  -3                    }, // Knight      OUR PIECES
+    {   0,  104,   4,    0              }, // Bishop
+    { -26,   -2,  47,   105,  -149      }, // Rook
+    {-189,   24, 117,   133,  -134, -10 }  // Queen
+  };
 
-  // Polynomial material balance parameters
+  const int QuadraticTheirs[][PIECE_TYPE_NB] = {
-  const Value RedundantQueenPenalty = Value(320);
+    //           THEIR PIECES
-  const Value RedundantRookPenalty  = Value(554);
+    // pair pawn knight bishop rook queen
+    {   0                               }, // Bishop pair
+    {  36,    0                         }, // Pawn
+    {   9,   63,   0                    }, // Knight      OUR PIECES
+    {  59,   65,  42,     0             }, // Bishop
+    {  46,   39,  24,   -24,    0       }, // Rook
+    {  97,  100, -42,   137,  268,    0 }  // Queen
+  };
 
-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+  // Endgame evaluation and scaling functions are accessed directly and not through
-
+  // the function maps because they correspond to more than one material hash key.
-  const int QuadraticCoefficientsSameColor[][8] = {
-  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
-  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
-
-  const int QuadraticCoefficientsOppositeColor[][8] = {
-  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
-  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
-
-  // Endgame evaluation and scaling functions accessed direcly and not through
-  // the function maps because correspond to more then one material hash key.
-  Endgame<KmmKm> EvaluateKmmKm[] = { Endgame<KmmKm>(WHITE), Endgame<KmmKm>(BLACK) };
   Endgame<KXK>    EvaluateKXK[] = { Endgame<KXK>(WHITE),    Endgame<KXK>(BLACK) };
 
   Endgame<KBPsK>  ScaleKBPsK[]  = { Endgame<KBPsK>(WHITE),  Endgame<KBPsK>(BLACK) };
@@ -58,229 +62,167 @@ namespace {
   Endgame<KPsK>   ScaleKPsK[]   = { Endgame<KPsK>(WHITE),   Endgame<KPsK>(BLACK) };
   Endgame<KPKP>   ScaleKPKP[]   = { Endgame<KPKP>(WHITE),   Endgame<KPKP>(BLACK) };
 
-  // Helper templates used to detect a given material distribution
+  // Helper used to detect a given material distribution
-  template<Color Us> bool is_KXK(const Position& pos) {
+  bool is_KXK(const Position& pos, Color us) {
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return  !more_than_one(pos.pieces(~us))
-    return   pos.non_pawn_material(Them) == VALUE_ZERO
+          && pos.non_pawn_material(us) >= RookValueMg;
-          && pos.piece_count(Them, PAWN) == 0
-          && pos.non_pawn_material(Us)   >= RookValueMidgame;
   }
 
-  template<Color Us> bool is_KBPsKs(const Position& pos) {
+  bool is_KBPsKs(const Position& pos, Color us) {
-    return   pos.non_pawn_material(Us)   == BishopValueMidgame
+    return   pos.non_pawn_material(us) == BishopValueMg
-          && pos.piece_count(Us, BISHOP) == 1
+          && pos.count<BISHOP>(us) == 1
-          && pos.piece_count(Us, PAWN)   >= 1;
+          && pos.count<PAWN  >(us) >= 1;
   }
 
-  template<Color Us> bool is_KQKRPs(const Position& pos) {
+  bool is_KQKRPs(const Position& pos, Color us) {
+    return  !pos.count<PAWN>(us)
+          && pos.non_pawn_material(us) == QueenValueMg
+          && pos.count<QUEEN>(us)  == 1
+          && pos.count<ROOK>(~us) == 1
+          && pos.count<PAWN>(~us) >= 1;
+  }
+
+  /// imbalance() calculates the imbalance by comparing the piece count of each
+  /// piece type for both colors.
+  template<Color Us>
+  int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
+
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.piece_count(Us, PAWN)    == 0
+
-          && pos.non_pawn_material(Us)    == QueenValueMidgame
+    int bonus = 0;
-          && pos.piece_count(Us, QUEEN)   == 1
+
-          && pos.piece_count(Them, ROOK)  == 1
+    // Second-degree polynomial material imbalance, by Tord Romstad
-          && pos.piece_count(Them, PAWN)  >= 1;
+    for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
+    {
+        if (!pieceCount[Us][pt1])
+            continue;
+
+        int v = 0;
+
+        for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2)
+            v +=  QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2]
+                + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2];
+
+        bonus += pieceCount[Us][pt1] * v;
+    }
+
+    return bonus;
   }
 
 } // namespace
 
+namespace Material {
 
-/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
+/// Material::probe() looks up the current position's material configuration in
+/// the material hash table. It returns a pointer to the Entry if the position
+/// is found. Otherwise a new Entry is computed and stored there, so we don't
+/// have to recompute all when the same material configuration occurs again.
 
-void MaterialInfoTable::init() { Base::init(); if (!funcs) funcs = new Endgames(); }
+Entry* probe(const Position& pos) {
-MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
-
-
-/// MaterialInfoTable::material_info() takes a position object as input,
-/// computes or looks up a MaterialInfo object, and returns a pointer to it.
-/// If the material configuration is not already present in the table, it
-/// is stored there, so we don't have to recompute everything when the
-/// same material configuration occurs again.
-
-MaterialInfo* MaterialInfoTable::material_info(const Position& pos) const {
 
   Key key = pos.material_key();
-  MaterialInfo* mi = probe(key);
+  Entry* e = pos.this_thread()->materialTable[key];
 
-  // If mi->key matches the position's material hash key, it means that we
+  if (e->key == key)
-  // have analysed this material configuration before, and we can simply
+      return e;
-  // return the information we found the last time instead of recomputing it.
-  if (mi->key == key)
-      return mi;
 
-  // Initialize MaterialInfo entry
+  std::memset(e, 0, sizeof(Entry));
-  memset(mi, 0, sizeof(MaterialInfo));
+  e->key = key;
-  mi->key = key;
+  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-
-  // Store game phase
-  mi->gamePhase = MaterialInfoTable::game_phase(pos);
-
-  // Let's look if we have a specialized evaluation function for this
-  // particular material configuration. First we look for a fixed
-  // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->get<Value>(key)) != NULL)
-      return mi;
-
-  if (is_KXK<WHITE>(pos))
-  {
-      mi->evaluationFunction = &EvaluateKXK[WHITE];
-      return mi;
-  }
-
-  if (is_KXK<BLACK>(pos))
-  {
-      mi->evaluationFunction = &EvaluateKXK[BLACK];
-      return mi;
-  }
-
-  if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN))
-  {
-      // Minor piece endgame with at least one minor piece per side and
-      // no pawns. Note that the case KmmK is already handled by KXK.
-      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
-      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
-
-      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
-          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
-      {
-          mi->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
-          return mi;
-      }
-  }
-
-  // OK, we didn't find any special evaluation function for the current
-  // material configuration. Is there a suitable scaling function?
-  //
-  // We face problems when there are several conflicting applicable
-  // scaling functions and we need to decide which one to use.
-  EndgameBase<ScaleFactor>* sf;
-
-  if ((sf = funcs->get<ScaleFactor>(key)) != NULL)
-  {
-      mi->scalingFunction[sf->color()] = sf;
-      return mi;
-  }
-
-  // Generic scaling functions that refer to more then one material
-  // distribution. Should be probed after the specialized ones.
-  // Note that these ones don't return after setting the function.
-  if (is_KBPsKs<WHITE>(pos))
-      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
-
-  if (is_KBPsKs<BLACK>(pos))
-      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
-
-  if (is_KQKRPs<WHITE>(pos))
-      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
-
-  else if (is_KQKRPs<BLACK>(pos))
-      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
 
   Value npm_w = pos.non_pawn_material(WHITE);
   Value npm_b = pos.non_pawn_material(BLACK);
+  Value npm = std::max(EndgameLimit, std::min(npm_w + npm_b, MidgameLimit));
 
-  if (npm_w + npm_b == VALUE_ZERO)
+  // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME]
+  e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
+
+  // Let's look if we have a specialized evaluation function for this particular
+  // material configuration. Firstly we look for a fixed configuration one, then
+  // for a generic one if the previous search failed.
+  if ((e->evaluationFunction = pos.this_thread()->endgames.probe<Value>(key)) != nullptr)
+      return e;
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      if (is_KXK(pos, c))
       {
-      if (pos.piece_count(BLACK, PAWN) == 0)
+          e->evaluationFunction = &EvaluateKXK[c];
-      {
+          return e;
-          assert(pos.piece_count(WHITE, PAWN) >= 2);
-          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
       }
-      else if (pos.piece_count(WHITE, PAWN) == 0)
+
+  // OK, we didn't find any special evaluation function for the current material
+  // configuration. Is there a suitable specialized scaling function?
+  EndgameBase<ScaleFactor>* sf;
+
+  if ((sf = pos.this_thread()->endgames.probe<ScaleFactor>(key)) != nullptr)
   {
-          assert(pos.piece_count(BLACK, PAWN) >= 2);
+      e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned
-          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+      return e;
   }
-      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+
+  // We didn't find any specialized scaling function, so fall back on generic
+  // ones that refer to more than one material distribution. Note that in this
+  // case we don't return after setting the function.
+  for (Color c = WHITE; c <= BLACK; ++c)
+  {
+    if (is_KBPsKs(pos, c))
+        e->scalingFunction[c] = &ScaleKBPsK[c];
+
+    else if (is_KQKRPs(pos, c))
+        e->scalingFunction[c] = &ScaleKQKRPs[c];
+  }
+
+  if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board
+  {
+      if (!pos.count<PAWN>(BLACK))
+      {
+          assert(pos.count<PAWN>(WHITE) >= 2);
+
+          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+      }
+      else if (!pos.count<PAWN>(WHITE))
+      {
+          assert(pos.count<PAWN>(BLACK) >= 2);
+
+          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+      }
+      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
       {
           // This is a special case because we set scaling functions
           // for both colors instead of only one.
-          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
-          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
+          e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
   }
 
-  // No pawns makes it difficult to win, even with a material advantage
+  // Zero or just one pawn makes it difficult to win, even with a small material
-  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMidgame)
+  // advantage. This catches some trivial draws like KK, KBK and KNK and gives a
-  {
+  // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN).
-      mi->factor[WHITE] = uint8_t
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
-      (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(WHITE, BISHOP), 2)]);
+      e->factor[WHITE] = uint8_t(npm_w <  RookValueMg   ? SCALE_FACTOR_DRAW :
-  }
+                                 npm_b <= BishopValueMg ? 4 : 14);
 
-  if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMidgame)
+  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
-  {
+      e->factor[BLACK] = uint8_t(npm_b <  RookValueMg   ? SCALE_FACTOR_DRAW :
-      mi->factor[BLACK] = uint8_t
+                                 npm_w <= BishopValueMg ? 4 : 14);
-      (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(BLACK, BISHOP), 2)]);
-  }
 
-  // Compute the space weight
+  if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)
-  if (npm_w + npm_b >= 2 * QueenValueMidgame + 4 * RookValueMidgame + 2 * KnightValueMidgame)
+      e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;
-  {
-      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
-                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
 
-      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg)
-  }
+      e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN;
 
   // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
-  // for the bishop pair "extended piece", this allow us to be more flexible
+  // for the bishop pair "extended piece", which allows us to be more flexible
   // in defining bishop pair bonuses.
-  const int pieceCount[2][8] = {
+  const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = {
-  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
-    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
-  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
-    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
 
-  mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
+  e->value = int16_t((imbalance<WHITE>(PieceCount) - imbalance<BLACK>(PieceCount)) / 16);
-  return mi;
+  return e;
 }
 
-
+} // namespace Material
-/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
-/// piece type for both colors.
-
-template<Color Us>
-int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
-
-  const Color Them = (Us == WHITE ? BLACK : WHITE);
-
-  int pt1, pt2, pc, v;
-  int value = 0;
-
-  // Redundancy of major pieces, formula based on Kaufman's paper
-  // "The Evaluation of Material Imbalances in Chess"
-  if (pieceCount[Us][ROOK] > 0)
-      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
-              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
-
-  // Second-degree polynomial material imbalance by Tord Romstad
-  for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
-  {
-      pc = pieceCount[Us][pt1];
-      if (!pc)
-          continue;
-
-      v = LinearCoefficients[pt1];
-
-      for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
-          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
-              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
-
-      value += pc * v;
-  }
-  return value;
-}
-
-
-/// MaterialInfoTable::game_phase() calculates the phase given the current
-/// position. Because the phase is strictly a function of the material, it
-/// is stored in MaterialInfo.
-
-Phase MaterialInfoTable::game_phase(const Position& pos) {
-
-  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
-
-  return  npm >= MidgameLimit ? PHASE_MIDGAME
-        : npm <= EndgameLimit ? PHASE_ENDGAME
-        : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
-}

src/material.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,108 +18,56 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(MATERIAL_H_INCLUDED)
+#ifndef MATERIAL_H_INCLUDED
 #define MATERIAL_H_INCLUDED
 
 #include "endgame.h"
+#include "misc.h"
 #include "position.h"
-#include "tt.h"
 #include "types.h"
 
-const int MaterialTableSize = 8192;
+namespace Material {
 
-/// Game phase
+/// Material::Entry contains various information about a material configuration.
-enum Phase {
+/// It contains a material imbalance evaluation, a function pointer to a special
-  PHASE_ENDGAME = 0,
+/// endgame evaluation function (which in most cases is NULL, meaning that the
-  PHASE_MIDGAME = 128
+/// standard evaluation function will be used), and scale factors.
-};
-
-
-/// MaterialInfo is a class which contains various information about a
-/// material configuration. It contains a material balance evaluation,
-/// a function pointer to a special endgame evaluation function (which in
-/// most cases is NULL, meaning that the standard evaluation function will
-/// be used), and "scale factors" for black and white.
 ///
-/// The scale factors are used to scale the evaluation score up or down.
+/// The scale factors are used to scale the evaluation score up or down. For
-/// For instance, in KRB vs KR endgames, the score is scaled down by a factor
+/// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4,
-/// of 4, which will result in scores of absolute value less than one pawn.
+/// which will result in scores of absolute value less than one pawn.
 
-class MaterialInfo {
+struct Entry {
 
-  friend class MaterialInfoTable;
+  Score imbalance() const { return make_score(value, value); }
+  Phase game_phase() const { return gamePhase; }
+  bool specialized_eval_exists() const { return evaluationFunction != nullptr; }
+  Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); }
 
-public:
+  // scale_factor takes a position and a color as input and returns a scale factor
-  Score material_value() const;
+  // for the given color. We have to provide the position in addition to the color
-  ScaleFactor scale_factor(const Position& pos, Color c) const;
+  // because the scale factor may also be a function which should be applied to
-  int space_weight() const;
+  // the position. For instance, in KBP vs K endgames, the scaling function looks
-  Phase game_phase() const;
+  // for rook pawns and wrong-colored bishops.
-  bool specialized_eval_exists() const;
+  ScaleFactor scale_factor(const Position& pos, Color c) const {
-  Value evaluate(const Position& pos) const;
+    ScaleFactor sf = scalingFunction[c] ? (*scalingFunction[c])(pos)
+                                        :  SCALE_FACTOR_NONE;
+    return sf != SCALE_FACTOR_NONE ? sf : ScaleFactor(factor[c]);
+  }
 
-private:
   Key key;
-  int16_t value;
-  uint8_t factor[2];
   EndgameBase<Value>* evaluationFunction;
-  EndgameBase<ScaleFactor>* scalingFunction[2];
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each
-  int spaceWeight;
+                                                       // side (e.g. KPKP, KBPsKs)
+  int16_t value;
+  uint8_t factor[COLOR_NB];
   Phase gamePhase;
 };
 
+typedef HashTable<Entry, 8192> Table;
 
-/// The MaterialInfoTable class represents a pawn hash table. The most important
+Entry* probe(const Position& pos);
-/// method is material_info(), which returns a pointer to a MaterialInfo object.
 
-class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
+} // namespace Material
-public:
-  ~MaterialInfoTable();
-  void init();
-  MaterialInfo* material_info(const Position& pos) const;
-  static Phase game_phase(const Position& pos);
 
-private:
+#endif // #ifndef MATERIAL_H_INCLUDED
-  template<Color Us>
-  static int imbalance(const int pieceCount[][8]);
-
-  Endgames* funcs;
-};
-
-
-/// MaterialInfo::scale_factor takes a position and a color as input, and
-/// returns a scale factor for the given color. We have to provide the
-/// position in addition to the color, because the scale factor need not
-/// to be a constant: It can also be a function which should be applied to
-/// the position. For instance, in KBP vs K endgames, a scaling function
-/// which checks for draws with rook pawns and wrong-colored bishops.
-
-inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
-
-  if (!scalingFunction[c])
-      return ScaleFactor(factor[c]);
-
-  ScaleFactor sf = (*scalingFunction[c])(pos);
-  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
-}
-
-inline Value MaterialInfo::evaluate(const Position& pos) const {
-  return (*evaluationFunction)(pos);
-}
-
-inline Score MaterialInfo::material_value() const {
-  return make_score(value, value);
-}
-
-inline int MaterialInfo::space_weight() const {
-  return spaceWeight;
-}
-
-inline Phase MaterialInfo::game_phase() const {
-  return gamePhase;
-}
-
-inline bool MaterialInfo::specialized_eval_exists() const {
-  return evaluationFunction != NULL;
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)

src/misc.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,88 +18,133 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if defined(_MSC_VER)
+#ifdef _WIN32
-
+#if _WIN32_WINNT < 0x0601
-#define _CRT_SECURE_NO_DEPRECATE
+#undef  _WIN32_WINNT
-#define NOMINMAX // disable macros min() and max()
+#define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
+#endif
 #include <windows.h>
-#include <sys/timeb.h>
+// The needed Windows API for processor groups could be missed from old Windows
-
+// versions, so instead of calling them directly (forcing the linker to resolve
-#else
+// the calls at compile time), try to load them at runtime. To do this we need
-
+// first to define the corresponding function pointers.
-#  include <sys/time.h>
+extern "C" {
-#  include <sys/types.h>
+typedef bool(*fun1_t)(LOGICAL_PROCESSOR_RELATIONSHIP,
-#  include <unistd.h>
+                      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD);
-#  if defined(__hpux)
+typedef bool(*fun2_t)(USHORT, PGROUP_AFFINITY);
-#     include <sys/pstat.h>
+typedef bool(*fun3_t)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
+}
 #endif
 
-#endif
+#include <fstream>
-
-#if !defined(NO_PREFETCH)
-#  include <xmmintrin.h>
-#endif
-
-#include <algorithm>
-#include <cassert>
-#include <cstdio>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <vector>
 
-#include "bitcount.h"
 #include "misc.h"
 #include "thread.h"
 
 using namespace std;
 
-/// Version number. If Version is left empty, then Tag plus current
+namespace {
-/// date (in the format YYMMDD) is used as a version number.
 
-static const string Version = "2.2";
+/// Version number. If Version is left empty, then compile date in the format
-static const string Tag  = "";
+/// DD-MM-YY and show in engine_info.
+const string Version = "9";
 
+/// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
+/// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
+/// can toggle the logging of std::cout and std:cin at runtime whilst preserving
+/// usual I/O functionality, all without changing a single line of code!
+/// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
 
-/// engine_info() returns the full name of the current Stockfish version.
+struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
-/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when
+
-/// the program was compiled) or "Stockfish <version number>", depending
+  Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
-/// on whether Version is empty.
+
+  int sync() override { return logBuf->pubsync(), buf->pubsync(); }
+  int overflow(int c) override { return log(buf->sputc((char)c), "<< "); }
+  int underflow() override { return buf->sgetc(); }
+  int uflow() override { return log(buf->sbumpc(), ">> "); }
+
+  streambuf *buf, *logBuf;
+
+  int log(int c, const char* prefix) {
+
+    static int last = '\n'; // Single log file
+
+    if (last == '\n')
+        logBuf->sputn(prefix, 3);
+
+    return last = logBuf->sputc((char)c);
+  }
+};
+
+class Logger {
+
+  Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
+ ~Logger() { start(""); }
+
+  ofstream file;
+  Tie in, out;
+
+public:
+  static void start(const std::string& fname) {
+
+    static Logger l;
+
+    if (!fname.empty() && !l.file.is_open())
+    {
+        l.file.open(fname, ifstream::out);
+        cin.rdbuf(&l.in);
+        cout.rdbuf(&l.out);
+    }
+    else if (fname.empty() && l.file.is_open())
+    {
+        cout.rdbuf(l.out.buf);
+        cin.rdbuf(l.in.buf);
+        l.file.close();
+    }
+  }
+};
+
+} // namespace
+
+/// engine_info() returns the full name of the current Stockfish version. This
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// Version is empty.
 
 const string engine_info(bool to_uci) {
 
   const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
-  const string cpu64(Is64Bit ? " 64bit" : "");
-  const string popcnt(HasPopCnt ? " SSE4.2" : "");
-
   string month, day, year;
-  stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"
+  stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008"
+
+  ss << "Stockfish " << Version << setfill('0');
 
   if (Version.empty())
   {
       date >> month >> day >> year;
-
+      ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
-      s << "Stockfish " << Tag
-        << setfill('0') << " " << year.substr(2)
-        << setw(2) << (1 + months.find(month) / 4)
-        << setw(2) << day << cpu64 << popcnt;
   }
-  else
-      s << "Stockfish " << Version << cpu64 << popcnt;
 
-  s << (to_uci ? "\nid author ": " by ")
+  ss << (Is64Bit ? " 64" : "")
-    << "Tord Romstad, Marco Costalba and Joona Kiiski";
+     << (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : ""))
+     << (to_uci  ? "\nid author ": " by ")
+     << "T. Romstad, M. Costalba, J. Kiiski, G. Linscott";
 
-  return s.str();
+  return ss.str();
 }
 
 
 /// Debug functions used mainly to collect run-time statistics
+static int64_t hits[2], means[2];
 
-static uint64_t hits[2], means[2];
+void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
-
+void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
-void dbg_hit_on(bool b) { hits[0]++; if (b) hits[1]++; }
+void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
-void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
-void dbg_mean_of(int v) { means[0]++; means[1] += v; }
 
 void dbg_print() {
 
@@ -108,97 +154,164 @@ void dbg_print() {
 
   if (means[0])
       cerr << "Total " << means[0] << " Mean "
-           << (float)means[1] / means[0] << endl;
+           << (double)means[1] / means[0] << endl;
 }
 
 
-/// system_time() returns the current system time, measured in milliseconds
+/// Used to serialize access to std::cout to avoid multiple threads writing at
+/// the same time.
 
-int system_time() {
+std::ostream& operator<<(std::ostream& os, SyncCout sc) {
 
-#if defined(_MSC_VER)
+  static Mutex m;
-  struct _timeb t;
+
-  _ftime(&t);
+  if (sc == IO_LOCK)
-  return int(t.time * 1000 + t.millitm);
+      m.lock();
-#else
+
-  struct timeval t;
+  if (sc == IO_UNLOCK)
-  gettimeofday(&t, NULL);
+      m.unlock();
-  return t.tv_sec * 1000 + t.tv_usec / 1000;
+
-#endif
+  return os;
 }
 
 
-/// cpu_count() tries to detect the number of CPU cores
+/// Trampoline helper to avoid moving Logger to misc.h
-
+void start_logger(const std::string& fname) { Logger::start(fname); }
-int cpu_count() {
-
-#if defined(_MSC_VER)
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return std::min(int(s.dwNumberOfProcessors), MAX_THREADS);
-#else
-
-#  if defined(_SC_NPROCESSORS_ONLN)
-  return std::min((int)sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
-#  elif defined(__hpux)
-  struct pst_dynamic psd;
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-  return std::min((int)psd.psd_proc_cnt, MAX_THREADS);
-#  else
-  return 1;
-#  endif
-
-#endif
-}
 
 
-/// timed_wait() waits for msec milliseconds. It is mainly an helper to wrap
+/// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
-/// conversion from milliseconds to struct timespec, as used by pthreads.
+/// function that doesn't stall the CPU waiting for data to be loaded from memory,
+/// which can be quite slow.
+#ifdef NO_PREFETCH
 
-void timed_wait(WaitCondition* sleepCond, Lock* sleepLock, int msec) {
+void prefetch(void*) {}
-
-#if defined(_MSC_VER)
-  int tm = msec;
-#else
-  struct timeval t;
-  struct timespec abstime, *tm = &abstime;
-
-  gettimeofday(&t, NULL);
-
-  abstime.tv_sec = t.tv_sec + (msec / 1000);
-  abstime.tv_nsec = (t.tv_usec + (msec % 1000) * 1000) * 1000;
-
-  if (abstime.tv_nsec > 1000000000LL)
-  {
-      abstime.tv_sec += 1;
-      abstime.tv_nsec -= 1000000000LL;
-  }
-#endif
-
-  cond_timedwait(sleepCond, sleepLock, tm);
-}
-
-
-/// prefetch() preloads the given address in L1/L2 cache. This is a non
-/// blocking function and do not stalls the CPU waiting for data to be
-/// loaded from memory, that can be quite slow.
-#if defined(NO_PREFETCH)
-
-void prefetch(char*) {}
 
 #else
 
-void prefetch(char* addr) {
+void prefetch(void* addr) {
 
-#  if defined(__INTEL_COMPILER) || defined(__ICL)
+#  if defined(__INTEL_COMPILER)
-   // This hack prevents prefetches to be optimized away by
+   // This hack prevents prefetches from being optimized away by
-   // Intel compiler. Both MSVC and gcc seems not affected.
+   // Intel compiler. Both MSVC and gcc seem not be affected by this.
    __asm__ ("");
 #  endif
 
-  _mm_prefetch(addr, _MM_HINT_T2);
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
+  _mm_prefetch((char*)addr, _MM_HINT_T0);
+#  else
+  __builtin_prefetch(addr);
+#  endif
 }
 
 #endif
+
+void prefetch2(void* addr) {
+
+  prefetch(addr);
+  prefetch((uint8_t*)addr + 64);
+}
+
+namespace WinProcGroup {
+
+#ifndef _WIN32
+
+void bindThisThread(size_t) {}
+
+#else
+
+/// get_group() retrieves logical processor information using Windows specific
+/// API and returns the best group id for the thread with index idx. Original
+/// code from Texel by Peter Österlund.
+
+int get_group(size_t idx) {
+
+  int threads = 0;
+  int nodes = 0;
+  int cores = 0;
+  DWORD returnLength = 0;
+  DWORD byteOffset = 0;
+
+  // Early exit if the needed API is not available at runtime
+  HMODULE k32 = GetModuleHandle("Kernel32.dll");
+  auto fun1 = (fun1_t)GetProcAddress(k32, "GetLogicalProcessorInformationEx");
+  if (!fun1)
+      return -1;
+
+  // First call to get returnLength. We expect it to fail due to null buffer
+  if (fun1(RelationAll, nullptr, &returnLength))
+      return -1;
+
+  // Once we know returnLength, allocate the buffer
+  SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr;
+  ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(returnLength);
+
+  // Second call, now we expect to succeed
+  if (!fun1(RelationAll, buffer, &returnLength))
+  {
+      free(buffer);
+      return -1;
+  }
+
+  while (ptr->Size > 0 && byteOffset + ptr->Size <= returnLength)
+  {
+      if (ptr->Relationship == RelationNumaNode)
+          nodes++;
+
+      else if (ptr->Relationship == RelationProcessorCore)
+      {
+          cores++;
+          threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
+      }
+
+      byteOffset += ptr->Size;
+      ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
+  }
+
+  free(buffer);
+
+  std::vector<int> groups;
+
+  // Run as many threads as possible on the same node until core limit is
+  // reached, then move on filling the next node.
+  for (int n = 0; n < nodes; n++)
+      for (int i = 0; i < cores / nodes; i++)
+          groups.push_back(n);
+
+  // In case a core has more than one logical processor (we assume 2) and we
+  // have still threads to allocate, then spread them evenly across available
+  // nodes.
+  for (int t = 0; t < threads - cores; t++)
+      groups.push_back(t % nodes);
+
+  // If we still have more threads than the total number of logical processors
+  // then return -1 and let the OS to decide what to do.
+  return idx < groups.size() ? groups[idx] : -1;
+}
+
+
+/// bindThisThread() set the group affinity of the current thread
+
+void bindThisThread(size_t idx) {
+
+  // Use only local variables to be thread-safe
+  int group = get_group(idx);
+
+  if (group == -1)
+      return;
+
+  // Early exit if the needed API are not available at runtime
+  HMODULE k32 = GetModuleHandle("Kernel32.dll");
+  auto fun2 = (fun2_t)GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
+  auto fun3 = (fun3_t)GetProcAddress(k32, "SetThreadGroupAffinity");
+
+  if (!fun2 || !fun3)
+      return;
+
+  GROUP_AFFINITY affinity;
+  if (fun2(group, &affinity))
+      fun3(GetCurrentThread(), &affinity, nullptr);
+}
+
+#endif
+
+} // namespace WinProcGroup

src/misc.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,34 +18,95 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(MISC_H_INCLUDED)
+#ifndef MISC_H_INCLUDED
 #define MISC_H_INCLUDED
 
-#include <fstream>
+#include <cassert>
+#include <chrono>
+#include <ostream>
 #include <string>
+#include <vector>
 
-#include "lock.h"
 #include "types.h"
 
-extern const std::string engine_info(bool to_uci = false);
+const std::string engine_info(bool to_uci = false);
-extern int system_time();
+void prefetch(void* addr);
-extern int cpu_count();
+void prefetch2(void* addr);
-extern void timed_wait(WaitCondition*, Lock*, int);
+void start_logger(const std::string& fname);
-extern void prefetch(char* addr);
 
-extern void dbg_hit_on(bool b);
+void dbg_hit_on(bool b);
-extern void dbg_hit_on_c(bool c, bool b);
+void dbg_hit_on(bool c, bool b);
-extern void dbg_mean_of(int v);
+void dbg_mean_of(int v);
-extern void dbg_print();
+void dbg_print();
 
-class Position;
+typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
-extern Move move_from_uci(const Position& pos, const std::string& str);
-extern const std::string move_to_uci(Move m, bool chess960);
-extern const std::string move_to_san(Position& pos, Move m);
 
-struct Log : public std::ofstream {
+inline TimePoint now() {
-  Log(const std::string& f = "log.txt") : std::ofstream(f.c_str(), std::ios::out | std::ios::app) {}
+  return std::chrono::duration_cast<std::chrono::milliseconds>
- ~Log() { if (is_open()) close(); }
+        (std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+template<class Entry, int Size>
+struct HashTable {
+  Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
+
+private:
+  std::vector<Entry> table = std::vector<Entry>(Size);
 };
 
-#endif // !defined(MISC_H_INCLUDED)
+
+enum SyncCout { IO_LOCK, IO_UNLOCK };
+std::ostream& operator<<(std::ostream&, SyncCout);
+
+#define sync_cout std::cout << IO_LOCK
+#define sync_endl std::endl << IO_UNLOCK
+
+
+/// xorshift64star Pseudo-Random Number Generator
+/// This class is based on original code written and dedicated
+/// to the public domain by Sebastiano Vigna (2014).
+/// It has the following characteristics:
+///
+///  -  Outputs 64-bit numbers
+///  -  Passes Dieharder and SmallCrush test batteries
+///  -  Does not require warm-up, no zeroland to escape
+///  -  Internal state is a single 64-bit integer
+///  -  Period is 2^64 - 1
+///  -  Speed: 1.60 ns/call (Core i7 @3.40GHz)
+///
+/// For further analysis see
+///   <http://vigna.di.unimi.it/ftp/papers/xorshift.pdf>
+
+class PRNG {
+
+  uint64_t s;
+
+  uint64_t rand64() {
+
+    s ^= s >> 12, s ^= s << 25, s ^= s >> 27;
+    return s * 2685821657736338717LL;
+  }
+
+public:
+  PRNG(uint64_t seed) : s(seed) { assert(seed); }
+
+  template<typename T> T rand() { return T(rand64()); }
+
+  /// Special generator used to fast init magic numbers.
+  /// Output values only have 1/8th of their bits set on average.
+  template<typename T> T sparse_rand()
+  { return T(rand64() & rand64() & rand64()); }
+};
+
+
+/// Under Windows it is not possible for a process to run on more than one
+/// logical processor group. This usually means to be limited to use max 64
+/// cores. To overcome this, some special platform specific API should be
+/// called to set group affinity for each thread. Original code from Texel by
+/// Peter Österlund.
+
+namespace WinProcGroup {
+  void bindThisThread(size_t idx);
+}
+
+#endif // #ifndef MISC_H_INCLUDED

src/move.cpp

@@ -1,159 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <cassert>
-#include <cstring>
-#include <string>
-
-#include "movegen.h"
-#include "position.h"
-
-using std::string;
-
-/// move_to_uci() converts a move to a string in coordinate notation
-/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we
-/// print in the e1g1 notation in normal chess mode, and in e1h1 notation in
-/// Chess960 mode. Instead internally Move is coded as "king captures rook".
-
-const string move_to_uci(Move m, bool chess960) {
-
-  Square from = move_from(m);
-  Square to = move_to(m);
-  string promotion;
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "0000";
-
-  if (is_castle(m) && !chess960)
-      to = from + (file_of(to) == FILE_H ? Square(2) : -Square(2));
-
-  if (is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(promotion_piece_type(m))));
-
-  return square_to_string(from) + square_to_string(to) + promotion;
-}
-
-
-/// move_from_uci() takes a position and a string representing a move in
-/// simple coordinate notation and returns an equivalent Move if any.
-/// Moves are guaranteed to be legal.
-
-Move move_from_uci(const Position& pos, const string& str) {
-
-  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
-      if (str == move_to_uci(ml.move(), pos.is_chess960()))
-          return ml.move();
-
-  return MOVE_NONE;
-}
-
-
-/// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move for the position. The return value is
-/// a string containing the move in short algebraic notation.
-
-const string move_to_san(Position& pos, Move m) {
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "(null)";
-
-  assert(is_ok(m));
-
-  Bitboard attackers;
-  bool ambiguousMove, ambiguousFile, ambiguousRank;
-  Square sq, from = move_from(m);
-  Square to = move_to(m);
-  PieceType pt = type_of(pos.piece_on(from));
-  string san;
-
-  if (is_castle(m))
-      san = (move_to(m) < move_from(m) ? "O-O-O" : "O-O");
-  else
-  {
-      if (pt != PAWN)
-      {
-          san = piece_type_to_char(pt);
-
-          // Disambiguation if we have more then one piece with destination 'to'
-          // note that for pawns is not needed because starting file is explicit.
-          attackers = pos.attackers_to(to) & pos.pieces(pt, pos.side_to_move());
-          clear_bit(&attackers, from);
-          ambiguousMove = ambiguousFile = ambiguousRank = false;
-
-          while (attackers)
-          {
-              sq = pop_1st_bit(&attackers);
-
-              // Pinned pieces are not included in the possible sub-set
-              if (!pos.pl_move_is_legal(make_move(sq, to), pos.pinned_pieces()))
-                  continue;
-
-              if (file_of(sq) == file_of(from))
-                  ambiguousFile = true;
-
-              if (rank_of(sq) == rank_of(from))
-                  ambiguousRank = true;
-
-              ambiguousMove = true;
-          }
-
-          if (ambiguousMove)
-          {
-              if (!ambiguousFile)
-                  san += file_to_char(file_of(from));
-              else if (!ambiguousRank)
-                  san += rank_to_char(rank_of(from));
-              else
-                  san += square_to_string(from);
-          }
-      }
-
-      if (pos.is_capture(m))
-      {
-          if (pt == PAWN)
-              san += file_to_char(file_of(from));
-
-          san += 'x';
-      }
-
-      san += square_to_string(to);
-
-      if (is_promotion(m))
-      {
-          san += '=';
-          san += piece_type_to_char(promotion_piece_type(m));
-      }
-  }
-
-  // The move gives check? We don't use pos.move_gives_check() here
-  // because we need to test for a mate after the move is done.
-  StateInfo st;
-  pos.do_move(m, st);
-  if (pos.in_check())
-      san += pos.is_mate() ? "#" : "+";
-  pos.undo_move(m);
-
-  return san;
-}

src/movegen.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,526 +19,402 @@
 */
 
 #include <cassert>
-#include <algorithm>
 
-#include "bitcount.h"
 #include "movegen.h"
 #include "position.h"
 
-// Simple macro to wrap a very common while loop, no facny, no flexibility,
-// hardcoded list name 'mlist' and from square 'from'.
-#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
-
-// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
-
 namespace {
 
-  enum CastlingSide {
+  template<CastlingRight Cr, bool Checks, bool Chess960>
-    KING_SIDE,
+  ExtMove* generate_castling(const Position& pos, ExtMove* moveList, Color us) {
-    QUEEN_SIDE
-  };
 
-  template<CastlingSide>
+    static const bool KingSide = (Cr == WHITE_OO || Cr == BLACK_OO);
-  MoveStack* generate_castle_moves(const Position&, MoveStack*, Color us);
 
-  template<Color, MoveType>
+    if (pos.castling_impeded(Cr) || !pos.can_castle(Cr))
-  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard, Square);
+        return moveList;
 
-  template<PieceType Pt>
+    // After castling, the rook and king final positions are the same in Chess960
-  inline MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
+    // as they would be in standard chess.
+    Square kfrom = pos.square<KING>(us);
+    Square rfrom = pos.castling_rook_square(Cr);
+    Square kto = relative_square(us, KingSide ? SQ_G1 : SQ_C1);
+    Bitboard enemies = pos.pieces(~us);
 
-    assert(Pt != QUEEN && Pt != PAWN);
+    assert(!pos.checkers());
 
-    Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
+    const Direction K = Chess960 ? kto > kfrom ? WEST : EAST
+                                 : KingSide    ? WEST : EAST;
 
-    if (Pt == KING)
+    for (Square s = kto; s != kfrom; s += K)
-        b &= ~QueenPseudoAttacks[pos.king_square(flip(pos.side_to_move()))];
+        if (pos.attackers_to(s) & enemies)
+            return moveList;
 
-    SERIALIZE_MOVES(b);
+    // Because we generate only legal castling moves we need to verify that
-    return mlist;
+    // when moving the castling rook we do not discover some hidden checker.
+    // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
+    if (Chess960 && (attacks_bb<ROOK>(kto, pos.pieces() ^ rfrom) & pos.pieces(~us, ROOK, QUEEN)))
+        return moveList;
+
+    Move m = make<CASTLING>(kfrom, rfrom);
+
+    if (Checks && !pos.gives_check(m))
+        return moveList;
+
+    *moveList++ = m;
+    return moveList;
   }
 
-  template<PieceType Pt>
-  inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
-                                           Bitboard dc, Square ksq) {
-    assert(Pt != KING && Pt != PAWN);
 
-    Bitboard checkSqs, b;
+  template<GenType Type, Direction D>
-    Square from;
+  ExtMove* make_promotions(ExtMove* moveList, Square to, Square ksq) {
-    const Square* pl = pos.piece_list(us, Pt);
 
-    if ((from = *pl++) == SQ_NONE)
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
-        return mlist;
+        *moveList++ = make<PROMOTION>(to - D, to, QUEEN);
 
-    checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();
+    if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
-
-    do
     {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
+        *moveList++ = make<PROMOTION>(to - D, to, ROOK);
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
+        *moveList++ = make<PROMOTION>(to - D, to, BISHOP);
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
+        *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
-            continue;
-
-        if (dc && bit_is_set(dc, from))
-            continue;
-
-        b = pos.attacks_from<Pt>(from) & checkSqs;
-        SERIALIZE_MOVES(b);
-
-    } while ((from = *pl++) != SQ_NONE);
-
-    return mlist;
     }
 
-  template<>
+    // Knight promotion is the only promotion that can give a direct check
-  FORCE_INLINE MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
+    // that's not already included in the queen promotion.
-
+    if (Type == QUIET_CHECKS && (PseudoAttacks[KNIGHT][to] & ksq))
-    return (us == WHITE ? generate_pawn_moves<WHITE, MV_CHECK>(p, m, dc, ksq)
+        *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
-                        : generate_pawn_moves<BLACK, MV_CHECK>(p, m, dc, ksq));
-  }
-
-  template<PieceType Pt, MoveType Type>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
-
-    assert(Pt == PAWN);
-    assert(Type == MV_CAPTURE || Type == MV_NON_CAPTURE || Type == MV_EVASION);
-
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
-  }
-
-  template<PieceType Pt>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from;
-    const Square* pl = pos.piece_list(us, Pt);
-
-    if (*pl != SQ_NONE)
-    {
-        do {
-            from = *pl;
-            b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE_MOVES(b);
-        } while (*++pl != SQ_NONE);
-    }
-    return mlist;
-  }
-
-  template<>
-  FORCE_INLINE MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from = pos.king_square(us);
-
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
-
-}
-
-
-/// generate<MV_CAPTURE> generates all pseudo-legal captures and queen
-/// promotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_CAPTURE> generates all pseudo-legal non-captures and
-/// underpromotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_EVASION> generates all pseudo-legal captures and
-/// non-captures. Returns a pointer to the end of the move list.
-
-template<MoveType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
-
-  assert(!pos.in_check());
-
-  Color us = pos.side_to_move();
-  Bitboard target;
-
-  if (Type == MV_CAPTURE || Type == MV_NON_EVASION)
-      target = pos.pieces(flip(us));
-  else if (Type == MV_NON_CAPTURE)
-      target = pos.empty_squares();
     else
-      assert(false);
+        (void)ksq; // Silence a warning under MSVC
 
-  if (Type == MV_NON_EVASION)
+    return moveList;
-  {
-      mlist = generate_piece_moves<PAWN, MV_CAPTURE>(pos, mlist, us, target);
-      mlist = generate_piece_moves<PAWN, MV_NON_CAPTURE>(pos, mlist, us, pos.empty_squares());
-      target |= pos.empty_squares();
-  }
-  else
-      mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
-
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KING>(pos, mlist, us, target);
-
-  if (Type != MV_CAPTURE && pos.can_castle(us))
-  {
-      if (pos.can_castle(us == WHITE ? WHITE_OO : BLACK_OO))
-          mlist = generate_castle_moves<KING_SIDE>(pos, mlist, us);
-
-      if (pos.can_castle(us == WHITE ? WHITE_OOO : BLACK_OOO))
-          mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist, us);
-  }
-
-  return mlist;
-}
-
-// Explicit template instantiations
-template MoveStack* generate<MV_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mlist);
-
-
-/// generate<MV_NON_CAPTURE_CHECK> generates all pseudo-legal non-captures and knight
-/// underpromotions that give check. Returns a pointer to the end of the move list.
-template<>
-MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist) {
-
-  assert(!pos.in_check());
-
-  Bitboard b, dc;
-  Square from;
-  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(flip(us));
-
-  assert(pos.piece_on(ksq) == make_piece(flip(us), KING));
-
-  // Discovered non-capture checks
-  b = dc = pos.discovered_check_candidates();
-
-  while (b)
-  {
-     from = pop_1st_bit(&b);
-     switch (type_of(pos.piece_on(from)))
-     {
-      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
-      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
-      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, mlist, from); break;
-      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, mlist, from);   break;
-      case KING:   mlist = generate_discovered_checks<KING>(pos, mlist, from);   break;
-      default: assert(false); break;
-     }
-  }
-
-  // Direct non-capture checks
-  mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<ROOK>(pos, mlist, us, dc, ksq);
-  return  generate_direct_checks<QUEEN>(pos, mlist, us, dc, ksq);
   }
 
 
-/// generate<MV_EVASION> generates all pseudo-legal check evasions when the side
+  template<Color Us, GenType Type>
-/// to move is in check. Returns a pointer to the end of the move list.
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
-template<>
-MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
 
-  assert(pos.in_check());
+    // Compute our parametrized parameters at compile time, named according to
-
+    // the point of view of white side.
-  Bitboard b, target;
-  Square from, checksq;
-  int checkersCnt = 0;
-  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(us);
-  Bitboard checkers = pos.checkers();
-  Bitboard sliderAttacks = 0;
-
-  assert(pos.piece_on(ksq) == make_piece(us, KING));
-  assert(checkers);
-
-  // Find squares attacked by slider checkers, we will remove
-  // them from the king evasions set so to early skip known
-  // illegal moves and avoid an useless legality check later.
-  b = checkers;
-  do
-  {
-      checkersCnt++;
-      checksq = pop_1st_bit(&b);
-
-      assert(color_of(pos.piece_on(checksq)) == flip(us));
-
-      switch (type_of(pos.piece_on(checksq)))
-      {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
-      case QUEEN:
-          // If queen and king are far we can safely remove all the squares attacked
-          // in the other direction becuase are not reachable by the king anyway.
-          if (squares_between(ksq, checksq) || (RookPseudoAttacks[checksq] & (1ULL << ksq)))
-              sliderAttacks |= QueenPseudoAttacks[checksq];
-
-          // Otherwise, if king and queen are adjacent and on a diagonal line, we need to
-          // use real rook attacks to check if king is safe to move in the other direction.
-          // For example: king in B2, queen in A1 a knight in B1, and we can safely move to C1.
-          else
-              sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
-
-      default:
-          break;
-      }
-  } while (b);
-
-  // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
-  from = ksq;
-  SERIALIZE_MOVES(b);
-
-  // Generate evasions for other pieces only if not double check
-  if (checkersCnt > 1)
-      return mlist;
-
-  // Find squares where a blocking evasion or a capture of the
-  // checker piece is possible.
-  target = squares_between(checksq, ksq) | checkers;
-
-  mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  return  generate_piece_moves<QUEEN>(pos, mlist, us, target);
-}
-
-
-/// generate<MV_LEGAL> computes a complete list of legal moves in the current position
-
-template<>
-MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
-
-  MoveStack *last, *cur = mlist;
-  Bitboard pinned = pos.pinned_pieces();
-
-  last = pos.in_check() ? generate<MV_EVASION>(pos, mlist)
-                        : generate<MV_NON_EVASION>(pos, mlist);
-
-  // Remove illegal moves from the list
-  while (cur != last)
-      if (!pos.pl_move_is_legal(cur->move, pinned))
-          cur->move = (--last)->move;
-      else
-          cur++;
-
-  return last;
-}
-
-
-namespace {
-
-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
-
-    return Delta == DELTA_N  ? p << 8 : Delta == DELTA_S  ? p >> 8 :
-           Delta == DELTA_NE ? p << 9 : Delta == DELTA_SE ? p >> 7 :
-           Delta == DELTA_NW ? p << 7 : Delta == DELTA_SW ? p >> 9 : p;
-  }
-
-  template<MoveType Type, Square Delta>
-  inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
-    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
-    SERIALIZE_MOVES_D(b, -Delta);
-    return mlist;
-  }
-
-  template<MoveType Type, Square Delta>
-  inline MoveStack* generate_promotions(const Position& pos, MoveStack* mlist, Bitboard pawnsOn7, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Promotions and under-promotions, both captures and non-captures
-    b = move_pawns<Delta>(pawnsOn7) & target;
-
-    if (Delta != DELTA_N && Delta != DELTA_S)
-        b &= ~TFileABB;
-
-    while (b)
-    {
-        to = pop_1st_bit(&b);
-
-        if (Type == MV_CAPTURE || Type == MV_EVASION)
-            (*mlist++).move = make_promotion_move(to - Delta, to, QUEEN);
-
-        if (Type == MV_NON_CAPTURE || Type == MV_EVASION)
-        {
-            (*mlist++).move = make_promotion_move(to - Delta, to, ROOK);
-            (*mlist++).move = make_promotion_move(to - Delta, to, BISHOP);
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        }
-
-        // This is the only possible under promotion that can give a check
-        // not already included in the queen-promotion.
-        if (   Type == MV_CHECK
-            && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(Delta > 0 ? BLACK : WHITE)))
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        else (void)pos; // Silence a warning under MSVC
-    }
-    return mlist;
-  }
-
-  template<Color Us, MoveType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq) {
-
-    // Calculate our parametrized parameters at compile time, named
-    // according to the point of view of white side.
     const Color     Them     = (Us == WHITE ? BLACK      : WHITE);
+    const Bitboard  TRank8BB = (Us == WHITE ? Rank8BB    : Rank1BB);
     const Bitboard  TRank7BB = (Us == WHITE ? Rank7BB    : Rank2BB);
     const Bitboard  TRank3BB = (Us == WHITE ? Rank3BB    : Rank6BB);
-    const Square   UP        = (Us == WHITE ? DELTA_N  : DELTA_S);
+    const Direction Up       = (Us == WHITE ? NORTH      : SOUTH);
-    const Square   RIGHT_UP  = (Us == WHITE ? DELTA_NE : DELTA_SW);
+    const Direction Right    = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
-    const Square   LEFT_UP   = (Us == WHITE ? DELTA_NW : DELTA_SE);
+    const Direction Left     = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
 
-    Square to;
+    Bitboard emptySquares;
-    Bitboard b1, b2, dc1, dc2, pawnPushes, emptySquares;
-    Bitboard pawns = pos.pieces(PAWN, Us);
-    Bitboard pawnsOn7 = pawns & TRank7BB;
-    Bitboard enemyPieces = (Type == MV_CAPTURE ? target : pos.pieces(Them));
 
-    // Pre-calculate pawn pushes before changing emptySquares definition
+    Bitboard pawnsOn7    = pos.pieces(Us, PAWN) &  TRank7BB;
-    if (Type != MV_CAPTURE)
+    Bitboard pawnsNotOn7 = pos.pieces(Us, PAWN) & ~TRank7BB;
+
+    Bitboard enemies = (Type == EVASIONS ? pos.pieces(Them) & target:
+                        Type == CAPTURES ? target : pos.pieces(Them));
+
+    // Single and double pawn pushes, no promotions
+    if (Type != CAPTURES)
     {
-        emptySquares = (Type == MV_NON_CAPTURE ? target : pos.empty_squares());
+        emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces());
-        pawnPushes = move_pawns<UP>(pawns & ~TRank7BB) & emptySquares;
+
+        Bitboard b1 = shift<Up>(pawnsNotOn7)   & emptySquares;
+        Bitboard b2 = shift<Up>(b1 & TRank3BB) & emptySquares;
+
+        if (Type == EVASIONS) // Consider only blocking squares
+        {
+            b1 &= target;
+            b2 &= target;
         }
 
-    if (Type == MV_EVASION)
+        if (Type == QUIET_CHECKS)
         {
-        emptySquares &= target; // Only blocking squares
+            Square ksq = pos.square<KING>(Them);
-        enemyPieces  &= target; // Capture only the checker piece
-    }
 
-    // Promotions and underpromotions
-    if (pawnsOn7)
-    {
-        if (Type == MV_CAPTURE)
-            emptySquares = pos.empty_squares();
-
-        pawns &= ~TRank7BB;
-        mlist = generate_promotions<Type, RIGHT_UP>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Type, LEFT_UP>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Type, UP>(pos, mlist, pawnsOn7, emptySquares);
-    }
-
-    // Standard captures
-    if (Type == MV_CAPTURE || Type == MV_EVASION)
-    {
-        mlist = generate_pawn_captures<Type, RIGHT_UP>(mlist, pawns, enemyPieces);
-        mlist = generate_pawn_captures<Type, LEFT_UP>(mlist, pawns, enemyPieces);
-    }
-
-    // Single and double pawn pushes
-    if (Type != MV_CAPTURE)
-    {
-        b1 = (Type != MV_EVASION ? pawnPushes : pawnPushes & emptySquares);
-        b2 = move_pawns<UP>(pawnPushes & TRank3BB) & emptySquares;
-
-        if (Type == MV_CHECK)
-        {
-            // Consider only pawn moves which give direct checks
             b1 &= pos.attacks_from<PAWN>(ksq, Them);
             b2 &= pos.attacks_from<PAWN>(ksq, Them);
 
-            // Add pawn moves which gives discovered check. This is possible only
+            // Add pawn pushes which give discovered check. This is possible only
             // if the pawn is not on the same file as the enemy king, because we
-            // don't generate captures.
+            // don't generate captures. Note that a possible discovery check
-            if (pawns & target) // For CHECK type target is dc bitboard
+            // promotion has been already generated amongst the captures.
+            Bitboard dcCandidates = pos.discovered_check_candidates();
+            if (pawnsNotOn7 & dcCandidates)
             {
-                dc1 = move_pawns<UP>(pawns & target & ~file_bb(ksq)) & emptySquares;
+                Bitboard dc1 = shift<Up>(pawnsNotOn7 & dcCandidates) & emptySquares & ~file_bb(ksq);
-                dc2 = move_pawns<UP>(dc1 & TRank3BB) & emptySquares;
+                Bitboard dc2 = shift<Up>(dc1 & TRank3BB) & emptySquares;
 
                 b1 |= dc1;
                 b2 |= dc2;
             }
         }
-        SERIALIZE_MOVES_D(b1, -UP);
+
-        SERIALIZE_MOVES_D(b2, -UP -UP);
+        while (b1)
+        {
+            Square to = pop_lsb(&b1);
+            *moveList++ = make_move(to - Up, to);
         }
 
-    // En passant captures
+        while (b2)
-    if ((Type == MV_CAPTURE || Type == MV_EVASION) && pos.ep_square() != SQ_NONE)
         {
-        assert(Us != WHITE || rank_of(pos.ep_square()) == RANK_6);
+            Square to = pop_lsb(&b2);
-        assert(Us != BLACK || rank_of(pos.ep_square()) == RANK_3);
+            *moveList++ = make_move(to - Up - Up, to);
+        }
+    }
+
+    // Promotions and underpromotions
+    if (pawnsOn7 && (Type != EVASIONS || (target & TRank8BB)))
+    {
+        if (Type == CAPTURES)
+            emptySquares = ~pos.pieces();
+
+        if (Type == EVASIONS)
+            emptySquares &= target;
+
+        Bitboard b1 = shift<Right>(pawnsOn7) & enemies;
+        Bitboard b2 = shift<Left >(pawnsOn7) & enemies;
+        Bitboard b3 = shift<Up   >(pawnsOn7) & emptySquares;
+
+        Square ksq = pos.square<KING>(Them);
+
+        while (b1)
+            moveList = make_promotions<Type, Right>(moveList, pop_lsb(&b1), ksq);
+
+        while (b2)
+            moveList = make_promotions<Type, Left >(moveList, pop_lsb(&b2), ksq);
+
+        while (b3)
+            moveList = make_promotions<Type, Up   >(moveList, pop_lsb(&b3), ksq);
+    }
+
+    // Standard and en-passant captures
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+    {
+        Bitboard b1 = shift<Right>(pawnsNotOn7) & enemies;
+        Bitboard b2 = shift<Left >(pawnsNotOn7) & enemies;
+
+        while (b1)
+        {
+            Square to = pop_lsb(&b1);
+            *moveList++ = make_move(to - Right, to);
+        }
+
+        while (b2)
+        {
+            Square to = pop_lsb(&b2);
+            *moveList++ = make_move(to - Left, to);
+        }
+
+        if (pos.ep_square() != SQ_NONE)
+        {
+            assert(rank_of(pos.ep_square()) == relative_rank(Us, RANK_6));
 
             // An en passant capture can be an evasion only if the checking piece
             // is the double pushed pawn and so is in the target. Otherwise this
             // is a discovery check and we are forced to do otherwise.
-        if (Type == MV_EVASION && !bit_is_set(target, pos.ep_square() - UP))
+            if (Type == EVASIONS && !(target & (pos.ep_square() - Up)))
-            return mlist;
+                return moveList;
 
-        b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+            b1 = pawnsNotOn7 & pos.attacks_from<PAWN>(pos.ep_square(), Them);
 
             assert(b1);
 
             while (b1)
+                *moveList++ = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
+        }
+    }
+
+    return moveList;
+  }
+
+
+  template<PieceType Pt, bool Checks>
+  ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Color us,
+                          Bitboard target) {
+
+    assert(Pt != KING && Pt != PAWN);
+
+    const Square* pl = pos.squares<Pt>(us);
+
+    for (Square from = *pl; from != SQ_NONE; from = *++pl)
     {
-            to = pop_1st_bit(&b1);
+        if (Checks)
-            (*mlist++).move = make_enpassant_move(to, pos.ep_square());
+        {
-        }
+            if (    (Pt == BISHOP || Pt == ROOK || Pt == QUEEN)
-    }
+                && !(PseudoAttacks[Pt][from] & target & pos.check_squares(Pt)))
-    return mlist;
+                continue;
+
+            if (pos.discovered_check_candidates() & from)
+                continue;
         }
 
-  template<CastlingSide Side>
+        Bitboard b = pos.attacks_from<Pt>(from) & target;
-  MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
 
-    CastleRight f = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
+        if (Checks)
-    Color them = flip(us);
+            b &= pos.check_squares(Pt);
 
-    // After castling, the rook and king's final positions are exactly the same
+        while (b)
-    // in Chess960 as they would be in standard chess.
+            *moveList++ = make_move(from, pop_lsb(&b));
-    Square kfrom = pos.king_square(us);
+    }
-    Square rfrom = pos.castle_rook_square(f);
-    Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-    Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
 
-    assert(!pos.in_check());
+    return moveList;
-    assert(pos.piece_on(kfrom) == make_piece(us, KING));
+  }
-    assert(pos.piece_on(rfrom) == make_piece(us, ROOK));
 
-    // Unimpeded rule: All the squares between the king's initial and final squares
-    // (including the final square), and all the squares between the rook's initial
-    // and final squares (including the final square), must be vacant except for
-    // the king and castling rook.
-    for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
-        if (  (s != kfrom && s != rfrom && !pos.square_is_empty(s))
-            ||(pos.attackers_to(s) & pos.pieces(them)))
-            return mlist;
 
-    for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
+  template<Color Us, GenType Type>
-        if (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+  ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) {
-            return mlist;
 
-    // Because we generate only legal castling moves we need to verify that
+    const bool Checks = Type == QUIET_CHECKS;
-    // when moving the castling rook we do not discover some hidden checker.
+
-    // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
+    moveList = generate_pawn_moves<Us, Type>(pos, moveList, target);
+    moveList = generate_moves<KNIGHT, Checks>(pos, moveList, Us, target);
+    moveList = generate_moves<BISHOP, Checks>(pos, moveList, Us, target);
+    moveList = generate_moves<  ROOK, Checks>(pos, moveList, Us, target);
+    moveList = generate_moves< QUEEN, Checks>(pos, moveList, Us, target);
+
+    if (Type != QUIET_CHECKS && Type != EVASIONS)
+    {
+        Square ksq = pos.square<KING>(Us);
+        Bitboard b = pos.attacks_from<KING>(ksq) & target;
+        while (b)
+            *moveList++ = make_move(ksq, pop_lsb(&b));
+    }
+
+    if (Type != CAPTURES && Type != EVASIONS && pos.can_castle(Us))
+    {
         if (pos.is_chess960())
         {
-        Bitboard occ = pos.occupied_squares();
+            moveList = generate_castling<MakeCastling<Us,  KING_SIDE>::right, Checks, true>(pos, moveList, Us);
-        clear_bit(&occ, rfrom);
+            moveList = generate_castling<MakeCastling<Us, QUEEN_SIDE>::right, Checks, true>(pos, moveList, Us);
-        if (pos.attackers_to(kto, occ) & pos.pieces(them))
+        }
-            return mlist;
+        else
+        {
+            moveList = generate_castling<MakeCastling<Us,  KING_SIDE>::right, Checks, false>(pos, moveList, Us);
+            moveList = generate_castling<MakeCastling<Us, QUEEN_SIDE>::right, Checks, false>(pos, moveList, Us);
+        }
     }
 
-    (*mlist++).move = make_castle_move(kfrom, rfrom);
+    return moveList;
-
-    return mlist;
   }
 
 } // namespace
+
+
+/// generate<CAPTURES> generates all pseudo-legal captures and queen
+/// promotions. Returns a pointer to the end of the move list.
+///
+/// generate<QUIETS> generates all pseudo-legal non-captures and
+/// underpromotions. Returns a pointer to the end of the move list.
+///
+/// generate<NON_EVASIONS> generates all pseudo-legal captures and
+/// non-captures. Returns a pointer to the end of the move list.
+
+template<GenType Type>
+ExtMove* generate(const Position& pos, ExtMove* moveList) {
+
+  assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
+  assert(!pos.checkers());
+
+  Color us = pos.side_to_move();
+
+  Bitboard target =  Type == CAPTURES     ?  pos.pieces(~us)
+                   : Type == QUIETS       ? ~pos.pieces()
+                   : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;
+
+  return us == WHITE ? generate_all<WHITE, Type>(pos, moveList, target)
+                     : generate_all<BLACK, Type>(pos, moveList, target);
+}
+
+// Explicit template instantiations
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
+
+
+/// generate<QUIET_CHECKS> generates all pseudo-legal non-captures and knight
+/// underpromotions that give check. Returns a pointer to the end of the move list.
+template<>
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* moveList) {
+
+  assert(!pos.checkers());
+
+  Color us = pos.side_to_move();
+  Bitboard dc = pos.discovered_check_candidates();
+
+  while (dc)
+  {
+     Square from = pop_lsb(&dc);
+     PieceType pt = type_of(pos.piece_on(from));
+
+     if (pt == PAWN)
+         continue; // Will be generated together with direct checks
+
+     Bitboard b = pos.attacks_from(pt, from) & ~pos.pieces();
+
+     if (pt == KING)
+         b &= ~PseudoAttacks[QUEEN][pos.square<KING>(~us)];
+
+     while (b)
+         *moveList++ = make_move(from, pop_lsb(&b));
+  }
+
+  return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, moveList, ~pos.pieces())
+                     : generate_all<BLACK, QUIET_CHECKS>(pos, moveList, ~pos.pieces());
+}
+
+
+/// generate<EVASIONS> generates all pseudo-legal check evasions when the side
+/// to move is in check. Returns a pointer to the end of the move list.
+template<>
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* moveList) {
+
+  assert(pos.checkers());
+
+  Color us = pos.side_to_move();
+  Square ksq = pos.square<KING>(us);
+  Bitboard sliderAttacks = 0;
+  Bitboard sliders = pos.checkers() & ~pos.pieces(KNIGHT, PAWN);
+
+  // Find all the squares attacked by slider checkers. We will remove them from
+  // the king evasions in order to skip known illegal moves, which avoids any
+  // useless legality checks later on.
+  while (sliders)
+  {
+      Square checksq = pop_lsb(&sliders);
+      sliderAttacks |= LineBB[checksq][ksq] ^ checksq;
+  }
+
+  // Generate evasions for king, capture and non capture moves
+  Bitboard b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
+  while (b)
+      *moveList++ = make_move(ksq, pop_lsb(&b));
+
+  if (more_than_one(pos.checkers()))
+      return moveList; // Double check, only a king move can save the day
+
+  // Generate blocking evasions or captures of the checking piece
+  Square checksq = lsb(pos.checkers());
+  Bitboard target = between_bb(checksq, ksq) | checksq;
+
+  return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, moveList, target)
+                     : generate_all<BLACK, EVASIONS>(pos, moveList, target);
+}
+
+
+/// generate<LEGAL> generates all the legal moves in the given position
+
+template<>
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) {
+
+  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+  Square ksq = pos.square<KING>(pos.side_to_move());
+  ExtMove* cur = moveList;
+
+  moveList = pos.checkers() ? generate<EVASIONS    >(pos, moveList)
+                            : generate<NON_EVASIONS>(pos, moveList);
+  while (cur != moveList)
+      if (   (pinned || from_sq(*cur) == ksq || type_of(*cur) == ENPASSANT)
+          && !pos.legal(*cur))
+          *cur = (--moveList)->move;
+      else
+          ++cur;
+
+  return moveList;
+}

src/movegen.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,40 +18,58 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(MOVEGEN_H_INCLUDED)
+#ifndef MOVEGEN_H_INCLUDED
 #define MOVEGEN_H_INCLUDED
 
+#include <algorithm>
+
 #include "types.h"
 
-enum MoveType {
-  MV_CAPTURE,
-  MV_NON_CAPTURE,
-  MV_CHECK,
-  MV_NON_CAPTURE_CHECK,
-  MV_EVASION,
-  MV_NON_EVASION,
-  MV_LEGAL
-};
-
 class Position;
 
-template<MoveType>
+enum GenType {
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+  CAPTURES,
-
+  QUIETS,
-/// The MoveList struct is a simple wrapper around generate(), sometimes comes
+  QUIET_CHECKS,
-/// handy to use this class instead of the low level generate() function.
+  EVASIONS,
-template<MoveType T>
+  NON_EVASIONS,
-struct MoveList {
+  LEGAL
-
-  explicit MoveList(const Position& pos) : cur(mlist), last(generate<T>(pos, mlist)) {}
-  void operator++() { cur++; }
-  bool end() const { return cur == last; }
-  Move move() const { return cur->move; }
-  int size() const { return int(last - mlist); }
-
-private:
-  MoveStack mlist[MAX_MOVES];
-  MoveStack *cur, *last;
 };
 
-#endif // !defined(MOVEGEN_H_INCLUDED)
+struct ExtMove {
+  Move move;
+  int value;
+
+  operator Move() const { return move; }
+  void operator=(Move m) { move = m; }
+
+  // Inhibit unwanted implicit conversions to Move
+  // with an ambiguity that yields to a compile error.
+  operator float() const = delete;
+};
+
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
+  return f.value < s.value;
+}
+
+template<GenType>
+ExtMove* generate(const Position& pos, ExtMove* moveList);
+
+/// The MoveList struct is a simple wrapper around generate(). It sometimes comes
+/// in handy to use this class instead of the low level generate() function.
+template<GenType T>
+struct MoveList {
+
+  explicit MoveList(const Position& pos) : last(generate<T>(pos, moveList)) {}
+  const ExtMove* begin() const { return moveList; }
+  const ExtMove* end() const { return last; }
+  size_t size() const { return last - moveList; }
+  bool contains(Move move) const {
+    return std::find(begin(), end(), move) != end();
+  }
+
+private:
+  ExtMove moveList[MAX_MOVES], *last;
+};
+
+#endif // #ifndef MOVEGEN_H_INCLUDED

src/movepick.cpp

@@ -1,14 +1,14 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-
   Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
@@ -18,382 +18,317 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <algorithm>
 #include <cassert>
 
-#include "movegen.h"
 #include "movepick.h"
-#include "search.h"
-#include "types.h"
 
 namespace {
 
-  enum MovegenPhase {
+  enum Stages {
-    PH_TT_MOVE,       // Transposition table move
+    MAIN_SEARCH, CAPTURES_INIT, GOOD_CAPTURES, KILLERS, COUNTERMOVE, QUIET_INIT, QUIET, BAD_CAPTURES,
-    PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= captureThreshold (captureThreshold <= 0)
+    EVASION, EVASIONS_INIT, ALL_EVASIONS,
-    PH_GOOD_PROBCUT,  // Queen promotions and captures with SEE values > captureThreshold (captureThreshold >= 0)
+    PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES,
-    PH_KILLERS,       // Killer moves from the current ply
+    QSEARCH_WITH_CHECKS, QCAPTURES_1_INIT, QCAPTURES_1, QCHECKS,
-    PH_NONCAPTURES_1, // Non-captures and underpromotions with positive score
+    QSEARCH_NO_CHECKS, QCAPTURES_2_INIT, QCAPTURES_2,
-    PH_NONCAPTURES_2, // Non-captures and underpromotions with non-positive score
+    QSEARCH_RECAPTURES, QRECAPTURES
-    PH_BAD_CAPTURES,  // Queen promotions and captures with SEE values < captureThreshold (captureThreshold <= 0)
-    PH_EVASIONS,      // Check evasions
-    PH_QCAPTURES,     // Captures in quiescence search
-    PH_QRECAPTURES,   // Recaptures in quiescence search
-    PH_QCHECKS,       // Non-capture checks in quiescence search
-    PH_STOP
   };
 
-  CACHE_LINE_ALIGNMENT
+  // partial_insertion_sort() sorts moves in descending order up to and including
-  const uint8_t MainSearchTable[] = { PH_TT_MOVE, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES_1, PH_NONCAPTURES_2, PH_BAD_CAPTURES, PH_STOP };
+  // a given limit. The order of moves smaller than the limit is left unspecified.
-  const uint8_t EvasionTable[] = { PH_TT_MOVE, PH_EVASIONS, PH_STOP };
+  void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) {
-  const uint8_t QsearchWithChecksTable[] = { PH_TT_MOVE, PH_QCAPTURES, PH_QCHECKS, PH_STOP };
-  const uint8_t QsearchWithoutChecksTable[] = { PH_TT_MOVE, PH_QCAPTURES, PH_STOP };
-  const uint8_t QsearchRecapturesTable[] = { PH_TT_MOVE, PH_QRECAPTURES, PH_STOP };
-  const uint8_t ProbCutTable[] = { PH_TT_MOVE, PH_GOOD_PROBCUT, PH_STOP };
 
-  // Unary predicate used by std::partition to split positive scores from remaining
+    for (ExtMove *sortedEnd = begin, *p = begin + 1; p < end; ++p)
-  // ones so to sort separately the two sets, and with the second sort delayed.
+        if (p->value >= limit)
-  inline bool has_positive_score(const MoveStack& move) { return move.score > 0; }
-
-  // Picks and pushes to the front the best move in range [firstMove, lastMove),
-  // it is faster than sorting all the moves in advance when moves are few, as
-  // normally are the possible captures.
-  inline MoveStack* pick_best(MoveStack* firstMove, MoveStack* lastMove)
         {
-      std::swap(*firstMove, *std::max_element(firstMove, lastMove));
+            ExtMove tmp = *p, *q;
-      return firstMove;
+            *p = *++sortedEnd;
+            for (q = sortedEnd; q != begin && *(q - 1) < tmp; --q)
+                *q = *(q - 1);
+            *q = tmp;
         }
   }
 
-/// Constructors for the MovePicker class. As arguments we pass information
+  // pick_best() finds the best move in the range (begin, end) and moves it to
-/// to help it to return the presumably good moves first, to decide which
+  // the front. It's faster than sorting all the moves in advance when there
+  // are few moves, e.g., the possible captures.
+  Move pick_best(ExtMove* begin, ExtMove* end) {
+
+    std::swap(*begin, *std::max_element(begin, end));
+    return *begin;
+  }
+
+} // namespace
+
+
+/// Constructors of the MovePicker class. As arguments we pass information
+/// to help it to return the (presumably) good moves first, to decide which
 /// moves to return (in the quiescence search, for instance, we only want to
-/// search captures, promotions and some checks) and about how important good
+/// search captures, promotions, and some checks) and how important good move
-/// move ordering is at the current node.
+/// ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
+/// MovePicker constructor for the main search
-                       Search::Stack* ss, Value beta) : pos(p), H(h), depth(d) {
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,
-  captureThreshold = 0;
+                       const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers_p)
-  badCaptures = moves + MAX_MOVES;
+           : pos(p), mainHistory(mh), captureHistory(cph), contHistory(ch), countermove(cm),
+             killers{killers_p[0], killers_p[1]}, depth(d){
 
   assert(d > DEPTH_ZERO);
 
-  if (p.in_check())
+  stage = pos.checkers() ? EVASION : MAIN_SEARCH;
-  {
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
-      killers[0].move = killers[1].move = MOVE_NONE;
+  stage += (ttMove == MOVE_NONE);
-      phasePtr = EvasionTable;
-  }
-  else
-  {
-      killers[0].move = ss->killers[0];
-      killers[1].move = ss->killers[1];
-
-      // Consider sligtly negative captures as good if at low depth and far from beta
-      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
-          captureThreshold = -PawnValueMidgame;
-
-      // Consider negative captures as good if still enough to reach beta
-      else if (ss && ss->eval > beta)
-          captureThreshold = beta - ss->eval;
-
-      phasePtr = MainSearchTable;
 }
 
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
+/// MovePicker constructor for quiescence search
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,  const CapturePieceToHistory* cph, Square s)
-  go_next_phase();
+           : pos(p), mainHistory(mh), captureHistory(cph) {
-}
-
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h, Square recaptureSq)
-                      : pos(p), H(h) {
 
   assert(d <= DEPTH_ZERO);
 
-  if (p.in_check())
+  if (pos.checkers())
-      phasePtr = EvasionTable;
+      stage = EVASION;
-  else if (d >= DEPTH_QS_CHECKS)
+
-      phasePtr = QsearchWithChecksTable;
+  else if (d > DEPTH_QS_NO_CHECKS)
-  else if (d >= DEPTH_QS_RECAPTURES)
+      stage = QSEARCH_WITH_CHECKS;
-  {
+
-      phasePtr = QsearchWithoutChecksTable;
+  else if (d > DEPTH_QS_RECAPTURES)
+      stage = QSEARCH_NO_CHECKS;
 
-      // Skip TT move if is not a capture or a promotion, this avoids
-      // qsearch tree explosion due to a possible perpetual check or
-      // similar rare cases when TT table is full.
-      if (ttm != MOVE_NONE && !pos.is_capture_or_promotion(ttm))
-          ttm = MOVE_NONE;
-  }
   else
   {
-      phasePtr = QsearchRecapturesTable;
+      stage = QSEARCH_RECAPTURES;
-      recaptureSquare = recaptureSq;
+      recaptureSquare = s;
-      ttm = MOVE_NONE;
-  }
-
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
-  go_next_phase();
-}
-
-MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType parentCapture)
-                       : pos(p), H(h) {
-
-  assert (!pos.in_check());
-
-  // In ProbCut we consider only captures better than parent's move
-  captureThreshold = PieceValueMidgame[Piece(parentCapture)];
-  phasePtr = ProbCutTable;
-
-  if (   ttm != MOVE_NONE
-      && (!pos.is_capture(ttm) ||  pos.see(ttm) <= captureThreshold))
-      ttm = MOVE_NONE;
-
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
-  go_next_phase();
-}
-
-
-/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
-/// of moves when there are no more moves to try for the current phase.
-
-void MovePicker::go_next_phase() {
-
-  curMove = moves;
-  phase = *(++phasePtr);
-  switch (phase) {
-
-  case PH_TT_MOVE:
-      lastMove = curMove + 1;
-      return;
-
-  case PH_GOOD_CAPTURES:
-  case PH_GOOD_PROBCUT:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_KILLERS:
-      curMove = killers;
-      lastMove = curMove + 2;
-      return;
-
-  case PH_NONCAPTURES_1:
-      lastNonCapture = lastMove = generate<MV_NON_CAPTURE>(pos, moves);
-      score_noncaptures();
-      lastMove = std::partition(curMove, lastMove, has_positive_score);
-      sort<MoveStack>(curMove, lastMove);
-      return;
-
-  case PH_NONCAPTURES_2:
-      curMove = lastMove;
-      lastMove = lastNonCapture;
-      if (depth >= 3 * ONE_PLY)
-          sort<MoveStack>(curMove, lastMove);
-      return;
-
-  case PH_BAD_CAPTURES:
-      // Bad captures SEE value is already calculated so just pick
-      // them in order to get SEE move ordering.
-      curMove = badCaptures;
-      lastMove = moves + MAX_MOVES;
-      return;
-
-  case PH_EVASIONS:
-      assert(pos.in_check());
-      lastMove = generate<MV_EVASION>(pos, moves);
-      score_evasions();
-      return;
-
-  case PH_QCAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_QRECAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      return;
-
-  case PH_QCHECKS:
-      lastMove = generate<MV_NON_CAPTURE_CHECK>(pos, moves);
-      return;
-
-  case PH_STOP:
-      lastMove = curMove + 1; // Avoid another go_next_phase() call
-      return;
-
-  default:
-      assert(false);
       return;
   }
+
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
+  stage += (ttMove == MOVE_NONE);
 }
 
+/// MovePicker constructor for ProbCut: we generate captures with SEE higher
+/// than or equal to the given threshold.
+MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph)
+           : pos(p), captureHistory(cph), threshold(th) {
 
-/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
+  assert(!pos.checkers());
-/// MovePicker::score_evasions() assign a numerical move ordering score
-/// to each move in a move list.  The moves with highest scores will be
-/// picked first by next_move().
 
-void MovePicker::score_captures() {
+  stage = PROBCUT;
-  // Winning and equal captures in the main search are ordered by MVV/LVA.
+  ttMove =   ttm
-  // Suprisingly, this appears to perform slightly better than SEE based
+          && pos.pseudo_legal(ttm)
-  // move ordering. The reason is probably that in a position with a winning
+          && pos.capture(ttm)
-  // capture, capturing a more valuable (but sufficiently defended) piece
+          && pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE;
-  // first usually doesn't hurt. The opponent will have to recapture, and
-  // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece). Exchanging
-  // big pieces before capturing a hanging piece probably helps to reduce
-  // the subtree size.
-  // In main search we want to push captures with negative SEE values to
-  // badCaptures[] array, but instead of doing it now we delay till when
-  // the move has been picked up in pick_move_from_list(), this way we save
-  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
-  Move m;
 
-  // Use MVV/LVA ordering
+  stage += (ttMove == MOVE_NONE);
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
+}
+
+/// score() assigns a numerical value to each move in a list, used for sorting.
+/// Captures are ordered by Most Valuable Victim (MVV), preferring captures
+/// with a good history. Quiets are ordered using the histories.
+template<GenType Type>
+void MovePicker::score() {
+
+  static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
+
+  for (auto& m : *this)
+      if (Type == CAPTURES)
+          m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                   + Value((*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))]);
+
+      else if (Type == QUIETS)
+          m.value =  (*mainHistory)[pos.side_to_move()][from_to(m)]
+                   + (*contHistory[0])[pos.moved_piece(m)][to_sq(m)]
+                   + (*contHistory[1])[pos.moved_piece(m)][to_sq(m)]
+                   + (*contHistory[3])[pos.moved_piece(m)][to_sq(m)];
+
+      else // Type == EVASIONS
       {
-      m = cur->move;
+          if (pos.capture(m))
-      cur->score =  PieceValueMidgame[pos.piece_on(move_to(m))]
+              m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                  - type_of(pos.piece_on(move_from(m)));
+                       - Value(type_of(pos.moved_piece(m)));
-
-      if (is_promotion(m))
-          cur->score += PieceValueMidgame[Piece(promotion_piece_type(m))];
-  }
-}
-
-void MovePicker::score_noncaptures() {
-
-  Move m;
-  Square from;
-
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
-  {
-      m = cur->move;
-      from = move_from(m);
-      cur->score = H.value(pos.piece_on(from), move_to(m));
-  }
-}
-
-void MovePicker::score_evasions() {
-  // Try good captures ordered by MVV/LVA, then non-captures if
-  // destination square is not under attack, ordered by history
-  // value, and at the end bad-captures and non-captures with a
-  // negative SEE. This last group is ordered by the SEE score.
-  Move m;
-  int seeScore;
-
-  // Skip if we don't have at least two moves to order
-  if (lastMove < moves + 2)
-      return;
-
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
-  {
-      m = cur->move;
-      if ((seeScore = pos.see_sign(m)) < 0)
-          cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
-      else if (pos.is_capture(m))
-          cur->score =  PieceValueMidgame[pos.piece_on(move_to(m))]
-                      - type_of(pos.piece_on(move_from(m))) + History::MaxValue;
           else
-          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
+              m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] - (1 << 28);
       }
 }
 
-/// MovePicker::next_move() is the most important method of the MovePicker class.
+/// next_move() is the most important method of the MovePicker class. It returns
-/// It returns a new pseudo legal move every time it is called, until there
+/// a new pseudo legal move every time it is called, until there are no more moves
-/// are no more moves left. It picks the move with the biggest score from a list
+/// left. It picks the move with the biggest value from a list of generated moves
-/// of generated moves taking care not to return the tt move if has already been
+/// taking care not to return the ttMove if it has already been searched.
-/// searched previously. Note that this function is not thread safe so should be
-/// lock protected by caller when accessed through a shared MovePicker object.
 
-Move MovePicker::next_move() {
+Move MovePicker::next_move(bool skipQuiets) {
 
   Move move;
 
-  while (true)
+  switch (stage) {
-  {
-      while (curMove == lastMove)
-          go_next_phase();
 
-      switch (phase) {
+  case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS:
-
+  case QSEARCH_NO_CHECKS: case PROBCUT:
-      case PH_TT_MOVE:
+      ++stage;
-          curMove++;
       return ttMove;
-          break;
 
-      case PH_GOOD_CAPTURES:
+  case CAPTURES_INIT:
-          move = pick_best(curMove++, lastMove)->move;
+      endBadCaptures = cur = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
+      score<CAPTURES>();
+      ++stage;
+      /* fallthrough */
+
+  case GOOD_CAPTURES:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
           if (move != ttMove)
           {
-              assert(captureThreshold <= 0); // Otherwise we must use see instead of see_sign
+              if (pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)))
-
-              // Check for a non negative SEE now
-              int seeValue = pos.see_sign(move);
-              if (seeValue >= captureThreshold)
                   return move;
 
-              // Losing capture, move it to the tail of the array
+              // Losing capture, move it to the beginning of the array
-              (--badCaptures)->move = move;
+              *endBadCaptures++ = move;
-              badCaptures->score = seeValue;
+          }
+      }
+
+      ++stage;
+      move = killers[0];  // First killer move
+      if (    move != MOVE_NONE
+          &&  move != ttMove
+          &&  pos.pseudo_legal(move)
+          && !pos.capture(move))
+          return move;
+      /* fallthrough */
+
+  case KILLERS:
+      ++stage;
+      move = killers[1]; // Second killer move
+      if (    move != MOVE_NONE
+          &&  move != ttMove
+          &&  pos.pseudo_legal(move)
+          && !pos.capture(move))
+          return move;
+      /* fallthrough */
+
+  case COUNTERMOVE:
+      ++stage;
+      move = countermove;
+      if (    move != MOVE_NONE
+          &&  move != ttMove
+          &&  move != killers[0]
+          &&  move != killers[1]
+          &&  pos.pseudo_legal(move)
+          && !pos.capture(move))
+          return move;
+      /* fallthrough */
+
+  case QUIET_INIT:
+      cur = endBadCaptures;
+      endMoves = generate<QUIETS>(pos, cur);
+      score<QUIETS>();
+      partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY);
+      ++stage;
+      /* fallthrough */
+
+  case QUIET:
+      while (    cur < endMoves
+             && (!skipQuiets || cur->value >= VALUE_ZERO))
+      {
+          move = *cur++;
+
+          if (   move != ttMove
+              && move != killers[0]
+              && move != killers[1]
+              && move != countermove)
+              return move;
+      }
+      ++stage;
+      cur = moves; // Point to beginning of bad captures
+      /* fallthrough */
+
+  case BAD_CAPTURES:
+      if (cur < endBadCaptures)
+          return *cur++;
+      break;
+
+  case EVASIONS_INIT:
+      cur = moves;
+      endMoves = generate<EVASIONS>(pos, cur);
+      score<EVASIONS>();
+      ++stage;
+      /* fallthrough */
+
+  case ALL_EVASIONS:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
+          if (move != ttMove)
+              return move;
       }
       break;
 
-     case PH_GOOD_PROBCUT:
+  case PROBCUT_INIT:
-          move = pick_best(curMove++, lastMove)->move;
+      cur = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
+      score<CAPTURES>();
+      ++stage;
+      /* fallthrough */
+
+  case PROBCUT_CAPTURES:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
           if (   move != ttMove
-              && pos.see(move) > captureThreshold)
+              && pos.see_ge(move, threshold))
               return move;
+      }
       break;
 
-      case PH_KILLERS:
+  case QCAPTURES_1_INIT: case QCAPTURES_2_INIT:
-          move = (curMove++)->move;
+      cur = moves;
-          if (   move != MOVE_NONE
+      endMoves = generate<CAPTURES>(pos, cur);
-              && pos.is_pseudo_legal(move)
+      score<CAPTURES>();
-              && move != ttMove
+      ++stage;
-              && !pos.is_capture(move))
+      /* fallthrough */
-              return move;
-          break;
 
-      case PH_NONCAPTURES_1:
+  case QCAPTURES_1: case QCAPTURES_2:
-      case PH_NONCAPTURES_2:
+      while (cur < endMoves)
-          move = (curMove++)->move;
+      {
-          if (   move != ttMove
+          move = pick_best(cur++, endMoves);
-              && move != killers[0].move
-              && move != killers[1].move)
-              return move;
-          break;
-
-      case PH_BAD_CAPTURES:
-          move = pick_best(curMove++, lastMove)->move;
-          return move;
-
-      case PH_EVASIONS:
-      case PH_QCAPTURES:
-          move = pick_best(curMove++, lastMove)->move;
           if (move != ttMove)
               return move;
+      }
+      if (stage == QCAPTURES_2)
           break;
+      cur = moves;
+      endMoves = generate<QUIET_CHECKS>(pos, cur);
+      ++stage;
+      /* fallthrough */
 
-      case PH_QRECAPTURES:
+  case QCHECKS:
-          move = (curMove++)->move;
+      while (cur < endMoves)
-          if (move_to(move) == recaptureSquare)
+      {
-              return move;
+          move = cur++->move;
-          break;
-
-      case PH_QCHECKS:
-          move = (curMove++)->move;
           if (move != ttMove)
               return move;
+      }
       break;
 
-      case PH_STOP:
+  case QSEARCH_RECAPTURES:
-          return MOVE_NONE;
+      cur = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
+      score<CAPTURES>();
+      ++stage;
+      /* fallthrough */
+
+  case QRECAPTURES:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
+          if (to_sq(move) == recaptureSquare)
+              return move;
+      }
+      break;
 
   default:
       assert(false);
-          break;
-      }
   }
+
+  return MOVE_NONE;
 }

src/movepick.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,48 +18,134 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined MOVEPICK_H_INCLUDED
+#ifndef MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED
 
-#include "history.h"
+#include <array>
+#include <limits>
+
+#include "movegen.h"
 #include "position.h"
-#include "search.h"
 #include "types.h"
 
-/// MovePicker is a class which is used to pick one pseudo legal move at a time
+/// StatBoards is a generic 2-dimensional array used to store various statistics
-/// from the current position. It is initialized with a Position object and a few
+template<int Size1, int Size2, typename T = int16_t>
-/// moves we have reason to believe are good. The most important method is
+struct StatBoards : public std::array<std::array<T, Size2>, Size1> {
-/// MovePicker::next_move(), which returns a new pseudo legal move each time
-/// it is called, until there are no moves left, when MOVE_NONE is returned.
-/// In order to improve the efficiency of the alpha beta algorithm, MovePicker
-/// attempts to return the moves which are most likely to get a cut-off first.
 
-class MovePicker {
+  void fill(const T& v) {
+    T* p = &(*this)[0][0];
+    std::fill(p, p + sizeof(*this) / sizeof(*p), v);
+  }
 
-  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
+  void update(T& entry, int bonus, const int D) {
 
-public:
+    assert(abs(bonus) <= D); // Ensure range is [-32 * D, 32 * D]
-  MovePicker(const Position&, Move, Depth, const History&, Search::Stack*, Value);
+    assert(abs(32 * D) < (std::numeric_limits<T>::max)()); // Ensure we don't overflow
-  MovePicker(const Position&, Move, Depth, const History&, Square recaptureSq);
-  MovePicker(const Position&, Move, const History&, PieceType parentCapture);
-  Move next_move();
 
-private:
+    entry += bonus * 32 - entry * abs(bonus) / D;
-  void score_captures();
-  void score_noncaptures();
-  void score_evasions();
-  void go_next_phase();
 
-  const Position& pos;
+    assert(abs(entry) <= 32 * D);
-  const History& H;
+  }
-  Depth depth;
-  Move ttMove;
-  MoveStack killers[2];
-  Square recaptureSquare;
-  int captureThreshold, phase;
-  const uint8_t* phasePtr;
-  MoveStack *curMove, *lastMove, *lastNonCapture, *badCaptures;
-  MoveStack moves[MAX_MOVES];
 };
 
-#endif // !defined(MOVEPICK_H_INCLUDED)
+/// StatCubes is a generic 3-dimensional array used to store various statistics
+template<int Size1, int Size2, int Size3, typename T = int16_t>
+struct StatCubes : public std::array<std::array<std::array<T, Size3>, Size2>, Size1> {
+
+  void fill(const T& v) {
+    T* p = &(*this)[0][0][0];
+    std::fill(p, p + sizeof(*this) / sizeof(*p), v);
+  }
+
+  void update(T& entry, int bonus, const int D, const int W) {
+
+    assert(abs(bonus) <= D); // Ensure range is [-W * D, W * D]
+    assert(abs(W * D) < (std::numeric_limits<T>::max)()); // Ensure we don't overflow
+
+    entry += bonus * W - entry * abs(bonus) / D;
+
+    assert(abs(entry) <= W * D);
+  }
+};
+
+/// ButterflyBoards are 2 tables (one for each color) indexed by the move's from
+/// and to squares, see chessprogramming.wikispaces.com/Butterfly+Boards
+typedef StatBoards<COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)> ButterflyBoards;
+
+/// PieceToBoards are addressed by a move's [piece][to] information
+typedef StatBoards<PIECE_NB, SQUARE_NB> PieceToBoards;
+
+/// CapturePieceToBoards are addressed by a move's [piece][to][captured piece type] information
+typedef StatCubes<PIECE_NB, SQUARE_NB, PIECE_TYPE_NB> CapturePieceToBoards;
+
+/// ButterflyHistory records how often quiet moves have been successful or
+/// unsuccessful during the current search, and is used for reduction and move
+/// ordering decisions. It uses ButterflyBoards as backing store.
+struct ButterflyHistory : public ButterflyBoards {
+
+  void update(Color c, Move m, int bonus) {
+    StatBoards::update((*this)[c][from_to(m)], bonus, 324);
+  }
+};
+
+/// PieceToHistory is like ButterflyHistory, but is based on PieceToBoards
+struct PieceToHistory : public PieceToBoards {
+
+  void update(Piece pc, Square to, int bonus) {
+    StatBoards::update((*this)[pc][to], bonus, 936);
+  }
+};
+
+/// CapturePieceToHistory is like PieceToHistory, but is based on CapturePieceToBoards
+struct CapturePieceToHistory : public CapturePieceToBoards {
+
+  void update(Piece pc, Square to, PieceType captured, int bonus) {
+    StatCubes::update((*this)[pc][to][captured], bonus, 324, 2);
+  }
+};
+
+/// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous
+/// move, see chessprogramming.wikispaces.com/Countermove+Heuristic
+typedef StatBoards<PIECE_NB, SQUARE_NB, Move> CounterMoveHistory;
+
+/// ContinuationHistory is the history of a given pair of moves, usually the
+/// current one given a previous one. History table is based on PieceToBoards
+/// instead of ButterflyBoards.
+typedef StatBoards<PIECE_NB, SQUARE_NB, PieceToHistory> ContinuationHistory;
+
+
+/// MovePicker class is used to pick one pseudo legal move at a time from the
+/// current position. The most important method is next_move(), which returns a
+/// new pseudo legal move each time it is called, until there are no moves left,
+/// when MOVE_NONE is returned. In order to improve the efficiency of the alpha
+/// beta algorithm, MovePicker attempts to return the moves which are most likely
+/// to get a cut-off first.
+
+class MovePicker {
+public:
+  MovePicker(const MovePicker&) = delete;
+  MovePicker& operator=(const MovePicker&) = delete;
+  MovePicker(const Position&, Move, Value, const CapturePieceToHistory*);
+  MovePicker(const Position&, Move, Depth, const ButterflyHistory*,  const CapturePieceToHistory*, Square);
+  MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, Move, Move*);
+  Move next_move(bool skipQuiets = false);
+
+private:
+  template<GenType> void score();
+  ExtMove* begin() { return cur; }
+  ExtMove* end() { return endMoves; }
+
+  const Position& pos;
+  const ButterflyHistory* mainHistory;
+  const CapturePieceToHistory* captureHistory;
+  const PieceToHistory** contHistory;
+  Move ttMove, countermove, killers[2];
+  ExtMove *cur, *endMoves, *endBadCaptures;
+  int stage;
+  Square recaptureSquare;
+  Value threshold;
+  Depth depth;
+  ExtMove moves[MAX_MOVES];
+};
+
+#endif // #ifndef MOVEPICK_H_INCLUDED

src/pawns.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,224 +18,282 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
 #include <cassert>
 
 #include "bitboard.h"
-#include "bitcount.h"
 #include "pawns.h"
 #include "position.h"
+#include "thread.h"
 
 namespace {
 
+  #define V Value
   #define S(mg, eg) make_score(mg, eg)
 
-  // Doubled pawn penalty by opposed flag and file
+  // Isolated pawn penalty
-  const Score DoubledPawnPenalty[2][8] = {
+  const Score Isolated = S(13, 18);
-  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
-    S(23, 48), S(23, 48), S(20, 48), S(13, 43) },
-  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
-    S(23, 48), S(23, 48), S(20, 48), S(13, 43) }};
 
-  // Isolated pawn penalty by opposed flag and file
+  // Backward pawn penalty
-  const Score IsolatedPawnPenalty[2][8] = {
+  const Score Backward = S(24, 12);
-  { S(37, 45), S(54, 52), S(60, 52), S(60, 52),
-    S(60, 52), S(60, 52), S(54, 52), S(37, 45) },
-  { S(25, 30), S(36, 35), S(40, 35), S(40, 35),
-    S(40, 35), S(40, 35), S(36, 35), S(25, 30) }};
 
-  // Backward pawn penalty by opposed flag and file
+  // Connected pawn bonus by opposed, phalanx, #support and rank
-  const Score BackwardPawnPenalty[2][8] = {
+  Score Connected[2][2][3][RANK_NB];
-  { S(30, 42), S(43, 46), S(49, 46), S(49, 46),
-    S(49, 46), S(49, 46), S(43, 46), S(30, 42) },
-  { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
-    S(33, 31), S(33, 31), S(29, 31), S(20, 28) }};
 
-  // Pawn chain membership bonus by file
+  // Doubled pawn penalty
-  const Score ChainBonus[8] = {
+  const Score Doubled = S(18, 38);
-    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
+
-    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
+  // Weakness of our pawn shelter in front of the king by [isKingFile][distance from edge][rank].
+  // RANK_1 = 0 is used for files where we have no pawns or our pawn is behind our king.
+  const Value ShelterWeakness[][int(FILE_NB) / 2][RANK_NB] = {
+    { { V( 97), V(17), V( 9), V(44), V( 84), V( 87), V( 99) }, // Not On King file
+      { V(106), V( 6), V(33), V(86), V( 87), V(104), V(112) },
+      { V(101), V( 2), V(65), V(98), V( 58), V( 89), V(115) },
+      { V( 73), V( 7), V(54), V(73), V( 84), V( 83), V(111) } },
+    { { V(104), V(20), V( 6), V(27), V( 86), V( 93), V( 82) }, // On King file
+      { V(123), V( 9), V(34), V(96), V(112), V( 88), V( 75) },
+      { V(120), V(25), V(65), V(91), V( 66), V( 78), V(117) },
+      { V( 81), V( 2), V(47), V(63), V( 94), V( 93), V(104) } }
   };
 
-  // Candidate passed pawn bonus by rank
+  // Danger of enemy pawns moving toward our king by [type][distance from edge][rank].
-  const Score CandidateBonus[8] = {
+  // For the unopposed and unblocked cases, RANK_1 = 0 is used when opponent has
-    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
+  // no pawn on the given file, or their pawn is behind our king.
-    S(34,68), S(83,166), S(0, 0), S( 0, 0)
+  const Value StormDanger[][4][RANK_NB] = {
+    { { V( 0),  V(-290), V(-274), V(57), V(41) },  // BlockedByKing
+      { V( 0),  V(  60), V( 144), V(39), V(13) },
+      { V( 0),  V(  65), V( 141), V(41), V(34) },
+      { V( 0),  V(  53), V( 127), V(56), V(14) } },
+    { { V( 4),  V(  73), V( 132), V(46), V(31) },  // Unopposed
+      { V( 1),  V(  64), V( 143), V(26), V(13) },
+      { V( 1),  V(  47), V( 110), V(44), V(24) },
+      { V( 0),  V(  72), V( 127), V(50), V(31) } },
+    { { V( 0),  V(   0), V(  79), V(23), V( 1) },  // BlockedByPawn
+      { V( 0),  V(   0), V( 148), V(27), V( 2) },
+      { V( 0),  V(   0), V( 161), V(16), V( 1) },
+      { V( 0),  V(   0), V( 171), V(22), V(15) } },
+    { { V(22),  V(  45), V( 104), V(62), V( 6) },  // Unblocked
+      { V(31),  V(  30), V(  99), V(39), V(19) },
+      { V(23),  V(  29), V(  96), V(41), V(15) },
+      { V(21),  V(  23), V( 116), V(41), V(15) } }
   };
 
-  const Score PawnStructureWeight = S(233, 201);
+  // Max bonus for king safety. Corresponds to start position with all the pawns
+  // in front of the king and no enemy pawn on the horizon.
+  const Value MaxSafetyBonus = V(258);
 
   #undef S
-
+  #undef V
-  inline Score apply_weight(Score v, Score w) {
-    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
-                      (int(eg_value(v)) * eg_value(w)) / 0x100);
-  }
-}
-
-
-/// PawnInfoTable::pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it. The result is also stored
-/// in an hash table, so we don't have to recompute everything when the same
-/// pawn structure occurs again.
-
-PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
-
-  Key key = pos.pawn_key();
-  PawnInfo* pi = probe(key);
-
-  // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return
-  // the information we found the last time instead of recomputing it.
-  if (pi->key == key)
-      return pi;
-
-  // Initialize PawnInfo entry
-  pi->key = key;
-  pi->passedPawns[WHITE] = pi->passedPawns[BLACK] = 0;
-  pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
-  pi->halfOpenFiles[WHITE] = pi->halfOpenFiles[BLACK] = 0xFF;
-
-  // Calculate pawn attacks
-  Bitboard wPawns = pos.pieces(PAWN, WHITE);
-  Bitboard bPawns = pos.pieces(PAWN, BLACK);
-  pi->pawnAttacks[WHITE] = ((wPawns << 9) & ~FileABB) | ((wPawns << 7) & ~FileHBB);
-  pi->pawnAttacks[BLACK] = ((bPawns >> 7) & ~FileABB) | ((bPawns >> 9) & ~FileHBB);
-
-  // Evaluate pawns for both colors and weight the result
-  pi->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, pi)
-             - evaluate_pawns<BLACK>(pos, bPawns, wPawns, pi);
-
-  pi->value = apply_weight(pi->value, PawnStructureWeight);
-
-  return pi;
-}
-
-
-/// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
 
   template<Color Us>
-Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
+  Score evaluate(const Position& pos, Pawns::Entry* e) {
-                                    Bitboard theirPawns, PawnInfo* pi) {
 
     const Color     Them  = (Us == WHITE ? BLACK      : WHITE);
+    const Direction Up    = (Us == WHITE ? NORTH      : SOUTH);
+    const Direction Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
+    const Direction Left  = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
 
-  Bitboard b;
+    Bitboard b, neighbours, stoppers, doubled, supported, phalanx;
+    Bitboard lever, leverPush;
     Square s;
-  File f;
+    bool opposed, backward;
-  Rank r;
+    Score score = SCORE_ZERO;
-  bool passed, isolated, doubled, opposed, chain, backward, candidate;
+    const Square* pl = pos.squares<PAWN>(Us);
-  Score value = SCORE_ZERO;
+
-  const Square* pl = pos.piece_list(Us, PAWN);
+    Bitboard ourPawns   = pos.pieces(  Us, PAWN);
+    Bitboard theirPawns = pos.pieces(Them, PAWN);
+
+    e->passedPawns[Us] = e->pawnAttacksSpan[Us] = e->weakUnopposed[Us] = 0;
+    e->semiopenFiles[Us] = 0xFF;
+    e->kingSquares[Us]   = SQ_NONE;
+    e->pawnAttacks[Us]   = shift<Right>(ourPawns) | shift<Left>(ourPawns);
+    e->pawnsOnSquares[Us][BLACK] = popcount(ourPawns & DarkSquares);
+    e->pawnsOnSquares[Us][WHITE] = pos.count<PAWN>(Us) - e->pawnsOnSquares[Us][BLACK];
 
     // Loop through all pawns of the current color and score each pawn
     while ((s = *pl++) != SQ_NONE)
     {
         assert(pos.piece_on(s) == make_piece(Us, PAWN));
 
-      f = file_of(s);
+        File f = file_of(s);
-      r = rank_of(s);
 
-      // This file cannot be half open
+        e->semiopenFiles[Us]   &= ~(1 << f);
-      pi->halfOpenFiles[Us] &= ~(1 << f);
+        e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s);
 
-      // Our rank plus previous one. Used for chain detection
+        // Flag the pawn
-      b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
+        opposed    = theirPawns & forward_file_bb(Us, s);
+        stoppers   = theirPawns & passed_pawn_mask(Us, s);
+        lever      = theirPawns & PawnAttacks[Us][s];
+        leverPush  = theirPawns & PawnAttacks[Us][s + Up];
+        doubled    = ourPawns   & (s - Up);
+        neighbours = ourPawns   & adjacent_files_bb(f);
+        phalanx    = neighbours & rank_bb(s);
+        supported  = neighbours & rank_bb(s - Up);
 
-      // Flag the pawn as passed, isolated, doubled or member of a pawn
+        // A pawn is backward when it is behind all pawns of the same color on the
-      // chain (but not the backward one).
+        // adjacent files and cannot be safely advanced.
-      passed   = !(theirPawns & passed_pawn_mask(Us, s));
+        if (!neighbours || lever || relative_rank(Us, s) >= RANK_5)
-      doubled  =   ourPawns   & squares_in_front_of(Us, s);
-      opposed  =   theirPawns & squares_in_front_of(Us, s);
-      isolated = !(ourPawns   & neighboring_files_bb(f));
-      chain    =   ourPawns   & neighboring_files_bb(f) & b;
-
-      // Test for backward pawn
             backward = false;
-
+        else
-      // If the pawn is passed, isolated, or member of a pawn chain it cannot
-      // be backward. If there are friendly pawns behind on neighboring files
-      // or if can capture an enemy pawn it cannot be backward either.
-      if (   !(passed | isolated | chain)
-          && !(ourPawns & attack_span_mask(Them, s))
-          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
         {
-          // We now know that there are no friendly pawns beside or behind this
+            // Find the backmost rank with neighbours or stoppers
-          // pawn on neighboring files. We now check whether the pawn is
+            b = rank_bb(backmost_sq(Us, neighbours | stoppers));
-          // backward by looking in the forward direction on the neighboring
-          // files, and seeing whether we meet a friendly or an enemy pawn first.
-          b = pos.attacks_from<PAWN>(s, Us);
 
-          // Note that we are sure to find something because pawn is not passed
+            // The pawn is backward when it cannot safely progress to that rank:
-          // nor isolated, so loop is potentially infinite, but it isn't.
+            // either there is a stopper in the way on this rank, or there is a
-          while (!(b & (ourPawns | theirPawns)))
+            // stopper on adjacent file which controls the way to that rank.
-              Us == WHITE ? b <<= 8 : b >>= 8;
+            backward = (b | shift<Up>(b & adjacent_files_bb(f))) & stoppers;
 
-          // The friendly pawn needs to be at least two ranks closer than the
+            assert(!(backward && (forward_ranks_bb(Them, s + Up) & neighbours)));
-          // enemy pawn in order to help the potentially backward pawn advance.
-          backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
         }
 
-      assert(opposed | passed | (attack_span_mask(Us, s) & theirPawns));
-
-      // A not passed pawn is a candidate to become passed if it is free to
-      // advance and if the number of friendly pawns beside or behind this
-      // pawn on neighboring files is higher or equal than the number of
-      // enemy pawns in the forward direction on the neighboring files.
-      candidate =   !(opposed | passed | backward | isolated)
-                 && (b = attack_span_mask(Them, s + pawn_push(Us)) & ourPawns) != 0
-                 &&  popcount<Max15>(b) >= popcount<Max15>(attack_span_mask(Us, s) & theirPawns);
-
         // Passed pawns will be properly scored in evaluation because we need
-      // full attack info to evaluate passed pawns. Only the frontmost passed
+        // full attack info to evaluate them. Include also not passed pawns
-      // pawn on each file is considered a true passed pawn.
+        // which could become passed after one or two pawn pushes when are
-      if (passed && !doubled)
+        // not attacked more times than defended.
-          set_bit(&(pi->passedPawns[Us]), s);
+        if (   !(stoppers ^ lever ^ leverPush)
+            && !(ourPawns & forward_file_bb(Us, s))
+            && popcount(supported) >= popcount(lever)
+            && popcount(phalanx)   >= popcount(leverPush))
+            e->passedPawns[Us] |= s;
+
+        else if (   stoppers == SquareBB[s + Up]
+                 && relative_rank(Us, s) >= RANK_5)
+        {
+            b = shift<Up>(supported) & ~theirPawns;
+            while (b)
+                if (!more_than_one(theirPawns & PawnAttacks[Us][pop_lsb(&b)]))
+                    e->passedPawns[Us] |= s;
+        }
 
         // Score this pawn
-      if (isolated)
+        if (supported | phalanx)
-          value -= IsolatedPawnPenalty[opposed][f];
+            score += Connected[opposed][bool(phalanx)][popcount(supported)][relative_rank(Us, s)];
 
-      if (doubled)
+        else if (!neighbours)
-          value -= DoubledPawnPenalty[opposed][f];
+            score -= Isolated, e->weakUnopposed[Us] += !opposed;
 
-      if (backward)
+        else if (backward)
-          value -= BackwardPawnPenalty[opposed][f];
+            score -= Backward, e->weakUnopposed[Us] += !opposed;
 
-      if (chain)
+        if (doubled && !supported)
-          value += ChainBonus[f];
+            score -= Doubled;
-
+    }
-      if (candidate)
+
-          value += CandidateBonus[relative_rank(Us, s)];
+    return score;
+  }
+
+} // namespace
+
+namespace Pawns {
+
+/// Pawns::init() initializes some tables needed by evaluation. Instead of using
+/// hard-coded tables, when makes sense, we prefer to calculate them with a formula
+/// to reduce independent parameters and to allow easier tuning and better insight.
+
+void init() {
+
+  static const int Seed[RANK_NB] = { 0, 13, 24, 18, 76, 100, 175, 330 };
+
+  for (int opposed = 0; opposed <= 1; ++opposed)
+      for (int phalanx = 0; phalanx <= 1; ++phalanx)
+          for (int support = 0; support <= 2; ++support)
+              for (Rank r = RANK_2; r < RANK_8; ++r)
+  {
+      int v = 17 * support;
+      v += (Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0)) >> opposed;
+
+      Connected[opposed][phalanx][support][r] = make_score(v, v * (r - 2) / 4);
   }
-  return value;
 }
 
 
-/// PawnInfo::updateShelter() calculates and caches king shelter. It is called
+/// Pawns::probe() looks up the current position's pawns configuration in
-/// only when king square changes, about 20% of total king_shelter() calls.
+/// the pawns hash table. It returns a pointer to the Entry if the position
+/// is found. Otherwise a new Entry is computed and stored there, so we don't
+/// have to recompute all when the same pawns configuration occurs again.
+
+Entry* probe(const Position& pos) {
+
+  Key key = pos.pawn_key();
+  Entry* e = pos.this_thread()->pawnsTable[key];
+
+  if (e->key == key)
+      return e;
+
+  e->key = key;
+  e->score = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
+  e->asymmetry = popcount(e->semiopenFiles[WHITE] ^ e->semiopenFiles[BLACK]);
+  e->openFiles = popcount(e->semiopenFiles[WHITE] & e->semiopenFiles[BLACK]);
+  return e;
+}
+
+
+/// Entry::shelter_storm() calculates shelter and storm penalties for the file
+/// the king is on, as well as the two closest files.
+
 template<Color Us>
-Score PawnInfo::updateShelter(const Position& pos, Square ksq) {
+Value Entry::shelter_storm(const Position& pos, Square ksq) {
 
-  const int Shift = (Us == WHITE ? 8 : -8);
+  const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-  Bitboard pawns;
+  enum { BlockedByKing, Unopposed, BlockedByPawn, Unblocked };
-  int r, shelter = 0;
 
-  if (relative_rank(Us, ksq) <= RANK_4)
+  Bitboard b = pos.pieces(PAWN) & (forward_ranks_bb(Us, ksq) | rank_bb(ksq));
+  Bitboard ourPawns = b & pos.pieces(Us);
+  Bitboard theirPawns = b & pos.pieces(Them);
+  Value safety = MaxSafetyBonus;
+  File center = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
+
+  for (File f = File(center - 1); f <= File(center + 1); ++f)
   {
-      pawns = pos.pieces(PAWN, Us) & this_and_neighboring_files_bb(file_of(ksq));
+      b = ourPawns & file_bb(f);
-      r = ksq & (7 << 3);
+      Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
-      for (int i = 0; i < 3; i++)
+
-      {
+      b = theirPawns & file_bb(f);
-          r += Shift;
+      Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
-          shelter += BitCount8Bit[(pawns >> r) & 0xFF] << (6 - i);
+
+      int d = std::min(f, ~f);
+      safety -=  ShelterWeakness[f == file_of(ksq)][d][rkUs]
+               + StormDanger
+                 [f == file_of(ksq) && rkThem == relative_rank(Us, ksq) + 1 ? BlockedByKing  :
+                  rkUs   == RANK_1                                          ? Unopposed :
+                  rkThem == rkUs + 1                                        ? BlockedByPawn  : Unblocked]
+                 [d][rkThem];
   }
+
+  return safety;
 }
+
+
+/// Entry::do_king_safety() calculates a bonus for king safety. It is called only
+/// when king square changes, which is about 20% of total king_safety() calls.
+
+template<Color Us>
+Score Entry::do_king_safety(const Position& pos, Square ksq) {
+
   kingSquares[Us] = ksq;
-  kingShelters[Us] = make_score(shelter, 0);
+  castlingRights[Us] = pos.can_castle(Us);
-  return kingShelters[Us];
+  int minKingPawnDistance = 0;
+
+  Bitboard pawns = pos.pieces(Us, PAWN);
+  if (pawns)
+      while (!(DistanceRingBB[ksq][minKingPawnDistance++] & pawns)) {}
+
+  Value bonus = shelter_storm<Us>(pos, ksq);
+
+  // If we can castle use the bonus after the castling if it is bigger
+  if (pos.can_castle(MakeCastling<Us, KING_SIDE>::right))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_G1)));
+
+  if (pos.can_castle(MakeCastling<Us, QUEEN_SIDE>::right))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
+
+  return make_score(bonus, -16 * minKingPawnDistance);
 }
 
 // Explicit template instantiation
-template Score PawnInfo::updateShelter<WHITE>(const Position& pos, Square ksq);
+template Score Entry::do_king_safety<WHITE>(const Position& pos, Square ksq);
-template Score PawnInfo::updateShelter<BLACK>(const Position& pos, Square ksq);
+template Score Entry::do_king_safety<BLACK>(const Position& pos, Square ksq);
+
+} // namespace Pawns

src/pawns.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,91 +18,73 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(PAWNS_H_INCLUDED)
+#ifndef PAWNS_H_INCLUDED
 #define PAWNS_H_INCLUDED
 
+#include "misc.h"
 #include "position.h"
-#include "tt.h"
 #include "types.h"
 
-const int PawnTableSize = 16384;
+namespace Pawns {
 
-/// PawnInfo is a class which contains various information about a pawn
+/// Pawns::Entry contains various information about a pawn structure. A lookup
-/// structure. Currently, it only includes a middle game and an end game
+/// to the pawn hash table (performed by calling the probe function) returns a
-/// pawn structure evaluation, and a bitboard of passed pawns. We may want
+/// pointer to an Entry object.
-/// to add further information in the future. A lookup to the pawn hash
-/// table (performed by calling the pawn_info method in a PawnInfoTable
-/// object) returns a pointer to a PawnInfo object.
 
-class PawnInfo {
+struct Entry {
 
-  friend class PawnInfoTable;
+  Score pawns_score() const { return score; }
+  Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
+  Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
+  Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; }
+  int weak_unopposed(Color c) const { return weakUnopposed[c]; }
+  int pawn_asymmetry() const { return asymmetry; }
+  int open_files() const { return openFiles; }
 
-public:
+  int semiopen_file(Color c, File f) const {
-  Score pawns_value() const;
+    return semiopenFiles[c] & (1 << f);
-  Bitboard pawn_attacks(Color c) const;
+  }
-  Bitboard passed_pawns(Color c) const;
+
-  int file_is_half_open(Color c, File f) const;
+  int semiopen_side(Color c, File f, bool leftSide) const {
-  int has_open_file_to_left(Color c, File f) const;
+    return semiopenFiles[c] & (leftSide ? (1 << f) - 1 : ~((1 << (f + 1)) - 1));
-  int has_open_file_to_right(Color c, File f) const;
+  }
+
+  int pawns_on_same_color_squares(Color c, Square s) const {
+    return pawnsOnSquares[c][bool(DarkSquares & s)];
+  }
 
   template<Color Us>
-  Score king_shelter(const Position& pos, Square ksq);
+  Score king_safety(const Position& pos, Square ksq) {
+    return  kingSquares[Us] == ksq && castlingRights[Us] == pos.can_castle(Us)
+          ? kingSafety[Us] : (kingSafety[Us] = do_king_safety<Us>(pos, ksq));
+  }
 
-private:
   template<Color Us>
-  Score updateShelter(const Position& pos, Square ksq);
+  Score do_king_safety(const Position& pos, Square ksq);
+
+  template<Color Us>
+  Value shelter_storm(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns[2];
+  Score score;
-  Bitboard pawnAttacks[2];
+  Bitboard passedPawns[COLOR_NB];
-  Square kingSquares[2];
+  Bitboard pawnAttacks[COLOR_NB];
-  Score value;
+  Bitboard pawnAttacksSpan[COLOR_NB];
-  int halfOpenFiles[2];
+  Square kingSquares[COLOR_NB];
-  Score kingShelters[2];
+  Score kingSafety[COLOR_NB];
+  int weakUnopposed[COLOR_NB];
+  int castlingRights[COLOR_NB];
+  int semiopenFiles[COLOR_NB];
+  int pawnsOnSquares[COLOR_NB][COLOR_NB]; // [color][light/dark squares]
+  int asymmetry;
+  int openFiles;
 };
 
+typedef HashTable<Entry, 16384> Table;
 
-/// The PawnInfoTable class represents a pawn hash table. The most important
+void init();
-/// method is pawn_info, which returns a pointer to a PawnInfo object.
+Entry* probe(const Position& pos);
 
-class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
+} // namespace Pawns
-public:
-  PawnInfo* pawn_info(const Position& pos) const;
 
-private:
+#endif // #ifndef PAWNS_H_INCLUDED
-  template<Color Us>
-  static Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
-};
-
-
-inline Score PawnInfo::pawns_value() const {
-  return value;
-}
-
-inline Bitboard PawnInfo::pawn_attacks(Color c) const {
-  return pawnAttacks[c];
-}
-
-inline Bitboard PawnInfo::passed_pawns(Color c) const {
-  return passedPawns[c];
-}
-
-inline int PawnInfo::file_is_half_open(Color c, File f) const {
-  return halfOpenFiles[c] & (1 << int(f));
-}
-
-inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
-  return halfOpenFiles[c] & ((1 << int(f)) - 1);
-}
-
-inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
-  return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
-}
-
-template<Color Us>
-inline Score PawnInfo::king_shelter(const Position& pos, Square ksq) {
-  return kingSquares[Us] == ksq ? kingShelters[Us] : updateShelter<Us>(pos, ksq);
-}
-
-#endif // !defined(PAWNS_H_INCLUDED)

src/position.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,391 +18,309 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(POSITION_H_INCLUDED)
+#ifndef POSITION_H_INCLUDED
 #define POSITION_H_INCLUDED
 
 #include <cassert>
+#include <deque>
+#include <memory> // For std::unique_ptr
+#include <string>
 
 #include "bitboard.h"
 #include "types.h"
 
 
-/// The checkInfo struct is initialized at c'tor time and keeps info used
+/// StateInfo struct stores information needed to restore a Position object to
-/// to detect if a move gives check.
+/// its previous state when we retract a move. Whenever a move is made on the
-class Position;
+/// board (by calling Position::do_move), a StateInfo object must be passed.
-
-struct CheckInfo {
-
-  explicit CheckInfo(const Position&);
-
-  Bitboard dcCandidates;
-  Bitboard pinned;
-  Bitboard checkSq[8];
-};
-
-
-/// The StateInfo struct stores information we need to restore a Position
-/// object to its previous state when we retract a move. Whenever a move
-/// is made on the board (by calling Position::do_move), an StateInfo object
-/// must be passed as a parameter.
 
 struct StateInfo {
-  Key pawnKey, materialKey;
+
-  Value npMaterial[2];
+  // Copied when making a move
-  int castleRights, rule50, pliesFromNull;
+  Key    pawnKey;
-  Score value;
+  Key    materialKey;
+  Value  nonPawnMaterial[COLOR_NB];
+  int    castlingRights;
+  int    rule50;
+  int    pliesFromNull;
+  Score  psq;
   Square epSquare;
 
+  // Not copied when making a move (will be recomputed anyhow)
   Key        key;
   Bitboard   checkersBB;
-  PieceType capturedType;
+  Piece      capturedPiece;
   StateInfo* previous;
+  Bitboard   blockersForKing[COLOR_NB];
+  Bitboard   pinnersForKing[COLOR_NB];
+  Bitboard   checkSquares[PIECE_TYPE_NB];
 };
 
+/// A list to keep track of the position states along the setup moves (from the
+/// start position to the position just before the search starts). Needed by
+/// 'draw by repetition' detection. Use a std::deque because pointers to
+/// elements are not invalidated upon list resizing.
+typedef std::unique_ptr<std::deque<StateInfo>> StateListPtr;
 
-/// The position data structure. A position consists of the following data:
+
-///
+/// Position class stores information regarding the board representation as
-///    * For each piece type, a bitboard representing the squares occupied
+/// pieces, side to move, hash keys, castling info, etc. Important methods are
-///      by pieces of that type.
+/// do_move() and undo_move(), used by the search to update node info when
-///    * For each color, a bitboard representing the squares occupied by
+/// traversing the search tree.
-///      pieces of that color.
+class Thread;
-///    * A bitboard of all occupied squares.
-///    * A bitboard of all checking pieces.
-///    * A 64-entry array of pieces, indexed by the squares of the board.
-///    * The current side to move.
-///    * Information about the castling rights for both sides.
-///    * The initial files of the kings and both pairs of rooks. This is
-///      used to implement the Chess960 castling rules.
-///    * The en passant square (which is SQ_NONE if no en passant capture is
-///      possible).
-///    * The squares of the kings for both sides.
-///    * Hash keys for the position itself, the current pawn structure, and
-///      the current material situation.
-///    * Hash keys for all previous positions in the game for detecting
-///      repetition draws.
-///    * A counter for detecting 50 move rule draws.
 
 class Position {
-
-  // No copy c'tor or assignment operator allowed
-  Position(const Position&);
-  Position& operator=(const Position&);
-
 public:
-  Position() {}
+  static void init();
-  Position(const Position& pos, int th) { copy(pos, th); }
-  Position(const std::string& fen, bool isChess960, int th);
 
-  // Text input/output
+  Position() = default;
-  void copy(const Position& pos, int th);
+  Position(const Position&) = delete;
-  void from_fen(const std::string& fen, bool isChess960);
+  Position& operator=(const Position&) = delete;
-  const std::string to_fen() const;
-  void print(Move m = MOVE_NONE) const;
 
-  // The piece on a given square
+  // FEN string input/output
-  Piece piece_on(Square s) const;
+  Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th);
-  bool square_is_empty(Square s) const;
+  Position& set(const std::string& code, Color c, StateInfo* si);
+  const std::string fen() const;
 
-  // Side to move
+  // Position representation
-  Color side_to_move() const;
+  Bitboard pieces() const;
-
-  // Bitboard representation of the position
-  Bitboard empty_squares() const;
-  Bitboard occupied_squares() const;
-  Bitboard pieces(Color c) const;
   Bitboard pieces(PieceType pt) const;
-  Bitboard pieces(PieceType pt, Color c) const;
   Bitboard pieces(PieceType pt1, PieceType pt2) const;
-  Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
+  Bitboard pieces(Color c) const;
-
+  Bitboard pieces(Color c, PieceType pt) const;
-  // Number of pieces of each color and type
+  Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
-  int piece_count(Color c, PieceType pt) const;
+  Piece piece_on(Square s) const;
-
-  // The en passant square
   Square ep_square() const;
+  bool empty(Square s) const;
+  template<PieceType Pt> int count(Color c) const;
+  template<PieceType Pt> int count() const;
+  template<PieceType Pt> const Square* squares(Color c) const;
+  template<PieceType Pt> Square square(Color c) const;
 
-  // Current king position for each color
+  // Castling
-  Square king_square(Color c) const;
+  int can_castle(Color c) const;
+  int can_castle(CastlingRight cr) const;
+  bool castling_impeded(CastlingRight cr) const;
+  Square castling_rook_square(CastlingRight cr) const;
 
-  // Castling rights
+  // Checking
-  bool can_castle(CastleRight f) const;
-  bool can_castle(Color c) const;
-  Square castle_rook_square(CastleRight f) const;
-
-  // Bitboards for pinned pieces and discovered check candidates
-  Bitboard discovered_check_candidates() const;
-  Bitboard pinned_pieces() const;
-
-  // Checking pieces and under check information
   Bitboard checkers() const;
-  bool in_check() const;
+  Bitboard discovered_check_candidates() const;
+  Bitboard pinned_pieces(Color c) const;
+  Bitboard check_squares(PieceType pt) const;
 
-  // Piece lists
+  // Attacks to/from a given square
-  const Square* piece_list(Color c, PieceType pt) const;
-
-  // Information about attacks to or from a given square
   Bitboard attackers_to(Square s) const;
-  Bitboard attackers_to(Square s, Bitboard occ) const;
+  Bitboard attackers_to(Square s, Bitboard occupied) const;
-  Bitboard attacks_from(Piece p, Square s) const;
+  Bitboard attacks_from(PieceType pt, Square s) const;
-  static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
   template<PieceType> Bitboard attacks_from(Square s) const;
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
+  Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const;
 
   // Properties of moves
-  bool move_gives_check(Move m, const CheckInfo& ci) const;
+  bool legal(Move m) const;
-  bool move_attacks_square(Move m, Square s) const;
+  bool pseudo_legal(const Move m) const;
-  bool pl_move_is_legal(Move m, Bitboard pinned) const;
+  bool capture(Move m) const;
-  bool is_pseudo_legal(const Move m) const;
+  bool capture_or_promotion(Move m) const;
-  bool is_capture(Move m) const;
+  bool gives_check(Move m) const;
-  bool is_capture_or_promotion(Move m) const;
+  bool advanced_pawn_push(Move m) const;
-  bool is_passed_pawn_push(Move m) const;
+  Piece moved_piece(Move m) const;
+  Piece captured_piece() const;
 
-  // Piece captured with previous moves
+  // Piece specific
-  PieceType captured_piece_type() const;
+  bool pawn_passed(Color c, Square s) const;
-
+  bool opposite_bishops() const;
-  // Information about pawns
-  bool pawn_is_passed(Color c, Square s) const;
 
   // Doing and undoing moves
-  void do_move(Move m, StateInfo& st);
+  void do_move(Move m, StateInfo& newSt);
-  void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
+  void do_move(Move m, StateInfo& newSt, bool givesCheck);
   void undo_move(Move m);
-  template<bool Do> void do_null_move(StateInfo& st);
+  void do_null_move(StateInfo& newSt);
+  void undo_null_move();
 
-  // Static exchange evaluation
+  // Static Exchange Evaluation
-  int see(Move m) const;
+  bool see_ge(Move m, Value threshold = VALUE_ZERO) const;
-  int see_sign(Move m) const;
 
   // Accessing hash keys
   Key key() const;
-  Key exclusion_key() const;
+  Key key_after(Move m) const;
-  Key pawn_key() const;
   Key material_key() const;
-
+  Key pawn_key() const;
-  // Incremental evaluation
-  Score value() const;
-  Value non_pawn_material(Color c) const;
-  Score pst_delta(Piece piece, Square from, Square to) const;
-
-  // Game termination checks
-  bool is_mate() const;
-  template<bool SkipRepetition> bool is_draw() const;
-
-  // Plies from start position to the beginning of search
-  int startpos_ply_counter() const;
 
   // Other properties of the position
-  bool opposite_colored_bishops() const;
+  Color side_to_move() const;
-  bool has_pawn_on_7th(Color c) const;
+  int game_ply() const;
   bool is_chess960() const;
-
+  Thread* this_thread() const;
-  // Current thread ID searching on the position
+  bool is_draw(int ply) const;
-  int thread() const;
+  int rule50_count() const;
-
+  Score psq_score() const;
-  int64_t nodes_searched() const;
+  Value non_pawn_material(Color c) const;
-  void set_nodes_searched(int64_t n);
+  Value non_pawn_material() const;
 
   // Position consistency check, for debugging
-  bool pos_is_ok(int* failedStep = NULL) const;
+  bool pos_is_ok() const;
-  void flip_me();
+  void flip();
-
-  // Global initialization
-  static void init();
 
 private:
+  // Initialization helpers (used while setting up a position)
+  void set_castling_right(Color c, Square rfrom);
+  void set_state(StateInfo* si) const;
+  void set_check_info(StateInfo* si) const;
 
-  // Initialization helper functions (used while setting up a position)
+  // Other helpers
-  void clear();
+  void put_piece(Piece pc, Square s);
-  void put_piece(Piece p, Square s);
+  void remove_piece(Piece pc, Square s);
-  void set_castle_right(Square ksq, Square rsq);
+  void move_piece(Piece pc, Square from, Square to);
-  bool move_is_legal(const Move m) const;
+  template<bool Do>
+  void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
 
-  // Helper template functions
+  // Data members
-  template<bool Do> void do_castle_move(Move m);
+  Piece board[SQUARE_NB];
-  template<bool FindPinned> Bitboard hidden_checkers() const;
+  Bitboard byTypeBB[PIECE_TYPE_NB];
-
+  Bitboard byColorBB[COLOR_NB];
-  // Computing hash keys from scratch (for initialization and debugging)
+  int pieceCount[PIECE_NB];
-  Key compute_key() const;
+  Square pieceList[PIECE_NB][16];
-  Key compute_pawn_key() const;
+  int index[SQUARE_NB];
-  Key compute_material_key() const;
+  int castlingRightsMask[SQUARE_NB];
-
+  Square castlingRookSquare[CASTLING_RIGHT_NB];
-  // Computing incremental evaluation scores and material counts
+  Bitboard castlingPath[CASTLING_RIGHT_NB];
-  Score pst(Piece p, Square s) const;
+  int gamePly;
-  Score compute_value() const;
-  Value compute_non_pawn_material(Color c) const;
-
-  // Board
-  Piece board[64];             // [square]
-
-  // Bitboards
-  Bitboard byTypeBB[8];        // [pieceType]
-  Bitboard byColorBB[2];       // [color]
-  Bitboard occupied;
-
-  // Piece counts
-  int pieceCount[2][8];        // [color][pieceType]
-
-  // Piece lists
-  Square pieceList[2][8][16];  // [color][pieceType][index]
-  int index[64];               // [square]
-
-  // Other info
-  int castleRightsMask[64];    // [square]
-  Square castleRookSquare[16]; // [castleRight]
-  StateInfo startState;
-  int64_t nodes;
-  int startPosPly;
   Color sideToMove;
-  int threadID;
+  Thread* thisThread;
   StateInfo* st;
-  int chess960;
+  bool chess960;
-
-  // Static variables
-  static Score pieceSquareTable[16][64]; // [piece][square]
-  static Key zobrist[2][8][64];          // [color][pieceType][square]/[piece count]
-  static Key zobEp[64];                  // [square]
-  static Key zobCastle[16];              // [castleRight]
-  static Key zobSideToMove;
-  static Key zobExclusion;
 };
 
-inline int64_t Position::nodes_searched() const {
+extern std::ostream& operator<<(std::ostream& os, const Position& pos);
-  return nodes;
+
+inline Color Position::side_to_move() const {
+  return sideToMove;
 }
 
-inline void Position::set_nodes_searched(int64_t n) {
+inline bool Position::empty(Square s) const {
-  nodes = n;
+  return board[s] == NO_PIECE;
 }
 
 inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
-inline bool Position::square_is_empty(Square s) const {
+inline Piece Position::moved_piece(Move m) const {
-  return board[s] == NO_PIECE;
+  return board[from_sq(m)];
 }
 
-inline Color Position::side_to_move() const {
+inline Bitboard Position::pieces() const {
-  return sideToMove;
+  return byTypeBB[ALL_PIECES];
-}
-
-inline Bitboard Position::occupied_squares() const {
-  return occupied;
-}
-
-inline Bitboard Position::empty_squares() const {
-  return ~occupied;
-}
-
-inline Bitboard Position::pieces(Color c) const {
-  return byColorBB[c];
 }
 
 inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces(PieceType pt, Color c) const {
-  return byTypeBB[pt] & byColorBB[c];
-}
-
 inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
   return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
+inline Bitboard Position::pieces(Color c) const {
-  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
+  return byColorBB[c];
 }
 
-inline int Position::piece_count(Color c, PieceType pt) const {
+inline Bitboard Position::pieces(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+  return byColorBB[c] & byTypeBB[pt];
 }
 
-inline const Square* Position::piece_list(Color c, PieceType pt) const {
+inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
-  return pieceList[c][pt];
+  return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
+}
+
+template<PieceType Pt> inline int Position::count(Color c) const {
+  return pieceCount[make_piece(c, Pt)];
+}
+
+template<PieceType Pt> inline int Position::count() const {
+  return pieceCount[make_piece(WHITE, Pt)] + pieceCount[make_piece(BLACK, Pt)];
+}
+
+template<PieceType Pt> inline const Square* Position::squares(Color c) const {
+  return pieceList[make_piece(c, Pt)];
+}
+
+template<PieceType Pt> inline Square Position::square(Color c) const {
+  assert(pieceCount[make_piece(c, Pt)] == 1);
+  return pieceList[make_piece(c, Pt)][0];
 }
 
 inline Square Position::ep_square() const {
   return st->epSquare;
 }
 
-inline Square Position::king_square(Color c) const {
+inline int Position::can_castle(CastlingRight cr) const {
-  return pieceList[c][KING][0];
+  return st->castlingRights & cr;
 }
 
-inline bool Position::can_castle(CastleRight f) const {
+inline int Position::can_castle(Color c) const {
-  return st->castleRights & f;
+  return st->castlingRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
 }
 
-inline bool Position::can_castle(Color c) const {
+inline bool Position::castling_impeded(CastlingRight cr) const {
-  return st->castleRights & ((WHITE_OO | WHITE_OOO) << c);
+  return byTypeBB[ALL_PIECES] & castlingPath[cr];
 }
 
-inline Square Position::castle_rook_square(CastleRight f) const {
+inline Square Position::castling_rook_square(CastlingRight cr) const {
-  return castleRookSquare[f];
+  return castlingRookSquare[cr];
+}
+
+template<PieceType Pt>
+inline Bitboard Position::attacks_from(Square s) const {
+  assert(Pt != PAWN);
+  return  Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_PIECES])
+        : Pt == QUEEN  ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
+        : PseudoAttacks[Pt][s];
 }
 
 template<>
 inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
-  return StepAttacksBB[make_piece(c, PAWN)][s];
+  return PawnAttacks[c][s];
 }
 
-template<PieceType Piece> // Knight and King and white pawns
+inline Bitboard Position::attacks_from(PieceType pt, Square s) const {
-inline Bitboard Position::attacks_from(Square s) const {
+  return attacks_bb(pt, s, byTypeBB[ALL_PIECES]);
-  return StepAttacksBB[Piece][s];
-}
-
-template<>
-inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
-  return bishop_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<ROOK>(Square s) const {
-  return rook_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
-}
-
-inline Bitboard Position::attacks_from(Piece p, Square s) const {
-  return attacks_from(p, s, occupied_squares());
 }
 
 inline Bitboard Position::attackers_to(Square s) const {
-  return attackers_to(s, occupied_squares());
+  return attackers_to(s, byTypeBB[ALL_PIECES]);
 }
 
 inline Bitboard Position::checkers() const {
   return st->checkersBB;
 }
 
-inline bool Position::in_check() const {
-  return st->checkersBB != 0;
-}
-
 inline Bitboard Position::discovered_check_candidates() const {
-  return hidden_checkers<false>();
+  return st->blockersForKing[~sideToMove] & pieces(sideToMove);
 }
 
-inline Bitboard Position::pinned_pieces() const {
+inline Bitboard Position::pinned_pieces(Color c) const {
-  return hidden_checkers<true>();
+  return st->blockersForKing[c] & pieces(c);
 }
 
-inline bool Position::pawn_is_passed(Color c, Square s) const {
+inline Bitboard Position::check_squares(PieceType pt) const {
-  return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s));
+  return st->checkSquares[pt];
+}
+
+inline bool Position::pawn_passed(Color c, Square s) const {
+  return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
+}
+
+inline bool Position::advanced_pawn_push(Move m) const {
+  return   type_of(moved_piece(m)) == PAWN
+        && relative_rank(sideToMove, from_sq(m)) > RANK_4;
 }
 
 inline Key Position::key() const {
   return st->key;
 }
 
-inline Key Position::exclusion_key() const {
-  return st->key ^ zobExclusion;
-}
-
 inline Key Position::pawn_key() const {
   return st->pawnKey;
 }
@@ -410,66 +329,99 @@ inline Key Position::material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::pst(Piece p, Square s) const {
+inline Score Position::psq_score() const {
-  return pieceSquareTable[p][s];
+  return st->psq;
-}
-
-inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
-  return pieceSquareTable[piece][to] - pieceSquareTable[piece][from];
-}
-
-inline Score Position::value() const {
-  return st->value;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
-  return st->npMaterial[c];
+  return st->nonPawnMaterial[c];
 }
 
-inline bool Position::is_passed_pawn_push(Move m) const {
+inline Value Position::non_pawn_material() const {
-
+  return st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK];
-  return   board[move_from(m)] == make_piece(sideToMove, PAWN)
-        && pawn_is_passed(sideToMove, move_to(m));
 }
 
-inline int Position::startpos_ply_counter() const {
+inline int Position::game_ply() const {
-  return startPosPly + st->pliesFromNull; // HACK
+  return gamePly;
 }
 
-inline bool Position::opposite_colored_bishops() const {
+inline int Position::rule50_count() const {
-
+  return st->rule50;
-  return   pieceCount[WHITE][BISHOP] == 1
-        && pieceCount[BLACK][BISHOP] == 1
-        && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
 }
 
-inline bool Position::has_pawn_on_7th(Color c) const {
+inline bool Position::opposite_bishops() const {
-  return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
+  return   pieceCount[W_BISHOP] == 1
+        && pieceCount[B_BISHOP] == 1
+        && opposite_colors(square<BISHOP>(WHITE), square<BISHOP>(BLACK));
 }
 
 inline bool Position::is_chess960() const {
   return chess960;
 }
 
-inline bool Position::is_capture_or_promotion(Move m) const {
+inline bool Position::capture_or_promotion(Move m) const {
-
   assert(is_ok(m));
-  return is_special(m) ? !is_castle(m) : !square_is_empty(move_to(m));
+  return type_of(m) != NORMAL ? type_of(m) != CASTLING : !empty(to_sq(m));
 }
 
-inline bool Position::is_capture(Move m) const {
+inline bool Position::capture(Move m) const {
-
-  // Note that castle is coded as "king captures the rook"
   assert(is_ok(m));
-  return (!square_is_empty(move_to(m)) && !is_castle(m)) || is_enpassant(m);
+  // Castling is encoded as "king captures rook"
+  return (!empty(to_sq(m)) && type_of(m) != CASTLING) || type_of(m) == ENPASSANT;
 }
 
-inline PieceType Position::captured_piece_type() const {
+inline Piece Position::captured_piece() const {
-  return st->capturedType;
+  return st->capturedPiece;
 }
 
-inline int Position::thread() const {
+inline Thread* Position::this_thread() const {
-  return threadID;
+  return thisThread;
 }
 
-#endif // !defined(POSITION_H_INCLUDED)
+inline void Position::put_piece(Piece pc, Square s) {
+
+  board[s] = pc;
+  byTypeBB[ALL_PIECES] |= s;
+  byTypeBB[type_of(pc)] |= s;
+  byColorBB[color_of(pc)] |= s;
+  index[s] = pieceCount[pc]++;
+  pieceList[pc][index[s]] = s;
+  pieceCount[make_piece(color_of(pc), ALL_PIECES)]++;
+}
+
+inline void Position::remove_piece(Piece pc, Square s) {
+
+  // WARNING: This is not a reversible operation. If we remove a piece in
+  // do_move() and then replace it in undo_move() we will put it at the end of
+  // the list and not in its original place, it means index[] and pieceList[]
+  // are not invariant to a do_move() + undo_move() sequence.
+  byTypeBB[ALL_PIECES] ^= s;
+  byTypeBB[type_of(pc)] ^= s;
+  byColorBB[color_of(pc)] ^= s;
+  /* board[s] = NO_PIECE;  Not needed, overwritten by the capturing one */
+  Square lastSquare = pieceList[pc][--pieceCount[pc]];
+  index[lastSquare] = index[s];
+  pieceList[pc][index[lastSquare]] = lastSquare;
+  pieceList[pc][pieceCount[pc]] = SQ_NONE;
+  pieceCount[make_piece(color_of(pc), ALL_PIECES)]--;
+}
+
+inline void Position::move_piece(Piece pc, Square from, Square to) {
+
+  // index[from] is not updated and becomes stale. This works as long as index[]
+  // is accessed just by known occupied squares.
+  Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
+  byTypeBB[ALL_PIECES] ^= from_to_bb;
+  byTypeBB[type_of(pc)] ^= from_to_bb;
+  byColorBB[color_of(pc)] ^= from_to_bb;
+  board[from] = NO_PIECE;
+  board[to] = pc;
+  index[to] = index[from];
+  pieceList[pc][index[to]] = to;
+}
+
+inline void Position::do_move(Move m, StateInfo& newSt) {
+  do_move(m, newSt, gives_check(m));
+}
+
+#endif // #ifndef POSITION_H_INCLUDED

src/psqt.cpp

@@ -0,0 +1,126 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <algorithm>
+
+#include "types.h"
+
+Value PieceValue[PHASE_NB][PIECE_NB] = {
+  { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg },
+  { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg }
+};
+
+namespace PSQT {
+
+#define S(mg, eg) make_score(mg, eg)
+
+// Bonus[PieceType][Square / 2] contains Piece-Square scores. For each piece
+// type on a given square a (middlegame, endgame) score pair is assigned. Table
+// is defined for files A..D and white side: it is symmetric for black side and
+// second half of the files.
+const Score Bonus[][RANK_NB][int(FILE_NB) / 2] = {
+  { },
+  { // Pawn
+   { S(  0, 0), S(  0, 0), S(  0, 0), S( 0, 0) },
+   { S(-11, 7), S(  6,-4), S(  7, 8), S( 3,-2) },
+   { S(-18,-4), S( -2,-5), S( 19, 5), S(24, 4) },
+   { S(-17, 3), S( -9, 3), S( 20,-8), S(35,-3) },
+   { S( -6, 8), S(  5, 9), S(  3, 7), S(21,-6) },
+   { S( -6, 8), S( -8,-5), S( -6, 2), S(-2, 4) },
+   { S( -4, 3), S( 20,-9), S( -8, 1), S(-4,18) }
+  },
+  { // Knight
+   { S(-161,-105), S(-96,-82), S(-80,-46), S(-73,-14) },
+   { S( -83, -69), S(-43,-54), S(-21,-17), S(-10,  9) },
+   { S( -71, -50), S(-22,-39), S(  0, -7), S(  9, 28) },
+   { S( -25, -41), S( 18,-25), S( 43,  6), S( 47, 38) },
+   { S( -26, -46), S( 16,-25), S( 38,  3), S( 50, 40) },
+   { S( -11, -54), S( 37,-38), S( 56, -7), S( 65, 27) },
+   { S( -63, -65), S(-19,-50), S(  5,-24), S( 14, 13) },
+   { S(-195,-109), S(-67,-89), S(-42,-50), S(-29,-13) }
+  },
+  { // Bishop
+   { S(-44,-58), S(-13,-31), S(-25,-37), S(-34,-19) },
+   { S(-20,-34), S( 20, -9), S( 12,-14), S(  1,  4) },
+   { S( -9,-23), S( 27,  0), S( 21, -3), S( 11, 16) },
+   { S(-11,-26), S( 28, -3), S( 21, -5), S( 10, 16) },
+   { S(-11,-26), S( 27, -4), S( 16, -7), S(  9, 14) },
+   { S(-17,-24), S( 16, -2), S( 12,  0), S(  2, 13) },
+   { S(-23,-34), S( 17,-10), S(  6,-12), S( -2,  6) },
+   { S(-35,-55), S(-11,-32), S(-19,-36), S(-29,-17) }
+  },
+  { // Rook
+   { S(-25, 0), S(-16, 0), S(-16, 0), S(-9, 0) },
+   { S(-21, 0), S( -8, 0), S( -3, 0), S( 0, 0) },
+   { S(-21, 0), S( -9, 0), S( -4, 0), S( 2, 0) },
+   { S(-22, 0), S( -6, 0), S( -1, 0), S( 2, 0) },
+   { S(-22, 0), S( -7, 0), S(  0, 0), S( 1, 0) },
+   { S(-21, 0), S( -7, 0), S(  0, 0), S( 2, 0) },
+   { S(-12, 0), S(  4, 0), S(  8, 0), S(12, 0) },
+   { S(-23, 0), S(-15, 0), S(-11, 0), S(-5, 0) }
+  },
+  { // Queen
+   { S( 0,-71), S(-4,-56), S(-3,-42), S(-1,-29) },
+   { S(-4,-56), S( 6,-30), S( 9,-21), S( 8, -5) },
+   { S(-2,-39), S( 6,-17), S( 9, -8), S( 9,  5) },
+   { S(-1,-29), S( 8, -5), S(10,  9), S( 7, 19) },
+   { S(-3,-27), S( 9, -5), S( 8, 10), S( 7, 21) },
+   { S(-2,-40), S( 6,-16), S( 8,-10), S(10,  3) },
+   { S(-2,-55), S( 7,-30), S( 7,-21), S( 6, -6) },
+   { S(-1,-74), S(-4,-55), S(-1,-43), S( 0,-30) }
+  },
+  { // King
+   { S(267,  0), S(320, 48), S(270, 75), S(195, 84) },
+   { S(264, 43), S(304, 92), S(238,143), S(180,132) },
+   { S(200, 83), S(245,138), S(176,167), S(110,165) },
+   { S(177,106), S(185,169), S(148,169), S(110,179) },
+   { S(149,108), S(177,163), S(115,200), S( 66,203) },
+   { S(118, 95), S(159,155), S( 84,176), S( 41,174) },
+   { S( 87, 50), S(128, 99), S( 63,122), S( 20,139) },
+   { S( 63,  9), S( 88, 55), S( 47, 80), S(  0, 90) }
+  }
+};
+
+#undef S
+
+Score psq[PIECE_NB][SQUARE_NB];
+
+// init() initializes piece-square tables: the white halves of the tables are
+// copied from Bonus[] adding the piece value, then the black halves of the
+// tables are initialized by flipping and changing the sign of the white scores.
+void init() {
+
+  for (Piece pc = W_PAWN; pc <= W_KING; ++pc)
+  {
+      PieceValue[MG][~pc] = PieceValue[MG][pc];
+      PieceValue[EG][~pc] = PieceValue[EG][pc];
+
+      Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
+
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      {
+          File f = std::min(file_of(s), ~file_of(s));
+          psq[ pc][ s] = v + Bonus[pc][rank_of(s)][f];
+          psq[~pc][~s] = -psq[pc][s];
+      }
+  }
+}
+
+} // namespace PSQT

src/psqtab.h

@@ -1,98 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(PSQTAB_H_INCLUDED)
-#define PSQTAB_H_INCLUDED
-
-#include "types.h"
-
-#define S(mg, eg) make_score(mg, eg)
-
-
-/// PSQT[PieceType][Square] contains Piece-Square scores. For each piece type on
-/// a given square a (midgame, endgame) score pair is assigned. PSQT is defined
-/// for white side, for black side the tables are symmetric.
-
-static const Score PSQT[][64] = {
-  { },
-  { // Pawn
-   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(36,-8), S(36,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(58,-8), S(58,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(36,-8), S(36,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
-   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0)
-  },
-  { // Knight
-   S(-135,-104), S(-107,-79), S(-80,-55), S(-67,-42), S(-67,-42), S(-80,-55), S(-107,-79), S(-135,-104),
-   S( -93, -79), S( -67,-55), S(-39,-30), S(-25,-17), S(-25,-17), S(-39,-30), S( -67,-55), S( -93, -79),
-   S( -53, -55), S( -25,-30), S(  1, -6), S( 13,  5), S( 13,  5), S(  1, -6), S( -25,-30), S( -53, -55),
-   S( -25, -42), S(   1,-17), S( 27,  5), S( 41, 18), S( 41, 18), S( 27,  5), S(   1,-17), S( -25, -42),
-   S( -11, -42), S(  13,-17), S( 41,  5), S( 55, 18), S( 55, 18), S( 41,  5), S(  13,-17), S( -11, -42),
-   S( -11, -55), S(  13,-30), S( 41, -6), S( 55,  5), S( 55,  5), S( 41, -6), S(  13,-30), S( -11, -55),
-   S( -53, -79), S( -25,-55), S(  1,-30), S( 13,-17), S( 13,-17), S(  1,-30), S( -25,-55), S( -53, -79),
-   S(-193,-104), S( -67,-79), S(-39,-55), S(-25,-42), S(-25,-42), S(-39,-55), S( -67,-79), S(-193,-104)
-  },
-  { // Bishop
-   S(-40,-59), S(-40,-42), S(-35,-35), S(-30,-26), S(-30,-26), S(-35,-35), S(-40,-42), S(-40,-59),
-   S(-17,-42), S(  0,-26), S( -4,-18), S(  0,-11), S(  0,-11), S( -4,-18), S(  0,-26), S(-17,-42),
-   S(-13,-35), S( -4,-18), S(  8,-11), S(  4, -4), S(  4, -4), S(  8,-11), S( -4,-18), S(-13,-35),
-   S( -8,-26), S(  0,-11), S(  4, -4), S( 17,  4), S( 17,  4), S(  4, -4), S(  0,-11), S( -8,-26),
-   S( -8,-26), S(  0,-11), S(  4, -4), S( 17,  4), S( 17,  4), S(  4, -4), S(  0,-11), S( -8,-26),
-   S(-13,-35), S( -4,-18), S(  8,-11), S(  4, -4), S(  4, -4), S(  8,-11), S( -4,-18), S(-13,-35),
-   S(-17,-42), S(  0,-26), S( -4,-18), S(  0,-11), S(  0,-11), S( -4,-18), S(  0,-26), S(-17,-42),
-   S(-17,-59), S(-17,-42), S(-13,-35), S( -8,-26), S( -8,-26), S(-13,-35), S(-17,-42), S(-17,-59)
-  },
-  { // Rook
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3)
-  },
-  { // Queen
-   S(8,-80), S(8,-54), S(8,-42), S(8,-30), S(8,-30), S(8,-42), S(8,-54), S(8,-80),
-   S(8,-54), S(8,-30), S(8,-18), S(8, -6), S(8, -6), S(8,-18), S(8,-30), S(8,-54),
-   S(8,-42), S(8,-18), S(8, -6), S(8,  6), S(8,  6), S(8, -6), S(8,-18), S(8,-42),
-   S(8,-30), S(8, -6), S(8,  6), S(8, 18), S(8, 18), S(8,  6), S(8, -6), S(8,-30),
-   S(8,-30), S(8, -6), S(8,  6), S(8, 18), S(8, 18), S(8,  6), S(8, -6), S(8,-30),
-   S(8,-42), S(8,-18), S(8, -6), S(8,  6), S(8,  6), S(8, -6), S(8,-18), S(8,-42),
-   S(8,-54), S(8,-30), S(8,-18), S(8, -6), S(8, -6), S(8,-18), S(8,-30), S(8,-54),
-   S(8,-80), S(8,-54), S(8,-42), S(8,-30), S(8,-30), S(8,-42), S(8,-54), S(8,-80)
-  },
-  { // King
-   S(287, 18), S(311, 77), S(262,105), S(214,135), S(214,135), S(262,105), S(311, 77), S(287, 18),
-   S(262, 77), S(287,135), S(238,165), S(190,193), S(190,193), S(238,165), S(287,135), S(262, 77),
-   S(214,105), S(238,165), S(190,193), S(142,222), S(142,222), S(190,193), S(238,165), S(214,105),
-   S(190,135), S(214,193), S(167,222), S(119,251), S(119,251), S(167,222), S(214,193), S(190,135),
-   S(167,135), S(190,193), S(142,222), S( 94,251), S( 94,251), S(142,222), S(190,193), S(167,135),
-   S(142,105), S(167,165), S(119,193), S( 69,222), S( 69,222), S(119,193), S(167,165), S(142,105),
-   S(119, 77), S(142,135), S( 94,165), S( 46,193), S( 46,193), S( 94,165), S(142,135), S(119, 77),
-   S(94,  18), S(119, 77), S( 69,105), S( 21,135), S( 21,135), S( 69,105), S(119, 77), S( 94, 18)
-  }
-};
-
-#undef S
-
-#endif // !defined(PSQTAB_H_INCLUDED)

src/rkiss.h

@@ -1,78 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-  This file is based on original code by Heinz van Saanen and is
-  available under the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-*/
-
-#if !defined(RKISS_H_INCLUDED)
-#define RKISS_H_INCLUDED
-
-#include "types.h"
-
-/// RKISS is our pseudo random number generator (PRNG) used to compute hash keys.
-/// George Marsaglia invented the RNG-Kiss-family in the early 90's. This is a
-/// specific version that Heinz van Saanen derived from some public domain code
-/// by Bob Jenkins. Following the feature list, as tested by Heinz.
-///
-/// - Quite platform independent
-/// - Passes ALL dieharder tests! Here *nix sys-rand() e.g. fails miserably:-)
-/// - ~12 times faster than my *nix sys-rand()
-/// - ~4 times faster than SSE2-version of Mersenne twister
-/// - Average cycle length: ~2^126
-/// - 64 bit seed
-/// - Return doubles with a full 53 bit mantissa
-/// - Thread safe
-
-class RKISS {
-
-  // Keep variables always together
-  struct S { uint64_t a, b, c, d; } s;
-
-  uint64_t rotate(uint64_t x, uint64_t k) const {
-    return (x << k) | (x >> (64 - k));
-  }
-
-  // Return 64 bit unsigned integer in between [0, 2^64 - 1]
-  uint64_t rand64() {
-
-    const uint64_t
-      e = s.a - rotate(s.b,  7);
-    s.a = s.b ^ rotate(s.c, 13);
-    s.b = s.c + rotate(s.d, 37);
-    s.c = s.d + e;
-    return s.d = e + s.a;
-  }
-
-  // Init seed and scramble a few rounds
-  void raninit() {
-
-    s.a = 0xf1ea5eed;
-    s.b = s.c = s.d = 0xd4e12c77;
-    for (int i = 0; i < 73; i++)
-        rand64();
-  }
-
-public:
-  RKISS() { raninit(); }
-  template<typename T> T rand() { return T(rand64()); }
-};
-
-#endif // !defined(RKISS_H_INCLUDED)

src/search.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,66 +18,89 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(SEARCH_H_INCLUDED)
+#ifndef SEARCH_H_INCLUDED
 #define SEARCH_H_INCLUDED
 
-#include <cstring>
 #include <vector>
 
+#include "misc.h"
+#include "movepick.h"
 #include "types.h"
 
 class Position;
-struct SplitPoint;
 
 namespace Search {
 
-/// The Stack struct keeps track of the information we need to remember from
+/// Threshold used for countermoves based pruning
-/// nodes shallower and deeper in the tree during the search. Each search thread
+const int CounterMovePruneThreshold = 0;
-/// has its own array of Stack objects, indexed by the current ply.
+
+
+/// Stack struct keeps track of the information we need to remember from nodes
+/// shallower and deeper in the tree during the search. Each search thread has
+/// its own array of Stack objects, indexed by the current ply.
 
 struct Stack {
-  SplitPoint* sp;
+  Move* pv;
+  PieceToHistory* contHistory;
   int ply;
   Move currentMove;
   Move excludedMove;
-  Move bestMove;
   Move killers[2];
-  Depth reduction;
+  Value staticEval;
-  Value eval;
+  int statScore;
-  Value evalMargin;
+  int moveCount;
-  int skipNullMove;
 };
 
 
-/// The LimitsType struct stores information sent by GUI about available time
+/// RootMove struct is used for moves at the root of the tree. For each root move
-/// to search the current move, maximum depth/time, if we are in analysis mode
+/// we store a score and a PV (really a refutation in the case of moves which
-/// or if we have to ponder while is our opponent's side to move.
+/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
+
+struct RootMove {
+
+  explicit RootMove(Move m) : pv(1, m) {}
+  bool extract_ponder_from_tt(Position& pos);
+  bool operator==(const Move& m) const { return pv[0] == m; }
+  bool operator<(const RootMove& m) const { // Sort in descending order
+    return m.score != score ? m.score < score
+                            : m.previousScore < previousScore;
+  }
+
+  Value score = -VALUE_INFINITE;
+  Value previousScore = -VALUE_INFINITE;
+  int selDepth = 0;
+  std::vector<Move> pv;
+};
+
+typedef std::vector<RootMove> RootMoves;
+
+
+/// LimitsType struct stores information sent by GUI about available time to
+/// search the current move, maximum depth/time, or if we are in analysis mode.
 
 struct LimitsType {
 
-  LimitsType() {  memset(this, 0, sizeof(LimitsType)); }
+  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
-  bool useTimeManagement() const { return !(maxTime | maxDepth | maxNodes | infinite); }
+    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
+    npmsec = movestogo = depth = movetime = mate = perft = infinite = 0;
+  }
 
-  int time, increment, movesToGo, maxTime, maxDepth, maxNodes, infinite, ponder;
+  bool use_time_management() const {
+    return !(mate | movetime | depth | nodes | perft | infinite);
+  }
+
+  std::vector<Move> searchmoves;
+  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth,
+      movetime, mate, perft, infinite;
+  int64_t nodes;
+  TimePoint startTime;
 };
 
-
-/// The SignalsType struct stores volatile flags updated during the search
-/// typically in an async fashion, for instance to stop the search by the GUI.
-
-struct SignalsType {
-  bool stopOnPonderhit, firstRootMove, stop, failedLowAtRoot;
-};
-
-extern volatile SignalsType Signals;
 extern LimitsType Limits;
-extern std::vector<Move> SearchMoves;
-extern Position RootPosition;
 
-extern void init();
+void init();
-extern int64_t perft(Position& pos, Depth depth);
+void clear();
-extern void think();
 
-} // namespace
+} // namespace Search
 
-#endif // !defined(SEARCH_H_INCLUDED)
+#endif // #ifndef SEARCH_H_INCLUDED

src/syzygy/tbprobe.h

@@ -0,0 +1,79 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (c) 2013 Ronald de Man
+  Copyright (C) 2016-2018 Marco Costalba, Lucas Braesch
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef TBPROBE_H
+#define TBPROBE_H
+
+#include <ostream>
+
+#include "../search.h"
+
+namespace Tablebases {
+
+enum WDLScore {
+    WDLLoss        = -2, // Loss
+    WDLBlessedLoss = -1, // Loss, but draw under 50-move rule
+    WDLDraw        =  0, // Draw
+    WDLCursedWin   =  1, // Win, but draw under 50-move rule
+    WDLWin         =  2, // Win
+
+    WDLScoreNone  = -1000
+};
+
+// Possible states after a probing operation
+enum ProbeState {
+    FAIL              =  0, // Probe failed (missing file table)
+    OK                =  1, // Probe succesful
+    CHANGE_STM        = -1, // DTZ should check the other side
+    ZEROING_BEST_MOVE =  2  // Best move zeroes DTZ (capture or pawn move)
+};
+
+extern int MaxCardinality;
+
+void init(const std::string& paths);
+WDLScore probe_wdl(Position& pos, ProbeState* result);
+int probe_dtz(Position& pos, ProbeState* result);
+bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score);
+bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score);
+void filter_root_moves(Position& pos, Search::RootMoves& rootMoves);
+
+inline std::ostream& operator<<(std::ostream& os, const WDLScore v) {
+
+    os << (v == WDLLoss        ? "Loss" :
+           v == WDLBlessedLoss ? "Blessed loss" :
+           v == WDLDraw        ? "Draw" :
+           v == WDLCursedWin   ? "Cursed win" :
+           v == WDLWin         ? "Win" : "None");
+
+    return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const ProbeState v) {
+
+    os << (v == FAIL              ? "Failed" :
+           v == OK                ? "Success" :
+           v == CHANGE_STM        ? "Probed opponent side" :
+           v == ZEROING_BEST_MOVE ? "Best move zeroes DTZ" : "None");
+
+    return os;
+}
+
+}
+
+#endif

src/thread.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,485 +18,182 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <iostream>
+#include <algorithm> // For std::count
+#include <cassert>
 
+#include "movegen.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
-using namespace Search;
+ThreadPool Threads; // Global object
-
-ThreadsManager Threads; // Global object
-
-namespace { extern "C" {
-
- // start_routine() is the C function which is called when a new thread
- // is launched. It simply calls idle_loop() of the supplied thread. The first
- // and last thread are special. First one is the main search thread while the
- // last one mimics a timer, they run in main_loop() and timer_loop().
-
-#if defined(_MSC_VER)
-  DWORD WINAPI start_routine(LPVOID thread) {
-#else
-  void* start_routine(void* thread) {
-#endif
-
-    Thread* th = (Thread*)thread;
-
-    if (th->threadID == 0)
-        th->main_loop();
-
-    else if (th->threadID == MAX_THREADS)
-        th->timer_loop();
-
-    else
-        th->idle_loop(NULL);
-
-    return 0;
-  }
-
-} }
 
 
-// wake_up() wakes up the thread, normally at the beginning of the search or,
+/// Thread constructor launches the thread and waits until it goes to sleep
-// if "sleeping threads" is used, when there is some work to do.
+/// in idle_loop(). Note that 'searching' and 'exit' should be alredy set.
 
-void Thread::wake_up() {
+Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) {
 
-  lock_grab(&sleepLock);
+  wait_for_search_finished();
-  cond_signal(&sleepCond);
-  lock_release(&sleepLock);
 }
 
 
-// cutoff_occurred() checks whether a beta cutoff has occurred in the current
+/// Thread destructor wakes up the thread in idle_loop() and waits
-// active split point, or in some ancestor of the split point.
+/// for its termination. Thread should be already waiting.
 
-bool Thread::cutoff_occurred() const {
+Thread::~Thread() {
 
-  for (SplitPoint* sp = splitPoint; sp; sp = sp->parent)
+  assert(!searching);
-      if (sp->is_betaCutoff)
-          return true;
 
-  return false;
+  exit = true;
+  start_searching();
+  stdThread.join();
 }
 
 
-// is_available_to() checks whether the thread is available to help the thread with
+/// Thread::clear() reset histories, usually before a new game
-// threadID "master" at a split point. An obvious requirement is that thread must be
-// idle. With more than two threads, this is not by itself sufficient: If the thread
-// is the master of some active split point, it is only available as a slave to the
-// threads which are busy searching the split point at the top of "slave"'s split
-// point stack (the "helpful master concept" in YBWC terminology).
 
-bool Thread::is_available_to(int master) const {
+void Thread::clear() {
 
-  if (is_searching)
+  counterMoves.fill(MOVE_NONE);
-      return false;
+  mainHistory.fill(0);
+  captureHistory.fill(0);
 
-  // Make a local copy to be sure doesn't become zero under our feet while
+  for (auto& to : contHistory)
-  // testing next condition and so leading to an out of bound access.
+      for (auto& h : to)
-  int localActiveSplitPoints = activeSplitPoints;
+          h.fill(0);
 
-  // No active split points means that the thread is available as a slave for any
+  contHistory[NO_PIECE][0].fill(Search::CounterMovePruneThreshold - 1);
-  // other thread otherwise apply the "helpful master" concept if possible.
+}
-  if (   !localActiveSplitPoints
-      || splitPoints[localActiveSplitPoints - 1].is_slave[master])
-      return true;
 
-  return false;
+/// Thread::start_searching() wakes up the thread that will start the search
+
+void Thread::start_searching() {
+
+  std::lock_guard<Mutex> lk(mutex);
+  searching = true;
+  cv.notify_one(); // Wake up the thread in idle_loop()
 }
 
 
-// read_uci_options() updates number of active threads and other parameters
+/// Thread::wait_for_search_finished() blocks on the condition variable
-// according to the UCI options values. It is called before to start a new search.
+/// until the thread has finished searching.
 
-void ThreadsManager::read_uci_options() {
+void Thread::wait_for_search_finished() {
 
-  maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
+  std::unique_lock<Mutex> lk(mutex);
-  minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
+  cv.wait(lk, [&]{ return !searching; });
-  useSleepingThreads      = Options["Use Sleeping Threads"];
-
-  set_size(Options["Threads"]);
 }
 
 
-// set_size() changes the number of active threads and raises do_sleep flag for
+/// Thread::idle_loop() is where the thread is parked, blocked on the
-// all the unused threads that will go immediately to sleep.
+/// condition variable, when it has no work to do.
-
+
-void ThreadsManager::set_size(int cnt) {
+void Thread::idle_loop() {
-
+
-  assert(cnt > 0 && cnt <= MAX_THREADS);
+  // If OS already scheduled us on a different group than 0 then don't overwrite
-
+  // the choice, eventually we are one of many one-threaded processes running on
-  activeThreads = cnt;
+  // some Windows NUMA hardware, for instance in fishtest. To make it simple,
-
+  // just check if running threads are below a threshold, in this case all this
-  for (int i = 1; i < MAX_THREADS; i++) // Ignore main thread
+  // NUMA machinery is not needed.
-      if (i < activeThreads)
+  if (Options["Threads"] >= 8)
-      {
+      WinProcGroup::bindThisThread(idx);
-          // Dynamically allocate pawn and material hash tables according to the
-          // number of active threads. This avoids preallocating memory for all
-          // possible threads if only few are used.
-          threads[i].pawnTable.init();
-          threads[i].materialTable.init();
-
-          threads[i].do_sleep = false;
-      }
-      else
-          threads[i].do_sleep = true;
-}
-
-
-// init() is called during startup. Initializes locks and condition variables
-// and launches all threads sending them immediately to sleep.
-
-void ThreadsManager::init() {
-
-  // Initialize sleep condition and lock used by thread manager
-  cond_init(&sleepCond);
-  lock_init(&threadsLock);
-
-  // Initialize thread's sleep conditions and split point locks
-  for (int i = 0; i <= MAX_THREADS; i++)
-  {
-      lock_init(&threads[i].sleepLock);
-      cond_init(&threads[i].sleepCond);
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_init(&(threads[i].splitPoints[j].lock));
-  }
-
-  // Allocate main thread tables to call evaluate() also when not searching
-  threads[0].pawnTable.init();
-  threads[0].materialTable.init();
-
-  // Create and launch all the threads, threads will go immediately to sleep
-  for (int i = 0; i <= MAX_THREADS; i++)
-  {
-      threads[i].is_searching = false;
-      threads[i].do_sleep = true;
-      threads[i].threadID = i;
-
-#if defined(_MSC_VER)
-      threads[i].handle = CreateThread(NULL, 0, start_routine, &threads[i], 0, NULL);
-      bool ok = (threads[i].handle != NULL);
-#else
-      bool ok = !pthread_create(&threads[i].handle, NULL, start_routine, &threads[i]);
-#endif
-
-      if (!ok)
-      {
-          std::cerr << "Failed to create thread number " << i << std::endl;
-          ::exit(EXIT_FAILURE);
-      }
-  }
-}
-
-
-// exit() is called to cleanly terminate the threads when the program finishes
-
-void ThreadsManager::exit() {
-
-  for (int i = 0; i <= MAX_THREADS; i++)
-  {
-      threads[i].do_terminate = true; // Search must be already finished
-      threads[i].wake_up();
-
-      // Wait for thread termination
-#if defined(_MSC_VER)
-      WaitForSingleObject(threads[i].handle, 0);
-      CloseHandle(threads[i].handle);
-#else
-      pthread_join(threads[i].handle, NULL);
-#endif
-
-      // Now we can safely destroy associated locks and wait conditions
-      lock_destroy(&threads[i].sleepLock);
-      cond_destroy(&threads[i].sleepCond);
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_destroy(&(threads[i].splitPoints[j].lock));
-  }
-
-  lock_destroy(&threadsLock);
-  cond_destroy(&sleepCond);
-}
-
-
-// available_slave_exists() tries to find an idle thread which is available as
-// a slave for the thread with threadID 'master'.
-
-bool ThreadsManager::available_slave_exists(int master) const {
-
-  assert(master >= 0 && master < activeThreads);
-
-  for (int i = 0; i < activeThreads; i++)
-      if (threads[i].is_available_to(master))
-          return true;
-
-  return false;
-}
-
-
-// split_point_finished() checks if all the slave threads of a given split
-// point have finished searching.
-
-bool ThreadsManager::split_point_finished(SplitPoint* sp) const {
-
-  for (int i = 0; i < activeThreads; i++)
-      if (sp->is_slave[i])
-          return false;
-
-  return true;
-}
-
-
-// split() does the actual work of distributing the work at a node between
-// several available threads. If it does not succeed in splitting the node
-// (because no idle threads are available, or because we have no unused split
-// point objects), the function immediately returns. If splitting is possible, a
-// SplitPoint object is initialized with all the data that must be copied to the
-// helper threads and then helper threads are told that they have been assigned
-// work. This will cause them to instantly leave their idle loops and call
-// search(). When all threads have returned from search() then split() returns.
-
-template <bool Fake>
-Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
-                            Value bestValue, Depth depth, Move threatMove,
-                            int moveCount, MovePicker* mp, int nodeType) {
-  assert(pos.pos_is_ok());
-  assert(bestValue > -VALUE_INFINITE);
-  assert(bestValue <= alpha);
-  assert(alpha < beta);
-  assert(beta <= VALUE_INFINITE);
-  assert(depth > DEPTH_ZERO);
-  assert(pos.thread() >= 0 && pos.thread() < activeThreads);
-  assert(activeThreads > 1);
-
-  int i, master = pos.thread();
-  Thread& masterThread = threads[master];
-
-  // If we already have too many active split points, don't split
-  if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
-      return bestValue;
-
-  // Pick the next available split point from the split point stack
-  SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints];
-
-  // Initialize the split point
-  sp->parent = masterThread.splitPoint;
-  sp->master = master;
-  sp->is_betaCutoff = false;
-  sp->depth = depth;
-  sp->threatMove = threatMove;
-  sp->alpha = alpha;
-  sp->beta = beta;
-  sp->nodeType = nodeType;
-  sp->bestValue = bestValue;
-  sp->mp = mp;
-  sp->moveCount = moveCount;
-  sp->pos = &pos;
-  sp->nodes = 0;
-  sp->ss = ss;
-
-  for (i = 0; i < activeThreads; i++)
-      sp->is_slave[i] = false;
-
-  // If we are here it means we are not available
-  assert(masterThread.is_searching);
-
-  int workersCnt = 1; // At least the master is included
-
-  // Try to allocate available threads and ask them to start searching setting
-  // is_searching flag. This must be done under lock protection to avoid concurrent
-  // allocation of the same slave by another master.
-  lock_grab(&threadsLock);
-
-  for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
-      if (threads[i].is_available_to(master))
-      {
-          workersCnt++;
-          sp->is_slave[i] = true;
-          threads[i].splitPoint = sp;
-
-          // This makes the slave to exit from idle_loop()
-          threads[i].is_searching = true;
-
-          if (useSleepingThreads)
-              threads[i].wake_up();
-      }
-
-  lock_release(&threadsLock);
-
-  // We failed to allocate even one slave, return
-  if (!Fake && workersCnt == 1)
-      return bestValue;
-
-  masterThread.splitPoint = sp;
-  masterThread.activeSplitPoints++;
-
-  // Everything is set up. The master thread enters the idle loop, from which
-  // it will instantly launch a search, because its is_searching flag is set.
-  // We pass the split point as a parameter to the idle loop, which means that
-  // the thread will return from the idle loop when all slaves have finished
-  // their work at this split point.
-  masterThread.idle_loop(sp);
-
-  // In helpful master concept a master can help only a sub-tree of its split
-  // point, and because here is all finished is not possible master is booked.
-  assert(!masterThread.is_searching);
-
-  // We have returned from the idle loop, which means that all threads are
-  // finished. Note that changing state and decreasing activeSplitPoints is done
-  // under lock protection to avoid a race with Thread::is_available_to().
-  lock_grab(&threadsLock);
-
-  masterThread.is_searching = true;
-  masterThread.activeSplitPoints--;
-
-  lock_release(&threadsLock);
-
-  masterThread.splitPoint = sp->parent;
-  pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
-
-  return sp->bestValue;
-}
-
-// Explicit template instantiations
-template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
-template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
-
-
-// Thread::timer_loop() is where the timer thread waits maxPly milliseconds and
-// then calls do_timer_event(). If maxPly is 0 thread sleeps until is woken up.
-extern void do_timer_event();
-
-void Thread::timer_loop() {
-
-  while (!do_terminate)
-  {
-      lock_grab(&sleepLock);
-      timed_wait(&sleepCond, &sleepLock, maxPly ? maxPly : INT_MAX);
-      lock_release(&sleepLock);
-      do_timer_event();
-  }
-}
-
-
-// ThreadsManager::set_timer() is used to set the timer to trigger after msec
-// milliseconds. If msec is 0 then timer is stopped.
-
-void ThreadsManager::set_timer(int msec) {
-
-  Thread& timer = threads[MAX_THREADS];
-
-  lock_grab(&timer.sleepLock);
-  timer.maxPly = msec;
-  cond_signal(&timer.sleepCond); // Wake up and restart the timer
-  lock_release(&timer.sleepLock);
-}
-
-
-// Thread::main_loop() is where the main thread is parked waiting to be started
-// when there is a new search. Main thread will launch all the slave threads.
-
-void Thread::main_loop() {
 
   while (true)
   {
-      lock_grab(&sleepLock);
+      std::unique_lock<Mutex> lk(mutex);
+      searching = false;
+      cv.notify_one(); // Wake up anyone waiting for search finished
+      cv.wait(lk, [&]{ return searching; });
 
-      do_sleep = true; // Always return to sleep after a search
+      if (exit)
-      is_searching = false;
-
-      while (do_sleep && !do_terminate)
-      {
-          cond_signal(&Threads.sleepCond); // Wake up UI thread if needed
-          cond_wait(&sleepCond, &sleepLock);
-      }
-
-      is_searching = true;
-
-      lock_release(&sleepLock);
-
-      if (do_terminate)
           return;
 
-      think(); // This is the search entry point
+      lk.unlock();
+
+      search();
   }
 }
 
+/// ThreadPool::set() creates/destroys threads to match the requested number.
+/// Created and launced threads wil go immediately to sleep in idle_loop.
+/// Upon resizing, threads are recreated to allow for binding if necessary.
 
-// ThreadsManager::start_thinking() is used by UI thread to wake up the main
+void ThreadPool::set(size_t requested) {
-// thread parked in main_loop() and starting a new search. If asyncMode is true
-// then function returns immediately, otherwise caller is blocked waiting for
-// the search to finish.
 
-void ThreadsManager::start_thinking(const Position& pos, const LimitsType& limits,
+  if (size() > 0) { // destroy any existing thread(s)
-                                    const std::vector<Move>& searchMoves, bool asyncMode) {
+      main()->wait_for_search_finished();
-  Thread& main = threads[0];
 
-  lock_grab(&main.sleepLock);
+      while (size() > 0)
-
+          delete back(), pop_back();
-  // Wait main thread has finished before to launch a new search
-  while (!main.do_sleep)
-      cond_wait(&sleepCond, &main.sleepLock);
-
-  // Copy input arguments to initialize the search
-  RootPosition.copy(pos, 0);
-  Limits = limits;
-  SearchMoves = searchMoves;
-
-  // Reset signals before to start the new search
-  memset((void*)&Signals, 0, sizeof(Signals));
-
-  main.do_sleep = false;
-  cond_signal(&main.sleepCond); // Wake up main thread and start searching
-
-  if (!asyncMode)
-      cond_wait(&sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
   }
 
+  if (requested > 0) { // create new thread(s)
+      push_back(new MainThread(0));
 
-// ThreadsManager::stop_thinking() is used by UI thread to raise a stop request
+      while (size() < requested)
-// and to wait for the main thread finishing the search. Needed to wait exiting
+          push_back(new Thread(size()));
-// and terminate the threads after a 'quit' command.
+      clear();
-
+  }
-void ThreadsManager::stop_thinking() {
-
-  Thread& main = threads[0];
-
-  Search::Signals.stop = true;
-
-  lock_grab(&main.sleepLock);
-
-  cond_signal(&main.sleepCond); // In case is waiting for stop or ponderhit
-
-  while (!main.do_sleep)
-      cond_wait(&sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
 }
 
+/// ThreadPool::clear() sets threadPool data to initial values.
 
-// ThreadsManager::wait_for_stop_or_ponderhit() is called when the maximum depth
+void ThreadPool::clear() {
-// is reached while the program is pondering. The point is to work around a wrinkle
-// in the UCI protocol: When pondering, the engine is not allowed to give a
-// "bestmove" before the GUI sends it a "stop" or "ponderhit" command. We simply
-// wait here until one of these commands (that raise StopRequest) is sent and
-// then return, after which the bestmove and pondermove will be printed.
 
-void ThreadsManager::wait_for_stop_or_ponderhit() {
+  for (Thread* th : *this)
+      th->clear();
 
-  Signals.stopOnPonderhit = true;
+  main()->callsCnt = 0;
-
+  main()->previousScore = VALUE_INFINITE;
-  Thread& main = threads[0];
+  main()->previousTimeReduction = 1;
-
+}
-  lock_grab(&main.sleepLock);
+
-
+/// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and
-  while (!Signals.stop)
+/// returns immediately. Main thread will wake up other threads and start the search.
-      cond_wait(&main.sleepCond, &main.sleepLock);
+
-
+void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
-  lock_release(&main.sleepLock);
+                                const Search::LimitsType& limits, bool ponderMode) {
+
+  main()->wait_for_search_finished();
+
+  stopOnPonderhit = stop = false;
+  ponder = ponderMode;
+  Search::Limits = limits;
+  Search::RootMoves rootMoves;
+
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (   limits.searchmoves.empty()
+          || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
+          rootMoves.emplace_back(m);
+
+  if (!rootMoves.empty())
+      Tablebases::filter_root_moves(pos, rootMoves);
+
+  // After ownership transfer 'states' becomes empty, so if we stop the search
+  // and call 'go' again without setting a new position states.get() == NULL.
+  assert(states.get() || setupStates.get());
+
+  if (states.get())
+      setupStates = std::move(states); // Ownership transfer, states is now empty
+
+  // We use Position::set() to set root position across threads. But there are
+  // some StateInfo fields (previous, pliesFromNull, capturedPiece) that cannot
+  // be deduced from a fen string, so set() clears them and to not lose the info
+  // we need to backup and later restore setupStates->back(). Note that setupStates
+  // is shared by threads but is accessed in read-only mode.
+  StateInfo tmp = setupStates->back();
+
+  for (Thread* th : *this)
+  {
+      th->nodes = th->tbHits = th->nmp_ply = th->nmp_odd = 0;
+      th->rootDepth = th->completedDepth = DEPTH_ZERO;
+      th->rootMoves = rootMoves;
+      th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th);
+  }
+
+  setupStates->back() = tmp;
+
+  main()->start_searching();
 }

src/thread.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,126 +18,106 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(THREAD_H_INCLUDED)
+#ifndef THREAD_H_INCLUDED
 #define THREAD_H_INCLUDED
 
-#include <cstring>
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <vector>
 
-#include "lock.h"
 #include "material.h"
 #include "movepick.h"
 #include "pawns.h"
 #include "position.h"
 #include "search.h"
-
+#include "thread_win32.h"
-const int MAX_THREADS = 32;
-const int MAX_ACTIVE_SPLIT_POINTS = 8;
-
-struct SplitPoint {
-
-  // Const data after splitPoint has been setup
-  SplitPoint* parent;
-  const Position* pos;
-  Depth depth;
-  Value beta;
-  int nodeType;
-  int ply;
-  int master;
-  Move threatMove;
-
-  // Const pointers to shared data
-  MovePicker* mp;
-  Search::Stack* ss;
-
-  // Shared data
-  Lock lock;
-  volatile int64_t nodes;
-  volatile Value alpha;
-  volatile Value bestValue;
-  volatile int moveCount;
-  volatile bool is_betaCutoff;
-  volatile bool is_slave[MAX_THREADS];
-};
 
 
-/// Thread struct keeps together all the thread related stuff like locks, state
+/// Thread class keeps together all the thread-related stuff. We use
-/// and especially split points. We also use per-thread pawn and material hash
+/// per-thread pawn and material hash tables so that once we get a
-/// tables so that once we get a pointer to an entry its life time is unlimited
+/// pointer to an entry its life time is unlimited and we don't have
-/// and we don't have to care about someone changing the entry under our feet.
+/// to care about someone changing the entry under our feet.
 
-struct Thread {
+class Thread {
 
-  void wake_up();
+  Mutex mutex;
-  bool cutoff_occurred() const;
+  ConditionVariable cv;
-  bool is_available_to(int master) const;
+  size_t idx;
-  void idle_loop(SplitPoint* sp);
+  bool exit = false, searching = true; // Set before starting std::thread
-  void main_loop();
+  std::thread stdThread;
-  void timer_loop();
 
-  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
-  MaterialInfoTable materialTable;
-  PawnInfoTable pawnTable;
-  int threadID;
-  int maxPly;
-  Lock sleepLock;
-  WaitCondition sleepCond;
-  SplitPoint* volatile splitPoint;
-  volatile int activeSplitPoints;
-  volatile bool is_searching;
-  volatile bool do_sleep;
-  volatile bool do_terminate;
-
-#if defined(_MSC_VER)
-  HANDLE handle;
-#else
-  pthread_t handle;
-#endif
-};
-
-
-/// ThreadsManager class handles all the threads related stuff like init, starting,
-/// parking and, the most important, launching a slave thread at a split point.
-/// All the access to shared thread data is done through this class.
-
-class ThreadsManager {
-  /* As long as the single ThreadsManager object is defined as a global we don't
-     need to explicitly initialize to zero its data members because variables with
-     static storage duration are automatically set to zero before enter main()
-  */
 public:
-  Thread& operator[](int threadID) { return threads[threadID]; }
+  explicit Thread(size_t);
-  void init();
+  virtual ~Thread();
-  void exit();
+  virtual void search();
+  void clear();
+  void idle_loop();
+  void start_searching();
+  void wait_for_search_finished();
 
-  bool use_sleeping_threads() const { return useSleepingThreads; }
+  Pawns::Table pawnsTable;
-  int min_split_depth() const { return minimumSplitDepth; }
+  Material::Table materialTable;
-  int size() const { return activeThreads; }
+  Endgames endgames;
+  size_t PVIdx;
+  int selDepth, nmp_ply, nmp_odd;
+  std::atomic<uint64_t> nodes, tbHits;
 
-  void set_size(int cnt);
+  Position rootPos;
-  void read_uci_options();
+  Search::RootMoves rootMoves;
-  bool available_slave_exists(int master) const;
+  Depth rootDepth, completedDepth;
-  bool split_point_finished(SplitPoint* sp) const;
+  CounterMoveHistory counterMoves;
-  void set_timer(int msec);
+  ButterflyHistory mainHistory;
-  void wait_for_stop_or_ponderhit();
+  CapturePieceToHistory captureHistory;
-  void stop_thinking();
+  ContinuationHistory contHistory;
-  void start_thinking(const Position& pos, const Search::LimitsType& limits,
-                      const std::vector<Move>& searchMoves, bool asyncMode);
-
-  template <bool Fake>
-  Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue,
-              Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
-private:
-  friend struct Thread;
-
-  Thread threads[MAX_THREADS + 1]; // Last one is used as a timer
-  Lock threadsLock;
-  Depth minimumSplitDepth;
-  int maxThreadsPerSplitPoint;
-  int activeThreads;
-  bool useSleepingThreads;
-  WaitCondition sleepCond;
 };
 
-extern ThreadsManager Threads;
 
-#endif // !defined(THREAD_H_INCLUDED)
+/// MainThread is a derived class specific for main thread
+
+struct MainThread : public Thread {
+
+  using Thread::Thread;
+
+  void search() override;
+  void check_time();
+
+  bool failedLow;
+  double bestMoveChanges, previousTimeReduction;
+  Value previousScore;
+  int callsCnt;
+};
+
+
+/// ThreadPool struct handles all the threads-related stuff like init, starting,
+/// parking and, most importantly, launching a thread. All the access to threads
+/// is done through this class.
+
+struct ThreadPool : public std::vector<Thread*> {
+
+  void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false);
+  void clear();
+  void set(size_t);
+
+  MainThread* main()        const { return static_cast<MainThread*>(front()); }
+  uint64_t nodes_searched() const { return accumulate(&Thread::nodes); }
+  uint64_t tb_hits()        const { return accumulate(&Thread::tbHits); }
+
+  std::atomic_bool stop, ponder, stopOnPonderhit;
+
+private:
+  StateListPtr setupStates;
+
+  uint64_t accumulate(std::atomic<uint64_t> Thread::* member) const {
+
+    uint64_t sum = 0;
+    for (Thread* th : *this)
+        sum += (th->*member).load(std::memory_order_relaxed);
+    return sum;
+  }
+};
+
+extern ThreadPool Threads;
+
+#endif // #ifndef THREAD_H_INCLUDED

src/thread_win32.h

@@ -0,0 +1,70 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef THREAD_WIN32_H_INCLUDED
+#define THREAD_WIN32_H_INCLUDED
+
+/// STL thread library used by mingw and gcc when cross compiling for Windows
+/// relies on libwinpthread. Currently libwinpthread implements mutexes directly
+/// on top of Windows semaphores. Semaphores, being kernel objects, require kernel
+/// mode transition in order to lock or unlock, which is very slow compared to
+/// interlocked operations (about 30% slower on bench test). To work around this
+/// issue, we define our wrappers to the low level Win32 calls. We use critical
+/// sections to support Windows XP and older versions. Unfortunately, cond_wait()
+/// is racy between unlock() and WaitForSingleObject() but they have the same
+/// speed performance as the SRW locks.
+
+#include <condition_variable>
+#include <mutex>
+
+#if defined(_WIN32) && !defined(_MSC_VER)
+
+#ifndef NOMINMAX
+#  define NOMINMAX // Disable macros min() and max()
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#undef NOMINMAX
+
+/// Mutex and ConditionVariable struct are wrappers of the low level locking
+/// machinery and are modeled after the corresponding C++11 classes.
+
+struct Mutex {
+  Mutex() { InitializeCriticalSection(&cs); }
+ ~Mutex() { DeleteCriticalSection(&cs); }
+  void lock() { EnterCriticalSection(&cs); }
+  void unlock() { LeaveCriticalSection(&cs); }
+
+private:
+  CRITICAL_SECTION cs;
+};
+
+typedef std::condition_variable_any ConditionVariable;
+
+#else // Default case: use STL classes
+
+typedef std::mutex Mutex;
+typedef std::condition_variable ConditionVariable;
+
+#endif
+
+#endif // #ifndef THREAD_WIN32_H_INCLUDED

src/timeman.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,146 +18,115 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cmath>
 #include <algorithm>
+#include <cfloat>
+#include <cmath>
 
-#include "misc.h"
 #include "search.h"
 #include "timeman.h"
-#include "ucioption.h"
+#include "uci.h"
+
+TimeManagement Time; // Our global time management object
 
 namespace {
 
-  /// Constants
-
-  const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
-  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
-  const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio
-
-
-  // MoveImportance[] is based on naive statistical analysis of "how many games are still undecided
-  // after n half-moves". Game is considered "undecided" as long as neither side has >275cp advantage.
-  // Data was extracted from CCRL game database with some simple filtering criteria.
-  const int MoveImportance[512] = {
-    7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780,
-    7780, 7780, 7780, 7780, 7778, 7778, 7776, 7776, 7776, 7773, 7770, 7768, 7766, 7763, 7757, 7751,
-    7743, 7735, 7724, 7713, 7696, 7689, 7670, 7656, 7627, 7605, 7571, 7549, 7522, 7493, 7462, 7425,
-    7385, 7350, 7308, 7272, 7230, 7180, 7139, 7094, 7055, 7010, 6959, 6902, 6841, 6778, 6705, 6651,
-    6569, 6508, 6435, 6378, 6323, 6253, 6152, 6085, 5995, 5931, 5859, 5794, 5717, 5646, 5544, 5462,
-    5364, 5282, 5172, 5078, 4988, 4901, 4831, 4764, 4688, 4609, 4536, 4443, 4365, 4293, 4225, 4155,
-    4085, 4005, 3927, 3844, 3765, 3693, 3634, 3560, 3479, 3404, 3331, 3268, 3207, 3146, 3077, 3011,
-    2947, 2894, 2828, 2776, 2727, 2676, 2626, 2589, 2538, 2490, 2442, 2394, 2345, 2302, 2243, 2192,
-    2156, 2115, 2078, 2043, 2004, 1967, 1922, 1893, 1845, 1809, 1772, 1736, 1702, 1674, 1640, 1605,
-    1566, 1536, 1509, 1479, 1452, 1423, 1388, 1362, 1332, 1304, 1289, 1266, 1250, 1228, 1206, 1180,
-    1160, 1134, 1118, 1100, 1080, 1068, 1051, 1034, 1012, 1001, 980, 960, 945, 934, 916, 900, 888,
-    878, 865, 852, 828, 807, 787, 770, 753, 744, 731, 722, 706, 700, 683, 676, 671, 664, 652, 641,
-    634, 627, 613, 604, 591, 582, 568, 560, 552, 540, 534, 529, 519, 509, 495, 484, 474, 467, 460,
-    450, 438, 427, 419, 410, 406, 399, 394, 387, 382, 377, 372, 366, 359, 353, 348, 343, 337, 333,
-    328, 321, 315, 309, 303, 298, 293, 287, 284, 281, 277, 273, 265, 261, 255, 251, 247, 241, 240,
-    235, 229, 218, 217, 213, 212, 208, 206, 197, 193, 191, 189, 185, 184, 180, 177, 172, 170, 170,
-    170, 166, 163, 159, 158, 156, 155, 151, 146, 141, 138, 136, 132, 130, 128, 125, 123, 122, 118,
-    118, 118, 117, 115, 114, 108, 107, 105, 105, 105, 102, 97, 97, 95, 94, 93, 91, 88, 86, 83, 80,
-    80, 79, 79, 79, 78, 76, 75, 72, 72, 71, 70, 68, 65, 63, 61, 61, 59, 59, 59, 58, 56, 55, 54, 54,
-    52, 49, 48, 48, 48, 48, 45, 45, 45, 44, 43, 41, 41, 41, 41, 40, 40, 38, 37, 36, 34, 34, 34, 33,
-    31, 29, 29, 29, 28, 28, 28, 28, 28, 28, 28, 27, 27, 27, 27, 27, 24, 24, 23, 23, 22, 21, 20, 20,
-    19, 19, 19, 19, 19, 18, 18, 18, 18, 17, 17, 17, 17, 17, 16, 16, 15, 15, 14, 14, 14, 12, 12, 11,
-    9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
-    8, 8, 8, 8, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 2, 2, 2,
-    2, 1, 1, 1, 1, 1, 1, 1 };
-
-  int move_importance(int ply) { return MoveImportance[std::min(ply, 511)]; }
-
-
-  /// Function Prototypes
-
   enum TimeType { OptimumTime, MaxTime };
 
-  template<TimeType>
+  const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
-  int remaining(int myTime, int movesToGo, int fullMoveNumber);
+  const double MaxRatio   = 7.09; // When in trouble, we can step over reserved time with this ratio
+  const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio
+
+
+  // move_importance() is a skew-logistic function based on naive statistical
+  // analysis of "how many games are still undecided after n half-moves". Game
+  // is considered "undecided" as long as neither side has >275cp advantage.
+  // Data was extracted from the CCRL game database with some simple filtering criteria.
+
+  double move_importance(int ply) {
+
+    const double XScale = 7.64;
+    const double XShift = 58.4;
+    const double Skew   = 0.183;
+
+    return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero
   }
 
+  template<TimeType T>
+  int remaining(int myTime, int movesToGo, int ply, int slowMover) {
 
-void TimeManager::pv_instability(int curChanges, int prevChanges) {
+    const double TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const double TStealRatio = (T == OptimumTime ? 0 : StealRatio);
 
-  unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
+    double moveImportance = (move_importance(ply) * slowMover) / 100;
-                       + prevChanges * (optimumSearchTime / 3);
+    double otherMovesImportance = 0;
+
+    for (int i = 1; i < movesToGo; ++i)
+        otherMovesImportance += move_importance(ply + 2 * i);
+
+    double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance);
+    double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance);
+
+    return int(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast
   }
 
+} // namespace
 
-void TimeManager::init(const Search::LimitsType& limits, int currentPly)
-{
-  /* We support four different kind of time controls:
 
-      increment == 0 && movesToGo == 0 means: x basetime  [sudden death!]
+/// init() is called at the beginning of the search and calculates the allowed
-      increment == 0 && movesToGo != 0 means: x moves in y minutes
+/// thinking time out of the time control and current game ply. We support four
-      increment >  0 && movesToGo == 0 means: x basetime + z increment
+/// different kinds of time controls, passed in 'limits':
-      increment >  0 && movesToGo != 0 means: x moves in y minutes + z increment
+///
+///  inc == 0 && movestogo == 0 means: x basetime  [sudden death!]
+///  inc == 0 && movestogo != 0 means: x moves in y minutes
+///  inc >  0 && movestogo == 0 means: x basetime + z increment
+///  inc >  0 && movestogo != 0 means: x moves in y minutes + z increment
 
-    Time management is adjusted by following UCI parameters:
+void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
 
-      emergencyMoveHorizon: Be prepared to always play at least this many moves
-      emergencyBaseTime   : Always attempt to keep at least this much time (in ms) at clock
-      emergencyMoveTime   : Plus attempt to keep at least this much time for each remaining emergency move
-      minThinkingTime     : No matter what, use at least this much thinking before doing the move
-  */
-
-  int hypMTG, hypMyTime, t1, t2;
-
-  // Read uci parameters
-  int emergencyMoveHorizon = Options["Emergency Move Horizon"];
-  int emergencyBaseTime    = Options["Emergency Base Time"];
-  int emergencyMoveTime    = Options["Emergency Move Time"];
   int minThinkingTime = Options["Minimum Thinking Time"];
+  int moveOverhead    = Options["Move Overhead"];
+  int slowMover       = Options["Slow Mover"];
+  int npmsec          = Options["nodestime"];
 
-  // Initialize to maximum values but unstablePVExtraTime that is reset
+  // If we have to play in 'nodes as time' mode, then convert from time
-  unstablePVExtraTime = 0;
+  // to nodes, and use resulting values in time management formulas.
-  optimumSearchTime = maximumSearchTime = limits.time;
+  // WARNING: Given npms (nodes per millisecond) must be much lower then
-
+  // the real engine speed to avoid time losses.
-  // We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
+  if (npmsec)
-  // minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values.
-  for (hypMTG = 1; hypMTG <= (limits.movesToGo ? std::min(limits.movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
   {
-      // Calculate thinking time for hypothetic "moves to go"-value
+      if (!availableNodes) // Only once at game start
-      hypMyTime =  limits.time
+          availableNodes = npmsec * limits.time[us]; // Time is in msec
-                 + limits.increment * (hypMTG - 1)
+
-                 - emergencyBaseTime
+      // Convert from millisecs to nodes
-                 - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon);
+      limits.time[us] = (int)availableNodes;
+      limits.inc[us] *= npmsec;
+      limits.npmsec = npmsec;
+  }
+
+  startTime = limits.startTime;
+  optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime);
+
+  const int MaxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon;
+
+  // We calculate optimum time usage for different hypothetical "moves to go"-values
+  // and choose the minimum of calculated search time values. Usually the greatest
+  // hypMTG gives the minimum values.
+  for (int hypMTG = 1; hypMTG <= MaxMTG; ++hypMTG)
+  {
+      // Calculate thinking time for hypothetical "moves to go"-value
+      int hypMyTime =  limits.time[us]
+                     + limits.inc[us] * (hypMTG - 1)
+                     - moveOverhead * (2 + std::min(hypMTG, 40));
 
       hypMyTime = std::max(hypMyTime, 0);
 
-      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
+      int t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
-      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+      int t2 = minThinkingTime + remaining<MaxTime    >(hypMyTime, hypMTG, ply, slowMover);
 
-      optimumSearchTime = std::min(optimumSearchTime, t1);
+      optimumTime = std::min(t1, optimumTime);
-      maximumSearchTime = std::min(maximumSearchTime, t2);
+      maximumTime = std::min(t2, maximumTime);
   }
 
   if (Options["Ponder"])
-      optimumSearchTime += optimumSearchTime / 4;
+      optimumTime += optimumTime / 4;
-
-  // Make sure that maxSearchTime is not over absoluteMaxSearchTime
-  optimumSearchTime = std::min(optimumSearchTime, maximumSearchTime);
-}
-
-
-namespace {
-
-  template<TimeType T>
-  int remaining(int myTime, int movesToGo, int currentPly)
-  {
-    const float TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
-    const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
-
-    int thisMoveImportance = move_importance(currentPly);
-    int otherMovesImportance = 0;
-
-    for (int i = 1; i < movesToGo; i++)
-        otherMovesImportance += move_importance(currentPly + 2 * i);
-
-    float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
-    float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
-
-    return int(floor(myTime * std::min(ratio1, ratio2)));
-  }
 }

src/timeman.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,23 +18,31 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TIMEMAN_H_INCLUDED)
+#ifndef TIMEMAN_H_INCLUDED
 #define TIMEMAN_H_INCLUDED
 
-/// The TimeManager class computes the optimal time to think depending on the
+#include "misc.h"
-/// maximum available time, the move game number and other parameters.
+#include "search.h"
+#include "thread.h"
 
-class TimeManager {
+/// The TimeManagement class computes the optimal time to think depending on
+/// the maximum available time, the game move number and other parameters.
+
+class TimeManagement {
 public:
-  void init(const Search::LimitsType& limits, int currentPly);
+  void init(Search::LimitsType& limits, Color us, int ply);
-  void pv_instability(int curChanges, int prevChanges);
+  int optimum() const { return optimumTime; }
-  int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
+  int maximum() const { return maximumTime; }
-  int maximum_time() const { return maximumSearchTime; }
+  int elapsed() const { return int(Search::Limits.npmsec ? Threads.nodes_searched() : now() - startTime); }
+
+  int64_t availableNodes; // When in 'nodes as time' mode
 
 private:
-  int optimumSearchTime;
+  TimePoint startTime;
-  int maximumSearchTime;
+  int optimumTime;
-  int unstablePVExtraTime;
+  int maximumTime;
 };
 
-#endif // !defined(TIMEMAN_H_INCLUDED)
+extern TimeManagement Time;
+
+#endif // #ifndef TIMEMAN_H_INCLUDED

src/tt.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,127 +18,101 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cstring>
+#include <cstring>   // For std::memset
 #include <iostream>
 
+#include "bitboard.h"
 #include "tt.h"
 
 TranspositionTable TT; // Our global transposition table
 
-TranspositionTable::TranspositionTable() {
 
-  size = generation = 0;
+/// TranspositionTable::resize() sets the size of the transposition table,
-  entries = NULL;
+/// measured in megabytes. Transposition table consists of a power of 2 number
-}
+/// of clusters and each cluster consists of ClusterSize number of TTEntry.
 
-TranspositionTable::~TranspositionTable() {
+void TranspositionTable::resize(size_t mbSize) {
 
-  delete [] entries;
+  size_t newClusterCount = mbSize * 1024 * 1024 / sizeof(Cluster);
-}
 
-
+  if (newClusterCount == clusterCount)
-/// TranspositionTable::set_size() sets the size of the transposition table,
-/// measured in megabytes.
-
-void TranspositionTable::set_size(size_t mbSize) {
-
-  size_t newSize = 1024;
-
-  // Transposition table consists of clusters and each cluster consists
-  // of ClusterSize number of TTEntries. Each non-empty entry contains
-  // information of exactly one position and newSize is the number of
-  // clusters we are going to allocate.
-  while (2ULL * newSize * sizeof(TTCluster) <= (mbSize << 20))
-      newSize *= 2;
-
-  if (newSize == size)
       return;
 
-  size = newSize;
+  clusterCount = newClusterCount;
-  delete [] entries;
+
-  entries = new (std::nothrow) TTCluster[size];
+  free(mem);
-  if (!entries)
+  mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1);
+
+  if (!mem)
   {
       std::cerr << "Failed to allocate " << mbSize
                 << "MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
   }
+
+  table = (Cluster*)((uintptr_t(mem) + CacheLineSize - 1) & ~(CacheLineSize - 1));
   clear();
 }
 
 
 /// TranspositionTable::clear() overwrites the entire transposition table
-/// with zeroes. It is called whenever the table is resized, or when the
+/// with zeros. It is called whenever the table is resized, or when the
 /// user asks the program to clear the table (from the UCI interface).
 
 void TranspositionTable::clear() {
 
-  memset(entries, 0, size * sizeof(TTCluster));
+  std::memset(table, 0, clusterCount * sizeof(Cluster));
 }
 
 
-/// TranspositionTable::store() writes a new entry containing position key and
+/// TranspositionTable::probe() looks up the current position in the transposition
-/// valuable information of current position. The lowest order bits of position
+/// table. It returns true and a pointer to the TTEntry if the position is found.
-/// key are used to decide on which cluster the position will be placed.
+/// Otherwise, it returns false and a pointer to an empty or least valuable TTEntry
-/// When a new entry is written and there are no empty entries available in cluster,
+/// to be replaced later. The replace value of an entry is calculated as its depth
-/// it replaces the least valuable of entries. A TTEntry t1 is considered to be
+/// minus 8 times its relative age. TTEntry t1 is considered more valuable than
-/// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
+/// TTEntry t2 if its replace value is greater than that of t2.
-/// a previous search, or if the depth of t1 is bigger than the depth of t2.
 
-void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
+TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
 
-  int c1, c2, c3;
+  TTEntry* const tte = first_entry(key);
-  TTEntry *tte, *replace;
+  const uint16_t key16 = key >> 48;  // Use the high 16 bits as key inside the cluster
-  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key inside the cluster
 
-  tte = replace = first_entry(posKey);
+  for (int i = 0; i < ClusterSize; ++i)
-
+      if (!tte[i].key16 || tte[i].key16 == key16)
-  for (int i = 0; i < ClusterSize; i++, tte++)
       {
-      if (!tte->key() || tte->key() == posKey32) // Empty or overwrite old
+          if ((tte[i].genBound8 & 0xFC) != generation8 && tte[i].key16)
+              tte[i].genBound8 = uint8_t(generation8 | tte[i].bound()); // Refresh
+
+          return found = (bool)tte[i].key16, &tte[i];
+      }
+
+  // Find an entry to be replaced according to the replacement strategy
+  TTEntry* replace = tte;
+  for (int i = 1; i < ClusterSize; ++i)
+      // Due to our packed storage format for generation and its cyclic
+      // nature we add 259 (256 is the modulus plus 3 to keep the lowest
+      // two bound bits from affecting the result) to calculate the entry
+      // age correctly even after generation8 overflows into the next cycle.
+      if (  replace->depth8 - ((259 + generation8 - replace->genBound8) & 0xFC) * 2
+          >   tte[i].depth8 - ((259 + generation8 -   tte[i].genBound8) & 0xFC) * 2)
+          replace = &tte[i];
+
+  return found = false, replace;
+}
+
+
+/// TranspositionTable::hashfull() returns an approximation of the hashtable
+/// occupation during a search. The hash is x permill full, as per UCI protocol.
+
+int TranspositionTable::hashfull() const {
+
+  int cnt = 0;
+  for (int i = 0; i < 1000 / ClusterSize; i++)
   {
-          // Preserve any existing ttMove
+      const TTEntry* tte = &table[i].entry[0];
-          if (m == MOVE_NONE)
+      for (int j = 0; j < ClusterSize; j++)
-              m = tte->move();
+          if ((tte[j].genBound8 & 0xFC) == generation8)
-
+              cnt++;
-          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
-          return;
   }
-
+  return cnt;
-      // Implement replace strategy
-      c1 = (replace->generation() == generation ?  2 : 0);
-      c2 = (tte->generation() == generation || tte->type() == VALUE_TYPE_EXACT ? -2 : 0);
-      c3 = (tte->depth() < replace->depth() ?  1 : 0);
-
-      if (c1 + c2 + c3 > 0)
-          replace = tte;
-  }
-  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
-}
-
-
-/// TranspositionTable::probe() looks up the current position in the
-/// transposition table. Returns a pointer to the TTEntry or NULL if
-/// position is not found.
-
-TTEntry* TranspositionTable::probe(const Key posKey) const {
-
-  uint32_t posKey32 = posKey >> 32;
-  TTEntry* tte = first_entry(posKey);
-
-  for (int i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == posKey32)
-          return tte;
-
-  return NULL;
-}
-
-
-/// TranspositionTable::new_search() is called at the beginning of every new
-/// search. It increments the "generation" variable, which is used to
-/// distinguish transposition table entries from previous searches from
-/// entries from the current search.
-
-void TranspositionTable::new_search() {
-  generation++;
 }

src/tt.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,157 +18,104 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TT_H_INCLUDED)
+#ifndef TT_H_INCLUDED
 #define TT_H_INCLUDED
 
-#include <iostream>
-
 #include "misc.h"
 #include "types.h"
 
-
+/// TTEntry struct is the 10 bytes transposition table entry, defined as below:
-/// The TTEntry is the class of transposition table entries
 ///
-/// A TTEntry needs 128 bits to be stored
+/// key        16 bit
-///
+/// move       16 bit
-/// bit  0-31: key
+/// value      16 bit
-/// bit 32-63: data
+/// eval value 16 bit
-/// bit 64-79: value
+/// generation  6 bit
-/// bit 80-95: depth
+/// bound type  2 bit
-/// bit 96-111: static value
+/// depth       8 bit
-/// bit 112-127: margin of static value
-///
-/// the 32 bits of the data field are so defined
-///
-/// bit  0-15: move
-/// bit 16-20: not used
-/// bit 21-22: value type
-/// bit 23-31: generation
 
-class TTEntry {
+struct TTEntry {
 
-public:
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
-
-    key32        = (uint32_t)k;
-    move16       = (uint16_t)m;
-    valueType    = (uint8_t)t;
-    generation8  = (uint8_t)g;
-    value16      = (int16_t)v;
-    depth16      = (int16_t)d;
-    staticValue  = (int16_t)statV;
-    staticMargin = (int16_t)statM;
-  }
-  void set_generation(int g) { generation8 = (uint8_t)g; }
-
-  uint32_t key() const              { return key32; }
-  Depth depth() const               { return (Depth)depth16; }
   Move  move()  const { return (Move )move16; }
   Value value() const { return (Value)value16; }
-  ValueType type() const            { return (ValueType)valueType; }
+  Value eval()  const { return (Value)eval16; }
-  int generation() const            { return (int)generation8; }
+  Depth depth() const { return (Depth)(depth8 * int(ONE_PLY)); }
-  Value static_value() const        { return (Value)staticValue; }
+  Bound bound() const { return (Bound)(genBound8 & 0x3); }
-  Value static_value_margin() const { return (Value)staticMargin; }
+
+  void save(Key k, Value v, Bound b, Depth d, Move m, Value ev, uint8_t g) {
+
+    assert(d / ONE_PLY * ONE_PLY == d);
+
+    // Preserve any existing move for the same position
+    if (m || (k >> 48) != key16)
+        move16 = (uint16_t)m;
+
+    // Don't overwrite more valuable entries
+    if (  (k >> 48) != key16
+        || d / ONE_PLY > depth8 - 4
+     /* || g != (genBound8 & 0xFC) // Matching non-zero keys are already refreshed by probe() */
+        || b == BOUND_EXACT)
+    {
+        key16     = (uint16_t)(k >> 48);
+        value16   = (int16_t)v;
+        eval16    = (int16_t)ev;
+        genBound8 = (uint8_t)(g | b);
+        depth8    = (int8_t)(d / ONE_PLY);
+    }
+  }
 
 private:
-  uint32_t key32;
+  friend class TranspositionTable;
+
+  uint16_t key16;
   uint16_t move16;
-  uint8_t valueType, generation8;
+  int16_t  value16;
-  int16_t value16, depth16, staticValue, staticMargin;
+  int16_t  eval16;
+  uint8_t  genBound8;
+  int8_t   depth8;
 };
 
 
-/// This is the number of TTEntry slots for each cluster
+/// A TranspositionTable consists of a power of 2 number of clusters and each
-const int ClusterSize = 4;
+/// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
-
+/// contains information of exactly one position. The size of a cluster should
-
+/// divide the size of a cache line size, to ensure that clusters never cross
-/// TTCluster consists of ClusterSize number of TTEntries. Size of TTCluster
+/// cache lines. This ensures best cache performance, as the cacheline is
-/// must not be bigger than a cache line size. In case it is less, it should
+/// prefetched, as soon as possible.
-/// be padded to guarantee always aligned accesses.
-
-struct TTCluster {
-  TTEntry data[ClusterSize];
-};
-
-
-/// The transposition table class. This is basically just a huge array containing
-/// TTCluster objects, and a few methods for writing and reading entries.
 
 class TranspositionTable {
 
-  TranspositionTable(const TranspositionTable&);
+  static const int CacheLineSize = 64;
-  TranspositionTable& operator=(const TranspositionTable&);
+  static const int ClusterSize = 3;
+
+  struct Cluster {
+    TTEntry entry[ClusterSize];
+    char padding[2]; // Align to a divisor of the cache line size
+  };
+
+  static_assert(CacheLineSize % sizeof(Cluster) == 0, "Cluster size incorrect");
 
 public:
-  TranspositionTable();
+ ~TranspositionTable() { free(mem); }
-  ~TranspositionTable();
+  void new_search() { generation8 += 4; } // Lower 2 bits are used by Bound
-  void set_size(size_t mbSize);
+  uint8_t generation() const { return generation8; }
+  TTEntry* probe(const Key key, bool& found) const;
+  int hashfull() const;
+  void resize(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+
-  TTEntry* probe(const Key posKey) const;
+  // The 32 lowest order bits of the key are used to get the index of the cluster
-  void new_search();
+  TTEntry* first_entry(const Key key) const {
-  TTEntry* first_entry(const Key posKey) const;
+    return &table[(uint32_t(key) * uint64_t(clusterCount)) >> 32].entry[0];
-  void refresh(const TTEntry* tte) const;
+  }
 
 private:
-  size_t size;
+  size_t clusterCount;
-  TTCluster* entries;
+  Cluster* table;
-  uint8_t generation; // Size must be not bigger then TTEntry::generation8
+  void* mem;
+  uint8_t generation8; // Size must be not bigger than TTEntry::genBound8
 };
 
 extern TranspositionTable TT;
 
-
+#endif // #ifndef TT_H_INCLUDED
-/// TranspositionTable::first_entry() returns a pointer to the first entry of
-/// a cluster given a position. The lowest order bits of the key are used to
-/// get the index of the cluster.
-
-inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
-
-  return entries[((uint32_t)posKey) & (size - 1)].data;
-}
-
-
-/// TranspositionTable::refresh() updates the 'generation' value of the TTEntry
-/// to avoid aging. Normally called after a TT hit.
-
-inline void TranspositionTable::refresh(const TTEntry* tte) const {
-
-  const_cast<TTEntry*>(tte)->set_generation(generation);
-}
-
-
-/// A simple fixed size hash table used to store pawns and material
-/// configurations. It is basically just an array of Entry objects.
-/// Without cluster concept or overwrite policy.
-
-template<class Entry, int HashSize>
-struct SimpleHash {
-
-  typedef SimpleHash<Entry, HashSize> Base;
-
-  void init() {
-
-    if (entries)
-        return;
-
-    entries = new (std::nothrow) Entry[HashSize];
-    if (!entries)
-    {
-        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
-                  << " bytes for hash table." << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    memset(entries, 0, HashSize * sizeof(Entry));
-  }
-
-  virtual ~SimpleHash() { delete [] entries; }
-
-  Entry* probe(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
-  void prefetch(Key key) const { ::prefetch((char*)probe(key)); }
-
-protected:
-  Entry* entries;
-};
-
-#endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,84 +18,80 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TYPES_H_INCLUDED)
+#ifndef TYPES_H_INCLUDED
 #define TYPES_H_INCLUDED
 
-/// For Linux and OSX configuration is done automatically using Makefile. To get
+/// When compiling with provided Makefile (e.g. for Linux and OSX), configuration
-/// started type 'make help'.
+/// is done automatically. To get started type 'make help'.
 ///
-/// For Windows, part of the configuration is detected automatically, but some
+/// When Makefile is not used (e.g. with Microsoft Visual Studio) some switches
-/// switches need to be set manually:
+/// need to be set manually:
 ///
-/// -DNDEBUG      | Disable debugging mode. Use always.
+/// -DNDEBUG      | Disable debugging mode. Always use this for release.
 ///
-/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want
+/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. You may need this to
-///               | the executable to run on some very old machines.
+///               | run on some very old machines.
 ///
 /// -DUSE_POPCNT  | Add runtime support for use of popcnt asm-instruction. Works
-///               | only in 64-bit mode. For compiling requires hardware with
+///               | only in 64-bit mode and requires hardware with popcnt support.
-///               | popcnt support.
 ///
-/// -DOLD_LOCKS   | Under Windows are used the fast Slim Reader/Writer (SRW)
+/// -DUSE_PEXT    | Add runtime support for use of pext asm-instruction. Works
-///               | Locks and Condition Variables: these are not supported by
+///               | only in 64-bit mode and requires hardware with pext support.
-///               | Windows XP and older, to compile for those platforms you
-///               | should enable OLD_LOCKS.
 
+#include <cassert>
+#include <cctype>
 #include <climits>
+#include <cstdint>
 #include <cstdlib>
 
 #if defined(_MSC_VER)
-
 // Disable some silly and noisy warning from MSVC compiler
 #pragma warning(disable: 4127) // Conditional expression is constant
 #pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
 #pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
-
-// MSVC does not support <inttypes.h>
-typedef   signed __int8    int8_t;
-typedef unsigned __int8   uint8_t;
-typedef   signed __int16  int16_t;
-typedef unsigned __int16 uint16_t;
-typedef   signed __int32  int32_t;
-typedef unsigned __int32 uint32_t;
-typedef   signed __int64  int64_t;
-typedef unsigned __int64 uint64_t;
-
-#else
-#  include <inttypes.h>
 #endif
 
-#if defined(_WIN64)
+/// Predefined macros hell:
-#  include <intrin.h> // MSVC popcnt and bsfq instrinsics
+///
+/// __GNUC__           Compiler is gcc, Clang or Intel on Linux
+/// __INTEL_COMPILER   Compiler is Intel
+/// _MSC_VER           Compiler is MSVC or Intel on Windows
+/// _WIN32             Building on Windows (any)
+/// _WIN64             Building on Windows 64 bit
+
+#if defined(_WIN64) && defined(_MSC_VER) // No Makefile used
+#  include <intrin.h> // Microsoft header for _BitScanForward64()
 #  define IS_64BIT
-#  define USE_BSFQ
 #endif
 
-#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
+#if defined(USE_POPCNT) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
-#  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
+#  include <nmmintrin.h> // Intel and Microsoft header for _mm_popcnt_u64()
 #endif
 
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
-#  define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#  include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
+#endif
+
+#if defined(USE_PEXT)
+#  include <immintrin.h> // Header for _pext_u64() intrinsic
+#  define pext(b, m) _pext_u64(b, m)
 #else
-#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#  define pext(b, m) 0
 #endif
 
-#if defined(_MSC_VER)
+#ifdef USE_POPCNT
-#  define FORCE_INLINE  __forceinline
-#elif defined(__GNUC__)
-#  define FORCE_INLINE  inline __attribute__((always_inline))
-#else
-#  define FORCE_INLINE  inline
-#endif
-
-#if defined(USE_POPCNT)
 const bool HasPopCnt = true;
 #else
 const bool HasPopCnt = false;
 #endif
 
-#if defined(IS_64BIT)
+#ifdef USE_PEXT
+const bool HasPext = true;
+#else
+const bool HasPext = false;
+#endif
+
+#ifdef IS_64BIT
 const bool Is64Bit = true;
 #else
 const bool Is64Bit = false;
@@ -104,119 +101,129 @@ typedef uint64_t Key;
 typedef uint64_t Bitboard;
 
 const int MAX_MOVES = 256;
-const int MAX_PLY        = 100;
+const int MAX_PLY   = 128;
-const int MAX_PLY_PLUS_2 = MAX_PLY + 2;
-
-const Bitboard FileABB = 0x0101010101010101ULL;
-const Bitboard FileBBB = FileABB << 1;
-const Bitboard FileCBB = FileABB << 2;
-const Bitboard FileDBB = FileABB << 3;
-const Bitboard FileEBB = FileABB << 4;
-const Bitboard FileFBB = FileABB << 5;
-const Bitboard FileGBB = FileABB << 6;
-const Bitboard FileHBB = FileABB << 7;
-
-const Bitboard Rank1BB = 0xFF;
-const Bitboard Rank2BB = Rank1BB << (8 * 1);
-const Bitboard Rank3BB = Rank1BB << (8 * 2);
-const Bitboard Rank4BB = Rank1BB << (8 * 3);
-const Bitboard Rank5BB = Rank1BB << (8 * 4);
-const Bitboard Rank6BB = Rank1BB << (8 * 5);
-const Bitboard Rank7BB = Rank1BB << (8 * 6);
-const Bitboard Rank8BB = Rank1BB << (8 * 7);
-
 
 /// A move needs 16 bits to be stored
 ///
 /// bit  0- 5: destination square (from 0 to 63)
 /// bit  6-11: origin square (from 0 to 63)
 /// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)
-/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)
+/// bit 14-15: special move flag: promotion (1), en passant (2), castling (3)
+/// NOTE: EN-PASSANT bit is set only when a pawn can be captured
 ///
 /// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in because in
 /// any normal move destination square is always different from origin square
 /// while MOVE_NONE and MOVE_NULL have the same origin and destination square.
 
-enum Move {
+enum Move : int {
-  MOVE_NONE = 0,
+  MOVE_NONE,
   MOVE_NULL = 65
 };
 
-struct MoveStack {
+enum MoveType {
-  Move move;
+  NORMAL,
-  int score;
+  PROMOTION = 1 << 14,
+  ENPASSANT = 2 << 14,
+  CASTLING  = 3 << 14
 };
 
-inline bool operator<(const MoveStack& f, const MoveStack& s) {
+enum Color {
-  return f.score < s.score;
+  WHITE, BLACK, COLOR_NB = 2
-}
+};
 
-enum CastleRight {
+enum CastlingSide {
-  CASTLES_NONE = 0,
+  KING_SIDE, QUEEN_SIDE, CASTLING_SIDE_NB = 2
-  WHITE_OO     = 1,
+};
-  BLACK_OO     = 2,
+
-  WHITE_OOO    = 4,
+enum CastlingRight {
-  BLACK_OOO    = 8,
+  NO_CASTLING,
-  ALL_CASTLES  = 15
+  WHITE_OO,
+  WHITE_OOO = WHITE_OO << 1,
+  BLACK_OO  = WHITE_OO << 2,
+  BLACK_OOO = WHITE_OO << 3,
+  ANY_CASTLING = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
+  CASTLING_RIGHT_NB = 16
+};
+
+template<Color C, CastlingSide S> struct MakeCastling {
+  static constexpr CastlingRight
+  right = C == WHITE ? S == QUEEN_SIDE ? WHITE_OOO : WHITE_OO
+                     : S == QUEEN_SIDE ? BLACK_OOO : BLACK_OO;
+};
+
+enum Phase {
+  PHASE_ENDGAME,
+  PHASE_MIDGAME = 128,
+  MG = 0, EG = 1, PHASE_NB = 2
 };
 
 enum ScaleFactor {
   SCALE_FACTOR_DRAW    = 0,
+  SCALE_FACTOR_ONEPAWN = 48,
   SCALE_FACTOR_NORMAL  = 64,
   SCALE_FACTOR_MAX     = 128,
   SCALE_FACTOR_NONE    = 255
 };
 
-enum ValueType {
+enum Bound {
-  VALUE_TYPE_NONE  = 0,
+  BOUND_NONE,
-  VALUE_TYPE_UPPER = 1,
+  BOUND_UPPER,
-  VALUE_TYPE_LOWER = 2,
+  BOUND_LOWER,
-  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
-enum Value {
+enum Value : int {
   VALUE_ZERO      = 0,
   VALUE_DRAW      = 0,
-  VALUE_KNOWN_WIN = 15000,
+  VALUE_KNOWN_WIN = 10000,
-  VALUE_MATE      = 30000,
+  VALUE_MATE      = 32000,
-  VALUE_INFINITE  = 30001,
+  VALUE_INFINITE  = 32001,
-  VALUE_NONE      = 30002,
+  VALUE_NONE      = 32002,
 
-  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - MAX_PLY,
+  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - 2 * MAX_PLY,
-  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + MAX_PLY,
+  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY,
 
-  VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+  PawnValueMg   = 171,   PawnValueEg   = 240,
-  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN
+  KnightValueMg = 764,   KnightValueEg = 848,
+  BishopValueMg = 826,   BishopValueEg = 891,
+  RookValueMg   = 1282,  RookValueEg   = 1373,
+  QueenValueMg  = 2526,  QueenValueEg  = 2646,
+
+  MidgameLimit  = 15258, EndgameLimit  = 3915
 };
 
 enum PieceType {
-  NO_PIECE_TYPE = 0,
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+  ALL_PIECES = 0,
+  QUEEN_DIAGONAL = 7,
+  PIECE_TYPE_NB = 8
 };
 
 enum Piece {
-  NO_PIECE = 16, // color_of(NO_PIECE) == NO_COLOR
+  NO_PIECE,
-  W_PAWN = 1, W_KNIGHT =  2, W_BISHOP =  3, W_ROOK =  4, W_QUEEN =  5, W_KING =  6,
+  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
-  B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14
+  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
+  PIECE_NB = 16
 };
 
-enum Color {
+extern Value PieceValue[PHASE_NB][PIECE_NB];
-  WHITE, BLACK, NO_COLOR
-};
 
-enum Depth {
+enum Depth : int {
 
-  ONE_PLY = 2,
+  ONE_PLY = 1,
 
   DEPTH_ZERO          =  0 * ONE_PLY,
-  DEPTH_QS_CHECKS     = -1 * ONE_PLY,
+  DEPTH_QS_CHECKS     =  0 * ONE_PLY,
-  DEPTH_QS_NO_CHECKS  = -2 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS  = -1 * ONE_PLY,
-  DEPTH_QS_RECAPTURES = -4 * ONE_PLY,
+  DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
 
-  DEPTH_NONE = -127 * ONE_PLY
+  DEPTH_NONE = -6 * ONE_PLY,
+  DEPTH_MAX  = MAX_PLY * ONE_PLY
 };
 
-enum Square {
+static_assert(!(ONE_PLY & (ONE_PLY - 1)), "ONE_PLY is not a power of 2");
+
+enum Square : int {
   SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,
   SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
   SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,
@@ -227,286 +234,233 @@ enum Square {
   SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
   SQ_NONE,
 
-  DELTA_N =  8,
+  SQUARE_NB = 64
-  DELTA_E =  1,
-  DELTA_S = -8,
-  DELTA_W = -1,
-
-  DELTA_NN = DELTA_N + DELTA_N,
-  DELTA_NE = DELTA_N + DELTA_E,
-  DELTA_SE = DELTA_S + DELTA_E,
-  DELTA_SS = DELTA_S + DELTA_S,
-  DELTA_SW = DELTA_S + DELTA_W,
-  DELTA_NW = DELTA_N + DELTA_W
 };
 
-enum File {
+enum Direction : int {
-  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H
+  NORTH =  8,
+  EAST  =  1,
+  SOUTH = -NORTH,
+  WEST  = -EAST,
+
+  NORTH_EAST = NORTH + EAST,
+  SOUTH_EAST = SOUTH + EAST,
+  SOUTH_WEST = SOUTH + WEST,
+  NORTH_WEST = NORTH + WEST
 };
 
-enum Rank {
+enum File : int {
-  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8
+  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB
+};
+
+enum Rank : int {
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB
 };
 
 
-/// Score enum keeps a midgame and an endgame value in a single integer (enum),
+/// Score enum stores a middlegame and an endgame value in a single integer
-/// first LSB 16 bits are used to store endgame value, while upper bits are used
+/// (enum). The least significant 16 bits are used to store the endgame value
-/// for midgame value. Compiler is free to choose the enum type as long as can
+/// and the upper 16 bits are used to store the middlegame value. Take some
-/// keep its data, so ensure Score to be an integer type.
+/// care to avoid left-shifting a signed int to avoid undefined behavior.
-enum Score {
+enum Score : int { SCORE_ZERO };
-  SCORE_ZERO = 0,
-  SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
-  SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
-};
 
-inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
+constexpr Score make_score(int mg, int eg) {
-
+  return Score((int)((unsigned int)eg << 16) + mg);
-/// Extracting the signed lower and upper 16 bits it not so trivial because
-/// according to the standard a simple cast to short is implementation defined
-/// and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((s + 32768) & ~0xffff) / 0x10000); }
-
-/// On Intel 64 bit we have a small speed regression with the standard conforming
-/// version, so use a faster code in this case that, although not 100% standard
-/// compliant it seems to work for Intel and MSVC.
-#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
-
-inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
-
-#else
-
-inline Value eg_value(Score s) {
-  return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u));
 }
 
-#endif
+/// Extracting the signed lower and upper 16 bits is not so trivial because
+/// according to the standard a simple cast to short is implementation defined
+/// and so is a right shift of a signed integer.
+inline Value eg_value(Score s) {
+  union { uint16_t u; int16_t s; } eg = { uint16_t(unsigned(s + 0x8000) >> 16) };
+  return Value(eg.s);
+}
 
-#define ENABLE_SAFE_OPERATORS_ON(T)                                         \
+inline Value mg_value(Score s) {
-inline T operator+(const T d1, const T d2) { return T(int(d1) + int(d2)); } \
+  union { uint16_t u; int16_t s; } mg = { uint16_t(unsigned(s)) };
-inline T operator-(const T d1, const T d2) { return T(int(d1) - int(d2)); } \
+  return Value(mg.s);
-inline T operator*(int i, const T d) { return T(i * int(d)); }              \
+}
-inline T operator*(const T d, int i) { return T(int(d) * i); }              \
-inline T operator-(const T d) { return T(-int(d)); }                        \
-inline T& operator+=(T& d1, const T d2) { d1 = d1 + d2; return d1; }        \
-inline T& operator-=(T& d1, const T d2) { d1 = d1 - d2; return d1; }        \
-inline T& operator*=(T& d, int i) { d = T(int(d) * i); return d; }
 
-#define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_OPERATORS_ON(T)                  \
+#define ENABLE_BASE_OPERATORS_ON(T)                                \
-inline T operator++(T& d, int) { d = T(int(d) + 1); return d; }             \
+constexpr T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \
-inline T operator--(T& d, int) { d = T(int(d) - 1); return d; }             \
+constexpr T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \
-inline T operator/(const T d, int i) { return T(int(d) / i); }              \
+constexpr T operator-(T d) { return T(-int(d)); }                  \
-inline T& operator/=(T& d, int i) { d = T(int(d) / i); return d; }
+inline T& operator+=(T& d1, T d2) { return d1 = d1 + d2; }         \
+inline T& operator-=(T& d1, T d2) { return d1 = d1 - d2; }
 
-ENABLE_OPERATORS_ON(Value)
+#define ENABLE_INCR_OPERATORS_ON(T)                                \
-ENABLE_OPERATORS_ON(PieceType)
+inline T& operator++(T& d) { return d = T(int(d) + 1); }           \
-ENABLE_OPERATORS_ON(Piece)
+inline T& operator--(T& d) { return d = T(int(d) - 1); }
-ENABLE_OPERATORS_ON(Color)
-ENABLE_OPERATORS_ON(Depth)
-ENABLE_OPERATORS_ON(Square)
-ENABLE_OPERATORS_ON(File)
-ENABLE_OPERATORS_ON(Rank)
 
-/// Added operators for adding integers to a Value
+#define ENABLE_FULL_OPERATORS_ON(T)                                \
-inline Value operator+(Value v, int i) { return Value(int(v) + i); }
+ENABLE_BASE_OPERATORS_ON(T)                                        \
-inline Value operator-(Value v, int i) { return Value(int(v) - i); }
+ENABLE_INCR_OPERATORS_ON(T)                                        \
+constexpr T operator*(int i, T d) { return T(i * int(d)); }        \
+constexpr T operator*(T d, int i) { return T(int(d) * i); }        \
+constexpr T operator/(T d, int i) { return T(int(d) / i); }        \
+constexpr int operator/(T d1, T d2) { return int(d1) / int(d2); }  \
+inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }    \
+inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
-ENABLE_SAFE_OPERATORS_ON(Score)
+ENABLE_FULL_OPERATORS_ON(Value)
+ENABLE_FULL_OPERATORS_ON(Depth)
+ENABLE_FULL_OPERATORS_ON(Direction)
+
+ENABLE_INCR_OPERATORS_ON(PieceType)
+ENABLE_INCR_OPERATORS_ON(Piece)
+ENABLE_INCR_OPERATORS_ON(Color)
+ENABLE_INCR_OPERATORS_ON(Square)
+ENABLE_INCR_OPERATORS_ON(File)
+ENABLE_INCR_OPERATORS_ON(Rank)
+
+ENABLE_BASE_OPERATORS_ON(Score)
+
+#undef ENABLE_FULL_OPERATORS_ON
+#undef ENABLE_INCR_OPERATORS_ON
+#undef ENABLE_BASE_OPERATORS_ON
+
+/// Additional operators to add integers to a Value
+constexpr Value operator+(Value v, int i) { return Value(int(v) + i); }
+constexpr Value operator-(Value v, int i) { return Value(int(v) - i); }
+inline Value& operator+=(Value& v, int i) { return v = v + i; }
+inline Value& operator-=(Value& v, int i) { return v = v - i; }
+
+/// Additional operators to add a Direction to a Square
+inline Square operator+(Square s, Direction d) { return Square(int(s) + int(d)); }
+inline Square operator-(Square s, Direction d) { return Square(int(s) - int(d)); }
+inline Square& operator+=(Square &s, Direction d) { return s = s + d; }
+inline Square& operator-=(Square &s, Direction d) { return s = s - d; }
 
 /// Only declared but not defined. We don't want to multiply two scores due to
 /// a very high risk of overflow. So user should explicitly convert to integer.
-inline Score operator*(Score s1, Score s2);
+Score operator*(Score, Score) = delete;
 
 /// Division of a Score must be handled separately for each term
 inline Score operator/(Score s, int i) {
   return make_score(mg_value(s) / i, eg_value(s) / i);
 }
 
-#undef ENABLE_OPERATORS_ON
+/// Multiplication of a Score by an integer. We check for overflow in debug mode.
-#undef ENABLE_SAFE_OPERATORS_ON
+inline Score operator*(Score s, int i) {
 
-const Value PawnValueMidgame   = Value(0x0C6);
+  Score result = Score(int(s) * i);
-const Value PawnValueEndgame   = Value(0x102);
-const Value KnightValueMidgame = Value(0x331);
-const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame  = Value(0x9FE);
 
-extern const Value PieceValueMidgame[17];
+  assert(eg_value(result) == (i * eg_value(s)));
-extern const Value PieceValueEndgame[17];
+  assert(mg_value(result) == (i * mg_value(s)));
-extern int SquareDistance[64][64];
+  assert((i == 0) || (result / i) == s );
 
-inline Value mate_in(int ply) {
+  return result;
+}
+
+constexpr Color operator~(Color c) {
+  return Color(c ^ BLACK); // Toggle color
+}
+
+constexpr Square operator~(Square s) {
+  return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8
+}
+
+constexpr File operator~(File f) {
+  return File(f ^ FILE_H); // Horizontal flip FILE_A -> FILE_H
+}
+
+constexpr Piece operator~(Piece pc) {
+  return Piece(pc ^ 8); // Swap color of piece B_KNIGHT -> W_KNIGHT
+}
+
+constexpr CastlingRight operator|(Color c, CastlingSide s) {
+  return CastlingRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
+}
+
+constexpr Value mate_in(int ply) {
   return VALUE_MATE - ply;
 }
 
-inline Value mated_in(int ply) {
+constexpr Value mated_in(int ply) {
   return -VALUE_MATE + ply;
 }
 
-inline Piece make_piece(Color c, PieceType pt) {
+constexpr Square make_square(File f, Rank r) {
-  return Piece((c << 3) | pt);
+  return Square((r << 3) + f);
 }
 
-inline PieceType type_of(Piece p)  {
+constexpr Piece make_piece(Color c, PieceType pt) {
-  return PieceType(p & 7);
+  return Piece((c << 3) + pt);
 }
 
-inline Color color_of(Piece p) {
+constexpr PieceType type_of(Piece pc) {
-  return Color(p >> 3);
+  return PieceType(pc & 7);
 }
 
-inline Color flip(Color c) {
+inline Color color_of(Piece pc) {
-  return Color(c ^ 1);
+  assert(pc != NO_PIECE);
+  return Color(pc >> 3);
 }
 
-inline Square make_square(File f, Rank r) {
+constexpr bool is_ok(Square s) {
-  return Square((r << 3) | f);
-}
-
-inline bool square_is_ok(Square s) {
   return s >= SQ_A1 && s <= SQ_H8;
 }
 
-inline File file_of(Square s) {
+constexpr File file_of(Square s) {
   return File(s & 7);
 }
 
-inline Rank rank_of(Square s) {
+constexpr Rank rank_of(Square s) {
   return Rank(s >> 3);
 }
 
-inline Square flip(Square s) {
+constexpr Square relative_square(Color c, Square s) {
-  return Square(s ^ 56);
-}
-
-inline Square mirror(Square s) {
-  return Square(s ^ 7);
-}
-
-inline Square relative_square(Color c, Square s) {
   return Square(s ^ (c * 56));
 }
 
-inline Rank relative_rank(Color c, Rank r) {
+constexpr Rank relative_rank(Color c, Rank r) {
   return Rank(r ^ (c * 7));
 }
 
-inline Rank relative_rank(Color c, Square s) {
+constexpr Rank relative_rank(Color c, Square s) {
   return relative_rank(c, rank_of(s));
 }
 
 inline bool opposite_colors(Square s1, Square s2) {
-  int s = s1 ^ s2;
+  int s = int(s1) ^ int(s2);
   return ((s >> 3) ^ s) & 1;
 }
 
-inline int file_distance(Square s1, Square s2) {
+constexpr Direction pawn_push(Color c) {
-  return abs(file_of(s1) - file_of(s2));
+  return c == WHITE ? NORTH : SOUTH;
 }
 
-inline int rank_distance(Square s1, Square s2) {
+constexpr Square from_sq(Move m) {
-  return abs(rank_of(s1) - rank_of(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return SquareDistance[s1][s2];
-}
-
-inline char piece_type_to_char(PieceType pt) {
-  return " PNBRQK"[pt];
-}
-
-inline char file_to_char(File f) {
-  return char(f - FILE_A + int('a'));
-}
-
-inline char rank_to_char(Rank r) {
-  return char(r - RANK_1 + int('1'));
-}
-
-inline Square pawn_push(Color c) {
-  return c == WHITE ? DELTA_N : DELTA_S;
-}
-
-inline Square move_from(Move m) {
   return Square((m >> 6) & 0x3F);
 }
 
-inline Square move_to(Move m) {
+constexpr Square to_sq(Move m) {
   return Square(m & 0x3F);
 }
 
-inline bool is_special(Move m) {
+constexpr int from_to(Move m) {
-  return m & (3 << 14);
+ return m & 0xFFF;
 }
 
-inline bool is_promotion(Move m) {
+constexpr MoveType type_of(Move m) {
-  return (m & (3 << 14)) == (1 << 14);
+  return MoveType(m & (3 << 14));
 }
 
-inline int is_enpassant(Move m) {
+constexpr PieceType promotion_type(Move m) {
-  return (m & (3 << 14)) == (2 << 14);
+  return PieceType(((m >> 12) & 3) + KNIGHT);
-}
-
-inline int is_castle(Move m) {
-  return (m & (3 << 14)) == (3 << 14);
-}
-
-inline PieceType promotion_piece_type(Move m) {
-  return PieceType(((m >> 12) & 3) + 2);
 }
 
 inline Move make_move(Square from, Square to) {
-  return Move(to | (from << 6));
+  return Move((from << 6) + to);
 }
 
-inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
+template<MoveType T>
-  return Move(to | (from << 6) | (1 << 14) | ((promotion - 2) << 12)) ;
+constexpr Move make(Square from, Square to, PieceType pt = KNIGHT) {
+  return Move(T + ((pt - KNIGHT) << 12) + (from << 6) + to);
 }
 
-inline Move make_enpassant_move(Square from, Square to) {
+constexpr bool is_ok(Move m) {
-  return Move(to | (from << 6) | (2 << 14));
+  return from_sq(m) != to_sq(m); // Catch MOVE_NULL and MOVE_NONE
 }
 
-inline Move make_castle_move(Square from, Square to) {
+#endif // #ifndef TYPES_H_INCLUDED
-  return Move(to | (from << 6) | (3 << 14));
-}
-
-inline bool is_ok(Move m) {
-  return move_from(m) != move_to(m); // Catches also MOVE_NULL and MOVE_NONE
-}
-
-#include <string>
-
-inline const std::string square_to_string(Square s) {
-  char ch[] = { file_to_char(file_of(s)), rank_to_char(rank_of(s)), 0 };
-  return ch;
-}
-
-/// Our insertion sort implementation, works with pointers and iterators and is
-/// guaranteed to be stable, as is needed.
-template<typename T, typename K>
-void sort(K firstMove, K lastMove)
-{
-  T value;
-  K cur, p, d;
-
-  if (firstMove != lastMove)
-      for (cur = firstMove + 1; cur != lastMove; cur++)
-      {
-          p = d = cur;
-          value = *p--;
-          if (*p < value)
-          {
-              do *d = *p;
-              while (--d != firstMove && *--p < value);
-              *d = value;
-          }
-      }
-}
-
-#endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,123 +18,37 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
-#include <vector>
 
 #include "evaluate.h"
-#include "misc.h"
+#include "movegen.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "tt.h"
+#include "timeman.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
 using namespace std;
 
+extern vector<string> setup_bench(const Position&, istream&);
+
 namespace {
 
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-  // Keep track of position keys along the setup moves (from start position to the
-  // position just before to start searching). This is needed by draw detection
-  // where, due to 50 moves rule, we need to check at most 100 plies back.
-  StateInfo StateRingBuf[102], *SetupState = StateRingBuf;
 
-  void set_option(istringstream& up);
+  // position() is called when engine receives the "position" UCI command.
-  void set_position(Position& pos, istringstream& up);
+  // The function sets up the position described in the given FEN string ("fen")
-  void go(Position& pos, istringstream& up);
+  // or the starting position ("startpos") and then makes the moves given in the
-  void perft(Position& pos, istringstream& up);
+  // following move list ("moves").
-}
 
-
+  void position(Position& pos, istringstream& is, StateListPtr& states) {
-/// Wait for a command from the user, parse this text string as an UCI command,
-/// and call the appropriate functions. Also intercepts EOF from stdin to ensure
-/// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI
-/// commands, the function also supports a few debug commands.
-
-void uci_loop() {
-
-  Position pos(StartFEN, false, 0); // The root position
-  string cmd, token;
-
-  while (token != "quit")
-  {
-      if (!getline(cin, cmd)) // Block here waiting for input
-          cmd = "quit";
-
-      istringstream is(cmd);
-
-      is >> skipws >> token;
-
-      if (token == "quit" || token == "stop")
-          Threads.stop_thinking();
-
-      else if (token == "ponderhit")
-      {
-          // The opponent has played the expected move. GUI sends "ponderhit" if
-          // we were told to ponder on the same move the opponent has played. We
-          // should continue searching but switching from pondering to normal search.
-          Search::Limits.ponder = false;
-
-          if (Search::Signals.stopOnPonderhit)
-              Threads.stop_thinking();
-      }
-
-      else if (token == "go")
-          go(pos, is);
-
-      else if (token == "ucinewgame")
-          pos.from_fen(StartFEN, false);
-
-      else if (token == "isready")
-          cout << "readyok" << endl;
-
-      else if (token == "position")
-          set_position(pos, is);
-
-      else if (token == "setoption")
-          set_option(is);
-
-      else if (token == "perft")
-          perft(pos, is);
-
-      else if (token == "d")
-          pos.print();
-
-      else if (token == "flip")
-          pos.flip_me();
-
-      else if (token == "eval")
-      {
-          read_evaluation_uci_options(pos.side_to_move());
-          cout << trace_evaluate(pos) << endl;
-      }
-
-      else if (token == "key")
-          cout << "key: " << hex     << pos.key()
-               << "\nmaterial key: " << pos.material_key()
-               << "\npawn key: "     << pos.pawn_key() << endl;
-
-      else if (token == "uci")
-          cout << "id name "     << engine_info(true)
-               << "\n"           << Options
-               << "\nuciok"      << endl;
-      else
-          cout << "Unknown command: " << cmd << endl;
-  }
-}
-
-
-namespace {
-
-  // set_position() is called when engine receives the "position" UCI
-  // command. The function sets up the position described in the given
-  // fen string ("fen") or the starting position ("startpos") and then
-  // makes the moves given in the following move list ("moves").
-
-  void set_position(Position& pos, istringstream& is) {
 
     Move m;
     string token, fen;
@@ -151,24 +66,22 @@ namespace {
     else
         return;
 
-    pos.from_fen(fen, Options["UCI_Chess960"]);
+    states = StateListPtr(new std::deque<StateInfo>(1)); // Drop old and create a new one
+    pos.set(fen, Options["UCI_Chess960"], &states->back(), Threads.main());
 
     // Parse move list (if any)
-    while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
+    while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
     {
-        pos.do_move(m, *SetupState);
+        states->emplace_back();
-
+        pos.do_move(m, states->back());
-        // Increment pointer to StateRingBuf circular buffer
-        if (++SetupState - StateRingBuf >= 102)
-            SetupState = StateRingBuf;
     }
   }
 
 
-  // set_option() is called when engine receives the "setoption" UCI command. The
+  // setoption() is called when engine receives the "setoption" UCI command. The
   // function updates the UCI option ("name") to the given value ("value").
 
-  void set_option(istringstream& is) {
+  void setoption(istringstream& is) {
 
     string token, name, value;
 
@@ -176,87 +89,228 @@ namespace {
 
     // Read option name (can contain spaces)
     while (is >> token && token != "value")
-        name += string(" ", !name.empty()) + token;
+        name += string(" ", name.empty() ? 0 : 1) + token;
 
     // Read option value (can contain spaces)
     while (is >> token)
-        value += string(" ", !value.empty()) + token;
+        value += string(" ", value.empty() ? 0 : 1) + token;
 
-    if (!Options.count(name))
+    if (Options.count(name))
-        cout << "No such option: " << name << endl;
-
-    else if (value.empty()) // UCI buttons don't have a value
-        Options[name] = true;
-
-    else
         Options[name] = value;
+    else
+        sync_cout << "No such option: " << name << sync_endl;
   }
 
 
   // go() is called when engine receives the "go" UCI command. The function sets
-  // the thinking time and other parameters from the input string, and then starts
+  // the thinking time and other parameters from the input string, then starts
-  // the main searching thread.
+  // the search.
 
-  void go(Position& pos, istringstream& is) {
+  void go(Position& pos, istringstream& is, StateListPtr& states) {
+
+    Search::LimitsType limits;
+    string token;
+    bool ponderMode = false;
+
+    limits.startTime = now(); // As early as possible!
+
+    while (is >> token)
+        if (token == "searchmoves")
+            while (is >> token)
+                limits.searchmoves.push_back(UCI::to_move(pos, token));
+
+        else if (token == "wtime")     is >> limits.time[WHITE];
+        else if (token == "btime")     is >> limits.time[BLACK];
+        else if (token == "winc")      is >> limits.inc[WHITE];
+        else if (token == "binc")      is >> limits.inc[BLACK];
+        else if (token == "movestogo") is >> limits.movestogo;
+        else if (token == "depth")     is >> limits.depth;
+        else if (token == "nodes")     is >> limits.nodes;
+        else if (token == "movetime")  is >> limits.movetime;
+        else if (token == "mate")      is >> limits.mate;
+        else if (token == "perft")     is >> limits.perft;
+        else if (token == "infinite")  limits.infinite = 1;
+        else if (token == "ponder")    ponderMode = true;
+
+    Threads.start_thinking(pos, states, limits, ponderMode);
+  }
+
+
+  // bench() is called when engine receives the "bench" command. Firstly
+  // a list of UCI commands is setup according to bench parameters, then
+  // it is run one by one printing a summary at the end.
+
+  void bench(Position& pos, istream& args, StateListPtr& states) {
 
     string token;
-    Search::LimitsType limits;
+    uint64_t num, nodes = 0, cnt = 1;
-    std::vector<Move> searchMoves;
-    int time[] = { 0, 0 }, inc[] = { 0, 0 };
 
-    while (is >> token)
+    vector<string> list = setup_bench(pos, args);
+    num = count_if(list.begin(), list.end(), [](string s) { return s.find("go ") == 0; });
+
+    TimePoint elapsed = now();
+
+    for (const auto& cmd : list)
     {
-        if (token == "infinite")
+        istringstream is(cmd);
-            limits.infinite = true;
+        is >> skipws >> token;
-        else if (token == "ponder")
+
-            limits.ponder = true;
+        if (token == "go")
-        else if (token == "wtime")
+        {
-            is >> time[WHITE];
+            cerr << "\nPosition: " << cnt++ << '/' << num << endl;
-        else if (token == "btime")
+            go(pos, is, states);
-            is >> time[BLACK];
+            Threads.main()->wait_for_search_finished();
-        else if (token == "winc")
+            nodes += Threads.nodes_searched();
-            is >> inc[WHITE];
+        }
-        else if (token == "binc")
+        else if (token == "setoption")  setoption(is);
-            is >> inc[BLACK];
+        else if (token == "position")   position(pos, is, states);
-        else if (token == "movestogo")
+        else if (token == "ucinewgame") Search::clear();
-            is >> limits.movesToGo;
-        else if (token == "depth")
-            is >> limits.maxDepth;
-        else if (token == "nodes")
-            is >> limits.maxNodes;
-        else if (token == "movetime")
-            is >> limits.maxTime;
-        else if (token == "searchmoves")
-            while (is >> token)
-                searchMoves.push_back(move_from_uci(pos, token));
     }
 
-    limits.time = time[pos.side_to_move()];
+    elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
-    limits.increment = inc[pos.side_to_move()];
 
-    Threads.start_thinking(pos, limits, searchMoves, true);
+    dbg_print(); // Just before exiting
+
+    cerr << "\n==========================="
+         << "\nTotal time (ms) : " << elapsed
+         << "\nNodes searched  : " << nodes
+         << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
+  }
+
+} // namespace
+
+
+/// UCI::loop() waits for a command from stdin, parses it and calls the appropriate
+/// function. Also intercepts EOF from stdin to ensure gracefully exiting if the
+/// GUI dies unexpectedly. When called with some command line arguments, e.g. to
+/// run 'bench', once the command is executed the function returns immediately.
+/// In addition to the UCI ones, also some additional debug commands are supported.
+
+void UCI::loop(int argc, char* argv[]) {
+
+  Position pos;
+  string token, cmd;
+  StateListPtr states(new std::deque<StateInfo>(1));
+  auto uiThread = std::make_shared<Thread>(0);
+
+  pos.set(StartFEN, false, &states->back(), uiThread.get());
+
+  for (int i = 1; i < argc; ++i)
+      cmd += std::string(argv[i]) + " ";
+
+  do {
+      if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF
+          cmd = "quit";
+
+      istringstream is(cmd);
+
+      token.clear(); // Avoid a stale if getline() returns empty or blank line
+      is >> skipws >> token;
+
+      // The GUI sends 'ponderhit' to tell us the user has played the expected move.
+      // So 'ponderhit' will be sent if we were told to ponder on the same move the
+      // user has played. We should continue searching but switch from pondering to
+      // normal search. In case Threads.stopOnPonderhit is set we are waiting for
+      // 'ponderhit' to stop the search, for instance if max search depth is reached.
+      if (    token == "quit"
+          ||  token == "stop"
+          || (token == "ponderhit" && Threads.stopOnPonderhit))
+          Threads.stop = true;
+
+      else if (token == "ponderhit")
+          Threads.ponder = false; // Switch to normal search
+
+      else if (token == "uci")
+          sync_cout << "id name " << engine_info(true)
+                    << "\n"       << Options
+                    << "\nuciok"  << sync_endl;
+
+      else if (token == "setoption")  setoption(is);
+      else if (token == "go")         go(pos, is, states);
+      else if (token == "position")   position(pos, is, states);
+      else if (token == "ucinewgame") Search::clear();
+      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
+
+      // Additional custom non-UCI commands, mainly for debugging
+      else if (token == "flip")  pos.flip();
+      else if (token == "bench") bench(pos, is, states);
+      else if (token == "d")     sync_cout << pos << sync_endl;
+      else if (token == "eval")  sync_cout << Eval::trace(pos) << sync_endl;
+      else
+          sync_cout << "Unknown command: " << cmd << sync_endl;
+
+  } while (token != "quit" && argc == 1); // Command line args are one-shot
 }
 
 
-  // perft() is called when engine receives the "perft" command. The function
+/// UCI::value() converts a Value to a string suitable for use with the UCI
-  // calls perft() with the required search depth then prints counted leaf nodes
+/// protocol specification:
-  // and elapsed time.
+///
+/// cp <x>    The score from the engine's point of view in centipawns.
+/// mate <y>  Mate in y moves, not plies. If the engine is getting mated
+///           use negative values for y.
 
-  void perft(Position& pos, istringstream& is) {
+string UCI::value(Value v) {
 
-    int depth, time;
+  assert(-VALUE_INFINITE < v && v < VALUE_INFINITE);
 
-    if (!(is >> depth))
+  stringstream ss;
-        return;
 
-    time = system_time();
+  if (abs(v) < VALUE_MATE - MAX_PLY)
+      ss << "cp " << v * 100 / PawnValueEg;
+  else
+      ss << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
 
-    int64_t n = Search::perft(pos, depth * ONE_PLY);
+  return ss.str();
-
-    time = system_time() - time;
-
-    std::cout << "\nNodes " << n
-              << "\nTime (ms) " << time
-              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
 }
+
+
+/// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.)
+
+std::string UCI::square(Square s) {
+  return std::string{ char('a' + file_of(s)), char('1' + rank_of(s)) };
+}
+
+
+/// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q).
+/// The only special case is castling, where we print in the e1g1 notation in
+/// normal chess mode, and in e1h1 notation in chess960 mode. Internally all
+/// castling moves are always encoded as 'king captures rook'.
+
+string UCI::move(Move m, bool chess960) {
+
+  Square from = from_sq(m);
+  Square to = to_sq(m);
+
+  if (m == MOVE_NONE)
+      return "(none)";
+
+  if (m == MOVE_NULL)
+      return "0000";
+
+  if (type_of(m) == CASTLING && !chess960)
+      to = make_square(to > from ? FILE_G : FILE_C, rank_of(from));
+
+  string move = UCI::square(from) + UCI::square(to);
+
+  if (type_of(m) == PROMOTION)
+      move += " pnbrqk"[promotion_type(m)];
+
+  return move;
+}
+
+
+/// UCI::to_move() converts a string representing a move in coordinate notation
+/// (g1f3, a7a8q) to the corresponding legal Move, if any.
+
+Move UCI::to_move(const Position& pos, string& str) {
+
+  if (str.length() == 5) // Junior could send promotion piece in uppercase
+      str[4] = char(tolower(str[4]));
+
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (str == UCI::move(m, pos.is_chess960()))
+          return m;
+
+  return MOVE_NONE;
 }

src/uci.h

@@ -0,0 +1,80 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef UCI_H_INCLUDED
+#define UCI_H_INCLUDED
+
+#include <map>
+#include <string>
+
+#include "types.h"
+
+class Position;
+
+namespace UCI {
+
+class Option;
+
+/// Custom comparator because UCI options should be case insensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
+
+/// Our options container is actually a std::map
+typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
+
+/// Option class implements an option as defined by UCI protocol
+class Option {
+
+  typedef void (*OnChange)(const Option&);
+
+public:
+  Option(OnChange = nullptr);
+  Option(bool v, OnChange = nullptr);
+  Option(const char* v, OnChange = nullptr);
+  Option(int v, int minv, int maxv, OnChange = nullptr);
+
+  Option& operator=(const std::string&);
+  void operator<<(const Option&);
+  operator int() const;
+  operator std::string() const;
+
+private:
+  friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
+
+  std::string defaultValue, currentValue, type;
+  int min, max;
+  size_t idx;
+  OnChange on_change;
+};
+
+void init(OptionsMap&);
+void loop(int argc, char* argv[]);
+std::string value(Value v);
+std::string square(Square s);
+std::string move(Move m, bool chess960);
+std::string pv(const Position& pos, Depth depth, Value alpha, Value beta);
+Move to_move(const Position& pos, std::string& str);
+
+} // namespace UCI
+
+extern UCI::OptionsMap Options;
+
+#endif // #ifndef UCI_H_INCLUDED

src/ucioption.cpp

@@ -1,7 +1,8 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,75 +19,76 @@
 */
 
 #include <algorithm>
-#include <sstream>
+#include <cassert>
+#include <ostream>
 
 #include "misc.h"
+#include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "tt.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
 using std::string;
 
-OptionsMap Options; // Global object
+UCI::OptionsMap Options; // Global object
+
+namespace UCI {
+
+/// 'On change' actions, triggered by an option's value change
+void on_clear_hash(const Option&) { Search::clear(); }
+void on_hash_size(const Option& o) { TT.resize(o); }
+void on_logger(const Option& o) { start_logger(o); }
+void on_threads(const Option& o) { Threads.set(o); }
+void on_tb_path(const Option& o) { Tablebases::init(o); }
 
 
 /// Our case insensitive less() function as required by UCI protocol
-static bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); }
-
 bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
-  return lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), ci_less);
+
+  return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
+         [](char c1, char c2) { return tolower(c1) < tolower(c2); });
 }
 
 
-/// OptionsMap c'tor initializes the UCI options to their hard coded default
+/// init() initializes the UCI options to their hard-coded default values
-/// values and initializes the default value of "Threads" and "Min Split Depth"
-/// parameters according to the number of CPU cores detected.
 
-OptionsMap::OptionsMap() {
+void init(OptionsMap& o) {
 
-  int cpus = std::min(cpu_count(), MAX_THREADS);
+  // at most 2^32 clusters.
-  int msd = cpus < 8 ? 4 : 7;
+  const int MaxHashMB = Is64Bit ? 131072 : 2048;
-  OptionsMap& o = *this;
 
-  o["Use Search Log"]              = UCIOption(false);
+  o["Debug Log File"]        << Option("", on_logger);
-  o["Search Log Filename"]         = UCIOption("SearchLog.txt");
+  o["Contempt"]              << Option(20, -100, 100);
-  o["Book File"]                   = UCIOption("book.bin");
+  o["Threads"]               << Option(1, 1, 512, on_threads);
-  o["Best Book Move"]              = UCIOption(false);
+  o["Hash"]                  << Option(16, 1, MaxHashMB, on_hash_size);
-  o["Mobility (Middle Game)"]      = UCIOption(100, 0, 200);
+  o["Clear Hash"]            << Option(on_clear_hash);
-  o["Mobility (Endgame)"]          = UCIOption(100, 0, 200);
+  o["Ponder"]                << Option(false);
-  o["Passed Pawns (Middle Game)"]  = UCIOption(100, 0, 200);
+  o["MultiPV"]               << Option(1, 1, 500);
-  o["Passed Pawns (Endgame)"]      = UCIOption(100, 0, 200);
+  o["Skill Level"]           << Option(20, 0, 20);
-  o["Space"]                       = UCIOption(100, 0, 200);
+  o["Move Overhead"]         << Option(30, 0, 5000);
-  o["Aggressiveness"]              = UCIOption(100, 0, 200);
+  o["Minimum Thinking Time"] << Option(20, 0, 5000);
-  o["Cowardice"]                   = UCIOption(100, 0, 200);
+  o["Slow Mover"]            << Option(89, 10, 1000);
-  o["Min Split Depth"]             = UCIOption(msd, 4, 7);
+  o["nodestime"]             << Option(0, 0, 10000);
-  o["Max Threads per Split Point"] = UCIOption(5, 4, 8);
+  o["UCI_Chess960"]          << Option(false);
-  o["Threads"]                     = UCIOption(cpus, 1, MAX_THREADS);
+  o["SyzygyPath"]            << Option("<empty>", on_tb_path);
-  o["Use Sleeping Threads"]        = UCIOption(false);
+  o["SyzygyProbeDepth"]      << Option(1, 1, 100);
-  o["Hash"]                        = UCIOption(32, 4, 8192);
+  o["Syzygy50MoveRule"]      << Option(true);
-  o["Clear Hash"]                  = UCIOption(false, "button");
+  o["SyzygyProbeLimit"]      << Option(6, 0, 6);
-  o["Ponder"]                      = UCIOption(true);
-  o["OwnBook"]                     = UCIOption(true);
-  o["MultiPV"]                     = UCIOption(1, 1, 500);
-  o["Skill Level"]                 = UCIOption(20, 0, 20);
-  o["Emergency Move Horizon"]      = UCIOption(40, 0, 50);
-  o["Emergency Base Time"]         = UCIOption(200, 0, 30000);
-  o["Emergency Move Time"]         = UCIOption(70, 0, 5000);
-  o["Minimum Thinking Time"]       = UCIOption(20, 0, 5000);
-  o["UCI_Chess960"]                = UCIOption(false);
-  o["UCI_AnalyseMode"]             = UCIOption(false);
 }
 
 
-/// operator<<() is used to output all the UCI options in chronological insertion
+/// operator<<() is used to print all the options default values in chronological
-/// order (the idx field) and in the format defined by the UCI protocol.
+/// insertion order (the idx field) and in the format defined by the UCI protocol.
+
 std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
-  for (size_t idx = 0; idx < om.size(); idx++)
+  for (size_t idx = 0; idx < om.size(); ++idx)
-      for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it)
+      for (const auto& it : om)
-          if (it->second.idx == idx)
+          if (it.second.idx == idx)
           {
-              const UCIOption& o = it->second;
+              const Option& o = it.second;
-              os << "\noption name " << it->first << " type " << o.type;
+              os << "\noption name " << it.first << " type " << o.type;
 
               if (o.type != "button")
                   os << " default " << o.defaultValue;
@@ -96,32 +98,67 @@ std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
               break;
           }
+
   return os;
 }
 
 
-/// UCIOption class c'tors
+/// Option class constructors and conversion operators
 
-UCIOption::UCIOption(const char* v) : type("string"), min(0), max(0), idx(Options.size())
+Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
 { defaultValue = currentValue = v; }
 
-UCIOption::UCIOption(bool v, string t) : type(t), min(0), max(0), idx(Options.size())
+Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
 { defaultValue = currentValue = (v ? "true" : "false"); }
 
-UCIOption::UCIOption(int v, int minv, int maxv) : type("spin"), min(minv), max(maxv), idx(Options.size())
+Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
-{ std::ostringstream ss; ss << v; defaultValue = currentValue = ss.str(); }
+{}
+
+Option::Option(int v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
+{ defaultValue = currentValue = std::to_string(v); }
+
+Option::operator int() const {
+  assert(type == "check" || type == "spin");
+  return (type == "spin" ? stoi(currentValue) : currentValue == "true");
+}
+
+Option::operator std::string() const {
+  assert(type == "string");
+  return currentValue;
+}
 
 
-/// UCIOption::operator=() updates currentValue. Normally it's up to the GUI to
+/// operator<<() inits options and assigns idx in the correct printing order
-/// check for option's limits, but we could receive the new value directly from
-/// the user by teminal window, so let's check the bounds anyway.
 
-void UCIOption::operator=(const string& v) {
+void Option::operator<<(const Option& o) {
+
+  static size_t insert_order = 0;
+
+  *this = o;
+  idx = insert_order++;
+}
+
+
+/// operator=() updates currentValue and triggers on_change() action. It's up to
+/// the GUI to check for option's limits, but we could receive the new value from
+/// the user by console window, so let's check the bounds anyway.
+
+Option& Option::operator=(const string& v) {
 
   assert(!type.empty());
 
-  if (   !v.empty()
+  if (   (type != "button" && v.empty())
-      && (type == "check" || type == "button") == (v == "true" || v == "false")
+      || (type == "check" && v != "true" && v != "false")
-      && (type != "spin" || (atoi(v.c_str()) >= min && atoi(v.c_str()) <= max)))
+      || (type == "spin" && (stoi(v) < min || stoi(v) > max)))
+      return *this;
+
+  if (type != "button")
       currentValue = v;
+
+  if (on_change)
+      on_change(*this);
+
+  return *this;
 }
+
+} // namespace UCI

src/ucioption.h

@@ -1,74 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(UCIOPTION_H_INCLUDED)
-#define UCIOPTION_H_INCLUDED
-
-#include <cassert>
-#include <cstdlib>
-#include <map>
-#include <string>
-
-struct OptionsMap;
-
-/// UCIOption class implements an option as defined by UCI protocol
-class UCIOption {
-public:
-  UCIOption() {} // Required by std::map::operator[]
-  UCIOption(const char* v);
-  UCIOption(bool v, std::string type = "check");
-  UCIOption(int v, int min, int max);
-
-  void operator=(const std::string& v);
-  void operator=(bool v) { *this = std::string(v ? "true" : "false"); }
-
-  operator int() const {
-    assert(type == "check" || type == "button" || type == "spin");
-    return (type == "spin" ? atoi(currentValue.c_str()) : currentValue == "true");
-  }
-
-  operator std::string() const {
-    assert(type == "string");
-    return currentValue;
-  }
-
-private:
-  friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
-
-  std::string defaultValue, currentValue, type;
-  int min, max;
-  size_t idx;
-};
-
-
-/// Custom comparator because UCI options should be case insensitive
-struct CaseInsensitiveLess {
-  bool operator() (const std::string&, const std::string&) const;
-};
-
-
-/// Our options container is actually a map with a customized c'tor
-struct OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
-  OptionsMap();
-};
-
-extern std::ostream& operator<<(std::ostream&, const OptionsMap&);
-extern OptionsMap Options;
-
-#endif // !defined(UCIOPTION_H_INCLUDED)

tests/instrumented.sh

@@ -0,0 +1,123 @@
+#!/bin/bash
+# check for errors under valgrind or sanitizers.
+
+error()
+{
+  echo "instrumented testing failed on line $1"
+  exit 1
+}
+trap 'error ${LINENO}' ERR
+
+# define suitable post and prefixes for testing options
+case $1 in
+  --valgrind)
+    echo "valgrind testing started"
+    prefix=''
+    exeprefix='valgrind --error-exitcode=42'
+    postfix='1>/dev/null'
+    threads="1"
+  ;;
+  --valgrind-thread)
+    echo "valgrind-thread testing started"
+    prefix=''
+    exeprefix='valgrind --error-exitcode=42'
+    postfix='1>/dev/null'
+    threads="2"
+  ;;
+  --sanitizer-undefined)
+    echo "sanitizer-undefined testing started"
+    prefix='!'
+    exeprefix=''
+    postfix='2>&1 | grep "runtime error:"'
+    threads="1"
+  ;;
+  --sanitizer-thread)
+    echo "sanitizer-thread testing started"
+    prefix='!'
+    exeprefix=''
+    postfix='2>&1 | grep "WARNING: ThreadSanitizer:"'
+    threads="2"
+
+cat << EOF > tsan.supp
+race:TTEntry::move
+race:TTEntry::depth
+race:TTEntry::bound
+race:TTEntry::save
+race:TTEntry::value
+race:TTEntry::eval
+
+race:TranspositionTable::probe
+race:TranspositionTable::hashfull
+
+EOF
+
+    export TSAN_OPTIONS="suppressions=./tsan.supp"
+
+  ;;
+  *)
+    echo "unknown testing started"
+    prefix=''
+    exeprefix=''
+    postfix=''
+    threads="1"
+  ;;
+esac
+
+# simple command line testing
+for args in "eval" \
+            "go nodes 1000" \
+            "go depth 10" \
+            "go movetime 1000" \
+            "go wtime 8000 btime 8000 winc 500 binc 500" \
+            "bench 128 $threads 10 default depth"
+do
+
+   echo "$prefix $exeprefix ./stockfish $args $postfix"
+   eval "$prefix $exeprefix ./stockfish $args $postfix"
+
+done
+
+# more general testing, following an uci protocol exchange
+cat << EOF > game.exp
+ set timeout 10
+ spawn $exeprefix ./stockfish
+
+ send "uci\n"
+ expect "uciok"
+
+ send "setoption name Threads value $threads\n"
+
+ send "ucinewgame\n"
+ send "position startpos\n"
+ send "go nodes 1000\n"
+ expect "bestmove"
+
+ send "position startpos moves e2e4 e7e6\n"
+ send "go nodes 1000\n"
+ expect "bestmove"
+
+ send "position fen 5rk1/1K4p1/8/8/3B4/8/8/8 b - - 0 1\n"
+ send "go depth 30\n"
+ expect "bestmove"
+
+ send "quit\n"
+ expect eof
+
+ # return error code of the spawned program, useful for valgrind
+ lassign [wait] pid spawnid os_error_flag value
+ exit \$value
+EOF
+
+for exps in game.exp
+do
+
+  echo "$prefix expect $exps $postfix"
+  eval "$prefix expect $exps $postfix"
+
+  rm $exps
+
+done
+
+rm -f tsan.supp
+
+echo "instrumented testing OK"

tests/perft.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# verify perft numbers (positions from https://chessprogramming.wikispaces.com/Perft+Results)
+
+error()
+{
+  echo "perft testing failed on line $1"
+  exit 1
+}
+trap 'error ${LINENO}' ERR
+
+echo "perft testing started"
+
+cat << EOF > perft.exp
+   set timeout 10
+   lassign \$argv pos depth result
+   spawn ./stockfish
+   send "position \$pos\\ngo perft \$depth\\n"
+   expect "Nodes searched? \$result" {} timeout {exit 1}
+   send "quit\\n"
+   expect eof
+EOF
+
+expect perft.exp startpos 5 4865609 > /dev/null
+expect perft.exp "fen r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -" 5 193690690 > /dev/null
+expect perft.exp "fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -" 6 11030083 > /dev/null
+expect perft.exp "fen r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1" 5 15833292 > /dev/null
+expect perft.exp "fen rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8" 5 89941194 > /dev/null
+expect perft.exp "fen r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10" 5 164075551 > /dev/null
+
+rm perft.exp
+
+echo "perft testing OK"

tests/reprosearch.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# verify reproducible search
+
+error()
+{
+  echo "reprosearch testing failed on line $1"
+  exit 1
+}
+trap 'error ${LINENO}' ERR
+
+echo "reprosearch testing started"
+
+# repeat two short games, separated by ucinewgame. 
+# with go nodes $nodes they should result in exactly
+# the same node count for each iteration.
+cat << EOF > repeat.exp
+ set timeout 10
+ spawn ./stockfish
+ lassign \$argv nodes
+
+ send "uci\n"
+ expect "uciok"
+
+ send "ucinewgame\n"
+ send "position startpos\n"
+ send "go nodes \$nodes\n"
+ expect "bestmove"
+
+ send "position startpos moves e2e4 e7e6\n"
+ send "go nodes \$nodes\n"
+ expect "bestmove"
+
+ send "ucinewgame\n"
+ send "position startpos\n"
+ send "go nodes \$nodes\n"
+ expect "bestmove"
+
+ send "position startpos moves e2e4 e7e6\n"
+ send "go nodes \$nodes\n"
+ expect "bestmove"
+
+ send "quit\n"
+ expect eof
+EOF
+
+# to increase the likelyhood of finding a non-reproducible case,
+# the allowed number of nodes are varied systematically
+for i in `seq 1 20`
+do
+
+  nodes=$((100*3**i/2**i))
+  echo "reprosearch testing with $nodes nodes"
+
+  # each line should appear exactly an even number of times
+  expect repeat.exp $nodes 2>&1 | grep -o "nodes [0-9]*" | sort | uniq -c | awk '{if ($1%2!=0) exit(1)}'
+
+done
+
+rm repeat.exp
+
+echo "reprosearch testing OK"

tests/signature.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+# obtain and optionally verify Bench / signature
+# if no reference is given, the output is deliberately limited to just the signature
+
+error()
+{
+  echo "running bench for signature failed on line $1"
+  exit 1
+}
+trap 'error ${LINENO}' ERR
+
+# obtain
+
+signature=`./stockfish bench 2>&1 | grep "Nodes searched  : " | awk '{print $4}'`
+
+if [ $# -gt 0 ]; then
+   # compare to given reference
+   if [ "$1" != "$signature" ]; then
+      echo "signature mismatch: reference $1 obtained $signature"
+      exit 1
+   else
+      echo "signature OK: $signature"
+   fi
+else
+   # just report signature
+   echo $signature
+fi