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

@@ -1,5 +1,8 @@
 ### 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
@@ -7,14 +10,12 @@ 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 64 CPUs, but has not been
-tested thoroughly with more than 4.  The program tries to detect the
-number of CPUs on your computer and sets 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 the *Min Split Depth* UCI parameter to 7.
+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
@@ -25,20 +26,60 @@ This distribution of Stockfish consists of the following files:
 
   * 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 below.
-
-  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
-    adapter.
+  * src, a subdirectory containing the full source code, including a Makefile
+    that can be used to compile Stockfish on Unix-like systems.
 
 
-### Opening books
+### Syzygybases
 
-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 *Book File*
-UCI parameter.
+**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
@@ -50,11 +91,19 @@ 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 Makefile to
+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
 
@@ -71,4 +120,4 @@ 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*
+*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
-Contempt Factor = 0
-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-2013 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
@@ -21,26 +22,25 @@
 ### ==========================================================================
 
 ### Establish the operating system name
-UNAME = $(shell uname)
+KERNEL = $(shell uname -s)
+ifeq ($(KERNEL),Linux)
+	OS = $(shell uname -o)
+endif
 
 ### Executable name
 EXE = stockfish
 
 ### Installation dir definitions
 PREFIX = /usr/local
-# Haiku has a non-standard filesystem layout
-ifeq ($(UNAME),Haiku)
-	PREFIX=/boot/common
-endif
 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 \
-	material.o misc.o movegen.o movepick.o notation.o pawns.o position.o \
-	search.o thread.o timeman.o tt.o uci.o ucioption.o
+OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.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 syzygy/tbprobe.o
 
 ### ==========================================================================
 ### Section 2. High-level Configuration
@@ -50,138 +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
-# prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch x86 asm-instruction
-# bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
-#                                              with GCC and ICC 64-bit)
-# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
+# prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch asm-instruction
+# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt asm-instruction
 # sse = yes/no        --- -msse            --- Use Intel Streaming SIMD Extensions
+# pext = yes/no       --- -DUSE_PEXT       --- Use pext 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
-debug = no
+### 2.1. General and architecture defaults
 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
-	prefetch = no
-	bsfq = no
-	popcnt = no
-	sse = no
-endif
-
 ifeq ($(ARCH),general-32)
 	arch = any
-	os = any
-	bits = 32
-	prefetch = no
-	bsfq = no
-	popcnt = no
-	sse = no
 endif
 
-# x86-section
+ifeq ($(ARCH),x86-32-old)
+	arch = i386
+endif
+
+ifeq ($(ARCH),x86-32)
+	arch = i386
+	prefetch = yes
+	sse = yes
+endif
+
+ifeq ($(ARCH),general-64)
+	arch = any
+	bits = 64
+endif
+
 ifeq ($(ARCH),x86-64)
 	arch = x86_64
-	os = any
 	bits = 64
 	prefetch = yes
-	bsfq = yes
-	popcnt = no
 	sse = yes
 endif
 
 ifeq ($(ARCH),x86-64-modern)
 	arch = x86_64
-	os = any
 	bits = 64
 	prefetch = yes
-	bsfq = yes
 	popcnt = yes
 	sse = yes
 endif
 
-ifeq ($(ARCH),x86-32)
-	arch = i386
-	os = any
-	bits = 32
+ifeq ($(ARCH),x86-64-bmi2)
+	arch = x86_64
+	bits = 64
 	prefetch = yes
-	bsfq = no
-	popcnt = no
+	popcnt = yes
 	sse = yes
+	pext = yes
 endif
 
-ifeq ($(ARCH),x86-32-old)
-	arch = i386
-	os = any
-	bits = 32
-	prefetch = no
-	bsfq = no
-	popcnt = no
-	sse = no
-endif
-
-#arm section
 ifeq ($(ARCH),armv7)
 	arch = armv7
-	os = any
-	bits = 32
 	prefetch = yes
-	bsfq = yes
-	popcnt = no
-	sse = no
 endif
 
-# osx-section
-ifeq ($(ARCH),osx-ppc-64)
-	arch = ppc64
-	os = osx
-	bits = 64
-	prefetch = no
-	bsfq = no
-	popcnt = no
-	sse = no
-endif
-
-ifeq ($(ARCH),osx-ppc-32)
+ifeq ($(ARCH),ppc-32)
 	arch = ppc
-	os = osx
-	bits = 32
-	prefetch = no
-	bsfq = no
-	popcnt = no
-	sse = no
 endif
 
-ifeq ($(ARCH),osx-x86-64)
-	arch = x86_64
-	os = osx
+ifeq ($(ARCH),ppc-64)
+	arch = ppc64
 	bits = 64
-	prefetch = yes
-	bsfq = yes
-	popcnt = no
-	sse = yes
-endif
-
-ifeq ($(ARCH),osx-x86-32)
-	arch = i386
-	os = osx
-	bits = 32
-	prefetch = yes
-	bsfq = no
-	popcnt = no
-	sse = yes
 endif
 
 
@@ -190,100 +140,147 @@ 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
-	profile_make = gcc-profile-make
-	profile_use = gcc-profile-use
-	profile_clean = gcc-profile-clean
+	CXXFLAGS += -pedantic -Wextra -Wshadow
+
+	ifeq ($(ARCH),armv7)
+		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
-	profile_make = icc-profile-make
-	profile_use = icc-profile-use
-	profile_clean = icc-profile-clean
+	CXXFLAGS += -diag-disable 1476,10120 -Wcheck -Wabi -Wdeprecated -strict-ansi
 endif
 
 ifeq ($(COMP),clang)
 	comp=clang
 	CXX=clang++
-	profile_prepare = gcc-profile-prepare
-	profile_make = gcc-profile-make
-	profile_use = gcc-profile-use
-	profile_clean = gcc-profile-clean
+	CXXFLAGS += -pedantic -Wextra -Wshadow
+ifneq ($(KERNEL),Darwin)
+ifneq ($(KERNEL),OpenBSD)
+	LDFLAGS += -latomic
+endif
 endif
 
-### 3.2 General compiler settings
-CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
-
-ifeq ($(comp),gcc)
-	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
-endif
-
-ifeq ($(comp),mingw)
-	CXXFLAGS += -Wextra -Wshadow
+	ifeq ($(ARCH),armv7)
+		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,1476,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
-endif
-
+	profile_make = icc-profile-make
+	profile_use = icc-profile-use
+else
 ifeq ($(comp),clang)
-	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
+	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)
-	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.0
+ifeq ($(KERNEL),Darwin)
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.9
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.9
 endif
 
-### 3.3 General linker settings
-LDFLAGS = $(EXTRALDFLAGS)
+### Travis CI script uses COMPILER to overwrite CXX
+ifdef COMPILER
+	COMPCXX=$(COMPILER)
+endif
 
-ifeq ($(comp),mingw)
-	LDFLAGS += -static-libstdc++ -static-libgcc
+### Allow overwriting CXX from command line
+ifdef COMPCXX
+	CXX=$(COMPCXX)
 endif
 
 ### On mingw use Windows threads, otherwise POSIX
 ifneq ($(comp),mingw)
-	# Haiku has pthreads in its libroot, so only link it in on other platforms
-	ifneq ($(UNAME),Haiku)
-		LDFLAGS += -lpthread
+	# 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
 
-ifeq ($(os),osx)
-	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.0
-endif
-
-### 3.4 Debugging
+### 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
+	CXXFLAGS += -O3
 
-		ifeq ($(os),osx)
+	ifeq ($(comp),gcc)
+
+		ifeq ($(KERNEL),Darwin)
 			ifeq ($(arch),i386)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
@@ -292,28 +289,21 @@ ifeq ($(optimize),yes)
 			endif
 		endif
 
-		ifeq ($(arch),armv7)
-			CXXFLAGS += -fno-gcse
+		ifeq ($(OS), Android)
+			CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
 		endif
 	endif
 
-	ifeq ($(comp),mingw)
-		CXXFLAGS += -O3
-	endif
-
 	ifeq ($(comp),icc)
-		ifeq ($(os),osx)
-			CXXFLAGS += -fast -mdynamic-no-pic
-		else
-			CXXFLAGS += -O3
+		ifeq ($(KERNEL),Darwin)
+			CXXFLAGS += -mdynamic-no-pic
 		endif
 	endif
 
 	ifeq ($(comp),clang)
-		### -O4 requires a linker that supports LLVM's LTO
-		CXXFLAGS += -O3
-
-		ifeq ($(os),osx)
+		ifeq ($(KERNEL),Darwin)
+				CXXFLAGS += -flto
+				LDFLAGS += $(CXXFLAGS)
 			ifeq ($(arch),i386)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
@@ -324,12 +314,12 @@ ifeq ($(optimize),yes)
 	endif
 endif
 
-### 3.6. Bits
+### 3.4 Bits
 ifeq ($(bits),64)
 	CXXFLAGS += -DIS_64BIT
 endif
 
-### 3.7 prefetch
+### 3.5 prefetch
 ifeq ($(prefetch),yes)
 	ifeq ($(sse),yes)
 		CXXFLAGS += -msse
@@ -339,30 +329,54 @@ else
 	CXXFLAGS += -DNO_PREFETCH
 endif
 
-### 3.8 bsfq
-ifeq ($(bsfq),yes)
-	CXXFLAGS += -DUSE_BSFQ
-endif
-
-### 3.9 popcnt
+### 3.6 popcnt
 ifeq ($(popcnt),yes)
-	CXXFLAGS += -msse3 -DUSE_POPCNT
+	ifeq ($(comp),icc)
+		CXXFLAGS += -msse3 -DUSE_POPCNT
+	else
+		CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT
+	endif
 endif
 
-### 3.10 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)
 	ifeq ($(optimize),yes)
-		GCC_MAJOR := `$(CXX) -dumpversion | cut -f1 -d.`
-		GCC_MINOR := `$(CXX) -dumpversion | cut -f2 -d.`
-		ifeq (1,$(shell expr \( $(GCC_MAJOR) \> 4 \) \| \( $(GCC_MAJOR) \= 4 \& $(GCC_MINOR) \>= 5 \)))
-			CXXFLAGS += -flto
-			LDFLAGS += $(CXXFLAGS)
-		endif
+	ifeq ($(debug),no)
+		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
 ### ==========================================================================
@@ -371,71 +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 "profile-build        > Build PGO-optimized version"
-	@echo "strip                > Strip executable"
-	@echo "install              > Install executable"
-	@echo "clean                > Clean up"
-	@echo "testrun              > Make sample run"
+	@echo "build                   > Standard build"
+	@echo "profile-build           > PGO build"
+	@echo "strip                   > Strip executable"
+	@echo "install                 > Install executable"
+	@echo "clean                   > Clean up"
 	@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-32               > x86 32-bit excluding old hardware without SSE-support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 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 "x86-64                  > x86 64-bit"
+	@echo "x86-64-modern           > x86 64-bit with popcnt support"
+	@echo "x86-64-bmi2             > x86 64-bit with pext support"
+	@echo "x86-32                  > x86 32-bit with SSE support"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
+	@echo "ppc-64                  > PPC 64-bit"
+	@echo "ppc-32                  > PPC 32-bit"
+	@echo "armv7                   > ARMv7 32-bit"
+	@echo "general-64              > unspecified 64-bit"
+	@echo "general-32              > unspecified 32-bit"
 	@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 "gcc                     > Gnu compiler (default)"
+	@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 profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo "make build ARCH=x86-64 COMP=clang"
+	@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:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+profile-build: config-sanity objclean profileclean
 	@echo ""
-	@echo "Step 0/4. Preparing for profile build."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
-	@echo ""
-	@echo "Step 1/4. Building executable for benchmark ..."
-	@touch *.cpp *.h
+	@echo "Step 1/4. Building instrumented executable ..."
 	$(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 ..."
-	@touch *.cpp
+	@echo "Step 3/4. Building optimized executable ..."
+	$(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
 
 strip:
 	strip $(EXE)
@@ -445,11 +457,19 @@ install:
 	-cp $(EXE) $(BINDIR)
 	-strip $(BINDIR)/$(EXE)
 
-clean:
-	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
+#clean all
+clean: objclean profileclean
+	@rm -f .depend *~ core
 
-testrun:
-	@$(PGOBENCH)
+# clean binaries and objects
+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
@@ -464,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 "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)"
@@ -481,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)" = "armv7"
-	@test "$(os)" = "any" || test "$(os)" = "osx"
 	@test "$(bits)" = "32" || test "$(bits)" = "64"
 	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
-	@test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
 	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
 	@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:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) gcc-profile-clean
+clang-profile-make:
+	$(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) \
@@ -506,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
@@ -527,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 -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-2013 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
@@ -22,22 +23,20 @@
 #include <istream>
 #include <vector>
 
-#include "misc.h"
 #include "position.h"
-#include "search.h"
-#include "thread.h"
-#include "tt.h"
-#include "ucioption.h"
 
 using namespace std;
 
-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",
-  "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 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 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",
@@ -47,49 +46,77 @@ 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
-/// of positions for a given limit each. There are five parameters; the
-/// transposition table size, the number of search threads that should
-/// be used, the limit value spent for each position (optional, default is
-/// depth 12), an optional file name where to look for positions in fen
-/// format (defaults are the positions defined above) and the type of the
-/// limit value: depth (default), time in secs or number of nodes.
+/// setup_bench() builds a list of UCI commands to be run by bench. There
+/// are five parameters: TT size in MB, number of search threads that
+/// should be used, the limit value spent for each position, a file name
+/// where to look for positions in FEN format and the type of the limit:
+/// depth, perft, nodes and movetime (in millisecs).
+///
+/// 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(const Position& current, istream& is) {
+vector<string> setup_bench(const Position& current, istream& is) {
 
-  string token;
-  Search::LimitsType limits;
-  vector<string> fens;
+  vector<string> fens, list;
+  string go, token;
 
   // Assign default values to missing arguments
-  string ttSize    = (is >> token) ? token : "32";
+  string ttSize    = (is >> token) ? token : "16";
   string threads   = (is >> token) ? token : "1";
-  string limit     = (is >> token) ? token : "12";
+  string limit     = (is >> token) ? token : "13";
   string fenFile   = (is >> token) ? token : "default";
   string limitType = (is >> token) ? token : "depth";
 
-  Options["Hash"]    = ttSize;
-  Options["Threads"] = threads;
-  TT.clear();
-
-  if (limitType == "time")
-      limits.movetime = 1000 * atoi(limit.c_str()); // movetime is in ms
-
-  else if (limitType == "nodes")
-      limits.nodes = atoi(limit.c_str());
-
-  else if (limitType == "mate")
-      limits.mate = atoi(limit.c_str());
-
-  else
-      limits.depth = atoi(limit.c_str());
+  go = "go " + limitType + " " + limit;
 
   if (fenFile == "default")
-      fens.assign(Defaults, Defaults + 16);
+      fens = Defaults;
 
   else if (fenFile == "current")
       fens.push_back(current.fen());
@@ -97,12 +124,12 @@ void benchmark(const Position& current, istream& is) {
   else
   {
       string fen;
-      ifstream file(fenFile.c_str());
+      ifstream file(fenFile);
 
       if (!file.is_open())
       {
           cerr << "Unable to open file " << fenFile << endl;
-          return;
+          exit(EXIT_FAILURE);
       }
 
       while (getline(file, fen))
@@ -112,34 +139,18 @@ void benchmark(const Position& current, istream& is) {
       file.close();
   }
 
-  int64_t nodes = 0;
-  Search::StateStackPtr st;
-  Time::point elapsed = Time::now();
+  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++)
-  {
-      Position pos(fens[i], Options["UCI_Chess960"], Threads.main_thread());
-
-      cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
-
-      if (limitType == "perft")
-      {
-          size_t cnt = Search::perft(pos, limits.depth * ONE_PLY);
-          cerr << "\nPerft " << limits.depth  << " leaf nodes: " << cnt << endl;
-          nodes += cnt;
-      }
+  for (const string& fen : fens)
+      if (fen.find("setoption") != string::npos)
+          list.emplace_back(fen);
       else
       {
-          Threads.start_thinking(pos, limits, vector<Move>(), st);
-          Threads.wait_for_think_finished();
-          nodes += Search::RootPos.nodes_searched();
+          list.emplace_back("position fen " + fen);
+          list.emplace_back(go);
       }
-  }
 
-  elapsed = Time::now() - elapsed + 1; // Assure positive to avoid a 'divide by zero'
-
-  cerr << "\n==========================="
-       << "\nTotal time (ms) : " << elapsed
-       << "\nNodes searched  : " << nodes
-       << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
+  return list;
 }

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-2013 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,7 +18,9 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
 #include <cassert>
+#include <numeric>
 #include <vector>
 
 #include "bitboard.h"
@@ -25,23 +28,23 @@
 
 namespace {
 
-  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
-  const unsigned IndexMax = 2*24*64*64; // stm * psq * wksq * bksq = 196608
+  // There are 24 possible pawn squares: the first 4 files and ranks from 2 to 7
+  const unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608
 
   // Each uint32_t stores results of 32 positions, one per bit
-  uint32_t KPKBitbase[IndexMax / 32];
+  uint32_t KPKBitbase[MAX_INDEX / 32];
 
   // A KPK bitbase index is an integer in [0, IndexMax] range
   //
-  // Information is mapped in a way that minimizes number of iterations:
+  // 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 6 - rank (from 6 - RANK_7 to 6 - RANK_2)
+  // 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) + ((6 - rank_of(psq)) << 15);
+    return wksq | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15);
   }
 
   enum Result {
@@ -51,27 +54,26 @@ namespace {
     WIN     = 4
   };
 
-  inline Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+  Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
 
   struct KPKPosition {
-
-    operator Result() const { return res; }
-    Result classify_leaf(unsigned idx);
+    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); }
 
-  private:
     template<Color Us> Result classify(const std::vector<KPKPosition>& db);
 
     Color us;
-    Square bksq, wksq, psq;
-    Result res;
+    Square ksq[COLOR_NB], psq;
+    Result result;
   };
 
 } // namespace
 
 
-bool Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color us) {
+bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color us) {
 
   assert(file_of(wpsq) <= FILE_D);
 
@@ -80,24 +82,23 @@ bool Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color us) {
 }
 
 
-void Bitbases::init_kpk() {
+void Bitbases::init() {
 
+  std::vector<KPKPosition> db(MAX_INDEX);
   unsigned idx, repeat = 1;
-  std::vector<KPKPosition> db(IndexMax);
 
   // Initialize db with known win / draw positions
-  for (idx = 0; idx < IndexMax; idx++)
-      db[idx].classify_leaf(idx);
+  for (idx = 0; idx < MAX_INDEX; ++idx)
+      db[idx] = KPKPosition(idx);
 
-  // Iterate through the positions until no more of the unknown positions can be
+  // Iterate through the positions until none of the unknown positions can be
   // changed to either wins or draws (15 cycles needed).
   while (repeat)
-      for (repeat = idx = 0; idx < IndexMax; idx++)
-          if (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN)
-              repeat = 1;
+      for (repeat = idx = 0; idx < MAX_INDEX; ++idx)
+          repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);
 
   // Map 32 results into one KPKBitbase[] entry
-  for (idx = 0; idx < IndexMax; idx++)
+  for (idx = 0; idx < MAX_INDEX; ++idx)
       if (db[idx] == WIN)
           KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
 }
@@ -105,69 +106,75 @@ void Bitbases::init_kpk() {
 
 namespace {
 
-  Result KPKPosition::classify_leaf(unsigned idx) {
+  KPKPosition::KPKPosition(unsigned idx) {
 
-    wksq = Square((idx >> 0) & 0x3F);
-    bksq = Square((idx >> 6) & 0x3F);
-    us   = Color((idx >> 12) & 0x01);
-    psq  = File((idx >> 13) & 3) | Rank(6 - (idx >> 15));
+    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 (   wksq == psq || wksq == bksq || bksq == psq
-        || (StepAttacksBB[KING][wksq] & bksq)
-        || (us == WHITE && (StepAttacksBB[PAWN][psq] & bksq)))
-        return res = INVALID;
+    if (   distance(ksq[WHITE], ksq[BLACK]) <= 1
+        || ksq[WHITE] == psq
+        || ksq[BLACK] == psq
+        || (us == WHITE && (PawnAttacks[WHITE][psq] & ksq[BLACK])))
+        result = INVALID;
 
-    if (us == WHITE)
-    {
-        // Immediate win if pawn can be promoted without getting captured
-        if (   rank_of(psq) == RANK_7
-            && wksq != psq + DELTA_N
-            && (   square_distance(bksq, psq + DELTA_N) > 1
-                ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N))))
-            return res = WIN;
-    }
-    // Immediate draw if is stalemate or king captures undefended pawn
-    else if (  !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq]))
-             || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq]))
-        return res = DRAW;
+    // 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;
 
-    return res = UNKNOWN;
+    // 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
+    // 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 DRAW otherwise the current
+    // as DRAW, the current position is classified as DRAW, otherwise the current
     // position is classified as UNKNOWN.
     //
-    // Black to Move: If one move leads to a position classified as DRAW, the result
+    // 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
-    // as WIN, the position is classified WIN otherwise the current position is
-    // classified UNKNOWN.
+    // as WIN, the position is classified as WIN, otherwise the current position is
+    // classified as UNKNOWN.
+
+    const Color  Them = (Us == WHITE ? BLACK : WHITE);
+    const Result Good = (Us == WHITE ? WIN   : DRAW);
+    const Result Bad  = (Us == WHITE ? DRAW  : WIN);
 
     Result r = INVALID;
-    Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq];
+    Bitboard b = PseudoAttacks[KING][ksq[Us]];
 
     while (b)
-        r |= Us == WHITE ? db[index(~Us, bksq, pop_lsb(&b), psq)]
-                         : db[index(~Us, pop_lsb(&b), wksq, psq)];
-
-    if (Us == WHITE && rank_of(psq) < RANK_7)
-    {
-        Square s = psq + DELTA_N;
-        r |= db[index(BLACK, bksq, wksq, s)]; // Single push
-
-        if (rank_of(s) == RANK_3 && s != wksq && s != bksq)
-            r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push
-    }
+        r |= Us == WHITE ? db[index(Them, ksq[Them]  , pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), ksq[Them]  , psq)];
 
     if (Us == WHITE)
-        return res = r & WIN  ? WIN  : r & UNKNOWN ? UNKNOWN : DRAW;
-    else
-        return res = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN;
+    {
+        if (rank_of(psq) < RANK_7)      // Single push
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH)];
+
+        if (   rank_of(psq) == RANK_2   // Double push
+            && psq + NORTH != ksq[Us]
+            && psq + NORTH != ksq[Them])
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH + NORTH)];
+    }
+
+    return result = r & Good  ? Good  : r & UNKNOWN ? UNKNOWN : Bad;
   }
 
 } // namespace

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-2013 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,85 +19,75 @@
 */
 
 #include <algorithm>
-#include <cstring>
-#include <iostream>
 
 #include "bitboard.h"
-#include "bitcount.h"
 #include "misc.h"
-#include "rkiss.h"
 
-CACHE_LINE_ALIGNMENT
-
-Bitboard RMasks[SQUARE_NB];
-Bitboard RMagics[SQUARE_NB];
-Bitboard* RAttacks[SQUARE_NB];
-unsigned RShifts[SQUARE_NB];
-
-Bitboard BMasks[SQUARE_NB];
-Bitboard BMagics[SQUARE_NB];
-Bitboard* BAttacks[SQUARE_NB];
-unsigned BShifts[SQUARE_NB];
+uint8_t PopCnt16[1 << 16];
+int SquareDistance[SQUARE_NB][SQUARE_NB];
 
 Bitboard SquareBB[SQUARE_NB];
 Bitboard FileBB[FILE_NB];
 Bitboard RankBB[RANK_NB];
 Bitboard AdjacentFilesBB[FILE_NB];
-Bitboard ThisAndAdjacentFilesBB[FILE_NB];
-Bitboard InFrontBB[COLOR_NB][RANK_NB];
-Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
 Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
-Bitboard DistanceRingsBB[SQUARE_NB][8];
-Bitboard ForwardBB[COLOR_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 AttackSpanMask[COLOR_NB][SQUARE_NB];
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
 Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
+Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
 
-int SquareDistance[SQUARE_NB][SQUARE_NB];
+Magic RookMagics[SQUARE_NB];
+Magic BishopMagics[SQUARE_NB];
 
 namespace {
 
   // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
-  const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
-  const uint32_t DeBruijn_32 = 0x783A9B23;
+  const uint64_t DeBruijn64 = 0x3F79D71B4CB0A89ULL;
+  const uint32_t DeBruijn32 = 0x783A9B23;
 
-  CACHE_LINE_ALIGNMENT
+  int MSBTable[256];            // To implement software msb()
+  Square BSFTable[SQUARE_NB];   // To implement software bitscan
+  Bitboard RookTable[0x19000];  // To store rook attacks
+  Bitboard BishopTable[0x1480]; // To store bishop attacks
 
-  int MS1BTable[256];
-  Square BSFTable[SQUARE_NB];
-  Bitboard RTable[0x19000]; // Storage space for rook attacks
-  Bitboard BTable[0x1480];  // Storage space for bishop attacks
+  void init_magics(Bitboard table[], Magic magics[], Direction directions[]);
 
-  typedef unsigned (Fn)(Square, Bitboard);
+  // 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.
 
-  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
+  unsigned bsf_index(Bitboard b) {
+    b ^= b - 1;
+    return Is64Bit ? (b * DeBruijn64) >> 58
+                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn32) >> 26;
+  }
 
-  FORCE_INLINE unsigned bsf_index(Bitboard b) {
 
-    // Matt Taylor's folding for 32 bit systems, extended to 64 bits by Kim Walisch
-    b ^= (b - 1);
-    return Is64Bit ? (b * DeBruijn_64) >> 58
-                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn_32) >> 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;
   }
 }
 
-/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
-/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
+#ifdef NO_BSF
 
-#if !defined(USE_BSFQ)
+/// Software fall-back of lsb() and msb() for CPU lacking hardware support
 
-Square lsb(Bitboard b) { return BSFTable[bsf_index(b)]; }
-
-Square pop_lsb(Bitboard* b) {
-
-  Bitboard bb = *b;
-  *b = bb & (bb - 1);
-  return BSFTable[bsf_index(bb)];
+Square lsb(Bitboard b) {
+  assert(b);
+  return BSFTable[bsf_index(b)];
 }
 
 Square msb(Bitboard b) {
 
+  assert(b);
   unsigned b32;
   int result = 0;
 
@@ -120,131 +111,128 @@ Square msb(Bitboard b) {
       result += 8;
   }
 
-  return (Square)(result + MS1BTable[b32]);
+  return Square(result + MSBTable[b32]);
 }
 
-#endif // !defined(USE_BSFQ)
+#endif // ifdef NO_BSF
 
 
-/// Bitboards::print() prints a bitboard in an easily readable format to the
-/// standard output. This is sometimes useful for debugging.
+/// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
+/// to be printed to standard output. Useful for debugging.
 
-void Bitboards::print(Bitboard b) {
+const std::string Bitboards::pretty(Bitboard b) {
 
-  sync_cout;
+  std::string s = "+---+---+---+---+---+---+---+---+\n";
 
-  for (Rank rank = RANK_8; rank >= RANK_1; rank--)
+  for (Rank r = RANK_8; r >= RANK_1; --r)
   {
-      std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
+      for (File f = FILE_A; f <= FILE_H; ++f)
+          s += b & make_square(f, r) ? "| X " : "|   ";
 
-      for (File file = FILE_A; file <= FILE_H; file++)
-          std::cout << "| " << (b & (file | rank) ? "X " : "  ");
-
-      std::cout << "|\n";
+      s += "|\n+---+---+---+---+---+---+---+---+\n";
   }
-  std::cout << "+---+---+---+---+---+---+---+---+" << sync_endl;
+
+  return s;
 }
 
 
-/// Bitboards::init() initializes various bitboard arrays. It is called during
-/// program initialization.
+/// 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 (int k = 0, i = 0; i < 8; i++)
-      while (k < (2 << i))
-          MS1BTable[k++] = i;
+  for (unsigned i = 0; i < (1 << 16); ++i)
+      PopCnt16[i] = (uint8_t) popcount16(i);
 
-  for (int i = 0; i < 64; i++)
-      BSFTable[bsf_index(1ULL << i)] = Square(i);
-
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
+  {
       SquareBB[s] = 1ULL << s;
-
-  FileBB[FILE_A] = FileABB;
-  RankBB[RANK_1] = Rank1BB;
-
-  for (int i = 1; i < 8; i++)
-  {
-      FileBB[i] = FileBB[i - 1] << 1;
-      RankBB[i] = RankBB[i - 1] << 8;
+      BSFTable[bsf_index(SquareBB[s])] = s;
   }
 
-  for (File f = FILE_A; f <= FILE_H; f++)
-  {
+  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);
-      ThisAndAdjacentFilesBB[f] = FileBB[f] | AdjacentFilesBB[f];
-  }
 
-  for (Rank r = RANK_1; r < RANK_8; r++)
-      InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
+  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++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
-          ForwardBB[c][s]      = InFrontBB[c][rank_of(s)] & FileBB[file_of(s)];
-          PassedPawnMask[c][s] = InFrontBB[c][rank_of(s)] & ThisAndAdjacentFilesBB[file_of(s)];
-          AttackSpanMask[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(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++)
-          SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
+  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;
+          }
 
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (int d = 1; d < 8; d++)
-          for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-              if (SquareDistance[s1][s2] == d)
-                  DistanceRingsBB[s1][d - 1] |= s2;
+  int steps[][5] = { {}, { 7, 9 }, { 6, 10, 15, 17 }, {}, {}, {}, { 1, 7, 8, 9 } };
 
-  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++)
+  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 + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
+                  Square to = s + Direction(c == WHITE ? steps[pt][i] : -steps[pt][i]);
 
-                  if (is_ok(to) && square_distance(s, to) < 3)
-                      StepAttacksBB[make_piece(c, pt)][s] |= to;
+                  if (is_ok(to) && distance(s, to) < 3)
+                  {
+                      if (pt == PAWN)
+                          PawnAttacks[c][s] |= to;
+                      else
+                          PseudoAttacks[pt][s] |= to;
+                  }
               }
 
-  Square RDeltas[] = { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  };
-  Square BDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
+  Direction RookDirections[] = { NORTH,  EAST,  SOUTH,  WEST };
+  Direction BishopDirections[] = { NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST };
 
-  init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, magic_index<ROOK>);
-  init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, magic_index<BISHOP>);
+  init_magics(RookTable, RookMagics, RookDirections);
+  init_magics(BishopTable, BishopMagics, BishopDirections);
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
   {
-      PseudoAttacks[QUEEN][s]  = PseudoAttacks[BISHOP][s] = attacks_bb<BISHOP>(s, 0);
-      PseudoAttacks[QUEEN][s] |= PseudoAttacks[  ROOK][s] = attacks_bb<  ROOK>(s, 0);
-  }
+      PseudoAttacks[QUEEN][s1]  = PseudoAttacks[BISHOP][s1] = attacks_bb<BISHOP>(s1, 0);
+      PseudoAttacks[QUEEN][s1] |= PseudoAttacks[  ROOK][s1] = attacks_bb<  ROOK>(s1, 0);
 
-  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
-          if (PseudoAttacks[QUEEN][s1] & s2)
+      for (PieceType pt : { BISHOP, ROOK })
+          for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
           {
-              Square delta = (s2 - s1) / square_distance(s1, s2);
+              if (!(PseudoAttacks[pt][s1] & s2))
+                  continue;
 
-              for (Square s = s1 + delta; s != s2; s += delta)
-                  BetweenBB[s1][s2] |= s;
+              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]);
           }
+  }
 }
 
 
 namespace {
 
-  Bitboard sliding_attack(Square deltas[], Square sq, Bitboard occupied) {
+  Bitboard sliding_attack(Direction directions[], Square sq, Bitboard occupied) {
 
     Bitboard attack = 0;
 
-    for (int i = 0; i < 4; i++)
-        for (Square s = sq + deltas[i];
-             is_ok(s) && square_distance(s, s - deltas[i]) == 1;
-             s += deltas[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])
         {
             attack |= s;
 
@@ -256,38 +244,21 @@ namespace {
   }
 
 
-  Bitboard pick_random(RKISS& rk, int booster) {
-
-    // 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;
-
-    Bitboard m = rk.rand<Bitboard>();
-    m = (m >> s1) | (m << (64 - s1));
-    m &= rk.rand<Bitboard>();
-    m = (m >> s2) | (m << (64 - s2));
-    return m & rk.rand<Bitboard>();
-  }
-
-
   // 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
   // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
   // use the so called "fancy" approach.
 
-  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
+  void init_magics(Bitboard table[], Magic magics[], Direction directions[]) {
+
+    // 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, booster;
+    int epoch[4096] = {}, cnt = 0, size = 0;
 
-    // attacks[s] is a pointer to the beginning of the attacks table for square 's'
-    attacks[SQ_A1] = table;
-
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    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));
@@ -297,49 +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_attack(deltas, s, 0) & ~edges;
-        shifts[s] = (Is64Bit ? 64 : 32) - popcount<Max15>(masks[s]);
+        Magic& m = magics[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 attack bitboard in reference[].
         b = size = 0;
         do {
             occupancy[size] = b;
-            reference[size++] = sliding_attack(deltas, s, b);
-            b = (b - masks[s]) & masks[s];
+            reference[size] = sliding_attack(directions, s, b);
+
+            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
-        // table sizes for each square with "Fancy Magic Bitboards".
-        if (s < SQ_H8)
-            attacks[s + 1] = attacks[s] + size;
+        if (HasPext)
+            continue;
 
-        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 {
-            do magics[s] = pick_random(rk, booster);
-            while (popcount<Max15>((magics[s] * masks[s]) >> 56) < 6);
-
-            memset(attacks[s], 0, size * sizeof(Bitboard));
+        for (int i = 0; i < size; )
+        {
+            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.
-            for (i = 0; i < size; i++)
+            // effect of verifying the magic. Keep track of the attempt count
+            // 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)
             {
-                Bitboard& attack = attacks[s][index(s, occupancy[i])];
+                unsigned idx = m.index(occupancy[i]);
 
-                if (attack && attack != reference[i])
+                if (epoch[idx] < cnt)
+                {
+                    epoch[idx] = cnt;
+                    m.attacks[idx] = reference[i];
+                }
+                else if (m.attacks[idx] != reference[i])
                     break;
-
-                assert(reference[i] != 0);
-
-                attack = reference[i];
             }
-        } 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-2013 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,52 +18,90 @@
   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"
 
+namespace Bitbases {
+
+void init();
+bool probe(Square wksq, Square wpsq, Square bksq, Color us);
+
+}
+
 namespace Bitboards {
 
 void init();
-void print(Bitboard b);
+const std::string pretty(Bitboard b);
 
 }
 
-namespace Bitbases {
+const Bitboard AllSquares = ~Bitboard(0);
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
 
-void init_kpk();
-bool probe_kpk(Square wksq, Square wpsq, Square bksq, Color us);
+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);
 
-CACHE_LINE_ALIGNMENT
-
-extern Bitboard RMasks[SQUARE_NB];
-extern Bitboard RMagics[SQUARE_NB];
-extern Bitboard* RAttacks[SQUARE_NB];
-extern unsigned RShifts[SQUARE_NB];
-
-extern Bitboard BMasks[SQUARE_NB];
-extern Bitboard BMagics[SQUARE_NB];
-extern Bitboard* BAttacks[SQUARE_NB];
-extern unsigned BShifts[SQUARE_NB];
+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 ThisAndAdjacentFilesBB[FILE_NB];
-extern Bitboard InFrontBB[COLOR_NB][RANK_NB];
-extern Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+extern Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
 extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
-extern Bitboard DistanceRingsBB[SQUARE_NB][8];
-extern Bitboard ForwardBB[COLOR_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 AttackSpanMask[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];
 
-const Bitboard BlackSquares = 0xAA55AA55AA55AA55ULL;
 
 /// 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.
@@ -72,14 +110,6 @@ inline Bitboard operator&(Bitboard b, Square s) {
   return b & SquareBB[s];
 }
 
-inline Bitboard& operator|=(Bitboard& b, Square s) {
-  return b |= SquareBB[s];
-}
-
-inline Bitboard& operator^=(Bitboard& b, Square s) {
-  return b ^= SquareBB[s];
-}
-
 inline Bitboard operator|(Bitboard b, Square s) {
   return b | SquareBB[s];
 }
@@ -88,16 +118,20 @@ inline Bitboard operator^(Bitboard b, Square s) {
   return b ^ SquareBB[s];
 }
 
+inline Bitboard& operator|=(Bitboard& b, Square s) {
+  return b |= SquareBB[s];
+}
 
-/// more_than_one() returns true if in 'b' there is more than one bit set
+inline Bitboard& operator^=(Bitboard& b, Square s) {
+  return b ^= SquareBB[s];
+}
 
-inline bool more_than_one(Bitboard b) {
+constexpr bool more_than_one(Bitboard b) {
   return b & (b - 1);
 }
 
-
-/// rank_bb() and file_bb() take a file or a square as input and return
-/// a bitboard representing all squares on the given file or rank.
+/// 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];
@@ -116,180 +150,190 @@ inline Bitboard file_bb(Square s) {
 }
 
 
-/// adjacent_files_bb takes a file as input and returns a bitboard representing
-/// all squares on the adjacent files.
+/// shift() moves a bitboard one step along direction D. Mainly for pawns
+
+template<Direction D>
+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;
+}
+
+
+/// adjacent_files_bb() returns a bitboard representing all the squares on the
+/// adjacent files of the given one.
 
 inline Bitboard adjacent_files_bb(File f) {
   return AdjacentFilesBB[f];
 }
 
 
-/// this_and_adjacent_files_bb takes a file as input and returns a bitboard
-/// representing all squares on the given and adjacent files.
-
-inline Bitboard this_and_adjacent_files_bb(File f) {
-  return ThisAndAdjacentFilesBB[f];
-}
-
-
-/// in_front_bb() takes a color and a rank or square as input, and returns a
-/// bitboard representing all the squares on all ranks in front of the rank
-/// (or square), from the given color's point of view.  For instance,
-/// in_front_bb(WHITE, RANK_5) will give all squares on ranks 6, 7 and 8, while
-/// in_front_bb(BLACK, SQ_D3) will give all squares on ranks 1 and 2.
-
-inline Bitboard in_front_bb(Color c, Rank r) {
-  return InFrontBB[c][r];
-}
-
-inline Bitboard in_front_bb(Color c, Square s) {
-  return InFrontBB[c][rank_of(s)];
-}
-
-
-/// between_bb returns a bitboard representing all squares between two squares.
-/// For instance, between_bb(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,
-/// 0 is returned.
+/// between_bb() returns a bitboard representing all the squares between the two
+/// given ones. For instance, between_bb(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 rank, file
+/// or diagonal, 0 is returned.
 
 inline Bitboard between_bb(Square s1, Square s2) {
   return BetweenBB[s1][s2];
 }
 
 
-/// forward_bb takes a color and a square as input, and returns a bitboard
-/// representing all squares along the line in front of the square, from the
-/// point of view of the given color. Definition of the table is:
-/// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
+/// forward_ranks_bb() returns a bitboard representing all the squares on all the ranks
+/// in front of the given one, from the point of view of the given color. For
+/// instance, forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2.
 
-inline Bitboard forward_bb(Color c, Square s) {
-  return ForwardBB[c][s];
+inline Bitboard forward_ranks_bb(Color c, Square s) {
+  return ForwardRanksBB[c][rank_of(s)];
 }
 
 
-/// passed_pawn_mask takes a color and a square as input, and returns a
-/// bitboard mask which can be used to test if a pawn of the given color on
-/// the given square is a passed pawn. Definition of the table is:
-/// PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_adjacent_files_bb(s)
+/// forward_file_bb() returns a bitboard representing all the squares along the line
+/// in front of the given one, from the point of view of the given color:
+///      ForwardFileBB[c][s] = forward_ranks_bb(c, s) & file_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
-/// representing all squares that can be attacked by a pawn of the given color
-/// when it moves along its file starting from the given square. Definition is:
-/// AttackSpanMask[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
+/// aligned() returns true if the squares s1, s2 and s3 are aligned either on a
+/// straight or on a diagonal line.
 
-inline Bitboard attack_span_mask(Color c, Square s) {
-  return AttackSpanMask[c][s];
+inline bool aligned(Square s1, Square s2, Square s3) {
+  return LineBB[s1][s2] & s3;
 }
 
 
-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
-/// either on a straight or on a diagonal line.
+/// distance() functions return the distance between x and y, defined as the
+/// 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) {
-  return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
-        & (     SquareBB[s1] |      SquareBB[s2] |      SquareBB[s3]);
-}
+template<typename T> inline int distance(T x, T y) { return x < y ? y - x : x - y; }
+template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; }
+
+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)); }
 
 
-/// same_color_squares() returns a bitboard representing all squares with
-/// the same color of the given square.
-
-inline Bitboard same_color_squares(Square s) {
-  return BlackSquares & s ? BlackSquares : ~BlackSquares;
-}
-
-
-/// Functions for computing sliding attack bitboards. Function attacks_bb() takes
-/// a square and a bitboard of occupied squares as input, and returns a bitboard
-/// representing all squares attacked by Pt (bishop or rook) on the given square.
-template<PieceType Pt>
-FORCE_INLINE unsigned magic_index(Square s, Bitboard occ) {
-
-  Bitboard* const Masks  = Pt == ROOK ? RMasks  : BMasks;
-  Bitboard* const Magics = Pt == ROOK ? RMagics : BMagics;
-  unsigned* const Shifts = Pt == ROOK ? RShifts : BShifts;
-
-  if (Is64Bit)
-      return unsigned(((occ & Masks[s]) * Magics[s]) >> Shifts[s]);
-
-  unsigned lo = unsigned(occ) & unsigned(Masks[s]);
-  unsigned hi = unsigned(occ >> 32) & unsigned(Masks[s] >> 32);
-  return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
-}
+/// 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 occ) {
-  return (Pt == ROOK ? RAttacks : BAttacks)[s][magic_index<Pt>(s, occ)];
+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];
+  }
 }
 
 
-/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
-/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
+/// popcount() counts the number of non-zero bits in a bitboard
 
-#if defined(USE_BSFQ)
+inline int popcount(Bitboard b) {
 
-#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#ifndef USE_POPCNT
 
-FORCE_INLINE Square lsb(Bitboard b) {
-  unsigned long index;
-  _BitScanForward64(&index, b);
-  return (Square) index;
+  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
 }
 
-FORCE_INLINE Square msb(Bitboard b) {
-  unsigned long index;
-  _BitScanReverse64(&index, b);
-  return (Square) index;
+
+/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
+
+#if defined(__GNUC__)
+
+inline Square lsb(Bitboard b) {
+  assert(b);
+  return Square(__builtin_ctzll(b));
 }
 
-#  elif defined(__arm__)
-
-FORCE_INLINE int lsb32(uint32_t v) {
-  __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
-  return __builtin_clz(v);
+inline Square msb(Bitboard b) {
+  assert(b);
+  return Square(63 ^ __builtin_clzll(b));
 }
 
-FORCE_INLINE Square msb(Bitboard 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;
 }
 
-FORCE_INLINE Square lsb(Bitboard b) {
-  return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+inline Square msb(Bitboard b) {
+  assert(b);
+  unsigned long idx;
+  _BitScanReverse64(&idx, b);
+  return (Square) idx;
 }
 
-#  else
+#else
 
-FORCE_INLINE Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
-  Bitboard index;
-  __asm__("bsfq %1, %0": "=r"(index): "rm"(b) );
-  return (Square) index;
-}
+#define NO_BSF // Fallback on software implementation for other cases
 
-FORCE_INLINE Square msb(Bitboard b) {
-  Bitboard index;
-  __asm__("bsrq %1, %0": "=r"(index): "rm"(b) );
-  return (Square) index;
-}
+Square lsb(Bitboard b);
+Square msb(Bitboard b);
 
-#  endif
+#endif
 
-FORCE_INLINE Square pop_lsb(Bitboard* b) {
+
+/// pop_lsb() finds and clears the least significant bit in a non-zero bitboard
+
+inline Square pop_lsb(Bitboard* b) {
   const Square s = lsb(*b);
   *b &= *b - 1;
   return s;
 }
 
-#else // if !defined(USE_BSFQ)
 
-extern Square msb(Bitboard b);
-extern Square lsb(Bitboard b);
-extern Square pop_lsb(Bitboard* b);
+/// frontmost_sq() and backmost_sq() return the square corresponding to the
+/// 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 // !defined(BITBOARD_H_INCLUDED)
+#endif // #ifndef BITBOARD_H_INCLUDED

src/bitcount.h

@@ -1,105 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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
-/// and if hardware popcnt instruction is 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;
-  return (b * 0x0101010101010101ULL) >> 56;
-}
-
-template<>
-inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -=  (b >> 1) & 0x5555555555555555ULL;
-  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  return (b * 0x1111111111111111ULL) >> 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 + (w >> 4) + w) & 0x0F0F0F0F;
-  return (v * 0x01010101) >> 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);
-  return ((v + w) * 0x11111111) >> 28;
-}
-
-template<>
-inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
-
-#if !defined(USE_POPCNT)
-
-  assert(false);
-  return 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
-
-  __asm__("popcnt %1, %0" : "=r" (b) : "r" (b));
-  return b;
-
-#endif
-}
-
-#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,478 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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 <algorithm>
-#include <cassert>
-#include <iostream>
-
-#include "book.h"
-#include "misc.h"
-#include "movegen.h"
-
-using namespace std;
-
-namespace {
-
-  // A Polyglot book is a series of "entries" of 16 bytes. All integers are
-  // stored in big-endian format, with highest byte first (regardless of size).
-  // The entries are ordered according to the key in ascending order.
-  struct Entry {
-    uint64_t key;
-    uint16_t move;
-    uint16_t count;
-    uint32_t learn;
-  };
-
-  // Random numbers from PolyGlot, used to compute book hash keys
-  const union {
-    Key PolyGlotRandoms[781];
-    struct {
-      Key psq[12][64];  // [piece][square]
-      Key castle[4];    // [castle right]
-      Key enpassant[8]; // [file]
-      Key turn;
-    } Zobrist;
-  } PG = {{
-    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
-  }};
-
-  // polyglot_key() returns the PolyGlot hash key of the given position
-  Key polyglot_key(const Position& pos) {
-
-    Key key = 0;
-    Bitboard b = pos.pieces();
-
-    while (b)
-    {
-        Square s = pop_lsb(&b);
-        Piece p = pos.piece_on(s);
-
-        // PolyGlot pieces are: BP = 0, WP = 1, BN = 2, ... BK = 10, WK = 11
-        key ^= PG.Zobrist.psq[2 * (type_of(p) - 1) + (color_of(p) == WHITE)][s];
-    }
-
-    b = pos.can_castle(ALL_CASTLES);
-
-    while (b)
-        key ^= PG.Zobrist.castle[pop_lsb(&b)];
-
-    if (pos.ep_square() != SQ_NONE)
-        key ^= PG.Zobrist.enpassant[file_of(pos.ep_square())];
-
-    if (pos.side_to_move() == WHITE)
-        key ^= PG.Zobrist.turn;
-
-    return key;
-  }
-
-} // namespace
-
-PolyglotBook::PolyglotBook() : rkiss(Time::now() % 10000) {}
-
-PolyglotBook::~PolyglotBook() { if (is_open()) close(); }
-
-
-/// operator>>() reads sizeof(T) chars from the file's binary byte stream and
-/// converts them in a number of type T. A Polyglot book stores numbers in
-/// big-endian format.
-
-template<typename T> PolyglotBook& PolyglotBook::operator>>(T& n) {
-
-  n = 0;
-  for (size_t i = 0; i < sizeof(T); i++)
-      n = T((n << 8) + ifstream::get());
-
-  return *this;
-}
-
-template<> PolyglotBook& PolyglotBook::operator>>(Entry& e) {
-  return *this >> e.key >> e.move >> e.count >> e.learn;
-}
-
-
-/// open() tries to open a book file with the given name after closing any
-/// exsisting one.
-
-bool PolyglotBook::open(const char* fName) {
-
-  if (is_open()) // Cannot close an already closed file
-      close();
-
-  ifstream::open(fName, ifstream::in | ifstream::binary);
-
-  fileName = is_open() ? fName : "";
-  ifstream::clear(); // Reset any error flag to allow retry ifstream::open()
-  return !fileName.empty();
-}
-
-
-/// probe() tries to find a book move for the given position. If no move is
-/// found returns MOVE_NONE. If pickBest is true returns always the highest
-/// rated move, otherwise randomly chooses one, based on the move score.
-
-Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) {
-
-  if (fileName != fName && !open(fName.c_str()))
-      return MOVE_NONE;
-
-  Entry e;
-  uint16_t best = 0;
-  unsigned sum = 0;
-  Move move = MOVE_NONE;
-  Key key = polyglot_key(pos);
-
-  seekg(find_first(key) * sizeof(Entry), ios_base::beg);
-
-  while (*this >> e, e.key == key && good())
-  {
-      best = max(best, e.count);
-      sum += e.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 (   (sum && rkiss.rand<unsigned>() % sum < e.count)
-          || (pickBest && e.count == best))
-          move = Move(e.move);
-  }
-
-  if (!move)
-      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-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 the
-  // other cases we can directly compare with a Move after having masked out
-  // the special Move's flags (bit 14-15) that are not supported by PolyGlot.
-  int pt = (move >> 12) & 7;
-  if (pt)
-      move = make<PROMOTION>(from_sq(move), to_sq(move), PieceType(pt + 1));
-
-  // Add 'special move' flags and verify it is legal
-  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
-      if (move == (ml.move() ^ type_of(ml.move())))
-          return ml.move();
-
-  return MOVE_NONE;
-}
-
-
-/// find_first() takes a book key as input, and does a binary search through
-/// the book file for the given key. Returns the index of the leftmost book
-/// entry with the same key as the input.
-
-size_t PolyglotBook::find_first(Key key) {
-
-  seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size
-
-  size_t low = 0, mid, high = (size_t)tellg() / sizeof(Entry) - 1;
-  Entry e;
-
-  assert(low <= high);
-
-  while (low < high && good())
-  {
-      mid = (low + high) / 2;
-
-      assert(mid >= low && mid < high);
-
-      seekg(mid * sizeof(Entry), ios_base::beg);
-      *this >> e;
-
-      if (key <= e.key)
-          high = mid;
-      else
-          low = mid + 1;
-  }
-
-  assert(low == high);
-
-  return low;
-}

src/book.h

@@ -1,45 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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"
-
-class PolyglotBook : private std::ifstream {
-public:
-  PolyglotBook();
- ~PolyglotBook();
-  Move probe(const Position& pos, const std::string& fName, bool pickBest);
-
-private:
-  template<typename T> PolyglotBook& operator>>(T& n);
-
-  bool open(const char* fName);
-  size_t find_first(Key key);
-
-  RKISS rkiss;
-  std::string fileName;
-};
-
-#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-2013 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,22 +18,25 @@
   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 {
-
-  // Evaluation functions
+enum EndgameCode {
 
+  EVALUATION_FUNCTIONS,
+  KNNK,  // KNN vs K
   KXK,   // Generic "mate lone king" eval
   KBNK,  // KBN vs K
   KPK,   // KP vs K
@@ -41,19 +45,14 @@ enum EndgameType {
   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
-  SCALE_FUNS,
-
-  KBPsK,   // KB+pawns vs K
-  KQKRPs,  // KQ vs KR+pawns
+  SCALING_FUNCTIONS,
+  KBPsK,   // KB and pawns vs K
+  KQKRPs,  // KQ vs KR and 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
@@ -63,60 +62,64 @@ enum EndgameType {
 };
 
 
-/// Endgame functions can be of two types according if return a Value or a
-/// ScaleFactor. Type eg_fun<int>::type equals to either ScaleFactor or Value
-/// depending if the template parameter is 0 or 1.
-
-template<int> struct eg_fun { typedef Value type; };
-template<> struct eg_fun<1> { typedef ScaleFactor type; };
+/// Endgame functions can be of two types depending on whether they return a
+/// Value or a ScaleFactor.
+template<EndgameCode E> using
+eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
 
 
-/// 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() {}
-  virtual Color color() const = 0;
+  explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {}
+  virtual ~EndgameBase() = default;
   virtual T operator()(const Position&) const = 0;
+
+  const Color strongSide, weakSide;
 };
 
 
-template<EndgameType E, typename T = typename eg_fun<(E > SCALE_FUNS)>::type>
+template<EndgameCode E, typename T = eg_type<E>>
 struct Endgame : public EndgameBase<T> {
 
-  explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {}
-  Color color() const { return strongerSide; }
-  T operator()(const Position&) const;
-
-private:
-  Color strongerSide, weakerSide;
+  explicit Endgame(Color c) : EndgameBase<T>(c) {}
+  T operator()(const Position&) const override;
 };
 
 
-/// Endgames class stores in two std::map the pointers to endgame evaluation
-/// and scaling base objects. Then we use polymorphism to invoke the actual
-/// endgame function calling its operator() that is virtual.
+/// The Endgames class stores the pointers to endgame evaluation and scaling
+/// base objects in two std::map. We use polymorphism to invoke the actual
+/// endgame function by calling its virtual operator().
 
 class Endgames {
 
-  typedef std::map<Key, EndgameBase<eg_fun<0>::type>*> M1;
-  typedef std::map<Key, EndgameBase<eg_fun<1>::type>*> M2;
+  template<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>;
+  template<typename T> using Map = std::map<Key, Ptr<T>>;
 
-  M1 m1;
-  M2 m2;
+  template<typename T>
+  Map<T>& map() {
+    return std::get<std::is_same<T, ScaleFactor>::value>(maps);
+  }
 
-  M1& map(M1::mapped_type) { return m1; }
-  M2& map(M2::mapped_type) { return m2; }
+  template<EndgameCode E, typename T = eg_type<E>, typename P = Ptr<T>>
+  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> T probe(Key key, T& eg)
-  { return eg = map(eg).count(key) ? map(eg)[key] : NULL; }
+  template<typename T>
+  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-2013 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,19 +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;
 
 namespace Eval {
 
-extern void init();
-extern Value evaluate(const Position& pos, Value& margin);
-extern std::string trace(const Position& pos);
+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 // !defined(EVALUATE_H_INCLUDED)
+#endif // #ifndef EVALUATE_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-2013 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,35 +19,37 @@
 */
 
 #include <iostream>
-#include <string>
 
 #include "bitboard.h"
-#include "evaluate.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
 #include "tt.h"
-#include "ucioption.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
+
+namespace PSQT {
+  void init();
+}
 
 int main(int argc, char* argv[]) {
 
   std::cout << engine_info() << std::endl;
 
   UCI::init(Options);
+  PSQT::init();
   Bitboards::init();
-  Zobrist::init();
-  Bitbases::init_kpk();
+  Position::init();
+  Bitbases::init();
   Search::init();
-  Eval::init();
-  Threads.init();
-  TT.set_size(Options["Hash"]);
+  Pawns::init();
+  Tablebases::init(Options["SyzygyPath"]);
+  TT.resize(Options["Hash"]);
+  Threads.set(Options["Threads"]);
+  Search::clear(); // After threads are up
 
-  std::string args;
+  UCI::loop(argc, argv);
 
-  for (int i = 1; i < argc; i++)
-      args += std::string(argv[i]) + " ";
-
-  UCI::loop(args);
-
-  Threads.exit();
+  Threads.set(0);
+  return 0;
 }

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-2013 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,221 +18,175 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <algorithm>  // For std::min
+#include <algorithm> // For std::min
 #include <cassert>
-#include <cstring>
+#include <cstring>   // For std::memset
 
 #include "material.h"
+#include "thread.h"
 
 using namespace std;
 
 namespace {
 
-  // Values modified by Joona Kiiski
-  const Value MidgameLimit = Value(15581);
-  const Value EndgameLimit = Value(3998);
+  // Polynomial material imbalance parameters
 
-  // Scale factors used when one side has no more pawns
-  const int NoPawnsSF[4] = { 6, 12, 32 };
-
-  // Polynomial material balance parameters
-  const Value RedundantQueenPenalty = Value(320);
-  const Value RedundantRookPenalty  = Value(554);
-
-  //                                  pair  pawn knight bishop rook queen
-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190,  105,  26 };
-
-  const int QuadraticCoefficientsSameColor[][PIECE_TYPE_NB] = {
+  const int QuadraticOurs[][PIECE_TYPE_NB] = {
+    //            OUR PIECES
     // pair pawn knight bishop rook queen
-    {   7                               }, // Bishop pair
-    {  39,    2                         }, // Pawn
-    {  35,  271,  -4                    }, // Knight
-    {   7,  105,   4,    7              }, // Bishop
-    { -27,   -2,  46,   100,   56       }, // Rook
-    {  58,   29,  83,   148,   -3,  -25 }  // 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
   };
 
-  const int QuadraticCoefficientsOppositeColor[][PIECE_TYPE_NB] = {
+  const int QuadraticTheirs[][PIECE_TYPE_NB] = {
     //           THEIR PIECES
     // pair pawn knight bishop rook queen
-    {  41                               }, // Bishop pair
-    {  37,   41                         }, // Pawn
-    {  10,   62,  41                    }, // Knight      OUR PIECES
-    {  57,   64,  39,    41             }, // Bishop
-    {  50,   40,  23,   -22,   41       }, // Rook
-    { 106,  101,   3,   151,  171,   41 }  // 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
   };
 
-  // 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 evaluation and scaling functions are accessed directly and not through
+  // the function maps because they correspond to more than one material hash key.
+  Endgame<KXK>    EvaluateKXK[] = { Endgame<KXK>(WHITE),    Endgame<KXK>(BLACK) };
 
   Endgame<KBPsK>  ScaleKBPsK[]  = { Endgame<KBPsK>(WHITE),  Endgame<KBPsK>(BLACK) };
   Endgame<KQKRPs> ScaleKQKRPs[] = { Endgame<KQKRPs>(WHITE), Endgame<KQKRPs>(BLACK) };
   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
-  template<Color Us> bool is_KXK(const Position& pos) {
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.non_pawn_material(Them) == VALUE_ZERO
-          && pos.piece_count(Them, PAWN) == 0
-          && pos.non_pawn_material(Us)   >= RookValueMg;
+  // Helper used to detect a given material distribution
+  bool is_KXK(const Position& pos, Color us) {
+    return  !more_than_one(pos.pieces(~us))
+          && pos.non_pawn_material(us) >= RookValueMg;
   }
 
-  template<Color Us> bool is_KBPsKs(const Position& pos) {
-    return   pos.non_pawn_material(Us)   == BishopValueMg
-          && pos.piece_count(Us, BISHOP) == 1
-          && pos.piece_count(Us, PAWN)   >= 1;
+  bool is_KBPsKs(const Position& pos, Color us) {
+    return   pos.non_pawn_material(us) == BishopValueMg
+          && pos.count<BISHOP>(us) == 1
+          && pos.count<PAWN  >(us) >= 1;
   }
 
-  template<Color Us> bool is_KQKRPs(const Position& pos) {
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.piece_count(Us, PAWN)    == 0
-          && pos.non_pawn_material(Us)    == QueenValueMg
-          && pos.piece_count(Us, QUEEN)   == 1
-          && pos.piece_count(Them, ROOK)  == 1
-          && pos.piece_count(Them, PAWN)  >= 1;
+  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 imbalance comparing piece count of each
+  /// 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);
 
-    int pt1, pt2, pc, v;
-    int value = 0;
+    int bonus = 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++)
+    // Second-degree polynomial material imbalance, by Tord Romstad
+    for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
     {
-        pc = pieceCount[Us][pt1];
-        if (!pc)
+        if (!pieceCount[Us][pt1])
             continue;
 
-        v = LinearCoefficients[pt1];
+        int v = 0;
 
-        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
-            v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
-                + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+        for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2)
+            v +=  QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2]
+                + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2];
 
-        value += pc * v;
+        bonus += pieceCount[Us][pt1] * v;
     }
-    return value;
+
+    return bonus;
   }
 
 } // namespace
 
 namespace Material {
 
-/// Material::probe() takes a position object as input, looks up a MaterialEntry
-/// object, and returns a pointer to it. If the material configuration is not
-/// already present in the table, it is computed and stored there, so we don't
-/// have to recompute everything when the same material configuration occurs again.
+/// 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.
 
-Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {
+Entry* probe(const Position& pos) {
 
   Key key = pos.material_key();
-  Entry* e = entries[key];
+  Entry* e = pos.this_thread()->materialTable[key];
 
-  // If e->key matches the position's material hash key, it means that we
-  // have analysed this material configuration before, and we can simply
-  // return the information we found the last time instead of recomputing it.
   if (e->key == key)
       return e;
 
-  memset(e, 0, sizeof(Entry));
+  std::memset(e, 0, sizeof(Entry));
   e->key = key;
   e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-  e->gamePhase = 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 (endgames.probe(key, e->evaluationFunction))
-      return e;
-
-  if (is_KXK<WHITE>(pos))
-  {
-      e->evaluationFunction = &EvaluateKXK[WHITE];
-      return e;
-  }
-
-  if (is_KXK<BLACK>(pos))
-  {
-      e->evaluationFunction = &EvaluateKXK[BLACK];
-      return e;
-  }
-
-  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(WHITE, KNIGHT) | pos.pieces(WHITE, BISHOP)));
-      assert((pos.pieces(BLACK, KNIGHT) | pos.pieces(BLACK, BISHOP)));
-
-      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
-          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
-      {
-          e->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
-          return e;
-      }
-  }
-
-  // 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 (endgames.probe(key, sf))
-  {
-      e->scalingFunction[sf->color()] = sf;
-      return e;
-  }
-
-  // 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))
-      e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
-
-  if (is_KBPsKs<BLACK>(pos))
-      e->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
-
-  if (is_KQKRPs<WHITE>(pos))
-      e->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
-
-  else if (is_KQKRPs<BLACK>(pos))
-      e->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)
-  {
-      if (pos.piece_count(BLACK, PAWN) == 0)
+  // 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))
       {
-          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          e->evaluationFunction = &EvaluateKXK[c];
+          return e;
+      }
+
+  // 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)
+  {
+      e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned
+      return e;
+  }
+
+  // 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.piece_count(WHITE, PAWN) == 0)
+      else if (!pos.count<PAWN>(WHITE))
       {
-          assert(pos.piece_count(BLACK, PAWN) >= 2);
+          assert(pos.count<PAWN>(BLACK) >= 2);
+
           e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
       }
-      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      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.
@@ -240,53 +195,34 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {
       }
   }
 
-  // No pawns makes it difficult to win, even with a material advantage
-  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMg)
-  {
-      e->factor[WHITE] = (uint8_t)
-      (npm_w == npm_b || npm_w < RookValueMg ? 0 : NoPawnsSF[std::min(pos.piece_count(WHITE, BISHOP), 2)]);
-  }
+  // Zero or just one pawn makes it difficult to win, even with a small material
+  // 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).
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
+      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 <= BishopValueMg)
-  {
-      e->factor[BLACK] = (uint8_t)
-      (npm_w == npm_b || npm_b < RookValueMg ? 0 : NoPawnsSF[std::min(pos.piece_count(BLACK, BISHOP), 2)]);
-  }
+  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
+      e->factor[BLACK] = uint8_t(npm_b <  RookValueMg   ? SCALE_FACTOR_DRAW :
+                                 npm_w <= BishopValueMg ? 4 : 14);
 
-  // Compute the space weight
-  if (npm_w + npm_b >= 2 * QueenValueMg + 4 * RookValueMg + 2 * KnightValueMg)
-  {
-      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
-                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+  if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)
+      e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;
 
-      e->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[COLOR_NB][PIECE_TYPE_NB] = {
-  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
-    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
-  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
-    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+  const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = {
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
 
-  e->value = (int16_t)((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
+  e->value = int16_t((imbalance<WHITE>(PieceCount) - imbalance<BLACK>(PieceCount)) / 16);
   return e;
 }
 
-
-/// Material::game_phase() calculates the phase given the current
-/// position. Because the phase is strictly a function of the material, it
-/// is stored in MaterialEntry.
-
-Phase 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));
-}
-
 } // namespace Material

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-2013 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,7 +18,7 @@
   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"
@@ -28,50 +29,45 @@
 namespace Material {
 
 /// Material::Entry contains various information about a material configuration.
-/// It contains a material balance evaluation, a function pointer to a special
+/// It contains a material imbalance 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".
+/// standard evaluation function will be used), and scale factors.
 ///
-/// The scale factors are used to scale the evaluation score up or down.
-/// For instance, in KRB vs KR endgames, the score is scaled down by a factor
-/// of 4, which will result in scores of absolute value less than one pawn.
+/// The scale factors are used to scale the evaluation score up or down. For
+/// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4,
+/// which will result in scores of absolute value less than one pawn.
 
 struct Entry {
 
-  Score material_value() const { return make_score(value, value); }
-  int space_weight() const { return spaceWeight; }
+  Score imbalance() const { return make_score(value, value); }
   Phase game_phase() const { return gamePhase; }
-  bool specialized_eval_exists() const { return evaluationFunction != NULL; }
-  Value evaluate(const Position& p) const { return (*evaluationFunction)(p); }
-  ScaleFactor scale_factor(const Position& pos, Color c) const;
+  bool specialized_eval_exists() const { return evaluationFunction != nullptr; }
+  Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); }
+
+  // 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 may also be a function which should be applied to
+  // the position. For instance, in KBP vs K endgames, the scaling function looks
+  // for rook pawns and wrong-colored bishops.
+  ScaleFactor scale_factor(const Position& pos, Color c) const {
+    ScaleFactor sf = scalingFunction[c] ? (*scalingFunction[c])(pos)
+                                        :  SCALE_FACTOR_NONE;
+    return sf != SCALE_FACTOR_NONE ? sf : ScaleFactor(factor[c]);
+  }
 
   Key key;
+  EndgameBase<Value>* evaluationFunction;
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each
+                                                       // side (e.g. KPKP, KBPsKs)
   int16_t value;
   uint8_t factor[COLOR_NB];
-  EndgameBase<Value>* evaluationFunction;
-  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB];
-  int spaceWeight;
   Phase gamePhase;
 };
 
 typedef HashTable<Entry, 8192> Table;
 
-Entry* probe(const Position& pos, Table& entries, Endgames& endgames);
-Phase game_phase(const Position& pos);
+Entry* probe(const Position& pos);
 
-/// Material::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.
+} // namespace Material
 
-inline ScaleFactor Entry::scale_factor(const Position& pos, Color c) const {
-
-  return !scalingFunction[c] || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE
-        ? ScaleFactor(factor[c]) : (*scalingFunction[c])(pos);
-}
-
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)
+#endif // #ifndef 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-2013 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,25 +18,98 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#ifdef _WIN32
+#if _WIN32_WINNT < 0x0601
+#undef  _WIN32_WINNT
+#define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
+#endif
+#include <windows.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
+// the calls at compile time), try to load them at runtime. To do this we need
+// first to define the corresponding function pointers.
+extern "C" {
+typedef bool(*fun1_t)(LOGICAL_PROCESSOR_RELATIONSHIP,
+                      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD);
+typedef bool(*fun2_t)(USHORT, PGROUP_AFFINITY);
+typedef bool(*fun3_t)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
+}
+#endif
+
+#include <fstream>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
+#include <vector>
 
 #include "misc.h"
 #include "thread.h"
 
-#if defined(__hpux)
-#    include <sys/pstat.h>
-#endif
-
 using namespace std;
 
-/// Version number. If Version is left empty, then Tag plus current
-/// date, in the format DD-MM-YY, are used as a version number.
+namespace {
 
-static const string Version = "3";
-static const string Tag = "";
+/// Version number. If Version is left empty, then compile date in the format
+/// 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
+
+struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
+
+  Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
+
+  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
@@ -45,43 +119,32 @@ static const string Tag = "";
 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"
 
-  s << "Stockfish " << Version;
+  ss << "Stockfish " << Version << setfill('0');
 
   if (Version.empty())
   {
       date >> month >> day >> year;
-
-      s << Tag << string(Tag.empty() ? "" : " ") << setfill('0') << setw(2) << day
-        << "-" << setw(2) << (1 + months.find(month) / 4) << "-" << year.substr(2);
+      ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
   }
 
-  s << cpu64 << popcnt << (to_uci ? "\nid author ": " by ")
-    << "Tord Romstad, Marco Costalba and Joona Kiiski";
+  ss << (Is64Bit ? " 64" : "")
+     << (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : ""))
+     << (to_uci  ? "\nid author ": " by ")
+     << "T. Romstad, M. Costalba, J. Kiiski, G. Linscott";
 
-  return s.str();
-}
-
-
-/// Convert system time to milliseconds. That's all we need.
-
-Time::point Time::now() {
-  sys_time_t t; system_time(&t); return time_to_msec(t);
+  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_c(bool c, bool b) { if (c) dbg_hit_on(b); }
-void dbg_mean_of(int v) { means[0]++; means[1] += v; }
+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_mean_of(int v) { ++means[0]; means[1] += v; }
 
 void dbg_print() {
 
@@ -91,79 +154,21 @@ void dbg_print() {
 
   if (means[0])
       cerr << "Total " << means[0] << " Mean "
-           << (float)means[1] / means[0] << endl;
+           << (double)means[1] / means[0] << endl;
 }
 
 
-/// 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 while preserving
-/// usual i/o functionality and without changing a single line of code!
-/// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
-
-struct Tie: public streambuf { // MSVC requires splitted streambuf for cin and cout
-
-  Tie(streambuf* b, ofstream* f) : buf(b), file(f) {}
-
-  int sync() { return file->rdbuf()->pubsync(), buf->pubsync(); }
-  int overflow(int c) { return log(buf->sputc((char)c), "<< "); }
-  int underflow() { return buf->sgetc(); }
-  int uflow() { return log(buf->sbumpc(), ">> "); }
-
-  streambuf* buf;
-  ofstream* file;
-
-  int log(int c, const char* prefix) {
-
-    static int last = '\n';
-
-    if (last == '\n')
-        file->rdbuf()->sputn(prefix, 3);
-
-    return last = file->rdbuf()->sputc((char)c);
-  }
-};
-
-class Logger {
-
-  Logger() : in(cin.rdbuf(), &file), out(cout.rdbuf(), &file) {}
- ~Logger() { start(false); }
-
-  ofstream file;
-  Tie in, out;
-
-public:
-  static void start(bool b) {
-
-    static Logger l;
-
-    if (b && !l.file.is_open())
-    {
-        l.file.open("io_log.txt", ifstream::out | ifstream::app);
-        cin.rdbuf(&l.in);
-        cout.rdbuf(&l.out);
-    }
-    else if (!b && l.file.is_open())
-    {
-        cout.rdbuf(l.out.buf);
-        cin.rdbuf(l.in.buf);
-        l.file.close();
-    }
-  }
-};
-
-
-/// Used to serialize access to std::cout to avoid multiple threads to write at
+/// Used to serialize access to std::cout to avoid multiple threads writing at
 /// the same time.
 
 std::ostream& operator<<(std::ostream& os, SyncCout sc) {
 
   static Mutex m;
 
-  if (sc == io_lock)
+  if (sc == IO_LOCK)
       m.lock();
 
-  if (sc == io_unlock)
+  if (sc == IO_UNLOCK)
       m.unlock();
 
   return os;
@@ -171,77 +176,142 @@ std::ostream& operator<<(std::ostream& os, SyncCout sc) {
 
 
 /// Trampoline helper to avoid moving Logger to misc.h
-void start_logger(bool b) { Logger::start(b); }
+void start_logger(const std::string& fname) { Logger::start(fname); }
 
 
-/// cpu_count() tries to detect the number of CPU cores
+/// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
+/// function that doesn't stall the CPU waiting for data to be loaded from memory,
+/// which can be quite slow.
+#ifdef NO_PREFETCH
 
-int cpu_count() {
-
-#if defined(_WIN32) || defined(_WIN64)
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return s.dwNumberOfProcessors;
-#else
-
-#  if defined(_SC_NPROCESSORS_ONLN)
-  return sysconf(_SC_NPROCESSORS_ONLN);
-#  elif defined(__hpux)
-  struct pst_dynamic psd;
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-  return psd.psd_proc_cnt;
-#  else
-  return 1;
-#  endif
-
-#endif
-}
-
-
-/// timed_wait() waits for msec milliseconds. It is mainly an helper to wrap
-/// conversion from milliseconds to struct timespec, as used by pthreads.
-
-void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) {
-
-#if defined(_WIN32) || defined(_WIN64)
-  int tm = msec;
-#else
-  timespec ts, *tm = &ts;
-  uint64_t ms = Time::now() + msec;
-
-  ts.tv_sec = ms / 1000;
-  ts.tv_nsec = (ms % 1000) * 1000000LL;
-#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*) {}
+void prefetch(void*) {}
 
 #else
 
-void prefetch(char* addr) {
+void prefetch(void* addr) {
 
 #  if defined(__INTEL_COMPILER)
-   // This hack prevents prefetches to be optimized away by
-   // Intel compiler. Both MSVC and gcc seems not affected.
+   // This hack prevents prefetches from being optimized away by
+   // Intel compiler. Both MSVC and gcc seem not be affected by this.
    __asm__ ("");
 #  endif
 
 #  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
-  _mm_prefetch(addr, _MM_HINT_T0);
-  _mm_prefetch(addr+64, _MM_HINT_T0); // 64 bytes ahead
+  _mm_prefetch((char*)addr, _MM_HINT_T0);
 #  else
   __builtin_prefetch(addr);
-  __builtin_prefetch(addr+64);
 #  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-2013 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,53 +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 "types.h"
 
-extern const std::string engine_info(bool to_uci = false);
-extern int cpu_count();
-extern void timed_wait(WaitCondition&, Lock&, int);
-extern void prefetch(char* addr);
-extern void start_logger(bool b);
+const std::string engine_info(bool to_uci = false);
+void prefetch(void* addr);
+void prefetch2(void* addr);
+void start_logger(const std::string& fname);
 
-extern void dbg_hit_on(bool b);
-extern void dbg_hit_on_c(bool c, bool b);
-extern void dbg_mean_of(int v);
-extern void dbg_print();
+void dbg_hit_on(bool b);
+void dbg_hit_on(bool c, bool b);
+void dbg_mean_of(int v);
+void dbg_print();
 
+typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
 
-struct Log : public std::ofstream {
-  Log(const std::string& f = "log.txt") : std::ofstream(f.c_str(), std::ios::out | std::ios::app) {}
- ~Log() { if (is_open()) close(); }
-};
-
-
-namespace Time {
-  typedef int64_t point;
-  point now();
+inline TimePoint now() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>
+        (std::chrono::steady_clock::now().time_since_epoch()).count();
 }
 
-
 template<class Entry, int Size>
 struct HashTable {
-  HashTable() : e(Size, Entry()) {}
-  Entry* operator[](Key k) { return &e[(uint32_t)k & (Size - 1)]; }
+  Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
 
 private:
-  std::vector<Entry> e;
+  std::vector<Entry> table = std::vector<Entry>(Size);
 };
 
 
-enum SyncCout { io_lock, io_unlock };
+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
+#define sync_cout std::cout << IO_LOCK
+#define sync_endl std::endl << IO_UNLOCK
 
-#endif // !defined(MISC_H_INCLUDED)
+
+/// 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/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-2013 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
@@ -22,111 +23,86 @@
 #include "movegen.h"
 #include "position.h"
 
-/// Simple macro to wrap a very common while loop, no facny, no flexibility,
-/// hardcoded names 'mlist' and 'from'.
-#define SERIALIZE(b) while (b) (*mlist++).move = make_move(from, pop_lsb(&b))
-
-/// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_lsb(&b); \
-                                         (*mlist++).move = make_move(to - (d), to); }
 namespace {
 
-  template<CastlingSide Side, bool Checks, bool Chess960>
-  MoveStack* generate_castle(const Position& pos, MoveStack* mlist, Color us) {
+  template<CastlingRight Cr, bool Checks, bool Chess960>
+  ExtMove* generate_castling(const Position& pos, ExtMove* moveList, Color us) {
 
-    if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
-        return mlist;
+    static const bool KingSide = (Cr == WHITE_OO || Cr == BLACK_OO);
+
+    if (pos.castling_impeded(Cr) || !pos.can_castle(Cr))
+        return moveList;
 
     // After castling, the rook and king final positions are the same in Chess960
     // as they would be in standard chess.
-    Square kfrom = pos.king_square(us);
-    Square rfrom = pos.castle_rook_square(us, Side);
-    Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
+    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(!pos.checkers());
 
-    const int K = Chess960 ? kto > kfrom ? -1 : 1
-                           : Side == KING_SIDE ? -1 : 1;
+    const Direction K = Chess960 ? kto > kfrom ? WEST : EAST
+                                 : KingSide    ? WEST : EAST;
 
-    for (Square s = kto; s != kfrom; s += (Square)K)
+    for (Square s = kto; s != kfrom; s += K)
         if (pos.attackers_to(s) & enemies)
-            return mlist;
+            return moveList;
 
     // Because we generate only legal castling moves we need to verify that
     // 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 && (pos.attackers_to(kto, pos.pieces() ^ rfrom) & enemies))
-        return mlist;
+    if (Chess960 && (attacks_bb<ROOK>(kto, pos.pieces() ^ rfrom) & pos.pieces(~us, ROOK, QUEEN)))
+        return moveList;
 
-    (*mlist++).move = make<CASTLE>(kfrom, rfrom);
+    Move m = make<CASTLING>(kfrom, rfrom);
 
-    if (Checks && !pos.move_gives_check((mlist - 1)->move, CheckInfo(pos)))
-        mlist--;
+    if (Checks && !pos.gives_check(m))
+        return moveList;
 
-    return mlist;
+    *moveList++ = m;
+    return moveList;
   }
 
 
-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
+  template<GenType Type, Direction D>
+  ExtMove* make_promotions(ExtMove* moveList, Square to, Square ksq) {
 
-    return  Delta == DELTA_N  ?  p << 8
-          : Delta == DELTA_S  ?  p >> 8
-          : Delta == DELTA_NE ? (p & ~FileHBB) << 9
-          : Delta == DELTA_SE ? (p & ~FileHBB) >> 7
-          : Delta == DELTA_NW ? (p & ~FileABB) << 7
-          : Delta == DELTA_SW ? (p & ~FileABB) >> 9 : 0;
-  }
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+        *moveList++ = make<PROMOTION>(to - D, to, QUEEN);
 
-
-  template<GenType Type, Square Delta>
-  inline MoveStack* generate_promotions(MoveStack* mlist, Bitboard pawnsOn7,
-                                        Bitboard target, const CheckInfo* ci) {
-
-    Bitboard b = move_pawns<Delta>(pawnsOn7) & target;
-
-    while (b)
+    if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
     {
-        Square to = pop_lsb(&b);
-
-        if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, QUEEN);
-
-        if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
-        {
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, ROOK);
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, BISHOP);
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, KNIGHT);
-        }
-
-        // Knight-promotion is the only one that can give a direct check not
-        // already included in the queen-promotion.
-        if (Type == QUIET_CHECKS && (StepAttacksBB[W_KNIGHT][to] & ci->ksq))
-            (*mlist++).move = make<PROMOTION>(to - Delta, to, KNIGHT);
-        else
-            (void)ci; // Silence a warning under MSVC
+        *moveList++ = make<PROMOTION>(to - D, to, ROOK);
+        *moveList++ = make<PROMOTION>(to - D, to, BISHOP);
+        *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
     }
 
-    return mlist;
+    // Knight promotion is the only promotion that can give a direct check
+    // that's not already included in the queen promotion.
+    if (Type == QUIET_CHECKS && (PseudoAttacks[KNIGHT][to] & ksq))
+        *moveList++ = make<PROMOTION>(to - D, to, KNIGHT);
+    else
+        (void)ksq; // Silence a warning under MSVC
+
+    return moveList;
   }
 
 
   template<Color Us, GenType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist,
-                                 Bitboard target, const CheckInfo* ci) {
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
 
     // Compute 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 Square   RIGHT    = (Us == WHITE ? DELTA_NE : DELTA_SW);
-    const Square   LEFT     = (Us == WHITE ? DELTA_NW : DELTA_SE);
+    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 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 b1, b2, dc1, dc2, emptySquares;
+    Bitboard emptySquares;
 
     Bitboard pawnsOn7    = pos.pieces(Us, PAWN) &  TRank7BB;
     Bitboard pawnsNotOn7 = pos.pieces(Us, PAWN) & ~TRank7BB;
@@ -139,8 +115,8 @@ namespace {
     {
         emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces());
 
-        b1 = move_pawns<UP>(pawnsNotOn7)   & emptySquares;
-        b2 = move_pawns<UP>(b1 & TRank3BB) & emptySquares;
+        Bitboard b1 = shift<Up>(pawnsNotOn7)   & emptySquares;
+        Bitboard b2 = shift<Up>(b1 & TRank3BB) & emptySquares;
 
         if (Type == EVASIONS) // Consider only blocking squares
         {
@@ -150,25 +126,37 @@ namespace {
 
         if (Type == QUIET_CHECKS)
         {
-            b1 &= pos.attacks_from<PAWN>(ci->ksq, Them);
-            b2 &= pos.attacks_from<PAWN>(ci->ksq, Them);
+            Square ksq = pos.square<KING>(Them);
+
+            b1 &= pos.attacks_from<PAWN>(ksq, Them);
+            b2 &= pos.attacks_from<PAWN>(ksq, Them);
 
             // 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. Note that a possible discovery check
-            // promotion has been already generated among captures.
-            if (pawnsNotOn7 & ci->dcCandidates)
+            // promotion has been already generated amongst the captures.
+            Bitboard dcCandidates = pos.discovered_check_candidates();
+            if (pawnsNotOn7 & dcCandidates)
             {
-                dc1 = move_pawns<UP>(pawnsNotOn7 & ci->dcCandidates) & emptySquares & ~file_bb(ci->ksq);
-                dc2 = move_pawns<UP>(dc1 & TRank3BB) & emptySquares;
+                Bitboard dc1 = shift<Up>(pawnsNotOn7 & dcCandidates) & emptySquares & ~file_bb(ksq);
+                Bitboard dc2 = shift<Up>(dc1 & TRank3BB) & emptySquares;
 
                 b1 |= dc1;
                 b2 |= dc2;
             }
         }
 
-        SERIALIZE_PAWNS(b1, UP);
-        SERIALIZE_PAWNS(b2, UP + UP);
+        while (b1)
+        {
+            Square to = pop_lsb(&b1);
+            *moveList++ = make_move(to - Up, to);
+        }
+
+        while (b2)
+        {
+            Square to = pop_lsb(&b2);
+            *moveList++ = make_move(to - Up - Up, to);
+        }
     }
 
     // Promotions and underpromotions
@@ -180,19 +168,39 @@ namespace {
         if (Type == EVASIONS)
             emptySquares &= target;
 
-        mlist = generate_promotions<Type, RIGHT>(mlist, pawnsOn7, enemies, ci);
-        mlist = generate_promotions<Type, LEFT>(mlist, pawnsOn7, enemies, ci);
-        mlist = generate_promotions<Type, UP>(mlist, pawnsOn7, emptySquares, ci);
+        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)
     {
-        b1 = move_pawns<RIGHT>(pawnsNotOn7) & enemies;
-        b2 = move_pawns<LEFT >(pawnsNotOn7) & enemies;
+        Bitboard b1 = shift<Right>(pawnsNotOn7) & enemies;
+        Bitboard b2 = shift<Left >(pawnsNotOn7) & enemies;
 
-        SERIALIZE_PAWNS(b1, RIGHT);
-        SERIALIZE_PAWNS(b2, LEFT);
+        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)
         {
@@ -201,93 +209,91 @@ namespace {
             // 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 == EVASIONS && !(target & (pos.ep_square() - UP)))
-                return mlist;
+            if (Type == EVASIONS && !(target & (pos.ep_square() - Up)))
+                return moveList;
 
             b1 = pawnsNotOn7 & pos.attacks_from<PAWN>(pos.ep_square(), Them);
 
             assert(b1);
 
             while (b1)
-                (*mlist++).move = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
+                *moveList++ = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
         }
     }
 
-    return mlist;
+    return moveList;
   }
 
 
-  template<PieceType Pt, bool Checks> FORCE_INLINE
-  MoveStack* generate_moves(const Position& pos, MoveStack* mlist, Color us,
-                            Bitboard target, const CheckInfo* ci) {
+  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.piece_list(us, Pt);
+    const Square* pl = pos.squares<Pt>(us);
 
     for (Square from = *pl; from != SQ_NONE; from = *++pl)
     {
         if (Checks)
         {
             if (    (Pt == BISHOP || Pt == ROOK || Pt == QUEEN)
-                && !(PseudoAttacks[Pt][from] & target & ci->checkSq[Pt]))
+                && !(PseudoAttacks[Pt][from] & target & pos.check_squares(Pt)))
                 continue;
 
-            if (ci->dcCandidates && (ci->dcCandidates & from))
+            if (pos.discovered_check_candidates() & from)
                 continue;
         }
 
         Bitboard b = pos.attacks_from<Pt>(from) & target;
 
         if (Checks)
-            b &= ci->checkSq[Pt];
+            b &= pos.check_squares(Pt);
 
-        SERIALIZE(b);
+        while (b)
+            *moveList++ = make_move(from, pop_lsb(&b));
     }
 
-    return mlist;
+    return moveList;
   }
 
 
-  template<GenType Type> FORCE_INLINE
-  MoveStack* generate_all(const Position& pos, MoveStack* mlist, Color us,
-                          Bitboard target, const CheckInfo* ci = NULL) {
+  template<Color Us, GenType Type>
+  ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) {
 
     const bool Checks = Type == QUIET_CHECKS;
 
-    mlist = (us == WHITE ? generate_pawn_moves<WHITE, Type>(pos, mlist, target, ci)
-                         : generate_pawn_moves<BLACK, Type>(pos, mlist, target, ci));
-
-    mlist = generate_moves<KNIGHT, Checks>(pos, mlist, us, target, ci);
-    mlist = generate_moves<BISHOP, Checks>(pos, mlist, us, target, ci);
-    mlist = generate_moves<ROOK,   Checks>(pos, mlist, us, target, ci);
-    mlist = generate_moves<QUEEN,  Checks>(pos, mlist, us, target, ci);
+    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 from = pos.king_square(us);
-        Bitboard b = pos.attacks_from<KING>(from) & target;
-        SERIALIZE(b);
+        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 (Type != CAPTURES && Type != EVASIONS && pos.can_castle(Us))
     {
         if (pos.is_chess960())
         {
-            mlist = generate_castle<KING_SIDE,  Checks, true>(pos, mlist, us);
-            mlist = generate_castle<QUEEN_SIDE, Checks, true>(pos, mlist, us);
+            moveList = generate_castling<MakeCastling<Us,  KING_SIDE>::right, Checks, true>(pos, moveList, Us);
+            moveList = generate_castling<MakeCastling<Us, QUEEN_SIDE>::right, Checks, true>(pos, moveList, Us);
         }
         else
         {
-            mlist = generate_castle<KING_SIDE,  Checks, false>(pos, mlist, us);
-            mlist = generate_castle<QUEEN_SIDE, Checks, false>(pos, mlist, us);
+            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);
         }
     }
 
-    return mlist;
+    return moveList;
   }
 
-
 } // namespace
 
 
@@ -301,35 +307,36 @@ namespace {
 /// non-captures. Returns a pointer to the end of the move list.
 
 template<GenType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+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;
+  Bitboard target =  Type == CAPTURES     ?  pos.pieces(~us)
+                   : Type == QUIETS       ? ~pos.pieces()
+                   : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;
 
-  return generate_all<Type>(pos, mlist, us, target);
+  return us == WHITE ? generate_all<WHITE, Type>(pos, moveList, target)
+                     : generate_all<BLACK, Type>(pos, moveList, target);
 }
 
 // Explicit template instantiations
-template MoveStack* generate<CAPTURES>(const Position&, MoveStack*);
-template MoveStack* generate<QUIETS>(const Position&, MoveStack*);
-template MoveStack* generate<NON_EVASIONS>(const Position&, MoveStack*);
+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<>
-MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* moveList) {
 
   assert(!pos.checkers());
 
-  CheckInfo ci(pos);
-  Bitboard dc = ci.dcCandidates;
+  Color us = pos.side_to_move();
+  Bitboard dc = pos.discovered_check_candidates();
 
   while (dc)
   {
@@ -337,99 +344,77 @@ MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
      PieceType pt = type_of(pos.piece_on(from));
 
      if (pt == PAWN)
-         continue; // Will be generated togheter with direct checks
+         continue; // Will be generated together with direct checks
 
-     Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.pieces();
+     Bitboard b = pos.attacks_from(pt, from) & ~pos.pieces();
 
      if (pt == KING)
-         b &= ~PseudoAttacks[QUEEN][ci.ksq];
+         b &= ~PseudoAttacks[QUEEN][pos.square<KING>(~us)];
 
-     SERIALIZE(b);
+     while (b)
+         *moveList++ = make_move(from, pop_lsb(&b));
   }
 
-  return generate_all<QUIET_CHECKS>(pos, mlist, pos.side_to_move(), ~pos.pieces(), &ci);
+  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<>
-MoveStack* generate<EVASIONS>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* moveList) {
 
   assert(pos.checkers());
 
-  Square from, checksq;
-  int checkersCnt = 0;
   Color us = pos.side_to_move();
-  Square ksq = pos.king_square(us);
+  Square ksq = pos.square<KING>(us);
   Bitboard sliderAttacks = 0;
-  Bitboard b = pos.checkers();
+  Bitboard sliders = pos.checkers() & ~pos.pieces(KNIGHT, PAWN);
 
-  assert(pos.checkers());
-
-  // Find squares attacked by slider checkers, we will remove them from the king
-  // evasions so to skip known illegal moves avoiding useless legality check later.
-  do
+  // 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)
   {
-      checkersCnt++;
-      checksq = pop_lsb(&b);
-
-      assert(color_of(pos.piece_on(checksq)) == ~us);
-
-      switch (type_of(pos.piece_on(checksq)))
-      {
-      case BISHOP: sliderAttacks |= PseudoAttacks[BISHOP][checksq]; break;
-      case ROOK:   sliderAttacks |= PseudoAttacks[ROOK][checksq];   break;
-      case QUEEN:
-          // If queen and king are far or not on a diagonal line we can safely
-          // remove all the squares attacked in the other direction becuase are
-          // not reachable by the king anyway.
-          if (between_bb(ksq, checksq) || !(PseudoAttacks[BISHOP][checksq] & ksq))
-              sliderAttacks |= PseudoAttacks[QUEEN][checksq];
-
-          // Otherwise 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 |= PseudoAttacks[BISHOP][checksq] | pos.attacks_from<ROOK>(checksq);
-
-      default:
-          break;
-      }
-  } while (b);
+      Square checksq = pop_lsb(&sliders);
+      sliderAttacks |= LineBB[checksq][ksq] ^ checksq;
+  }
 
   // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
-  from = ksq;
-  SERIALIZE(b);
+  Bitboard b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
+  while (b)
+      *moveList++ = make_move(ksq, pop_lsb(&b));
 
-  if (checkersCnt > 1)
-      return mlist; // Double check, only a king move can save the day
+  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
-  Bitboard target = between_bb(checksq, ksq) | pos.checkers();
+  Square checksq = lsb(pos.checkers());
+  Bitboard target = between_bb(checksq, ksq) | checksq;
 
-  return generate_all<EVASIONS>(pos, mlist, us, target);
+  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<>
-MoveStack* generate<LEGAL>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) {
 
-  MoveStack *end, *cur = mlist;
-  Bitboard pinned = pos.pinned_pieces();
-  Square ksq = pos.king_square(pos.side_to_move());
+  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+  Square ksq = pos.square<KING>(pos.side_to_move());
+  ExtMove* cur = moveList;
 
-  end = pos.checkers() ? generate<EVASIONS>(pos, mlist)
-                       : generate<NON_EVASIONS>(pos, mlist);
-  while (cur != end)
-      if (   (pinned || from_sq(cur->move) == ksq || type_of(cur->move) == ENPASSANT)
-          && !pos.pl_move_is_legal(cur->move, pinned))
-          cur->move = (--end)->move;
+  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++;
+          ++cur;
 
-  return end;
+  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-2013 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,11 +18,15 @@
   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"
 
+class Position;
+
 enum GenType {
   CAPTURES,
   QUIETS,
@@ -31,29 +36,40 @@ enum GenType {
   LEGAL
 };
 
-class Position;
+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>
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+ExtMove* generate(const Position& pos, ExtMove* moveList);
 
-/// The MoveList struct is a simple wrapper around generate(), sometimes comes
-/// handy to use this class instead of the low level generate() function.
+/// 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) : cur(mlist), last(generate<T>(pos, mlist)) {}
-  void operator++() { cur++; }
-  bool end() const { return cur == last; }
-  Move move() const { return cur->move; }
-  size_t size() const { return last - mlist; }
-  bool contains(Move m) const {
-    for (const MoveStack* it(mlist); it != last; ++it) if (it->move == m) return true;
-    return false;
+  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:
-  MoveStack mlist[MAX_MOVES];
-  MoveStack *cur, *last;
+  ExtMove moveList[MAX_MOVES], *last;
 };
 
-#endif // !defined(MOVEGEN_H_INCLUDED)
+#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-2013 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
@@ -21,357 +21,314 @@
 #include <cassert>
 
 #include "movepick.h"
-#include "thread.h"
 
 namespace {
 
-  enum Sequencer {
-    MAIN_SEARCH, CAPTURES_S1, KILLERS_S1, QUIETS_1_S1, QUIETS_2_S1, BAD_CAPTURES_S1,
-    EVASION,     EVASIONS_S2,
-    QSEARCH_0,   CAPTURES_S3, QUIET_CHECKS_S3,
-    QSEARCH_1,   CAPTURES_S4,
-    PROBCUT,     CAPTURES_S5,
-    RECAPTURE,   CAPTURES_S6,
-    STOP
+  enum Stages {
+    MAIN_SEARCH, CAPTURES_INIT, GOOD_CAPTURES, KILLERS, COUNTERMOVE, QUIET_INIT, QUIET, BAD_CAPTURES,
+    EVASION, EVASIONS_INIT, ALL_EVASIONS,
+    PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES,
+    QSEARCH_WITH_CHECKS, QCAPTURES_1_INIT, QCAPTURES_1, QCHECKS,
+    QSEARCH_NO_CHECKS, QCAPTURES_2_INIT, QCAPTURES_2,
+    QSEARCH_RECAPTURES, QRECAPTURES
   };
 
-  // Our insertion sort, guaranteed to be stable, as is needed
-  void insertion_sort(MoveStack* begin, MoveStack* end)
-  {
-    MoveStack tmp, *p, *q;
+  // partial_insertion_sort() sorts moves in descending order up to and including
+  // a given limit. The order of moves smaller than the limit is left unspecified.
+  void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) {
 
-    for (p = begin + 1; p < end; ++p)
-    {
-        tmp = *p;
-        for (q = p; q != begin && *(q-1) < tmp; --q)
-            *q = *(q-1);
-        *q = tmp;
-    }
+    for (ExtMove *sortedEnd = begin, *p = begin + 1; p < end; ++p)
+        if (p->value >= limit)
+        {
+            ExtMove tmp = *p, *q;
+            *p = *++sortedEnd;
+            for (q = sortedEnd; q != begin && *(q - 1) < tmp; --q)
+                *q = *(q - 1);
+            *q = tmp;
+        }
   }
 
-  // Unary predicate used by std::partition to split positive scores from remaining
-  // ones so to sort separately the two sets, and with the second sort delayed.
-  inline bool has_positive_score(const MoveStack& ms) { return ms.score > 0; }
+  // pick_best() finds the best move in the range (begin, end) and moves it to
+  // 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) {
 
-  // Picks and moves to the front the best move in the range [begin, end),
-  // 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* begin, MoveStack* end)
-  {
-      std::swap(*begin, *std::max_element(begin, end));
-      return begin;
+    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
+/// 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
-/// move ordering is at the current node.
+/// search captures, promotions, and some checks) and how important good move
+/// ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       Search::Stack* s, Value beta) : pos(p), Hist(h), depth(d) {
+/// MovePicker constructor for the main search
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,
+                       const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers_p)
+           : pos(p), mainHistory(mh), captureHistory(cph), contHistory(ch), countermove(cm),
+             killers{killers_p[0], killers_p[1]}, depth(d){
 
   assert(d > DEPTH_ZERO);
 
-  captureThreshold = 0;
-  cur = end = moves;
-  endBadCaptures = moves + MAX_MOVES - 1;
-  ss = s;
-
-  if (p.checkers())
-      phase = EVASION;
-
-  else
-  {
-      phase = MAIN_SEARCH;
-
-      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->staticEval < beta - PawnValueMg && d < 3 * ONE_PLY)
-          captureThreshold = -PawnValueMg;
-
-      // Consider negative captures as good if still enough to reach beta
-      else if (ss && ss->staticEval > beta)
-          captureThreshold = beta - ss->staticEval;
-  }
-
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  end += (ttMove != MOVE_NONE);
+  stage = pos.checkers() ? EVASION : MAIN_SEARCH;
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
+  stage += (ttMove == MOVE_NONE);
 }
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       Square sq) : pos(p), Hist(h), cur(moves), end(moves) {
+/// MovePicker constructor for quiescence search
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,  const CapturePieceToHistory* cph, Square s)
+           : pos(p), mainHistory(mh), captureHistory(cph) {
 
   assert(d <= DEPTH_ZERO);
 
-  if (p.checkers())
-      phase = EVASION;
+  if (pos.checkers())
+      stage = EVASION;
 
   else if (d > DEPTH_QS_NO_CHECKS)
-      phase = QSEARCH_0;
+      stage = QSEARCH_WITH_CHECKS;
 
   else if (d > DEPTH_QS_RECAPTURES)
-  {
-      phase = QSEARCH_1;
+      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 && !pos.is_capture_or_promotion(ttm))
-          ttm = MOVE_NONE;
-  }
   else
   {
-      phase = RECAPTURE;
-      recaptureSquare = sq;
-      ttm = MOVE_NONE;
+      stage = QSEARCH_RECAPTURES;
+      recaptureSquare = s;
+      return;
   }
 
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  end += (ttMove != MOVE_NONE);
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
+  stage += (ttMove == MOVE_NONE);
 }
 
-MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType pt)
-                       : pos(p), Hist(h), cur(moves), end(moves) {
+/// 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) {
 
   assert(!pos.checkers());
 
-  phase = PROBCUT;
+  stage = PROBCUT;
+  ttMove =   ttm
+          && pos.pseudo_legal(ttm)
+          && pos.capture(ttm)
+          && pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE;
 
-  // In ProbCut we generate only captures better than parent's captured piece
-  captureThreshold = PieceValue[MG][pt];
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-
-  if (ttMove && (!pos.is_capture(ttMove) ||  pos.see(ttMove) <= captureThreshold))
-      ttMove = MOVE_NONE;
-
-  end += (ttMove != MOVE_NONE);
+  stage += (ttMove == MOVE_NONE);
 }
 
+/// 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() {
 
-/// score() assign a numerical move ordering score to each move in a move list.
-/// The moves with highest scores will be picked first.
-template<>
-void MovePicker::score<CAPTURES>() {
-  // Winning and equal captures in the main search are ordered by MVV/LVA.
-  // Suprisingly, this appears to perform slightly better than SEE based
-  // move ordering. The reason is probably that in a position with a winning
-  // capture, capturing a more valuable (but sufficiently defended) piece
-  // 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;
+  static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type");
 
-  for (MoveStack* it = moves; it != end; ++it)
-  {
-      m = it->move;
-      it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                 - type_of(pos.piece_moved(m));
+  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)))]);
 
-      if (type_of(m) == PROMOTION)
-          it->score += PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN];
+      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 if (type_of(m) == ENPASSANT)
-          it->score += PieceValue[MG][PAWN];
-  }
+      else // Type == EVASIONS
+      {
+          if (pos.capture(m))
+              m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                       - Value(type_of(pos.moved_piece(m)));
+          else
+              m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] - (1 << 28);
+      }
 }
 
-template<>
-void MovePicker::score<QUIETS>() {
+/// next_move() is the most important method of the MovePicker class. It returns
+/// a new pseudo legal move every time it is called, until there are no more moves
+/// left. It picks the move with the biggest value from a list of generated moves
+/// taking care not to return the ttMove if it has already been searched.
 
-  Move m;
+Move MovePicker::next_move(bool skipQuiets) {
 
-  for (MoveStack* it = moves; it != end; ++it)
-  {
-      m = it->move;
-      it->score = Hist[pos.piece_moved(m)][to_sq(m)];
-  }
-}
+  Move move;
 
-template<>
-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, then bad-captures and quiet
-  // moves with a negative SEE. This last group is ordered by the SEE score.
-  Move m;
-  int seeScore;
+  switch (stage) {
 
-  for (MoveStack* it = moves; it != end; ++it)
-  {
-      m = it->move;
-      if ((seeScore = pos.see_sign(m)) < 0)
-          it->score = seeScore - History::Max; // At the bottom
+  case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS:
+  case QSEARCH_NO_CHECKS: case PROBCUT:
+      ++stage;
+      return ttMove;
 
-      else if (pos.is_capture(m))
-          it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                     - type_of(pos.piece_moved(m)) + History::Max;
-      else
-          it->score = Hist[pos.piece_moved(m)][to_sq(m)];
-  }
-}
-
-
-/// generate_next() generates, scores and sorts the next bunch of moves, when
-/// there are no more moves to try for the current phase.
-
-void MovePicker::generate_next() {
-
-  cur = moves;
-
-  switch (++phase) {
-
-  case CAPTURES_S1: case CAPTURES_S3: case CAPTURES_S4: case CAPTURES_S5: case CAPTURES_S6:
-      end = generate<CAPTURES>(pos, moves);
+  case CAPTURES_INIT:
+      endBadCaptures = cur = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
       score<CAPTURES>();
-      return;
+      ++stage;
+      /* fallthrough */
 
-  case KILLERS_S1:
-      cur = killers;
-      end = cur + 2;
-      return;
+  case GOOD_CAPTURES:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
+          if (move != ttMove)
+          {
+              if (pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)))
+                  return move;
 
-  case QUIETS_1_S1:
-      endQuiets = end = generate<QUIETS>(pos, moves);
+              // Losing capture, move it to the beginning of the array
+              *endBadCaptures++ = move;
+          }
+      }
+
+      ++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>();
-      end = std::partition(cur, end, has_positive_score);
-      insertion_sort(cur, end);
-      return;
+      partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY);
+      ++stage;
+      /* fallthrough */
 
-  case QUIETS_2_S1:
-      cur = end;
-      end = endQuiets;
-      if (depth >= 3 * ONE_PLY)
-          insertion_sort(cur, end);
-      return;
+  case QUIET:
+      while (    cur < endMoves
+             && (!skipQuiets || cur->value >= VALUE_ZERO))
+      {
+          move = *cur++;
 
-  case BAD_CAPTURES_S1:
-      // Just pick them in reverse order to get MVV/LVA ordering
-      cur = moves + MAX_MOVES - 1;
-      end = endBadCaptures;
-      return;
+          if (   move != ttMove
+              && move != killers[0]
+              && move != killers[1]
+              && move != countermove)
+              return move;
+      }
+      ++stage;
+      cur = moves; // Point to beginning of bad captures
+      /* fallthrough */
 
-  case EVASIONS_S2:
-      end = generate<EVASIONS>(pos, moves);
-      if (end > moves + 1)
-          score<EVASIONS>();
-      return;
+  case BAD_CAPTURES:
+      if (cur < endBadCaptures)
+          return *cur++;
+      break;
 
-  case QUIET_CHECKS_S3:
-      end = generate<QUIET_CHECKS>(pos, moves);
-      return;
+  case EVASIONS_INIT:
+      cur = moves;
+      endMoves = generate<EVASIONS>(pos, cur);
+      score<EVASIONS>();
+      ++stage;
+      /* fallthrough */
 
-  case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: case RECAPTURE:
-      phase = STOP;
-  case STOP:
-      end = cur + 1; // Avoid another next_phase() call
-      return;
+  case ALL_EVASIONS:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
+          if (move != ttMove)
+              return move;
+      }
+      break;
+
+  case PROBCUT_INIT:
+      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_ge(move, threshold))
+              return move;
+      }
+      break;
+
+  case QCAPTURES_1_INIT: case QCAPTURES_2_INIT:
+      cur = moves;
+      endMoves = generate<CAPTURES>(pos, cur);
+      score<CAPTURES>();
+      ++stage;
+      /* fallthrough */
+
+  case QCAPTURES_1: case QCAPTURES_2:
+      while (cur < endMoves)
+      {
+          move = pick_best(cur++, endMoves);
+          if (move != ttMove)
+              return move;
+      }
+      if (stage == QCAPTURES_2)
+          break;
+      cur = moves;
+      endMoves = generate<QUIET_CHECKS>(pos, cur);
+      ++stage;
+      /* fallthrough */
+
+  case QCHECKS:
+      while (cur < endMoves)
+      {
+          move = cur++->move;
+          if (move != ttMove)
+              return move;
+      }
+      break;
+
+  case QSEARCH_RECAPTURES:
+      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);
   }
+
+  return MOVE_NONE;
 }
-
-
-/// next_move() is the most important method of the MovePicker class. It returns
-/// a new pseudo legal move every time is called, until there are no more moves
-/// left. It picks the move with the biggest score from a list of generated moves
-/// taking care not returning the ttMove if has already been searched previously.
-template<>
-Move MovePicker::next_move<false>() {
-
-  Move move;
-
-  while (true)
-  {
-      while (cur == end)
-          generate_next();
-
-      switch (phase) {
-
-      case MAIN_SEARCH: case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT:
-          cur++;
-          return ttMove;
-
-      case CAPTURES_S1:
-          move = pick_best(cur++, end)->move;
-          if (move != ttMove)
-          {
-              assert(captureThreshold <= 0); // Otherwise we cannot use see_sign()
-
-              if (pos.see_sign(move) >= captureThreshold)
-                  return move;
-
-              // Losing capture, move it to the tail of the array
-              (endBadCaptures--)->move = move;
-          }
-          break;
-
-      case KILLERS_S1:
-          move = (cur++)->move;
-          if (    move != MOVE_NONE
-              &&  pos.is_pseudo_legal(move)
-              &&  move != ttMove
-              && !pos.is_capture(move))
-              return move;
-          break;
-
-      case QUIETS_1_S1: case QUIETS_2_S1:
-          move = (cur++)->move;
-          if (   move != ttMove
-              && move != killers[0].move
-              && move != killers[1].move)
-              return move;
-          break;
-
-      case BAD_CAPTURES_S1:
-          return (cur--)->move;
-
-      case EVASIONS_S2: case CAPTURES_S3: case CAPTURES_S4:
-          move = pick_best(cur++, end)->move;
-          if (move != ttMove)
-              return move;
-          break;
-
-      case CAPTURES_S5:
-           move = pick_best(cur++, end)->move;
-           if (move != ttMove && pos.see(move) > captureThreshold)
-               return move;
-           break;
-
-      case CAPTURES_S6:
-          move = pick_best(cur++, end)->move;
-          if (to_sq(move) == recaptureSquare)
-              return move;
-          break;
-
-      case QUIET_CHECKS_S3:
-          move = (cur++)->move;
-          if (move != ttMove)
-              return move;
-          break;
-
-      case STOP:
-          return MOVE_NONE;
-
-      default:
-          assert(false);
-      }
-  }
-}
-
-
-/// Version of next_move() to use at split point nodes where the move is grabbed
-/// from the split point's shared MovePicker object. This function is not thread
-/// safe so must be lock protected by the caller.
-template<>
-Move MovePicker::next_move<true>() { return ss->splitPoint->movePicker->next_move<false>(); }

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-2013 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,49 +18,100 @@
   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 <algorithm> // For std::max
-#include <cstring>   // For memset
+#include <array>
+#include <limits>
 
 #include "movegen.h"
 #include "position.h"
-#include "search.h"
 #include "types.h"
 
+/// StatBoards is a generic 2-dimensional array used to store various statistics
+template<int Size1, int Size2, typename T = int16_t>
+struct StatBoards : public std::array<std::array<T, Size2>, Size1> {
 
-/// The Stats struct stores moves statistics. According to the template parameter
-/// the class can store both History and Gains type statistics. History records
-/// how often different moves have been successful or unsuccessful during the
-/// current search and is used for reduction and move ordering decisions. Gains
-/// records the move's best evaluation gain from one ply to the next and is used
-/// for pruning decisions. 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.
-template<bool Gain>
-struct Stats {
-
-  static const Value Max = Value(2000);
-
-  const Value* operator[](Piece p) const { return &table[p][0]; }
-  void clear() { memset(table, 0, sizeof(table)); }
-
-  void update(Piece p, Square to, Value v) {
-
-    if (Gain)
-        table[p][to] = std::max(v, table[p][to] - 1);
-
-    else if (abs(table[p][to] + v) < Max)
-        table[p][to] +=  v;
+  void fill(const T& v) {
+    T* p = &(*this)[0][0];
+    std::fill(p, p + sizeof(*this) / sizeof(*p), v);
   }
 
-private:
-  Value table[PIECE_NB][SQUARE_NB];
+  void update(T& entry, int bonus, const int D) {
+
+    assert(abs(bonus) <= D); // Ensure range is [-32 * D, 32 * D]
+    assert(abs(32 * D) < (std::numeric_limits<T>::max)()); // Ensure we don't overflow
+
+    entry += bonus * 32 - entry * abs(bonus) / D;
+
+    assert(abs(entry) <= 32 * D);
+  }
 };
 
-typedef Stats<false> History;
-typedef Stats<true> Gains;
+/// 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
@@ -70,29 +122,30 @@ typedef Stats<true> Gains;
 /// to get a cut-off first.
 
 class MovePicker {
-
-  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
-
 public:
-  MovePicker(const Position&, Move, Depth, const History&, Search::Stack*, Value);
-  MovePicker(const Position&, Move, Depth, const History&, Square);
-  MovePicker(const Position&, Move, const History&, PieceType);
-  template<bool SpNode> Move next_move();
+  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();
-  void generate_next();
+  ExtMove* begin() { return cur; }
+  ExtMove* end() { return endMoves; }
 
   const Position& pos;
-  const History& Hist;
-  Search::Stack* ss;
-  Depth depth;
-  Move ttMove;
-  MoveStack killers[2];
+  const ButterflyHistory* mainHistory;
+  const CapturePieceToHistory* captureHistory;
+  const PieceToHistory** contHistory;
+  Move ttMove, countermove, killers[2];
+  ExtMove *cur, *endMoves, *endBadCaptures;
+  int stage;
   Square recaptureSquare;
-  int captureThreshold, phase;
-  MoveStack *cur, *end, *endQuiets, *endBadCaptures;
-  MoveStack moves[MAX_MOVES];
+  Value threshold;
+  Depth depth;
+  ExtMove moves[MAX_MOVES];
 };
 
-#endif // !defined(MOVEPICK_H_INCLUDED)
+#endif // #ifndef MOVEPICK_H_INCLUDED

src/notation.cpp

@@ -1,263 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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 <iomanip>
-#include <sstream>
-#include <stack>
-
-#include "movegen.h"
-#include "notation.h"
-#include "position.h"
-
-using namespace std;
-
-static const char* PieceToChar[COLOR_NB] = { " PNBRQK", " pnbrqk" };
-
-
-/// score_to_uci() converts a value to a string suitable for use with the UCI
-/// protocol specifications:
-///
-/// 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.
-
-string score_to_uci(Value v, Value alpha, Value beta) {
-
-  stringstream s;
-
-  if (abs(v) < VALUE_MATE_IN_MAX_PLY)
-      s << "cp " << v * 100 / int(PawnValueMg);
-  else
-      s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
-
-  s << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : "");
-
-  return s.str();
-}
-
-
-/// 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. Internally castle moves are always coded as "king captures rook".
-
-const string move_to_uci(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) == CASTLE && !chess960)
-      to = (to > from ? FILE_G : FILE_C) | rank_of(from);
-
-  string move = square_to_string(from) + square_to_string(to);
-
-  if (type_of(m) == PROMOTION)
-      move += PieceToChar[BLACK][promotion_type(m)]; // Lower case
-
-  return move;
-}
-
-
-/// move_from_uci() takes a position and a string representing a move in
-/// simple coordinate notation and returns an equivalent legal Move if any.
-
-Move move_from_uci(const Position& pos, string& str) {
-
-  if (str.length() == 5) // Junior could send promotion piece in uppercase
-      str[4] = char(tolower(str[4]));
-
-  for (MoveList<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 legal Move as input and returns its
-/// short algebraic notation representation.
-
-const string move_to_san(Position& pos, Move m) {
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "(null)";
-
-  assert(MoveList<LEGAL>(pos).contains(m));
-
-  Bitboard others, b;
-  string san;
-  Color us = pos.side_to_move();
-  Square from = from_sq(m);
-  Square to = to_sq(m);
-  Piece pc = pos.piece_on(from);
-  PieceType pt = type_of(pc);
-
-  if (type_of(m) == CASTLE)
-      san = to > from ? "O-O" : "O-O-O";
-  else
-  {
-      if (pt != PAWN)
-      {
-          san = PieceToChar[WHITE][pt]; // Upper case
-
-          // Disambiguation if we have more then one piece of type 'pt' that can
-          // reach 'to' with a legal move.
-          others = b = (pos.attacks_from(pc, to) & pos.pieces(us, pt)) ^ from;
-
-          while (b)
-          {
-              Move move = make_move(pop_lsb(&b), to);
-              if (!pos.pl_move_is_legal(move, pos.pinned_pieces()))
-                  others ^= from_sq(move);
-          }
-
-          if (others)
-          {
-              if (!(others & file_bb(from)))
-                  san += file_to_char(file_of(from));
-
-              else if (!(others & rank_bb(from)))
-                  san += rank_to_char(rank_of(from));
-
-              else
-                  san += square_to_string(from);
-          }
-      }
-      else if (pos.is_capture(m))
-          san = file_to_char(file_of(from));
-
-      if (pos.is_capture(m))
-          san += 'x';
-
-      san += square_to_string(to);
-
-      if (type_of(m) == PROMOTION)
-          san += string("=") + PieceToChar[WHITE][promotion_type(m)];
-  }
-
-  if (pos.move_gives_check(m, CheckInfo(pos)))
-  {
-      StateInfo st;
-      pos.do_move(m, st);
-      san += MoveList<LEGAL>(pos).size() ? "+" : "#";
-      pos.undo_move(m);
-  }
-
-  return san;
-}
-
-
-/// pretty_pv() formats human-readable search information, typically to be
-/// appended to the search log file. It uses the two helpers below to pretty
-/// format time and score respectively.
-
-static string time_to_string(int64_t msecs) {
-
-  const int MSecMinute = 1000 * 60;
-  const int MSecHour   = 1000 * 60 * 60;
-
-  int64_t hours   =   msecs / MSecHour;
-  int64_t minutes =  (msecs % MSecHour) / MSecMinute;
-  int64_t seconds = ((msecs % MSecHour) % MSecMinute) / 1000;
-
-  stringstream s;
-
-  if (hours)
-      s << hours << ':';
-
-  s << setfill('0') << setw(2) << minutes << ':' << setw(2) << seconds;
-
-  return s.str();
-}
-
-static string score_to_string(Value v) {
-
-  stringstream s;
-
-  if (v >= VALUE_MATE_IN_MAX_PLY)
-      s << "#" << (VALUE_MATE - v + 1) / 2;
-
-  else if (v <= VALUE_MATED_IN_MAX_PLY)
-      s << "-#" << (VALUE_MATE + v) / 2;
-
-  else
-      s << setprecision(2) << fixed << showpos << float(v) / PawnValueMg;
-
-  return s.str();
-}
-
-string pretty_pv(Position& pos, int depth, Value value, int64_t msecs, Move pv[]) {
-
-  const int64_t K = 1000;
-  const int64_t M = 1000000;
-
-  std::stack<StateInfo> st;
-  Move* m = pv;
-  string san, padding;
-  size_t length;
-  stringstream s;
-
-  s << setw(2) << depth
-    << setw(8) << score_to_string(value)
-    << setw(8) << time_to_string(msecs);
-
-  if (pos.nodes_searched() < M)
-      s << setw(8) << pos.nodes_searched() / 1 << "  ";
-
-  else if (pos.nodes_searched() < K * M)
-      s << setw(7) << pos.nodes_searched() / K << "K  ";
-
-  else
-      s << setw(7) << pos.nodes_searched() / M << "M  ";
-
-  padding = string(s.str().length(), ' ');
-  length = padding.length();
-
-  while (*m != MOVE_NONE)
-  {
-      san = move_to_san(pos, *m);
-
-      if (length + san.length() > 80)
-      {
-          s << "\n" + padding;
-          length = padding.length();
-      }
-
-      s << san << ' ';
-      length += san.length() + 1;
-
-      st.push(StateInfo());
-      pos.do_move(*m++, st.top());
-  }
-
-  while (m != pv)
-      pos.undo_move(*--m);
-
-  return s.str();
-}

src/notation.h

@@ -1,35 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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(NOTATION_H_INCLUDED)
-#define NOTATION_H_INCLUDED
-
-#include <string>
-
-#include "types.h"
-
-class Position;
-
-std::string score_to_uci(Value v, Value alpha = -VALUE_INFINITE, Value beta = VALUE_INFINITE);
-Move move_from_uci(const Position& pos, std::string& str);
-const std::string move_to_uci(Move m, bool chess960);
-const std::string move_to_san(Position& pos, Move m);
-std::string pretty_pv(Position& pos, int depth, Value score, int64_t msecs, Move pv[]);
-
-#endif // !defined(NOTATION_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-2013 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,276 +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
-  const Score DoubledPawnPenalty[2][FILE_NB] = {
-  { 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
+  const Score Isolated = S(13, 18);
 
-  // Isolated pawn penalty by opposed flag and file
-  const Score IsolatedPawnPenalty[2][FILE_NB] = {
-  { 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
+  const Score Backward = S(24, 12);
 
-  // Backward pawn penalty by opposed flag and file
-  const Score BackwardPawnPenalty[2][FILE_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) }};
+  // Connected pawn bonus by opposed, phalanx, #support and rank
+  Score Connected[2][2][3][RANK_NB];
 
-  // Pawn chain membership bonus by file
-  const Score ChainBonus[FILE_NB] = {
-    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
-    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
+  // Doubled pawn penalty
+  const Score Doubled = S(18, 38);
+
+  // 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
-  const Score CandidateBonus[RANK_NB] = {
-    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
-    S(34,68), S(83,166), S(0, 0), S( 0, 0)
+  // Danger of enemy pawns moving toward our king by [type][distance from edge][rank].
+  // For the unopposed and unblocked cases, RANK_1 = 0 is used when opponent has
+  // no pawn on the given file, or their pawn is behind our king.
+  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);
-
-  // Weakness of our pawn shelter in front of the king indexed by [king pawn][rank]
-  const Value ShelterWeakness[2][RANK_NB] =
-  { { V(141), V(0), V(38), V(102), V(128), V(141), V(141) },
-    { V( 61), V(0), V(16), V( 44), V( 56), V( 61), V( 61) } };
-
-  // Danger of enemy pawns moving toward our king indexed by [pawn blocked][rank]
-  const Value StormDanger[2][RANK_NB] =
-  { { V(26), V(0), V(128), V(51), V(26) },
-    { V(13), V(0), V( 64), V(25), V(13) } };
-
   // Max bonus for king safety. Corresponds to start position with all the pawns
-  // in front of the king and no enemy pawn on the horizont.
-  const Value MaxSafetyBonus = V(263);
+  // in front of the king and no enemy pawn on the horizon.
+  const Value MaxSafetyBonus = V(258);
 
   #undef S
   #undef V
 
   template<Color Us>
-  Score evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                       Bitboard theirPawns, Pawns::Entry* e) {
+  Score evaluate(const Position& pos, Pawns::Entry* e) {
 
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    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;
-    Rank r;
-    bool passed, isolated, doubled, opposed, chain, backward, candidate;
-    Score value = SCORE_ZERO;
-    const Square* pl = pos.piece_list(Us, PAWN);
+    bool opposed, backward;
+    Score score = SCORE_ZERO;
+    const Square* pl = pos.squares<PAWN>(Us);
+
+    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);
-        r = rank_of(s);
+        File f = file_of(s);
 
-        // This file cannot be half open
-        e->halfOpenFiles[Us] &= ~(1 << f);
+        e->semiopenFiles[Us]   &= ~(1 << f);
+        e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s);
 
-        // Our rank plus previous one. Used for chain detection
-        b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
+        // Flag the pawn
+        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
-        // chain (but not the backward one).
-        chain    =   ourPawns   & adjacent_files_bb(f) & b;
-        isolated = !(ourPawns   & adjacent_files_bb(f));
-        doubled  =   ourPawns   & forward_bb(Us, s);
-        opposed  =   theirPawns & forward_bb(Us, s);
-        passed   = !(theirPawns & passed_pawn_mask(Us, s));
-
-        // Test for backward pawn
-        backward = false;
-
-        // If the pawn is passed, isolated, or member of a pawn chain it cannot
-        // be backward. If there are friendly pawns behind on adjacent 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))
+        // A pawn is backward when it is behind all pawns of the same color on the
+        // adjacent files and cannot be safely advanced.
+        if (!neighbours || lever || relative_rank(Us, s) >= RANK_5)
+            backward = false;
+        else
         {
-            // We now know that there are no friendly pawns beside or behind this
-            // pawn on adjacent files. We now check whether the pawn is
-            // backward by looking in the forward direction on the adjacent
-            // files, and seeing whether we meet a friendly or an enemy pawn first.
-            b = pos.attacks_from<PAWN>(s, Us);
+            // Find the backmost rank with neighbours or stoppers
+            b = rank_bb(backmost_sq(Us, neighbours | stoppers));
 
-            // Note that we are sure to find something because pawn is not passed
-            // nor isolated, so loop is potentially infinite, but it isn't.
-            while (!(b & (ourPawns | theirPawns)))
-                Us == WHITE ? b <<= 8 : b >>= 8;
+            // The pawn is backward when it cannot safely progress to that rank:
+            // either there is a stopper in the way on this rank, or there is a
+            // stopper on adjacent file which controls the way to that rank.
+            backward = (b | shift<Up>(b & adjacent_files_bb(f))) & stoppers;
 
-            // The friendly pawn needs to be at least two ranks closer than the
-            // enemy pawn in order to help the potentially backward pawn advance.
-            backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
+            assert(!(backward && (forward_ranks_bb(Them, s + Up) & neighbours)));
         }
 
-        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 adjacent files is higher or equal than the number of
-        // enemy pawns in the forward direction on the adjacent 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
-        // pawn on each file is considered a true passed pawn.
-        if (passed && !doubled)
+        // full attack info to evaluate them. Include also not passed pawns
+        // which could become passed after one or two pawn pushes when are
+        // not attacked more times than defended.
+        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)
-            value -= IsolatedPawnPenalty[opposed][f];
+        if (supported | phalanx)
+            score += Connected[opposed][bool(phalanx)][popcount(supported)][relative_rank(Us, s)];
 
-        if (doubled)
-            value -= DoubledPawnPenalty[opposed][f];
+        else if (!neighbours)
+            score -= Isolated, e->weakUnopposed[Us] += !opposed;
 
-        if (backward)
-            value -= BackwardPawnPenalty[opposed][f];
+        else if (backward)
+            score -= Backward, e->weakUnopposed[Us] += !opposed;
 
-        if (chain)
-            value += ChainBonus[f];
-
-        if (candidate)
-            value += CandidateBonus[relative_rank(Us, s)];
+        if (doubled && !supported)
+            score -= Doubled;
     }
 
-    e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & BlackSquares);
-    e->pawnsOnSquares[Us][WHITE] = pos.piece_count(Us, PAWN) - e->pawnsOnSquares[Us][BLACK];
-
-    e->pawnsOnSquares[Them][BLACK] = popcount<Max15>(theirPawns & BlackSquares);
-    e->pawnsOnSquares[Them][WHITE] = pos.piece_count(Them, PAWN) - e->pawnsOnSquares[Them][BLACK];
-
-    return value;
+    return score;
   }
-}
+
+} // namespace
 
 namespace Pawns {
 
-/// probe() takes a position object as input, computes a Entry object, and returns
-/// a pointer to it. The result is also stored in a hash table, so we don't have
-/// to recompute everything when the same pawn structure occurs again.
+/// 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.
 
-Entry* probe(const Position& pos, Table& entries) {
+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);
+  }
+}
+
+
+/// Pawns::probe() looks up the current position's pawns configuration in
+/// 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 = entries[key];
+  Entry* e = pos.this_thread()->pawnsTable[key];
 
-  // If e->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 (e->key == key)
       return e;
 
   e->key = key;
-  e->passedPawns[WHITE] = e->passedPawns[BLACK] = 0;
-  e->kingSquares[WHITE] = e->kingSquares[BLACK] = SQ_NONE;
-  e->halfOpenFiles[WHITE] = e->halfOpenFiles[BLACK] = 0xFF;
-
-  Bitboard wPawns = pos.pieces(WHITE, PAWN);
-  Bitboard bPawns = pos.pieces(BLACK, PAWN);
-  e->pawnAttacks[WHITE] = ((wPawns & ~FileHBB) << 9) | ((wPawns & ~FileABB) << 7);
-  e->pawnAttacks[BLACK] = ((bPawns & ~FileHBB) >> 7) | ((bPawns & ~FileABB) >> 9);
-
-  e->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, e)
-            - evaluate_pawns<BLACK>(pos, bPawns, wPawns, e);
-
-  e->value = apply_weight(e->value, PawnStructureWeight);
-
+  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 adjacent files.
+/// the king is on, as well as the two closest files.
 
 template<Color Us>
 Value Entry::shelter_storm(const Position& pos, Square ksq) {
 
   const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-  Value safety = MaxSafetyBonus;
-  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, ksq) | rank_bb(ksq));
-  Bitboard ourPawns = b & pos.pieces(Us) & ~rank_bb(ksq);
+  enum { BlockedByKing, Unopposed, BlockedByPawn, Unblocked };
+
+  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);
-  Rank rkUs, rkThem;
-  File kf = file_of(ksq);
+  Value safety = MaxSafetyBonus;
+  File center = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
 
-  kf = (kf == FILE_A) ? FILE_B : (kf == FILE_H) ? FILE_G : kf;
-
-  for (int f = kf - 1; f <= kf + 1; f++)
+  for (File f = File(center - 1); f <= File(center + 1); ++f)
   {
-      // Shelter penalty is higher for the pawn in front of the king
-      b = ourPawns & FileBB[f];
-      rkUs = b ? rank_of(Us == WHITE ? lsb(b) : ~msb(b)) : RANK_1;
-      safety -= ShelterWeakness[f != kf][rkUs];
+      b = ourPawns & file_bb(f);
+      Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
 
-      // Storm danger is smaller if enemy pawn is blocked
-      b  = theirPawns & FileBB[f];
-      rkThem = b ? rank_of(Us == WHITE ? lsb(b) : ~msb(b)) : RANK_1;
-      safety -= StormDanger[rkThem == rkUs + 1][rkThem];
+      b = theirPawns & file_bb(f);
+      Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
+
+      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::update_safety() calculates and caches a bonus for king safety. It is
-/// called only when king square changes, about 20% of total king_safety() calls.
+/// 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::update_safety(const Position& pos, Square ksq) {
+Score Entry::do_king_safety(const Position& pos, Square ksq) {
 
   kingSquares[Us] = ksq;
-  castleRights[Us] = pos.can_castle(Us);
-  minKPdistance[Us] = 0;
+  castlingRights[Us] = pos.can_castle(Us);
+  int minKingPawnDistance = 0;
 
   Bitboard pawns = pos.pieces(Us, PAWN);
   if (pawns)
-      while (!(DistanceRingsBB[ksq][minKPdistance[Us]++] & pawns)) {}
-
-  if (relative_rank(Us, ksq) > RANK_4)
-      return kingSafety[Us] = make_score(0, -16 * minKPdistance[Us]);
+      while (!(DistanceRingBB[ksq][minKingPawnDistance++] & pawns)) {}
 
   Value bonus = shelter_storm<Us>(pos, ksq);
 
-  // If we can castle use the bonus after the castle if is bigger
-  if (pos.can_castle(make_castle_right(Us, KING_SIDE)))
+  // 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(make_castle_right(Us, QUEEN_SIDE)))
+  if (pos.can_castle(MakeCastling<Us, QUEEN_SIDE>::right))
       bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
 
-  return kingSafety[Us] = make_score(bonus, -16 * minKPdistance[Us]);
+  return make_score(bonus, -16 * minKingPawnDistance);
 }
 
 // Explicit template instantiation
-template Score Entry::update_safety<WHITE>(const Position& pos, Square ksq);
-template Score Entry::update_safety<BLACK>(const Position& pos, Square ksq);
+template Score Entry::do_king_safety<WHITE>(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-2013 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,7 +18,7 @@
   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"
@@ -26,51 +27,64 @@
 
 namespace Pawns {
 
-/// Pawns::Entry contains various information about a pawn structure. Currently,
-/// it only includes a middle game and end game pawn structure evaluation, and a
-/// bitboard of passed pawns. We may want to add further information in the future.
-/// A lookup to the pawn hash table (performed by calling the probe function)
-/// returns a pointer to an Entry object.
+/// Pawns::Entry contains various information about a pawn structure. A lookup
+/// to the pawn hash table (performed by calling the probe function) returns a
+/// pointer to an Entry object.
 
 struct Entry {
 
-  Score pawns_value() const { return value; }
+  Score pawns_score() const { return score; }
   Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
   Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
-  int file_is_half_open(Color c, File f) const { return halfOpenFiles[c] & (1 << int(f)); }
-  int has_open_file_to_left(Color c, File f) const { return halfOpenFiles[c] & ((1 << int(f)) - 1); }
-  int has_open_file_to_right(Color c, File f) const { return halfOpenFiles[c] & ~((1 << int(f+1)) - 1); }
-  int pawns_on_same_color_squares(Color c, Square s) const { return pawnsOnSquares[c][!!(BlackSquares & s)]; }
+  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; }
 
-  template<Color Us>
-  Score king_safety(const Position& pos, Square ksq)  {
+  int semiopen_file(Color c, File f) const {
+    return semiopenFiles[c] & (1 << f);
+  }
 
-    return kingSquares[Us] == ksq && castleRights[Us] == pos.can_castle(Us)
-         ? kingSafety[Us] : update_safety<Us>(pos, ksq);
+  int semiopen_side(Color c, File f, bool leftSide) const {
+    return semiopenFiles[c] & (leftSide ? (1 << f) - 1 : ~((1 << (f + 1)) - 1));
+  }
+
+  int pawns_on_same_color_squares(Color c, Square s) const {
+    return pawnsOnSquares[c][bool(DarkSquares & s)];
   }
 
   template<Color Us>
-  Score update_safety(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));
+  }
+
+  template<Color Us>
+  Score do_king_safety(const Position& pos, Square ksq);
 
   template<Color Us>
   Value shelter_storm(const Position& pos, Square ksq);
 
   Key key;
+  Score score;
   Bitboard passedPawns[COLOR_NB];
   Bitboard pawnAttacks[COLOR_NB];
+  Bitboard pawnAttacksSpan[COLOR_NB];
   Square kingSquares[COLOR_NB];
-  int minKPdistance[COLOR_NB];
-  int castleRights[COLOR_NB];
-  Score value;
-  int halfOpenFiles[COLOR_NB];
   Score kingSafety[COLOR_NB];
-  int pawnsOnSquares[COLOR_NB][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;
 
-Entry* probe(const Position& pos, Table& entries);
+void init();
+Entry* probe(const Position& pos);
 
-}
+} // namespace Pawns
 
-#endif // !defined(PAWNS_H_INCLUDED)
+#endif // #ifndef PAWNS_H_INCLUDED

src/platform.h

@@ -1,113 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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(PLATFORM_H_INCLUDED)
-#define PLATFORM_H_INCLUDED
-
-#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'
-#pragma warning(disable: 4996) // Function _ftime() may be unsafe
-
-// 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>
-#  include <unistd.h>  // Used by sysconf(_SC_NPROCESSORS_ONLN)
-#endif
-
-#if !defined(_WIN32) && !defined(_WIN64) // Linux - Unix
-
-#  include <sys/time.h>
-typedef timeval sys_time_t;
-
-inline void system_time(sys_time_t* t) { gettimeofday(t, NULL); }
-inline int64_t time_to_msec(const sys_time_t& t) { return t.tv_sec * 1000LL + t.tv_usec / 1000; }
-
-#  include <pthread.h>
-typedef pthread_mutex_t Lock;
-typedef pthread_cond_t WaitCondition;
-typedef pthread_t NativeHandle;
-typedef void*(*pt_start_fn)(void*);
-
-#  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)
-#  define thread_create(x,f,t) !pthread_create(&(x),NULL,(pt_start_fn)f,t)
-#  define thread_join(x) pthread_join(x, NULL)
-
-#else // Windows and MinGW
-
-#  include <sys/timeb.h>
-typedef _timeb sys_time_t;
-
-inline void system_time(sys_time_t* t) { _ftime(t); }
-inline int64_t time_to_msec(const sys_time_t& t) { return t.time * 1000LL + t.millitm; }
-
-#if !defined(NOMINMAX)
-#  define NOMINMAX // disable macros min() and max()
-#endif
-
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#undef NOMINMAX
-
-// We use critical sections on Windows to support Windows XP and older versions,
-// unfortunatly cond_wait() is racy between lock_release() and WaitForSingleObject()
-// but apart from this they have the same speed performance of SRW locks.
-typedef CRITICAL_SECTION Lock;
-typedef HANDLE WaitCondition;
-typedef HANDLE NativeHandle;
-
-// On Windows 95 and 98 parameter lpThreadId my not be null
-inline DWORD* dwWin9xKludge() { static DWORD dw; return &dw; }
-
-#  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) { lock_release(y); WaitForSingleObject(x, INFINITE); lock_grab(y); }
-#  define cond_timedwait(x,y,z) { lock_release(y); WaitForSingleObject(x,z); lock_grab(y); }
-#  define thread_create(x,f,t) (x = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)f,t,0,dwWin9xKludge()), x != NULL)
-#  define thread_join(x) { WaitForSingleObject(x, INFINITE); CloseHandle(x); }
-
-#endif
-
-#endif // !defined(PLATFORM_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-2013 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,89 +18,69 @@
   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 <cstddef>
+#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
-/// to detect if a move gives check.
-class Position;
-struct Thread;
-
-struct CheckInfo {
-
-  explicit CheckInfo(const Position&);
-
-  Bitboard dcCandidates;
-  Bitboard pinned;
-  Bitboard checkSq[PIECE_TYPE_NB];
-  Square ksq;
-};
-
-
-/// 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), a StateInfo object
-/// must be passed as a parameter.
+/// StateInfo struct stores information needed 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), a StateInfo object must be passed.
 
 struct StateInfo {
-  Key pawnKey, materialKey;
-  Value npMaterial[COLOR_NB];
-  int castleRights, rule50, pliesFromNull;
-  Score psqScore;
+
+  // Copied when making a move
+  Key    pawnKey;
+  Key    materialKey;
+  Value  nonPawnMaterial[COLOR_NB];
+  int    castlingRights;
+  int    rule50;
+  int    pliesFromNull;
+  Score  psq;
   Square epSquare;
 
-  Key key;
-  Bitboard checkersBB;
-  PieceType capturedType;
+  // Not copied when making a move (will be recomputed anyhow)
+  Key        key;
+  Bitboard   checkersBB;
+  Piece      capturedPiece;
   StateInfo* previous;
+  Bitboard   blockersForKing[COLOR_NB];
+  Bitboard   pinnersForKing[COLOR_NB];
+  Bitboard   checkSquares[PIECE_TYPE_NB];
 };
 
-
-/// When making a move the current StateInfo up to 'key' excluded is copied to
-/// the new one. Here we calculate the quad words (64bits) needed to be copied.
-const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1;
+/// 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:
-///
-///    * For each piece type, a bitboard representing the squares occupied
-///      by pieces of that type.
-///    * For each color, a bitboard representing the squares occupied by
-///      pieces of that color.
-///    * 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.
+/// Position class stores information regarding the board representation as
+/// pieces, side to move, hash keys, castling info, etc. Important methods are
+/// do_move() and undo_move(), used by the search to update node info when
+/// traversing the search tree.
+class Thread;
 
 class Position {
 public:
-  Position() {}
-  Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
-  Position(const std::string& f, bool c960, Thread* t) { set(f, c960, t); }
-  Position& operator=(const Position&);
+  static void init();
 
-  // Text input/output
-  void set(const std::string& fen, bool isChess960, Thread* th);
+  Position() = default;
+  Position(const Position&) = delete;
+  Position& operator=(const Position&) = delete;
+
+  // FEN string input/output
+  Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th);
+  Position& set(const std::string& code, Color c, StateInfo* si);
   const std::string fen() const;
-  const std::string pretty(Move m = MOVE_NONE) const;
 
   // Position representation
   Bitboard pieces() const;
@@ -109,146 +90,126 @@ public:
   Bitboard pieces(Color c, PieceType pt) const;
   Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
   Piece piece_on(Square s) const;
-  Square king_square(Color c) const;
   Square ep_square() const;
-  bool is_empty(Square s) const;
-  const Square* piece_list(Color c, PieceType pt) const;
-  int piece_count(Color c, PieceType pt) 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;
 
   // Castling
-  int can_castle(CastleRight f) const;
   int can_castle(Color c) const;
-  bool castle_impeded(Color c, CastlingSide s) const;
-  Square castle_rook_square(Color c, CastlingSide s) const;
+  int can_castle(CastlingRight cr) const;
+  bool castling_impeded(CastlingRight cr) const;
+  Square castling_rook_square(CastlingRight cr) const;
 
   // Checking
   Bitboard checkers() const;
   Bitboard discovered_check_candidates() const;
-  Bitboard pinned_pieces() const;
+  Bitboard pinned_pieces(Color c) const;
+  Bitboard check_squares(PieceType pt) const;
 
   // Attacks to/from a given square
   Bitboard attackers_to(Square s) const;
-  Bitboard attackers_to(Square s, Bitboard occ) const;
-  Bitboard attacks_from(Piece p, Square s) const;
-  static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
+  Bitboard attackers_to(Square s, Bitboard occupied) const;
+  Bitboard attacks_from(PieceType pt, Square s) const;
   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 pl_move_is_legal(Move m, Bitboard pinned) const;
-  bool is_pseudo_legal(const Move m) const;
-  bool is_capture(Move m) const;
-  bool is_capture_or_promotion(Move m) const;
-  bool is_passed_pawn_push(Move m) const;
-  Piece piece_moved(Move m) const;
-  PieceType captured_piece_type() const;
+  bool legal(Move m) const;
+  bool pseudo_legal(const Move m) const;
+  bool capture(Move m) const;
+  bool capture_or_promotion(Move m) const;
+  bool gives_check(Move m) const;
+  bool advanced_pawn_push(Move m) const;
+  Piece moved_piece(Move m) const;
+  Piece captured_piece() const;
 
   // Piece specific
-  bool pawn_is_passed(Color c, Square s) const;
-  bool pawn_on_7th(Color c) const;
+  bool pawn_passed(Color c, Square s) const;
   bool opposite_bishops() const;
-  bool bishop_pair(Color c) const;
 
   // Doing and undoing moves
-  void do_move(Move m, StateInfo& st);
-  void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
+  void do_move(Move m, StateInfo& newSt);
+  void do_move(Move m, StateInfo& newSt, bool givesCheck);
   void undo_move(Move m);
-  void do_null_move(StateInfo& st);
+  void do_null_move(StateInfo& newSt);
   void undo_null_move();
 
-  // Static exchange evaluation
-  int see(Move m, int asymmThreshold = 0) const;
-  int see_sign(Move m) const;
+  // Static Exchange Evaluation
+  bool see_ge(Move m, Value threshold = VALUE_ZERO) const;
 
   // Accessing hash keys
   Key key() const;
-  Key exclusion_key() const;
-  Key pawn_key() const;
+  Key key_after(Move m) const;
   Key material_key() const;
-
-  // Incremental piece-square evaluation
-  Score psq_score() const;
-  Score psq_delta(Piece p, Square from, Square to) const;
-  Value non_pawn_material(Color c) const;
+  Key pawn_key() const;
 
   // Other properties of the position
   Color side_to_move() const;
   int game_ply() const;
   bool is_chess960() const;
   Thread* this_thread() const;
-  int64_t nodes_searched() const;
-  void set_nodes_searched(int64_t n);
-  bool is_draw() const;
+  bool is_draw(int ply) const;
+  int rule50_count() const;
+  Score psq_score() const;
+  Value non_pawn_material(Color c) const;
+  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();
 
 private:
   // Initialization helpers (used while setting up a position)
-  void clear();
-  void put_piece(Piece p, Square s);
-  void set_castle_right(Color c, Square rfrom);
+  void set_castling_right(Color c, Square rfrom);
+  void set_state(StateInfo* si) const;
+  void set_check_info(StateInfo* si) const;
 
-  // Helper functions
-  void do_castle(Square kfrom, Square kto, Square rfrom, Square rto);
-  template<bool FindPinned> Bitboard hidden_checkers() const;
+  // Other helpers
+  void put_piece(Piece pc, Square s);
+  void remove_piece(Piece pc, Square s);
+  void move_piece(Piece pc, Square from, Square to);
+  template<bool Do>
+  void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
 
-  // Computing hash keys from scratch (for initialization and debugging)
-  Key compute_key() const;
-  Key compute_pawn_key() const;
-  Key compute_material_key() const;
-
-  // Computing incremental evaluation scores and material counts
-  Score compute_psq_score() const;
-  Value compute_non_pawn_material(Color c) const;
-
-  // Board and pieces
+  // Data members
   Piece board[SQUARE_NB];
   Bitboard byTypeBB[PIECE_TYPE_NB];
   Bitboard byColorBB[COLOR_NB];
-  int pieceCount[COLOR_NB][PIECE_TYPE_NB];
-  Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
+  int pieceCount[PIECE_NB];
+  Square pieceList[PIECE_NB][16];
   int index[SQUARE_NB];
-
-  // Other info
-  int castleRightsMask[SQUARE_NB];
-  Square castleRookSquare[COLOR_NB][CASTLING_SIDE_NB];
-  Bitboard castlePath[COLOR_NB][CASTLING_SIDE_NB];
-  StateInfo startState;
-  int64_t nodes;
+  int castlingRightsMask[SQUARE_NB];
+  Square castlingRookSquare[CASTLING_RIGHT_NB];
+  Bitboard castlingPath[CASTLING_RIGHT_NB];
   int gamePly;
   Color sideToMove;
   Thread* thisThread;
   StateInfo* st;
-  int chess960;
+  bool chess960;
 };
 
-inline int64_t Position::nodes_searched() const {
-  return nodes;
+extern std::ostream& operator<<(std::ostream& os, const Position& pos);
+
+inline Color Position::side_to_move() const {
+  return sideToMove;
 }
 
-inline void Position::set_nodes_searched(int64_t n) {
-  nodes = n;
+inline bool Position::empty(Square s) const {
+  return board[s] == NO_PIECE;
 }
 
 inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
-inline Piece Position::piece_moved(Move m) const {
+inline Piece Position::moved_piece(Move m) const {
   return board[from_sq(m)];
 }
 
-inline bool Position::is_empty(Square s) const {
-  return board[s] == NO_PIECE;
-}
-
-inline Color Position::side_to_move() const {
-  return sideToMove;
-}
-
 inline Bitboard Position::pieces() const {
   return byTypeBB[ALL_PIECES];
 }
@@ -273,53 +234,58 @@ inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
   return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
 }
 
-inline int Position::piece_count(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+template<PieceType Pt> inline int Position::count(Color c) const {
+  return pieceCount[make_piece(c, Pt)];
 }
 
-inline const Square* Position::piece_list(Color c, PieceType pt) const {
-  return pieceList[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 {
-  return pieceList[c][KING][0];
-}
-
-inline int Position::can_castle(CastleRight f) const {
-  return st->castleRights & f;
+inline int Position::can_castle(CastlingRight cr) const {
+  return st->castlingRights & cr;
 }
 
 inline int Position::can_castle(Color c) const {
-  return st->castleRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
+  return st->castlingRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
 }
 
-inline bool Position::castle_impeded(Color c, CastlingSide s) const {
-  return byTypeBB[ALL_PIECES] & castlePath[c][s];
+inline bool Position::castling_impeded(CastlingRight cr) const {
+  return byTypeBB[ALL_PIECES] & castlingPath[cr];
 }
 
-inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
-  return castleRookSquare[c][s];
+inline Square Position::castling_rook_square(CastlingRight cr) const {
+  return castlingRookSquare[cr];
 }
 
 template<PieceType Pt>
 inline Bitboard Position::attacks_from(Square s) const {
-
-  return  Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, pieces())
+  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)
-        : StepAttacksBB[Pt][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];
 }
 
-inline Bitboard Position::attacks_from(Piece p, Square s) const {
-  return attacks_from(p, s, byTypeBB[ALL_PIECES]);
+inline Bitboard Position::attacks_from(PieceType pt, Square s) const {
+  return attacks_bb(pt, s, byTypeBB[ALL_PIECES]);
 }
 
 inline Bitboard Position::attackers_to(Square s) const {
@@ -331,25 +297,30 @@ inline Bitboard Position::checkers() const {
 }
 
 inline Bitboard Position::discovered_check_candidates() const {
-  return hidden_checkers<false>();
+  return st->blockersForKing[~sideToMove] & pieces(sideToMove);
 }
 
-inline Bitboard Position::pinned_pieces() const {
-  return hidden_checkers<true>();
+inline Bitboard Position::pinned_pieces(Color c) const {
+  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 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 ^ Zobrist::exclusion;
-}
-
 inline Key Position::pawn_key() const {
   return st->pawnKey;
 }
@@ -358,68 +329,99 @@ inline Key Position::material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::psq_delta(Piece p, Square from, Square to) const {
-  return pieceSquareTable[p][to] - pieceSquareTable[p][from];
-}
-
 inline Score Position::psq_score() const {
-  return st->psqScore;
+  return st->psq;
 }
 
 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 {
-
-  return   type_of(piece_moved(m)) == PAWN
-        && pawn_is_passed(sideToMove, to_sq(m));
+inline Value Position::non_pawn_material() const {
+  return st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK];
 }
 
 inline int Position::game_ply() const {
   return gamePly;
 }
 
+inline int Position::rule50_count() const {
+  return st->rule50;
+}
+
 inline bool Position::opposite_bishops() const {
-
-  return   pieceCount[WHITE][BISHOP] == 1
-        && pieceCount[BLACK][BISHOP] == 1
-        && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
-}
-
-inline bool Position::bishop_pair(Color c) const {
-
-  return   pieceCount[c][BISHOP] >= 2
-        && opposite_colors(pieceList[c][BISHOP][0], pieceList[c][BISHOP][1]);
-}
-
-inline bool Position::pawn_on_7th(Color c) const {
-  return pieces(c, PAWN) & 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 type_of(m) ? type_of(m) != CASTLE : !is_empty(to_sq(m));
+  return type_of(m) != NORMAL ? type_of(m) != CASTLING : !empty(to_sq(m));
 }
 
-inline bool Position::is_capture(Move m) const {
-
-  // Note that castle is coded as "king captures the rook"
+inline bool Position::capture(Move m) const {
   assert(is_ok(m));
-  return (!is_empty(to_sq(m)) && type_of(m) != CASTLE) || type_of(m) == ENPASSANT;
+  // 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 {
-  return st->capturedType;
+inline Piece Position::captured_piece() const {
+  return st->capturedPiece;
 }
 
 inline Thread* Position::this_thread() const {
   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-2013 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[][SQUARE_NB] = {
-  { },
-  { // 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,76 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2013 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;
-  }
-
-public:
-  RKISS(int seed = 73) {
-
-    s.a = 0xf1ea5eed;
-    s.b = s.c = s.d = 0xd4e12c77;
-    for (int i = 0; i < seed; i++) // Scramble a few rounds
-        rand64();
-  }
-
-  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-2013 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,96 +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 <memory>
-#include <stack>
 #include <vector>
 
 #include "misc.h"
-#include "position.h"
+#include "movepick.h"
 #include "types.h"
 
-struct SplitPoint;
+class Position;
 
 namespace Search {
 
-/// The 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.
+/// Threshold used for countermoves based pruning
+const int CounterMovePruneThreshold = 0;
+
+
+/// 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* splitPoint;
+  Move* pv;
+  PieceToHistory* contHistory;
   int ply;
   Move currentMove;
   Move excludedMove;
   Move killers[2];
-  Depth reduction;
   Value staticEval;
-  Value evalMargin;
-  int skipNullMove;
-  int futilityMoveCount;
+  int statScore;
+  int moveCount;
 };
 
 
-/// RootMove struct is used for moves at the root of the tree. For each root
-/// move we store a score, a node count, and a PV (really a refutation in the
-/// case of moves which fail low). Score is normally set at -VALUE_INFINITE for
-/// all non-pv moves.
+/// RootMove struct is used for moves at the root of the tree. For each root move
+/// we store a score and a PV (really a refutation in the case of moves which
+/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
+
 struct RootMove {
 
-  RootMove(Move m) : score(-VALUE_INFINITE), prevScore(-VALUE_INFINITE) {
-    pv.push_back(m); pv.push_back(MOVE_NONE);
+  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;
   }
 
-  bool operator<(const RootMove& m) const { return score > m.score; } // Ascending sort
-  bool operator==(const Move& m) const { return pv[0] == m; }
-
-  void extract_pv_from_tt(Position& pos);
-  void insert_pv_in_tt(Position& pos);
-
-  Value score;
-  Value prevScore;
+  Value score = -VALUE_INFINITE;
+  Value previousScore = -VALUE_INFINITE;
+  int selDepth = 0;
   std::vector<Move> pv;
 };
 
+typedef std::vector<RootMove> RootMoves;
 
-/// The LimitsType struct stores information sent by GUI about available time
-/// to search the current move, maximum depth/time, if we are in analysis mode
-/// or if we have to ponder while is our opponent's side to move.
+
+/// 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)); }
-  bool use_time_management() const { return !(mate | movetime | depth | nodes | infinite); }
+  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
+    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
+    npmsec = movestogo = depth = movetime = mate = perft = infinite = 0;
+  }
 
-  int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, nodes, movetime, mate, 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;
-};
-
-typedef std::auto_ptr<std::stack<StateInfo> > StateStackPtr;
-
-extern volatile SignalsType Signals;
 extern LimitsType Limits;
-extern std::vector<RootMove> RootMoves;
-extern Position RootPos;
-extern Color RootColor;
-extern Time::point SearchTime;
-extern StateStackPtr SetupStates;
 
-extern void init();
-extern size_t perft(Position& pos, Depth depth);
-extern void think();
+void init();
+void clear();
 
 } // 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-2013 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,363 +20,180 @@
 
 #include <algorithm> // For std::count
 #include <cassert>
-#include <iostream>
 
 #include "movegen.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
-
-using namespace Search;
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
 ThreadPool Threads; // Global object
 
-namespace { extern "C" {
 
- // start_routine() is the C function which is called when a new thread
- // is launched. It is a wrapper to the virtual function idle_loop().
+/// Thread constructor launches the thread and waits until it goes to sleep
+/// in idle_loop(). Note that 'searching' and 'exit' should be alredy set.
 
- long start_routine(Thread* th) { th->idle_loop(); return 0; }
+Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) {
 
-} }
-
-
-// Thread c'tor starts a newly-created thread of execution that will call
-// the the virtual function idle_loop(), going immediately to sleep.
-
-Thread::Thread() /* : splitPoints() */ { // Value-initialization bug in MSVC
-
-  searching = exit = false;
-  maxPly = splitPointsSize = 0;
-  activeSplitPoint = NULL;
-  activePosition = NULL;
-  idx = Threads.size();
-
-  if (!thread_create(handle, start_routine, this))
-  {
-      std::cerr << "Failed to create thread number " << idx << std::endl;
-      ::exit(EXIT_FAILURE);
-  }
+  wait_for_search_finished();
 }
 
 
-// Thread d'tor waits for thread termination before to return
+/// Thread destructor wakes up the thread in idle_loop() and waits
+/// for its termination. Thread should be already waiting.
 
 Thread::~Thread() {
 
-  exit = true; // Search must be already finished
-  notify_one();
-  thread_join(handle); // Wait for thread termination
+  assert(!searching);
+
+  exit = true;
+  start_searching();
+  stdThread.join();
 }
 
 
-// TimerThread::idle_loop() is where the timer thread waits msec milliseconds
-// and then calls check_time(). If msec is 0 thread sleeps until is woken up.
-extern void check_time();
+/// Thread::clear() reset histories, usually before a new game
 
-void TimerThread::idle_loop() {
+void Thread::clear() {
 
-  while (!exit)
-  {
-      mutex.lock();
+  counterMoves.fill(MOVE_NONE);
+  mainHistory.fill(0);
+  captureHistory.fill(0);
 
-      if (!exit)
-          sleepCondition.wait_for(mutex, msec ? msec : INT_MAX);
+  for (auto& to : contHistory)
+      for (auto& h : to)
+          h.fill(0);
 
-      mutex.unlock();
+  contHistory[NO_PIECE][0].fill(Search::CounterMovePruneThreshold - 1);
+}
 
-      if (msec)
-          check_time();
-  }
+/// 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()
 }
 
 
-// MainThread::idle_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.
+/// Thread::wait_for_search_finished() blocks on the condition variable
+/// until the thread has finished searching.
 
-void MainThread::idle_loop() {
+void Thread::wait_for_search_finished() {
+
+  std::unique_lock<Mutex> lk(mutex);
+  cv.wait(lk, [&]{ return !searching; });
+}
+
+
+/// Thread::idle_loop() is where the thread is parked, blocked on the
+/// condition variable, when it has no work to do.
+
+void Thread::idle_loop() {
+
+  // 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
+  // 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
+  // NUMA machinery is not needed.
+  if (Options["Threads"] >= 8)
+      WinProcGroup::bindThisThread(idx);
 
   while (true)
   {
-      mutex.lock();
-
-      thinking = false;
-
-      while (!thinking && !exit)
-      {
-          Threads.sleepCondition.notify_one(); // Wake up UI thread if needed
-          sleepCondition.wait(mutex);
-      }
-
-      mutex.unlock();
+      std::unique_lock<Mutex> lk(mutex);
+      searching = false;
+      cv.notify_one(); // Wake up anyone waiting for search finished
+      cv.wait(lk, [&]{ return searching; });
 
       if (exit)
           return;
 
-      searching = true;
+      lk.unlock();
 
-      Search::think();
-
-      assert(searching);
-
-      searching = false;
+      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.
 
-// Thread::notify_one() wakes up the thread when there is some search to do
+void ThreadPool::set(size_t requested) {
 
-void Thread::notify_one() {
+  if (size() > 0) { // destroy any existing thread(s)
+      main()->wait_for_search_finished();
 
-  mutex.lock();
-  sleepCondition.notify_one();
-  mutex.unlock();
+      while (size() > 0)
+          delete back(), pop_back();
+  }
+
+  if (requested > 0) { // create new thread(s)
+      push_back(new MainThread(0));
+
+      while (size() < requested)
+          push_back(new Thread(size()));
+      clear();
+  }
 }
 
+/// ThreadPool::clear() sets threadPool data to initial values.
 
-// Thread::wait_for() set the thread to sleep until condition 'b' turns true
+void ThreadPool::clear() {
 
-void Thread::wait_for(volatile const bool& b) {
+  for (Thread* th : *this)
+      th->clear();
 
-  mutex.lock();
-  while (!b) sleepCondition.wait(mutex);
-  mutex.unlock();
+  main()->callsCnt = 0;
+  main()->previousScore = VALUE_INFINITE;
+  main()->previousTimeReduction = 1;
 }
 
+/// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and
+/// returns immediately. Main thread will wake up other threads and start the search.
 
-// Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the
-// current active split point, or in some ancestor of the split point.
+void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
+                                const Search::LimitsType& limits, bool ponderMode) {
 
-bool Thread::cutoff_occurred() const {
+  main()->wait_for_search_finished();
 
-  for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
-      if (sp->cutoff)
-          return true;
+  stopOnPonderhit = stop = false;
+  ponder = ponderMode;
+  Search::Limits = limits;
+  Search::RootMoves rootMoves;
 
-  return false;
-}
+  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);
 
-// Thread::is_available_to() checks whether the thread is available to help the
-// thread 'master' at a split point. An obvious requirement is that thread must
-// be idle. With more than two threads, this is not sufficient: If the thread is
-// the master of some split point, it is only available as a slave to the slaves
-// which are busy searching the split point at the top of slaves split point
-// stack (the "helpful master concept" in YBWC terminology).
+  // 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());
 
-bool Thread::is_available_to(Thread* master) const {
+  if (states.get())
+      setupStates = std::move(states); // Ownership transfer, states is now empty
 
-  if (searching)
-      return false;
+  // 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();
 
-  // Make a local copy to be sure doesn't become zero under our feet while
-  // testing next condition and so leading to an out of bound access.
-  int size = splitPointsSize;
-
-  // No split points means that the thread is available as a slave for any
-  // other thread otherwise apply the "helpful master" concept if possible.
-  return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
-}
-
-
-// init() is called at startup to create and launch requested threads, that will
-// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
-// a c'tor becuase Threads is a static object and we need a fully initialized
-// engine at this point due to allocation of Endgames in Thread c'tor.
-
-void ThreadPool::init() {
-
-  sleepWhileIdle = true;
-  timer = new TimerThread();
-  push_back(new MainThread());
-  read_uci_options();
-}
-
-
-// exit() cleanly terminates the threads before the program exits
-
-void ThreadPool::exit() {
-
-  delete timer; // As first because check_time() accesses threads data
-
-  for (iterator it = begin(); it != end(); ++it)
-      delete *it;
-}
-
-
-// read_uci_options() updates internal threads parameters from the corresponding
-// UCI options and creates/destroys threads to match the requested number. Thread
-// objects are dynamically allocated to avoid creating in advance all possible
-// threads, with included pawns and material tables, if only few are used.
-
-void ThreadPool::read_uci_options() {
-
-  maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
-  minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
-  size_t requested        = Options["Threads"];
-
-  assert(requested > 0);
-
-  while (size() < requested)
-      push_back(new Thread());
-
-  while (size() > requested)
+  for (Thread* th : *this)
   {
-      delete back();
-      pop_back();
-  }
-}
-
-
-// slave_available() tries to find an idle thread which is available as a slave
-// for the thread 'master'.
-
-Thread* ThreadPool::available_slave(Thread* master) const {
-
-  for (const_iterator it = begin(); it != end(); ++it)
-      if ((*it)->is_available_to(master))
-          return *it;
-
-  return NULL;
-}
-
-
-// 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), 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>
-void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bestValue,
-                   Move* bestMove, Depth depth, Move threatMove, int moveCount,
-                   MovePicker* movePicker, int nodeType) {
-
-  assert(pos.pos_is_ok());
-  assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
-  assert(*bestValue > -VALUE_INFINITE);
-  assert(depth >= Threads.minimumSplitDepth);
-  assert(searching);
-  assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD);
-
-  // Pick the next available split point from the split point stack
-  SplitPoint& sp = splitPoints[splitPointsSize];
-
-  sp.masterThread = this;
-  sp.parentSplitPoint = activeSplitPoint;
-  sp.slavesMask = 1ULL << idx;
-  sp.depth = depth;
-  sp.bestValue = *bestValue;
-  sp.bestMove = *bestMove;
-  sp.threatMove = threatMove;
-  sp.alpha = alpha;
-  sp.beta = beta;
-  sp.nodeType = nodeType;
-  sp.movePicker = movePicker;
-  sp.moveCount = moveCount;
-  sp.pos = &pos;
-  sp.nodes = 0;
-  sp.cutoff = false;
-  sp.ss = ss;
-
-  // Try to allocate available threads and ask them to start searching setting
-  // 'searching' flag. This must be done under lock protection to avoid concurrent
-  // allocation of the same slave by another master.
-  Threads.mutex.lock();
-  sp.mutex.lock();
-
-  splitPointsSize++;
-  activeSplitPoint = &sp;
-  activePosition = NULL;
-
-  size_t slavesCnt = 1; // This thread is always included
-  Thread* slave;
-
-  while (    (slave = Threads.available_slave(this)) != NULL
-         && ++slavesCnt <= Threads.maxThreadsPerSplitPoint && !Fake)
-  {
-      sp.slavesMask |= 1ULL << slave->idx;
-      slave->activeSplitPoint = &sp;
-      slave->searching = true; // Slave leaves idle_loop()
-      slave->notify_one(); // Could be sleeping
+      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);
   }
 
-  // Everything is set up. The master thread enters the idle loop, from which
-  // it will instantly launch a search, because its 'searching' flag is set.
-  // The thread will return from the idle loop when all slaves have finished
-  // their work at this split point.
-  if (slavesCnt > 1 || Fake)
-  {
-      sp.mutex.unlock();
-      Threads.mutex.unlock();
+  setupStates->back() = tmp;
 
-      Thread::idle_loop(); // Force a call to base class idle_loop()
-
-      // 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(!searching);
-      assert(!activePosition);
-
-      // We have returned from the idle loop, which means that all threads are
-      // finished. Note that setting 'searching' and decreasing splitPointsSize is
-      // done under lock protection to avoid a race with Thread::is_available_to().
-      Threads.mutex.lock();
-      sp.mutex.lock();
-  }
-
-  searching = true;
-  splitPointsSize--;
-  activeSplitPoint = sp.parentSplitPoint;
-  activePosition = &pos;
-  pos.set_nodes_searched(pos.nodes_searched() + sp.nodes);
-  *bestMove = sp.bestMove;
-  *bestValue = sp.bestValue;
-
-  sp.mutex.unlock();
-  Threads.mutex.unlock();
-}
-
-// Explicit template instantiations
-template void Thread::split<false>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int);
-template void Thread::split< true>(Position&, Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int);
-
-
-// wait_for_think_finished() waits for main thread to go to sleep then returns
-
-void ThreadPool::wait_for_think_finished() {
-
-  MainThread* t = main_thread();
-  t->mutex.lock();
-  while (t->thinking) sleepCondition.wait(t->mutex);
-  t->mutex.unlock();
-}
-
-
-// start_thinking() wakes up the main thread sleeping in MainThread::idle_loop()
-// so to start a new search, then returns immediately.
-
-void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
-                                const std::vector<Move>& searchMoves, StateStackPtr& states) {
-  wait_for_think_finished();
-
-  SearchTime = Time::now(); // As early as possible
-
-  Signals.stopOnPonderhit = Signals.firstRootMove = false;
-  Signals.stop = Signals.failedLowAtRoot = false;
-
-  RootPos = pos;
-  Limits = limits;
-  SetupStates = states; // Ownership transfer here
-  RootMoves.clear();
-
-  for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
-      if (   searchMoves.empty()
-          || std::count(searchMoves.begin(), searchMoves.end(), ml.move()))
-          RootMoves.push_back(RootMove(ml.move()));
-
-  main_thread()->thinking = true;
-  main_thread()->notify_one(); // Starts main thread
+  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-2013 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,9 +18,13 @@
   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 <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
 #include <vector>
 
 #include "material.h"
@@ -27,141 +32,92 @@
 #include "pawns.h"
 #include "position.h"
 #include "search.h"
+#include "thread_win32.h"
 
-const int MAX_THREADS = 64; // Because SplitPoint::slavesMask is a uint64_t
-const int MAX_SPLITPOINTS_PER_THREAD = 8;
 
-struct Mutex {
-  Mutex() { lock_init(l); }
- ~Mutex() { lock_destroy(l); }
+/// Thread class keeps together all the thread-related stuff. We use
+/// per-thread pawn and material hash tables so that once we get a
+/// pointer to an entry its life time is unlimited and we don't have
+/// to care about someone changing the entry under our feet.
 
-  void lock() { lock_grab(l); }
-  void unlock() { lock_release(l); }
+class Thread {
 
-private:
-  friend struct ConditionVariable;
-
-  Lock l;
-};
-
-struct ConditionVariable {
-  ConditionVariable() { cond_init(c); }
- ~ConditionVariable() { cond_destroy(c); }
-
-  void wait(Mutex& m) { cond_wait(c, m.l); }
-  void wait_for(Mutex& m, int ms) { timed_wait(c, m.l, ms); }
-  void notify_one() { cond_signal(c); }
-
-private:
-  WaitCondition c;
-};
-
-struct Thread;
-
-struct SplitPoint {
-
-  // Const data after split point has been setup
-  const Position* pos;
-  const Search::Stack* ss;
-  Thread* masterThread;
-  Depth depth;
-  Value beta;
-  int nodeType;
-  Move threatMove;
-
-  // Const pointers to shared data
-  MovePicker* movePicker;
-  SplitPoint* parentSplitPoint;
-
-  // Shared data
   Mutex mutex;
-  volatile uint64_t slavesMask;
-  volatile int64_t nodes;
-  volatile Value alpha;
-  volatile Value bestValue;
-  volatile Move bestMove;
-  volatile int moveCount;
-  volatile bool cutoff;
-};
+  ConditionVariable cv;
+  size_t idx;
+  bool exit = false, searching = true; // Set before starting std::thread
+  std::thread stdThread;
 
-
-/// Thread struct keeps together all the thread related stuff like locks, state
-/// and especially split points. We also use per-thread pawn and material hash
-/// tables so that once we get a pointer to an entry its life time is unlimited
-/// and we don't have to care about someone changing the entry under our feet.
-
-struct Thread {
-
-  Thread();
+public:
+  explicit Thread(size_t);
   virtual ~Thread();
+  virtual void search();
+  void clear();
+  void idle_loop();
+  void start_searching();
+  void wait_for_search_finished();
 
-  virtual void idle_loop();
-  void notify_one();
-  bool cutoff_occurred() const;
-  bool is_available_to(Thread* master) const;
-  void wait_for(volatile const bool& b);
-
-  template <bool Fake>
-  void split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
-             Depth depth, Move threatMove, int moveCount, MovePicker* movePicker, int nodeType);
-
-  SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
+  Pawns::Table pawnsTable;
   Material::Table materialTable;
   Endgames endgames;
-  Pawns::Table pawnsTable;
-  Position* activePosition;
-  size_t idx;
-  int maxPly;
-  Mutex mutex;
-  ConditionVariable sleepCondition;
-  NativeHandle handle;
-  SplitPoint* volatile activeSplitPoint;
-  volatile int splitPointsSize;
-  volatile bool searching;
-  volatile bool exit;
+  size_t PVIdx;
+  int selDepth, nmp_ply, nmp_odd;
+  std::atomic<uint64_t> nodes, tbHits;
+
+  Position rootPos;
+  Search::RootMoves rootMoves;
+  Depth rootDepth, completedDepth;
+  CounterMoveHistory counterMoves;
+  ButterflyHistory mainHistory;
+  CapturePieceToHistory captureHistory;
+  ContinuationHistory contHistory;
 };
 
 
-/// MainThread and TimerThread are sublassed from Thread to characterize the two
-/// special threads: the main one and the recurring timer.
+/// MainThread is a derived class specific for main thread
 
 struct MainThread : public Thread {
-  MainThread() : thinking(true) {} // Avoid a race with start_thinking()
-  virtual void idle_loop();
-  volatile bool thinking;
-};
 
-struct TimerThread : public Thread {
-  TimerThread() : msec(0) {}
-  virtual void idle_loop();
-  int msec;
+  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, the most important, launching a slave thread at a split point.
-/// All the access to shared thread data is done through this class.
+/// 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 init(); // No c'tor and d'tor, threads rely on globals that should
-  void exit(); // be initialized and valid during the whole thread lifetime.
+  void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false);
+  void clear();
+  void set(size_t);
 
-  MainThread* main_thread() { return static_cast<MainThread*>((*this)[0]); }
-  void read_uci_options();
-  Thread* available_slave(Thread* master) const;
-  void wait_for_think_finished();
-  void start_thinking(const Position&, const Search::LimitsType&,
-                      const std::vector<Move>&, Search::StateStackPtr&);
+  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); }
 
-  bool sleepWhileIdle;
-  Depth minimumSplitDepth;
-  size_t maxThreadsPerSplitPoint;
-  Mutex mutex;
-  ConditionVariable sleepCondition;
-  TimerThread* timer;
+  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 // !defined(THREAD_H_INCLUDED)
+#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-2013 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 "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   = 7.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>
-  int remaining(int myTime, int movesToGo, int fullMoveNumber, int slowMover);
-}
+  const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
+  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
 
 
-void TimeManager::pv_instability(int curChanges, int prevChanges) {
+  // 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.
 
-  unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
-                       + prevChanges * (optimumSearchTime / 3);
-}
+  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) {
+
+    const double TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const double TStealRatio = (T == OptimumTime ? 0 : StealRatio);
+
+    double moveImportance = (move_importance(ply) * slowMover) / 100;
+    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, Color us)
-{
-  /* We support four different kind of time controls:
+/// init() is called at the beginning of the search and calculates the allowed
+/// thinking time out of the time control and current game ply. We support four
+/// different kinds of time controls, passed in 'limits':
+///
+///  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
 
-      increment == 0 && movesToGo == 0 means: x basetime  [sudden death!]
-      increment == 0 && movesToGo != 0 means: x moves in y minutes
-      increment >  0 && movesToGo == 0 means: x basetime + z increment
-      increment >  0 && movesToGo != 0 means: x moves in y minutes + z increment
+void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
 
-    Time management is adjusted by following UCI parameters:
+  int minThinkingTime = Options["Minimum Thinking Time"];
+  int moveOverhead    = Options["Move Overhead"];
+  int slowMover       = Options["Slow Mover"];
+  int npmsec          = Options["nodestime"];
 
-      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 slowMover            = Options["Slow Mover"];
-
-  // Initialize to maximum values but unstablePVExtraTime that is reset
-  unstablePVExtraTime = 0;
-  optimumSearchTime = maximumSearchTime = limits.time[us];
-
-  // We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
-  // 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++)
+  // If we have to play in 'nodes as time' mode, then convert from time
+  // to nodes, and use resulting values in time management formulas.
+  // WARNING: Given npms (nodes per millisecond) must be much lower then
+  // the real engine speed to avoid time losses.
+  if (npmsec)
   {
-      // Calculate thinking time for hypothetic "moves to go"-value
-      hypMyTime =  limits.time[us]
-                 + limits.inc[us] * (hypMTG - 1)
-                 - emergencyBaseTime
-                 - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon);
+      if (!availableNodes) // Only once at game start
+          availableNodes = npmsec * limits.time[us]; // Time is in msec
+
+      // Convert from millisecs to nodes
+      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, slowMover);
-      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly, slowMover);
+      int t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
+      int t2 = minThinkingTime + remaining<MaxTime    >(hypMyTime, hypMTG, ply, slowMover);
 
-      optimumSearchTime = std::min(optimumSearchTime, t1);
-      maximumSearchTime = std::min(maximumSearchTime, t2);
+      optimumTime = std::min(t1, optimumTime);
+      maximumTime = std::min(t2, maximumTime);
   }
 
   if (Options["Ponder"])
-      optimumSearchTime += optimumSearchTime / 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, int slowMover)
-  {
-    const float TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
-    const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
-
-    int thisMoveImportance = move_importance(currentPly) * slowMover / 100;
-    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)));
-  }
+      optimumTime += optimumTime / 4;
 }

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-2013 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
-/// maximum available time, the move game number and other parameters.
+#include "misc.h"
+#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, Color us);
-  void pv_instability(int curChanges, int prevChanges);
-  int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
-  int maximum_time() const { return maximumSearchTime; }
+  void init(Search::LimitsType& limits, Color us, int ply);
+  int optimum() const { return optimumTime; }
+  int maximum() const { return maximumTime; }
+  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;
-  int maximumSearchTime;
-  int unstablePVExtraTime;
+  TimePoint startTime;
+  int optimumTime;
+  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-2013 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,7 +18,7 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cstring>
+#include <cstring>   // For std::memset
 #include <iostream>
 
 #include "bitboard.h"
@@ -26,96 +27,92 @@
 TranspositionTable TT; // Our global transposition table
 
 
-/// TranspositionTable::set_size() sets the size of the transposition table,
+/// TranspositionTable::resize() sets the size of the transposition table,
 /// measured in megabytes. Transposition table consists of a power of 2 number
 /// of clusters and each cluster consists of ClusterSize number of TTEntry.
 
-void TranspositionTable::set_size(size_t mbSize) {
+void TranspositionTable::resize(size_t mbSize) {
 
-  assert(msb((mbSize << 20) / sizeof(TTEntry)) < 32);
+  size_t newClusterCount = mbSize * 1024 * 1024 / sizeof(Cluster);
 
-  uint32_t size = ClusterSize << msb((mbSize << 20) / sizeof(TTEntry[ClusterSize]));
-
-  if (hashMask == size - ClusterSize)
+  if (newClusterCount == clusterCount)
       return;
 
-  hashMask = size - ClusterSize;
-  delete [] table;
-  table = new (std::nothrow) TTEntry[size];
+  clusterCount = newClusterCount;
 
-  if (!table)
+  free(mem);
+  mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1);
+
+  if (!mem)
   {
       std::cerr << "Failed to allocate " << mbSize
                 << "MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
   }
 
-  clear(); // Operator new is not guaranteed to initialize memory to zero
+  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(table, 0, (hashMask + ClusterSize) * sizeof(TTEntry));
+  std::memset(table, 0, clusterCount * sizeof(Cluster));
 }
 
 
-/// TranspositionTable::store() writes a new entry containing position key and
-/// valuable information of current position. The lowest order bits of position
-/// key are used to decide on which cluster the position will be placed.
-/// When a new entry is written and there are no empty entries available in cluster,
-/// it replaces the least valuable of entries. A TTEntry t1 is considered to be
-/// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
-/// a previous search, or if the depth of t1 is bigger than the depth of t2.
+/// TranspositionTable::probe() looks up the current position in the transposition
+/// table. It returns true and a pointer to the TTEntry if the position is found.
+/// Otherwise, it returns false and a pointer to an empty or least valuable TTEntry
+/// to be replaced later. The replace value of an entry is calculated as its depth
+/// minus 8 times its relative age. TTEntry t1 is considered more valuable than
+/// TTEntry t2 if its replace value is greater than that of t2.
 
-void TranspositionTable::store(const Key key, Value v, Bound t, Depth d, Move m, Value statV, Value kingD) {
+TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
 
-  int c1, c2, c3;
-  TTEntry *tte, *replace;
-  uint32_t key32 = key >> 32; // Use the high 32 bits as key inside the cluster
+  TTEntry* const tte = first_entry(key);
+  const uint16_t key16 = key >> 48;  // Use the high 16 bits as key inside the cluster
 
-  tte = replace = first_entry(key);
-
-  for (unsigned i = 0; i < ClusterSize; i++, tte++)
-  {
-      if (!tte->key() || tte->key() == key32) // Empty or overwrite old
+  for (int i = 0; i < ClusterSize; ++i)
+      if (!tte[i].key16 || tte[i].key16 == key16)
       {
-          // Preserve any existing ttMove
-          if (m == MOVE_NONE)
-              m = tte->move();
+          if ((tte[i].genBound8 & 0xFC) != generation8 && tte[i].key16)
+              tte[i].genBound8 = uint8_t(generation8 | tte[i].bound()); // Refresh
 
-          tte->save(key32, v, t, d, m, generation, statV, kingD);
-          return;
+          return found = (bool)tte[i].key16, &tte[i];
       }
 
-      // Implement replace strategy
-      c1 = (replace->generation() == generation ?  2 : 0);
-      c2 = (tte->generation() == generation || tte->type() == BOUND_EXACT ? -2 : 0);
-      c3 = (tte->depth() < replace->depth() ?  1 : 0);
+  // 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];
 
-      if (c1 + c2 + c3 > 0)
-          replace = tte;
+  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++)
+  {
+      const TTEntry* tte = &table[i].entry[0];
+      for (int j = 0; j < ClusterSize; j++)
+          if ((tte[j].genBound8 & 0xFC) == generation8)
+              cnt++;
   }
-  replace->save(key32, 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 key) const {
-
-  TTEntry* tte = first_entry(key);
-  uint32_t key32 = key >> 32;
-
-  for (unsigned i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == key32)
-          return tte;
-
-  return NULL;
+  return cnt;
 }

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-2013 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,109 +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 "misc.h"
 #include "types.h"
 
-/// The TTEntry is the class of transposition table entries
+/// TTEntry struct is the 10 bytes transposition table entry, defined as below:
 ///
-/// A TTEntry needs 128 bits to be stored
-///
-/// bit  0-31: key
-/// bit 32-63: data
-/// bit 64-79: value
-/// bit 80-95: depth
-/// bit 96-111: static value
-/// 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
+/// key        16 bit
+/// move       16 bit
+/// value      16 bit
+/// eval value 16 bit
+/// generation  6 bit
+/// bound type  2 bit
+/// depth       8 bit
 
-class TTEntry {
+struct TTEntry {
 
-public:
-  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev, Value em) {
+  Move  move()  const { return (Move )move16; }
+  Value value() const { return (Value)value16; }
+  Value eval()  const { return (Value)eval16; }
+  Depth depth() const { return (Depth)(depth8 * int(ONE_PLY)); }
+  Bound bound() const { return (Bound)(genBound8 & 0x3); }
 
-    key32        = (uint32_t)k;
-    move16       = (uint16_t)m;
-    bound        = (uint8_t)b;
-    generation8  = (uint8_t)g;
-    value16      = (int16_t)v;
-    depth16      = (int16_t)d;
-    evalValue    = (int16_t)ev;
-    evalMargin   = (int16_t)em;
+  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);
+    }
   }
-  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; }
-  Bound type() const        { return (Bound)bound; }
-  int generation() const    { return (int)generation8; }
-  Value eval_value() const  { return (Value)evalValue; }
-  Value eval_margin() const { return (Value)evalMargin; }
 
 private:
-  uint32_t key32;
+  friend class TranspositionTable;
+
+  uint16_t key16;
   uint16_t move16;
-  uint8_t bound, generation8;
-  int16_t value16, depth16, evalValue, evalMargin;
+  int16_t  value16;
+  int16_t  eval16;
+  uint8_t  genBound8;
+  int8_t   depth8;
 };
 
 
 /// A TranspositionTable consists of a power of 2 number of clusters and each
 /// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
-/// contains information of exactly one position. Size of a cluster shall not be
-/// bigger than a cache line size. In case it is less, it should be padded to
-/// guarantee always aligned accesses.
+/// 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
+/// cache lines. This ensures best cache performance, as the cacheline is
+/// prefetched, as soon as possible.
 
 class TranspositionTable {
 
-  static const unsigned ClusterSize = 4; // A cluster is 64 Bytes
+  static const int CacheLineSize = 64;
+  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() { delete [] table; }
-  void new_search() { generation++; }
-
-  TTEntry* probe(const Key key) const;
-  TTEntry* first_entry(const Key key) const;
-  void refresh(const TTEntry* tte) const;
-  void set_size(size_t mbSize);
+ ~TranspositionTable() { free(mem); }
+  void new_search() { generation8 += 4; } // Lower 2 bits are used by Bound
+  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 key, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
+
+  // The 32 lowest order bits of the key are used to get the index of the cluster
+  TTEntry* first_entry(const Key key) const {
+    return &table[(uint32_t(key) * uint64_t(clusterCount)) >> 32].entry[0];
+  }
 
 private:
-  uint32_t hashMask;
-  TTEntry* table;
-  uint8_t generation; // Size must be not bigger then TTEntry::generation8
+  size_t clusterCount;
+  Cluster* table;
+  void* mem;
+  uint8_t generation8; // Size must be not bigger than TTEntry::genBound8
 };
 
 extern TranspositionTable TT;
 
-
-/// 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 key) const {
-
-  return table + ((uint32_t)key & hashMask);
-}
-
-
-/// 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);
-}
-
-#endif // !defined(TT_H_INCLUDED)
+#endif // #ifndef 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-2013 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,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
-/// started type 'make help'.
+/// When compiling with provided Makefile (e.g. for Linux and OSX), configuration
+/// is done automatically. To get started type 'make help'.
 ///
-/// For Windows, part of the configuration is detected automatically, but some
-/// switches need to be set manually:
+/// When Makefile is not used (e.g. with Microsoft Visual Studio) some switches
+/// 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
-///               | the executable to run on some very old machines.
+/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. You may need this to
+///               | 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
-///               | popcnt support.
+///               | only in 64-bit mode and requires hardware with popcnt support.
+///
+/// -DUSE_PEXT    | Add runtime support for use of pext asm-instruction. Works
+///               | only in 64-bit mode and requires hardware with pext support.
 
 #include <cassert>
 #include <cctype>
 #include <climits>
+#include <cstdint>
 #include <cstdlib>
 
-#include "platform.h"
-
-#if defined(_WIN64) && !defined(IS_64BIT)
-#  include <intrin.h> // MSVC popcnt and bsfq instrinsics
-#  define IS_64BIT
-#  define USE_BSFQ
-#endif
-
-#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
-#  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
-#endif
-
-#  if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
-#   include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
-#  endif
-
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-#  define CACHE_LINE_ALIGNMENT __declspec(align(64))
-#else
-#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
-#endif
-
 #if defined(_MSC_VER)
-#  define FORCE_INLINE  __forceinline
-#elif defined(__GNUC__)
-#  define FORCE_INLINE  inline __attribute__((always_inline))
-#else
-#  define FORCE_INLINE  inline
+// 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'
 #endif
 
-#if defined(USE_POPCNT)
+/// Predefined macros hell:
+///
+/// __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
+#endif
+
+#if defined(USE_POPCNT) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#  include <nmmintrin.h> // Intel and Microsoft header for _mm_popcnt_u64()
+#endif
+
+#if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#  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 pext(b, m) 0
+#endif
+
+#ifdef 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;
@@ -85,139 +100,130 @@ const bool Is64Bit = false;
 typedef uint64_t Key;
 typedef uint64_t Bitboard;
 
-const int MAX_MOVES      = 192;
-const int MAX_PLY        = 100;
-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);
-
+const int MAX_MOVES = 256;
+const int MAX_PLY   = 128;
 
 /// 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 {
-  MOVE_NONE = 0,
+enum Move : int {
+  MOVE_NONE,
   MOVE_NULL = 65
 };
 
 enum MoveType {
-  NORMAL    = 0,
+  NORMAL,
   PROMOTION = 1 << 14,
   ENPASSANT = 2 << 14,
-  CASTLE    = 3 << 14
+  CASTLING  = 3 << 14
 };
 
-enum CastleRight {  // Defined as in PolyGlot book hash key
-  CASTLES_NONE = 0,
-  WHITE_OO     = 1,
-  WHITE_OOO    = 2,
-  BLACK_OO     = 4,
-  BLACK_OOO    = 8,
-  ALL_CASTLES  = 15,
-  CASTLE_RIGHT_NB = 16
+enum Color {
+  WHITE, BLACK, COLOR_NB = 2
 };
 
 enum CastlingSide {
-  KING_SIDE,
-  QUEEN_SIDE,
-  CASTLING_SIDE_NB = 2
+  KING_SIDE, QUEEN_SIDE, CASTLING_SIDE_NB = 2
+};
+
+enum CastlingRight {
+  NO_CASTLING,
+  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 = 0,
+  PHASE_ENDGAME,
   PHASE_MIDGAME = 128,
   MG = 0, EG = 1, PHASE_NB = 2
 };
 
 enum ScaleFactor {
-  SCALE_FACTOR_DRAW   = 0,
-  SCALE_FACTOR_NORMAL = 64,
-  SCALE_FACTOR_MAX    = 128,
-  SCALE_FACTOR_NONE   = 255
+  SCALE_FACTOR_DRAW    = 0,
+  SCALE_FACTOR_ONEPAWN = 48,
+  SCALE_FACTOR_NORMAL  = 64,
+  SCALE_FACTOR_MAX     = 128,
+  SCALE_FACTOR_NONE    = 255
 };
 
 enum Bound {
-  BOUND_NONE  = 0,
-  BOUND_UPPER = 1,
-  BOUND_LOWER = 2,
+  BOUND_NONE,
+  BOUND_UPPER,
+  BOUND_LOWER,
   BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
-enum Value {
+enum Value : int {
   VALUE_ZERO      = 0,
   VALUE_DRAW      = 0,
-  VALUE_KNOWN_WIN = 15000,
-  VALUE_MATE      = 30000,
-  VALUE_INFINITE  = 30001,
-  VALUE_NONE      = 30002,
+  VALUE_KNOWN_WIN = 10000,
+  VALUE_MATE      = 32000,
+  VALUE_INFINITE  = 32001,
+  VALUE_NONE      = 32002,
 
-  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - MAX_PLY,
-  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + MAX_PLY,
+  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - 2 * MAX_PLY,
+  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY,
 
-  VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
-  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN,
+  PawnValueMg   = 171,   PawnValueEg   = 240,
+  KnightValueMg = 764,   KnightValueEg = 848,
+  BishopValueMg = 826,   BishopValueEg = 891,
+  RookValueMg   = 1282,  RookValueEg   = 1373,
+  QueenValueMg  = 2526,  QueenValueEg  = 2646,
 
-  PawnValueMg   = 198,   PawnValueEg   = 258,
-  KnightValueMg = 817,   KnightValueEg = 846,
-  BishopValueMg = 836,   BishopValueEg = 857,
-  RookValueMg   = 1270,  RookValueEg   = 1278,
-  QueenValueMg  = 2521,  QueenValueEg  = 2558
+  MidgameLimit  = 15258, EndgameLimit  = 3915
 };
 
 enum PieceType {
-  NO_PIECE_TYPE = 0, ALL_PIECES = 0,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6,
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
+  ALL_PIECES = 0,
+  QUEEN_DIAGONAL = 7,
   PIECE_TYPE_NB = 8
 };
 
 enum Piece {
-  NO_PIECE = 0,
-  W_PAWN = 1, W_KNIGHT =  2, W_BISHOP =  3, W_ROOK =  4, W_QUEEN =  5, W_KING =  6,
-  B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14,
+  NO_PIECE,
+  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
+  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
   PIECE_NB = 16
 };
 
-enum Color {
-  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
-};
+extern Value PieceValue[PHASE_NB][PIECE_NB];
 
-enum Depth {
+enum Depth : int {
 
-  ONE_PLY = 2,
+  ONE_PLY = 1,
 
   DEPTH_ZERO          =  0 * ONE_PLY,
-  DEPTH_QS_CHECKS     = -1 * ONE_PLY,
-  DEPTH_QS_NO_CHECKS  = -2 * ONE_PLY,
+  DEPTH_QS_CHECKS     =  0 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS  = -1 * 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,
@@ -228,199 +234,190 @@ enum Square {
   SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
   SQ_NONE,
 
-  SQUARE_NB = 64,
-
-  DELTA_N =  8,
-  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
+  SQUARE_NB = 64
 };
 
-enum File {
-  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB = 8
+enum Direction : int {
+  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 {
-  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB = 8
+enum File : int {
+  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),
-/// first LSB 16 bits are used to store endgame value, while upper bits are used
-/// for midgame value. Compiler is free to choose the enum type as long as can
-/// keep its data, so ensure Score to be an integer type.
-enum Score {
-  SCORE_ZERO = 0,
-  SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
-  SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
-};
+/// Score enum stores a middlegame and an endgame value in a single integer
+/// (enum). The least significant 16 bits are used to store the endgame value
+/// and the upper 16 bits are used to store the middlegame value. Take some
+/// care to avoid left-shifting a signed int to avoid undefined behavior.
+enum Score : int { SCORE_ZERO };
 
-inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
-
-/// 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));
+constexpr Score make_score(int mg, int eg) {
+  return Score((int)((unsigned int)eg << 16) + mg);
 }
 
-#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 T operator+(const T d1, const T d2) { return T(int(d1) + int(d2)); } \
-inline T operator-(const T d1, const T d2) { return T(int(d1) - int(d2)); } \
-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; }
+inline Value mg_value(Score s) {
+  union { uint16_t u; int16_t s; } mg = { uint16_t(unsigned(s)) };
+  return Value(mg.s);
+}
 
-#define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_OPERATORS_ON(T)                  \
-inline T operator++(T& d, int) { d = T(int(d) + 1); return d; }             \
-inline T operator--(T& d, int) { d = T(int(d) - 1); return d; }             \
-inline T operator/(const T d, int i) { return T(int(d) / i); }              \
-inline T& operator/=(T& d, int i) { d = T(int(d) / i); return d; }
+#define ENABLE_BASE_OPERATORS_ON(T)                                \
+constexpr T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \
+constexpr T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \
+constexpr T operator-(T d) { return T(-int(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)
-ENABLE_OPERATORS_ON(PieceType)
-ENABLE_OPERATORS_ON(Piece)
-ENABLE_OPERATORS_ON(Color)
-ENABLE_OPERATORS_ON(Depth)
-ENABLE_OPERATORS_ON(Square)
-ENABLE_OPERATORS_ON(File)
-ENABLE_OPERATORS_ON(Rank)
+#define ENABLE_INCR_OPERATORS_ON(T)                                \
+inline T& operator++(T& d) { return d = T(int(d) + 1); }           \
+inline T& operator--(T& d) { return d = T(int(d) - 1); }
 
-/// Added operators for adding integers to a Value
-inline Value operator+(Value v, int i) { return Value(int(v) + i); }
-inline Value operator-(Value v, int i) { return Value(int(v) - i); }
+#define ENABLE_FULL_OPERATORS_ON(T)                                \
+ENABLE_BASE_OPERATORS_ON(T)                                        \
+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);
 }
 
-/// Weight score v by score w trying to prevent overflow
-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);
+/// Multiplication of a Score by an integer. We check for overflow in debug mode.
+inline Score operator*(Score s, int i) {
+
+  Score result = Score(int(s) * i);
+
+  assert(eg_value(result) == (i * eg_value(s)));
+  assert(mg_value(result) == (i * mg_value(s)));
+  assert((i == 0) || (result / i) == s );
+
+  return result;
 }
 
-#undef ENABLE_OPERATORS_ON
-#undef ENABLE_SAFE_OPERATORS_ON
-
-namespace Zobrist {
-
-  extern Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
-  extern Key enpassant[FILE_NB];
-  extern Key castle[CASTLE_RIGHT_NB];
-  extern Key side;
-  extern Key exclusion;
-
-  void init();
+constexpr Color operator~(Color c) {
+  return Color(c ^ BLACK); // Toggle color
 }
 
-CACHE_LINE_ALIGNMENT
-
-extern Score pieceSquareTable[PIECE_NB][SQUARE_NB];
-extern Value PieceValue[PHASE_NB][PIECE_NB];
-extern int SquareDistance[SQUARE_NB][SQUARE_NB];
-
-struct MoveStack {
-  Move move;
-  int score;
-};
-
-inline bool operator<(const MoveStack& f, const MoveStack& s) {
-  return f.score < s.score;
+constexpr Square operator~(Square s) {
+  return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8
 }
 
-inline Color operator~(Color c) {
-  return Color(c ^ 1);
+constexpr File operator~(File f) {
+  return File(f ^ FILE_H); // Horizontal flip FILE_A -> FILE_H
 }
 
-inline Square operator~(Square s) {
-  return Square(s ^ 56); // Vertical flip SQ_A1 -> SQ_A8
+constexpr Piece operator~(Piece pc) {
+  return Piece(pc ^ 8); // Swap color of piece B_KNIGHT -> W_KNIGHT
 }
 
-inline Square operator|(File f, Rank r) {
-  return Square((r << 3) | f);
+constexpr CastlingRight operator|(Color c, CastlingSide s) {
+  return CastlingRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
 }
 
-inline Value mate_in(int ply) {
+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) {
-  return Piece((c << 3) | pt);
+constexpr Square make_square(File f, Rank r) {
+  return Square((r << 3) + f);
 }
 
-inline CastleRight make_castle_right(Color c, CastlingSide s) {
-  return CastleRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
+constexpr Piece make_piece(Color c, PieceType pt) {
+  return Piece((c << 3) + pt);
 }
 
-inline PieceType type_of(Piece p)  {
-  return PieceType(p & 7);
+constexpr PieceType type_of(Piece pc) {
+  return PieceType(pc & 7);
 }
 
-inline Color color_of(Piece p) {
-  assert(p != NO_PIECE);
-  return Color(p >> 3);
+inline Color color_of(Piece pc) {
+  assert(pc != NO_PIECE);
+  return Color(pc >> 3);
 }
 
-inline bool is_ok(Square s) {
+constexpr bool 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 mirror(Square s) {
-  return Square(s ^ 7); // Horizontal flip SQ_A1 -> SQ_H1
-}
-
-inline Square relative_square(Color c, Square s) {
+constexpr 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));
 }
 
@@ -429,64 +426,41 @@ inline bool opposite_colors(Square s1, Square s2) {
   return ((s >> 3) ^ s) & 1;
 }
 
-inline int file_distance(Square s1, Square s2) {
-  return abs(file_of(s1) - file_of(s2));
+constexpr Direction pawn_push(Color c) {
+  return c == WHITE ? NORTH : SOUTH;
 }
 
-inline int rank_distance(Square s1, Square s2) {
-  return abs(rank_of(s1) - rank_of(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return SquareDistance[s1][s2];
-}
-
-inline char file_to_char(File f, bool tolower = true) {
-  return char(f - FILE_A + (tolower ? 'a' : 'A'));
-}
-
-inline char rank_to_char(Rank r) {
-  return char(r - RANK_1 + '1');
-}
-
-inline Square pawn_push(Color c) {
-  return c == WHITE ? DELTA_N : DELTA_S;
-}
-
-inline Square from_sq(Move m) {
+constexpr Square from_sq(Move m) {
   return Square((m >> 6) & 0x3F);
 }
 
-inline Square to_sq(Move m) {
+constexpr Square to_sq(Move m) {
   return Square(m & 0x3F);
 }
 
-inline MoveType type_of(Move m) {
+constexpr int from_to(Move m) {
+ return m & 0xFFF;
+}
+
+constexpr MoveType type_of(Move m) {
   return MoveType(m & (3 << 14));
 }
 
-inline PieceType promotion_type(Move m) {
-  return PieceType(((m >> 12) & 3) + 2);
+constexpr PieceType promotion_type(Move m) {
+  return PieceType(((m >> 12) & 3) + KNIGHT);
 }
 
 inline Move make_move(Square from, Square to) {
-  return Move(to | (from << 6));
+  return Move((from << 6) + to);
 }
 
 template<MoveType T>
-inline Move make(Square from, Square to, PieceType pt = KNIGHT) {
-  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));
+constexpr Move make(Square from, Square to, PieceType pt = KNIGHT) {
+  return Move(T + ((pt - KNIGHT) << 12) + (from << 6) + to);
 }
 
-inline bool is_ok(Move m) {
-  return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE
+constexpr bool is_ok(Move m) {
+  return from_sq(m) != to_sq(m); // Catch 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;
-}
-
-#endif // !defined(TYPES_H_INCLUDED)
+#endif // #ifndef 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-2013 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,117 +18,37 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <iomanip>
+#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
 
 #include "evaluate.h"
-#include "notation.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 void benchmark(const Position& pos, istream& is);
+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). Needed by repetition draw detection.
-  Search::StateStackPtr SetupStates;
 
-  void set_option(istringstream& up);
-  void set_position(Position& pos, istringstream& up);
-  void go(const Position& pos, istringstream& up);
-}
-
-
-/// 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(const string& args) {
-
-  Position pos(StartFEN, false, Threads.main_thread()); // The root position
-  string token, cmd = args;
-
-  do {
-      if (args.empty() && !getline(cin, cmd)) // Block here waiting for input
-          cmd = "quit";
-
-      istringstream is(cmd);
-
-      is >> skipws >> token;
-
-      if (token == "quit" || token == "stop" || token == "ponderhit")
-      {
-          // GUI sends 'ponderhit' to tell us to ponder on the same move the
-          // opponent has played. In case Signals.stopOnPonderhit is set we are
-          // waiting for 'ponderhit' to stop the search (for instance because we
-          // already ran out of time), otherwise we should continue searching but
-          // switching from pondering to normal search.
-          if (token != "ponderhit" || Search::Signals.stopOnPonderhit)
-          {
-              Search::Signals.stop = true;
-              Threads.main_thread()->notify_one(); // Could be sleeping
-          }
-          else
-              Search::Limits.ponder = false;
-      }
-      else if (token == "perft" && (is >> token)) // Read perft depth
-      {
-          stringstream ss;
-
-          ss << Options["Hash"]    << " "
-             << Options["Threads"] << " " << token << " current perft";
-
-          benchmark(pos, ss);
-      }
-      else if (token == "key")
-          sync_cout << hex << uppercase << setfill('0')
-                    << "position key: "   << setw(16) << pos.key()
-                    << "\nmaterial key: " << setw(16) << pos.material_key()
-                    << "\npawn key:     " << setw(16) << pos.pawn_key()
-                    << dec << sync_endl;
-
-      else if (token == "uci")
-          sync_cout << "id name " << engine_info(true)
-                    << "\n"       << Options
-                    << "\nuciok"  << sync_endl;
-
-      else if (token == "ucinewgame") { /* Avoid returning "Unknown command" */ }
-      else if (token == "go")         go(pos, is);
-      else if (token == "position")   set_position(pos, is);
-      else if (token == "setoption")  set_option(is);
-      else if (token == "flip")       pos.flip();
-      else if (token == "bench")      benchmark(pos, is);
-      else if (token == "d")          sync_cout << pos.pretty() << sync_endl;
-      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
-      else if (token == "eval")       sync_cout << Eval::trace(pos) << sync_endl;
-      else
-          sync_cout << "Unknown command: " << cmd << sync_endl;
-
-  } while (token != "quit" && args.empty()); // Args have one-shot behaviour
-
-  Threads.wait_for_think_finished(); // Cannot quit while search is running
-}
-
-
-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")
+  // 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) {
+  void position(Position& pos, istringstream& is, StateListPtr& states) {
 
     Move m;
     string token, fen;
@@ -145,22 +66,22 @@ namespace {
     else
         return;
 
-    pos.set(fen, Options["UCI_Chess960"], Threads.main_thread());
-    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());
+    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)
     {
-        SetupStates->push(StateInfo());
-        pos.do_move(m, SetupStates->top());
+        states->emplace_back();
+        pos.do_move(m, states->back());
     }
   }
 
 
-  // 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;
 
@@ -168,11 +89,11 @@ 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))
         Options[name] = value;
@@ -182,20 +103,21 @@ namespace {
 
 
   // go() is called when engine receives the "go" UCI command. The function sets
-  // the thinking time and other parameters from the input string, and starts
+  // the thinking time and other parameters from the input string, then starts
   // the search.
 
-  void go(const Position& pos, istringstream& is) {
+  void go(Position& pos, istringstream& is, StateListPtr& states) {
 
     Search::LimitsType limits;
-    vector<Move> searchMoves;
     string token;
+    bool ponderMode = false;
+
+    limits.startTime = now(); // As early as possible!
 
     while (is >> token)
-    {
         if (token == "searchmoves")
             while (is >> token)
-                searchMoves.push_back(move_from_uci(pos, 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];
@@ -206,10 +128,189 @@ namespace {
         else if (token == "nodes")     is >> limits.nodes;
         else if (token == "movetime")  is >> limits.movetime;
         else if (token == "mate")      is >> limits.mate;
-        else if (token == "infinite")  limits.infinite = true;
-        else if (token == "ponder")    limits.ponder = true;
+        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;
+    uint64_t num, nodes = 0, cnt = 1;
+
+    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)
+    {
+        istringstream is(cmd);
+        is >> skipws >> token;
+
+        if (token == "go")
+        {
+            cerr << "\nPosition: " << cnt++ << '/' << num << endl;
+            go(pos, is, states);
+            Threads.main()->wait_for_search_finished();
+            nodes += Threads.nodes_searched();
+        }
+        else if (token == "setoption")  setoption(is);
+        else if (token == "position")   position(pos, is, states);
+        else if (token == "ucinewgame") Search::clear();
     }
 
-    Threads.start_thinking(pos, limits, searchMoves, SetupStates);
+    elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
+
+    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
+}
+
+
+/// UCI::value() converts a Value to a string suitable for use with the UCI
+/// protocol specification:
+///
+/// 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.
+
+string UCI::value(Value v) {
+
+  assert(-VALUE_INFINITE < v && v < VALUE_INFINITE);
+
+  stringstream ss;
+
+  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;
+
+  return ss.str();
+}
+
+
+/// 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

@@ -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-2013 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,12 +18,16 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(UCIOPTION_H_INCLUDED)
-#define UCIOPTION_H_INCLUDED
+#ifndef UCI_H_INCLUDED
+#define UCI_H_INCLUDED
 
 #include <map>
 #include <string>
 
+#include "types.h"
+
+class Position;
+
 namespace UCI {
 
 class Option;
@@ -38,15 +43,16 @@ typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
 /// Option class implements an option as defined by UCI protocol
 class Option {
 
-  typedef void (Fn)(const Option&);
+  typedef void (*OnChange)(const Option&);
 
 public:
-  Option(Fn* = NULL);
-  Option(bool v, Fn* = NULL);
-  Option(const char* v, Fn* = NULL);
-  Option(int v, int min, int max, Fn* = NULL);
+  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& v);
+  Option& operator=(const std::string&);
+  void operator<<(const Option&);
   operator int() const;
   operator std::string() const;
 
@@ -56,14 +62,19 @@ private:
   std::string defaultValue, currentValue, type;
   int min, max;
   size_t idx;
-  Fn* on_change;
+  OnChange on_change;
 };
 
 void init(OptionsMap&);
-void loop(const std::string&);
+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 // !defined(UCIOPTION_H_INCLUDED)
+#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-2013 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,14 +20,14 @@
 
 #include <algorithm>
 #include <cassert>
-#include <cstdlib>
-#include <sstream>
+#include <ostream>
 
-#include "evaluate.h"
 #include "misc.h"
+#include "search.h"
 #include "thread.h"
 #include "tt.h"
-#include "ucioption.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
 using std::string;
 
@@ -35,60 +36,45 @@ 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_eval(const Option&) { Eval::init(); }
-void on_threads(const Option&) { Threads.read_uci_options(); }
-void on_hash_size(const Option& o) { TT.set_size(o); }
-void on_clear_hash(const Option&) { TT.clear(); }
+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
-bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); }
-
 bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
-  return std::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); });
 }
 
 
-/// init() initializes the UCI options to their hard coded default values
-/// and initializes the default value of "Threads" and "Min Split Depth"
-/// parameters according to the number of CPU cores detected.
+/// init() initializes the UCI options to their hard-coded default values
 
 void init(OptionsMap& o) {
 
-  int cpus = std::min(cpu_count(), MAX_THREADS);
-  int msd = cpus < 8 ? 4 : 7;
+  // at most 2^32 clusters.
+  const int MaxHashMB = Is64Bit ? 131072 : 2048;
 
-  o["Use Debug Log"]               = Option(false, on_logger);
-  o["Use Search Log"]              = Option(false);
-  o["Search Log Filename"]         = Option("SearchLog.txt");
-  o["Book File"]                   = Option("book.bin");
-  o["Best Book Move"]              = Option(false);
-  o["Contempt Factor"]             = Option(0, -50,  50);
-  o["Mobility (Middle Game)"]      = Option(100, 0, 200, on_eval);
-  o["Mobility (Endgame)"]          = Option(100, 0, 200, on_eval);
-  o["Passed Pawns (Middle Game)"]  = Option(100, 0, 200, on_eval);
-  o["Passed Pawns (Endgame)"]      = Option(100, 0, 200, on_eval);
-  o["Space"]                       = Option(100, 0, 200, on_eval);
-  o["Aggressiveness"]              = Option(100, 0, 200, on_eval);
-  o["Cowardice"]                   = Option(100, 0, 200, on_eval);
-  o["Min Split Depth"]             = Option(msd, 4, 12, on_threads);
-  o["Max Threads per Split Point"] = Option(5, 4, 8, on_threads);
-  o["Threads"]                     = Option(cpus, 1, MAX_THREADS, on_threads);
-  o["Use Sleeping Threads"]        = Option(false);
-  o["Hash"]                        = Option(32, 1, 8192, on_hash_size);
-  o["Clear Hash"]                  = Option(on_clear_hash);
-  o["Ponder"]                      = Option(true);
-  o["OwnBook"]                     = Option(false);
-  o["MultiPV"]                     = Option(1, 1, 500);
-  o["Skill Level"]                 = Option(20, 0, 20);
-  o["Emergency Move Horizon"]      = Option(40, 0, 50);
-  o["Emergency Base Time"]         = Option(200, 0, 30000);
-  o["Emergency Move Time"]         = Option(70, 0, 5000);
-  o["Minimum Thinking Time"]       = Option(20, 0, 5000);
-  o["Slow Mover"]                  = Option(100, 10, 1000);
-  o["UCI_Chess960"]                = Option(false);
-  o["UCI_AnalyseMode"]             = Option(false, on_eval);
+  o["Debug Log File"]        << Option("", on_logger);
+  o["Contempt"]              << Option(20, -100, 100);
+  o["Threads"]               << Option(1, 1, 512, on_threads);
+  o["Hash"]                  << Option(16, 1, MaxHashMB, on_hash_size);
+  o["Clear Hash"]            << Option(on_clear_hash);
+  o["Ponder"]                << Option(false);
+  o["MultiPV"]               << Option(1, 1, 500);
+  o["Skill Level"]           << Option(20, 0, 20);
+  o["Move Overhead"]         << Option(30, 0, 5000);
+  o["Minimum Thinking Time"] << Option(20, 0, 5000);
+  o["Slow Mover"]            << Option(89, 10, 1000);
+  o["nodestime"]             << Option(0, 0, 10000);
+  o["UCI_Chess960"]          << Option(false);
+  o["SyzygyPath"]            << Option("<empty>", on_tb_path);
+  o["SyzygyProbeDepth"]      << Option(1, 1, 100);
+  o["Syzygy50MoveRule"]      << Option(true);
+  o["SyzygyProbeLimit"]      << Option(6, 0, 6);
 }
 
 
@@ -97,12 +83,12 @@ void init(OptionsMap& o) {
 
 std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
-  for (size_t idx = 0; idx < om.size(); idx++)
-      for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it)
-          if (it->second.idx == idx)
+  for (size_t idx = 0; idx < om.size(); ++idx)
+      for (const auto& it : om)
+          if (it.second.idx == idx)
           {
-              const Option& o = it->second;
-              os << "\noption name " << it->first << " type " << o.type;
+              const Option& o = it.second;
+              os << "\noption name " << it.first << " type " << o.type;
 
               if (o.type != "button")
                   os << " default " << o.defaultValue;
@@ -112,28 +98,28 @@ std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
               break;
           }
+
   return os;
 }
 
 
-/// Option c'tors and conversion operators
+/// Option class constructors and conversion operators
 
-Option::Option(const char* v, Fn* f) : type("string"), min(0), max(0), idx(Options.size()), on_change(f)
+Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
 { defaultValue = currentValue = v; }
 
-Option::Option(bool v, Fn* f) : type("check"), min(0), max(0), idx(Options.size()), on_change(f)
+Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
 { defaultValue = currentValue = (v ? "true" : "false"); }
 
-Option::Option(Fn* f) : type("button"), min(0), max(0), idx(Options.size()), on_change(f)
+Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
 {}
 
-Option::Option(int v, int minv, int maxv, Fn* f) : type("spin"), min(minv), max(maxv), idx(Options.size()), 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" ? atoi(currentValue.c_str()) : currentValue == "true");
+  return (type == "spin" ? stoi(currentValue) : currentValue == "true");
 }
 
 Option::operator std::string() const {
@@ -142,6 +128,17 @@ Option::operator std::string() const {
 }
 
 
+/// operator<<() inits options and assigns idx in the correct printing order
+
+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.
@@ -152,14 +149,14 @@ Option& Option::operator=(const string& v) {
 
   if (   (type != "button" && v.empty())
       || (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);
+      on_change(*this);
 
   return *this;
 }

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