Stockfish 4

Stockfish bench signature is: 4132374

Readme.md

@@ -0,0 +1,70 @@
+### Overview
+
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program and requires some UCI-compatible GUI
+(e.g. XBoard with PolyGlot, eboard, Arena, Sigma Chess, Shredder, Chess
+Partner or Fritz) in order to be used comfortably. Read the
+documentation for your GUI of choice for information about how to use
+Stockfish with it.
+
+This version of Stockfish supports up to 64 CPUs. The engine defaults
+to one search thread 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.
+
+
+### Files
+
+This distribution of Stockfish consists of the following files:
+
+  * Readme.md, the file you are currently reading.
+
+  * Copying.txt, a text file containing the GNU General Public License.
+
+  * src, a subdirectory containing the full source code, including a Makefile
+    that can be used to compile Stockfish on Unix-like systems. For further
+    information about how to compile Stockfish yourself read section below.
+
+  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
+    adapter.
+
+
+### Opening books
+
+This version of Stockfish has support for PolyGlot opening books. For
+information about how to create such books, consult the PolyGlot
+documentation. The book file can be selected by setting the *Book File*
+UCI parameter.
+
+
+### Compiling it yourself
+
+On Unix-like systems, it should be possible to compile Stockfish
+directly from the source code with the included Makefile.
+
+Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT
+instruction, big-endian machines such as Power PC, and other platforms.
+
+In general it is recommended to run `make help` to see a list of make
+targets with corresponding descriptions. When not using 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.
+
+
+### Terms of use
+
+Stockfish is free, and distributed under the **GNU General Public License**
+(GPL). Essentially, this means that you are free to do almost exactly
+what you want with the program, including distributing it among your
+friends, making it available for download from your web site, selling
+it (either by itself or as part of some bigger software package), or
+using it as the starting point for a software project of your own.
+
+The only real limitation is that whenever you distribute Stockfish in
+some way, you must always include the full source code, or a pointer
+to where the source code can be found. If you make any changes to the
+source code, these changes must also be made available under the GPL.
+
+For full details, read the copy of the GPL found in the file named
+*Copying.txt*

Readme.txt

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

polyglot.ini

@@ -1,4 +1,3 @@
-
 [PolyGlot]
 
 EngineDir = .
@@ -15,25 +14,34 @@ ResignScore = 600
 
 [Engine]
 
-Hash = 128
+Write Debug Log = false
-Threads = 1
+Write Search Log = false
-OwnBook = false
+Search Log Filename = SearchLog.txt
 Book File = book.bin
 Best Book Move = false
-Use Search Log = false
+Contempt Factor = 0
-Search Log Filename = SearchLog.txt
+Mobility (Midgame) = 100
-Mobility (Middle Game) = 100
 Mobility (Endgame) = 100
-Passed Pawns (Middle Game) = 100
+Pawn Structure (Midgame) = 100
+Pawn Structure (Endgame) = 100
+Passed Pawns (Midgame) = 100
 Passed Pawns (Endgame) = 100
 Space = 100
 Aggressiveness = 100
 Cowardice = 100
-Minimum Split Depth = 4
+Min Split Depth = 0
-Maximum Number of Threads per Split Point = 5
+Max Threads per Split Point = 5
-Use Sleeping Threads = false
+Threads = 1
+Idle Threads Sleep = 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
+Slow Mover = 100
+UCI_Chess960 = false
+UCI_AnalyseMode = false

src/Makefile

@@ -1,6 +1,6 @@
 # Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-# Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+# 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
@@ -20,19 +20,27 @@
 ### Section 1. General Configuration
 ### ==========================================================================
 
+### Establish the operating system name
+UNAME = $(shell uname)
+
 ### 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
+### Built-in benchmark for pgo-builds and signature
 PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+SIGNBENCH = ./$(EXE) bench
 
 ### Object files
 OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
-	material.o misc.o move.o movegen.o movepick.o pawns.o position.o \
+	material.o misc.o movegen.o movepick.o notation.o pawns.o position.o \
 	search.o thread.o timeman.o tt.o uci.o ucioption.o
 
 ### ==========================================================================
@@ -42,16 +50,16 @@ OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
 # flag                --- Comp switch --- Description
 # ----------------------------------------------------------------------------
 #
-# debug = no/yes      --- -DNDEBUG    --- Enable/Disable debug mode
+# debug = yes/no      --- -DNDEBUG         --- Enable/Disable debug mode
 # optimize = yes/no   --- (-O3/-fast etc.) --- Enable/Disable optimizations
-# arch = (name)       --- (-arch)     --- Target architecture
+# arch = (name)       --- (-arch)          --- Target architecture
-# os = (name)         ---             --- Target operating system
+# os = (name)         ---                  --- Target operating system
-# bits = 64/32        --- -DIS_64BIT  --- 64-/32-bit operating system
+# bits = 64/32        --- -DIS_64BIT       --- 64-/32-bit operating system
-# bigendian = no/yes  --- -DBIGENDIAN --- big/little-endian byte order
+# prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch x86 asm-instruction
-# prefetch = no/yes   --- -DUSE_PREFETCH  --- Use prefetch x86 asm-instruction
+# bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
-# bsfq = no/yes       --- -DUSE_BSFQ  --- Use bsfq x86_64 asm-instruction
+#                                              with GCC and ICC 64-bit)
-#                                     --- (Works only with GCC and ICC 64-bit)
+# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
-# popcnt = no/yes     --- -DUSE_POPCNT --- Use popcnt x86_64 asm-instruction
+# sse = yes/no        --- -msse            --- Use Intel Streaming SIMD Extensions
 #
 # 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
@@ -68,40 +76,20 @@ ifeq ($(ARCH),general-64)
 	arch = any
 	os = any
 	bits = 64
-	bigendian = no
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif
 
 ifeq ($(ARCH),general-32)
 	arch = any
 	os = any
 	bits = 32
-	bigendian = no
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),bigendian-64)
-	arch = any
-	os = any
-	bits = 64
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
-endif
-
-ifeq ($(ARCH),bigendian-32)
-	arch = any
-	os = any
-	bits = 32
-	bigendian = yes
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif
 
 # x86-section
@@ -109,40 +97,51 @@ ifeq ($(ARCH),x86-64)
 	arch = x86_64
 	os = any
 	bits = 64
-	bigendian = no
 	prefetch = yes
 	bsfq = yes
 	popcnt = no
+	sse = yes
 endif
 
 ifeq ($(ARCH),x86-64-modern)
 	arch = x86_64
 	os = any
 	bits = 64
-	bigendian = no
 	prefetch = yes
 	bsfq = yes
 	popcnt = yes
+	sse = yes
 endif
 
 ifeq ($(ARCH),x86-32)
 	arch = i386
 	os = any
 	bits = 32
-	bigendian = no
 	prefetch = yes
 	bsfq = no
 	popcnt = no
+	sse = yes
 endif
 
 ifeq ($(ARCH),x86-32-old)
 	arch = i386
 	os = any
 	bits = 32
-	bigendian = no
 	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
@@ -150,40 +149,40 @@ ifeq ($(ARCH),osx-ppc-64)
 	arch = ppc64
 	os = osx
 	bits = 64
-	bigendian = yes
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif
 
 ifeq ($(ARCH),osx-ppc-32)
 	arch = ppc
 	os = osx
 	bits = 32
-	bigendian = yes
 	prefetch = no
 	bsfq = no
 	popcnt = no
+	sse = no
 endif
 
 ifeq ($(ARCH),osx-x86-64)
 	arch = x86_64
 	os = osx
 	bits = 64
-	bigendian = no
 	prefetch = yes
 	bsfq = yes
 	popcnt = no
+	sse = yes
 endif
 
 ifeq ($(ARCH),osx-x86-32)
 	arch = i386
 	os = osx
 	bits = 32
-	bigendian = no
 	prefetch = yes
 	bsfq = no
 	popcnt = no
+	sse = yes
 endif
 
 
@@ -223,8 +222,17 @@ ifeq ($(COMP),icc)
 	profile_clean = icc-profile-clean
 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
+endif
+
 ### 3.2 General compiler settings
-CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+CXXFLAGS = -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
 
 ifeq ($(comp),gcc)
 	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
@@ -235,23 +243,41 @@ ifeq ($(comp),mingw)
 endif
 
 ifeq ($(comp),icc)
-	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+	CXXFLAGS += -wd383,981,1418,1419,1476,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+endif
+
+ifeq ($(comp),clang)
+	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
 endif
 
 ifeq ($(os),osx)
-	CXXFLAGS += -arch $(arch)
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.0
 endif
 
 ### 3.3 General linker settings
-LDFLAGS = -lpthread $(EXTRALDFLAGS)
+LDFLAGS = $(EXTRALDFLAGS)
+
+ifeq ($(comp),mingw)
+	LDFLAGS += -static-libstdc++ -static-libgcc
+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
+	endif
+endif
 
 ifeq ($(os),osx)
-	LDFLAGS += -arch $(arch)
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.0
 endif
 
 ### 3.4 Debugging
 ifeq ($(debug),no)
 	CXXFLAGS += -DNDEBUG
+else
+	CXXFLAGS += -g
 endif
 
 ### 3.5 Optimization
@@ -268,6 +294,10 @@ ifeq ($(optimize),yes)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
 		endif
+
+		ifeq ($(arch),armv7)
+			CXXFLAGS += -fno-gcse
+		endif
 	endif
 
 	ifeq ($(comp),mingw)
@@ -281,6 +311,20 @@ ifeq ($(optimize),yes)
 			CXXFLAGS += -O3
 		endif
 	endif
+
+	ifeq ($(comp),clang)
+		### -O4 requires a linker that supports LLVM's LTO
+		CXXFLAGS += -O3
+
+		ifeq ($(os),osx)
+			ifeq ($(arch),i386)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+			ifeq ($(arch),x86_64)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+		endif
+	endif
 endif
 
 ### 3.6. Bits
@@ -288,36 +332,46 @@ ifeq ($(bits),64)
 	CXXFLAGS += -DIS_64BIT
 endif
 
-### 3.7 Endianess
+### 3.7 prefetch
-ifeq ($(bigendian),yes)
-	CXXFLAGS += -DBIGENDIAN
-endif
-
-### 3.8 prefetch
 ifeq ($(prefetch),yes)
-	CXXFLAGS += -msse
+	ifeq ($(sse),yes)
-	DEPENDFLAGS += -msse
+		CXXFLAGS += -msse
+		DEPENDFLAGS += -msse
+	endif
 else
 	CXXFLAGS += -DNO_PREFETCH
 endif
 
-### 3.9 bsfq
+### 3.8 bsfq
 ifeq ($(bsfq),yes)
 	CXXFLAGS += -DUSE_BSFQ
 endif
 
-### 3.10 popcnt
+### 3.9 popcnt
 ifeq ($(popcnt),yes)
-	CXXFLAGS += -DUSE_POPCNT
+	CXXFLAGS += -msse3 -DUSE_POPCNT
+endif
+
+### 3.10 Link Time Optimization, it works since gcc 4.5 but not on mingw.
+### 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)
+	ifeq ($(debug),no)
+		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
+	endif
+	endif
 endif
 
 ### ==========================================================================
 ### Section 4. Public targets
 ### ==========================================================================
 
-default:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) build
-
 help:
 	@echo ""
 	@echo "To compile stockfish, type: "
@@ -326,45 +380,46 @@ help:
 	@echo ""
 	@echo "Supported targets:"
 	@echo ""
-	@echo "build                > Build unoptimized version"
+	@echo "build                   > Standard build"
-	@echo "profile-build        > Build PGO-optimized version"
+	@echo "signature-build         > Standard build with embedded signature"
-	@echo "popcnt-profile-build > Build PGO-optimized version with optional popcnt-support"
+	@echo "profile-build           > PGO build"
-	@echo "strip                > Strip executable"
+	@echo "signature-profile-build > PGO build with embedded signature"
-	@echo "install              > Install executable"
+	@echo "strip                   > Strip executable"
-	@echo "clean                > Clean up"
+	@echo "install                 > Install executable"
-	@echo "testrun              > Make sample run"
+	@echo "clean                   > Clean up"
 	@echo ""
 	@echo "Supported archs:"
 	@echo ""
-	@echo "x86-64               > x86 64-bit"
+	@echo "x86-64                  > x86 64-bit"
-	@echo "x86-64-modern        > x86 64-bit with runtime support for popcnt-instruction"
+	@echo "x86-64-modern           > x86 64-bit with popcnt support"
-	@echo "x86-32               > x86 32-bit excluding very old hardware without SSE-support"
+	@echo "x86-32                  > x86 32-bit with SSE support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
+	@echo "osx-ppc-64              > PPC-Mac OS X 64 bit"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
+	@echo "osx-ppc-32              > PPC-Mac OS X 32 bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
+	@echo "osx-x86-64              > x86-Mac OS X 64 bit"
-	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
+	@echo "osx-x86-32              > x86-Mac OS X 32 bit"
-	@echo "general-64           > unspecified 64-bit"
+	@echo "armv7                   > ARMv7 32 bit"
-	@echo "general-32           > unspecified 32-bit"
+	@echo "general-64              > unspecified 64-bit"
-	@echo "bigendian-64         > unspecified 64-bit with bigendian byte order"
+	@echo "general-32              > unspecified 32-bit"
-	@echo "bigendian-32         > unspecified 32-bit with bigendian byte order"
 	@echo ""
-	@echo "Supported comps:"
+	@echo "Supported compilers:"
 	@echo ""
-	@echo "gcc                  > Gnu compiler (default)"
+	@echo "gcc                     > Gnu compiler (default)"
-	@echo "icc                  > Intel compiler"
+	@echo "mingw                   > Gnu compiler with MinGW under Windows"
-	@echo "mingw                > Gnu compiler with MinGW under Windows"
+	@echo "clang                   > LLVM Clang compiler"
+	@echo "icc                     > Intel compiler"
 	@echo ""
 	@echo "Non-standard targets:"
 	@echo ""
-	@echo "make hpux           >  Compile for HP-UX. Compiler = aCC"
+	@echo "make hpux               >  Compile for HP-UX. Compiler = aCC"
 	@echo ""
 	@echo "Examples. If you don't know what to do, you likely want to run: "
 	@echo ""
-	@echo "make profile-build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make 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-32    (This is for 32-bit systems)"
 	@echo ""
 
+.PHONY: build profile-build embed-signature
 build:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
@@ -389,33 +444,17 @@ profile-build:
 	@echo "Step 4/4. Deleting profile data ..."
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
 
-popcnt-profile-build:
+embed-signature:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+	@echo "Running benchmark for getting the signature ..."
-	@echo ""
+	@$(SIGNBENCH) 2>&1 | sed -n 's/Nodes searched  : \(.*\)/\/string Version\/s\/"\\(.*\\)"\/"sig-\1"\//p' > sign.txt
-	@echo "Step 0/6. Preparing for profile build."
+	@sed -f sign.txt misc.cpp > misc2.cpp
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
+	@mv misc2.cpp misc.cpp
-	@echo ""
+	@rm sign.txt
-	@echo "Step 1/6. Building executable for benchmark (popcnt disabled)..."
+
-	@touch *.cpp *.h
+signature-build: build embed-signature
-	$(MAKE) ARCH=x86-64 COMP=$(COMP) $(profile_make)
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
-	@echo ""
+
-	@echo "Step 2/6. Running benchmark for pgo-build (popcnt disabled)..."
+signature-profile-build: build embed-signature profile-build
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 3/6. Building executable for benchmark (popcnt enabled)..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=x86-64-modern COMP=$(COMP) $(profile_make)
-	@echo ""
-	@echo "Step 4/6. Running benchmark for pgo-build (popcnt enabled)..."
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 5/6. Building final executable ..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
-	@echo ""
-	@echo "Step 6/6. Deleting profile data ..."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
-	@echo ""
 
 strip:
 	strip $(EXE)
@@ -428,8 +467,8 @@ install:
 clean:
 	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
 
-testrun:
+default:
-	@$(PGOBENCH)
+	help
 
 ### ==========================================================================
 ### Section 5. Private targets
@@ -445,10 +484,10 @@ config-sanity:
 	@echo "arch: '$(arch)'"
 	@echo "os: '$(os)'"
 	@echo "bits: '$(bits)'"
-	@echo "bigendian: '$(bigendian)'"
 	@echo "prefetch: '$(prefetch)'"
 	@echo "bsfq: '$(bsfq)'"
 	@echo "popcnt: '$(popcnt)'"
+	@echo "sse: '$(sse)'"
 	@echo ""
 	@echo "Flags:"
 	@echo "CXX: $(CXX)"
@@ -460,14 +499,14 @@ config-sanity:
 	@test "$(debug)" = "yes" || test "$(debug)" = "no"
 	@test "$(optimize)" = "yes" || test "$(optimize)" = "no"
 	@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
-	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc"
+	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
 	@test "$(os)" = "any" || test "$(os)" = "osx"
 	@test "$(bits)" = "32" || test "$(bits)" = "64"
-	@test "$(bigendian)" = "yes" || test "$(bigendian)" = "no"
 	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
 	@test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
 	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
-	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw"
+	@test "$(sse)" = "yes" || test "$(sse)" = "no"
+	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang"
 
 $(EXE): $(OBJS)
 	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
@@ -484,6 +523,7 @@ gcc-profile-make:
 gcc-profile-use:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
 	EXTRACXXFLAGS='-fprofile-use' \
+	EXTRALDFLAGS='-lgcov' \
 	all
 
 gcc-profile-clean:
@@ -518,7 +558,7 @@ icc-profile-clean:
 
 hpux:
 	$(MAKE) \
-	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG -DNO_PREFETCH' \
+	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -mt +O3 -DNDEBUG -DNO_PREFETCH' \
 	CXXFLAGS="" \
 	LDFLAGS="" \
 	all

src/benchmark.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -19,18 +19,22 @@
 
 #include <fstream>
 #include <iostream>
+#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 string Defaults[] = {
+static const char* Defaults[] = {
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
-  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
+  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10",
-  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -",
+  "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",
@@ -43,111 +47,99 @@ static const string 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"
-  ""
 };
 
 
 /// benchmark() runs a simple benchmark by letting Stockfish analyze a set
-/// of positions for a given limit each.  There are five parameters; the
+/// 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
+/// be used, the limit value spent for each position (optional, default is
-/// is ply 12), an optional file name where to look for positions in fen
+/// depth 12), an optional file name where to look for positions in fen
-/// format (default are the BenchmarkPositions defined above) and the type
+/// format (defaults are the positions defined above) and the type of the
-/// of the limit value: depth (default), time in secs or number of nodes.
+/// limit value: depth (default), time in secs or number of nodes.
-/// The analysis is written to a file named bench.txt.
 
-void benchmark(int argc, char* argv[]) {
+void benchmark(const Position& current, istream& is) {
 
-  vector<string> fenList;
+  string token;
-  SearchLimits limits;
+  Search::LimitsType limits;
-  int64_t totalNodes;
+  vector<string> fens;
-  int time;
-
-  // Load default positions
-  for (int i = 0; !Defaults[i].empty(); i++)
-      fenList.push_back(Defaults[i]);
 
   // Assign default values to missing arguments
-  string ttSize  = argc > 2 ? argv[2] : "128";
+  string ttSize    = (is >> token) ? token : "32";
-  string threads = argc > 3 ? argv[3] : "1";
+  string threads   = (is >> token) ? token : "1";
-  string valStr  = argc > 4 ? argv[4] : "12";
+  string limit     = (is >> token) ? token : "12";
-  string fenFile = argc > 5 ? argv[5] : "default";
+  string fenFile   = (is >> token) ? token : "default";
-  string valType = argc > 6 ? argv[6] : "depth";
+  string limitType = (is >> token) ? token : "depth";
 
-  Options["Hash"].set_value(ttSize);
+  Options["Hash"]    = ttSize;
-  Options["Threads"].set_value(threads);
+  Options["Threads"] = threads;
-  Options["OwnBook"].set_value("false");
+  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());
 
-  // Search should be limited by nodes, time or depth ?
-  if (valType == "nodes")
-      limits.maxNodes = atoi(valStr.c_str());
-  else if (valType == "time")
-      limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
   else
-      limits.maxDepth = atoi(valStr.c_str());
+      limits.depth = atoi(limit.c_str());
 
-  // Do we need to load positions from a given FEN file ?
+  if (fenFile == "default")
-  if (fenFile != "default")
+      fens.assign(Defaults, Defaults + 16);
+
+  else if (fenFile == "current")
+      fens.push_back(current.fen());
+
+  else
   {
       string fen;
-      ifstream f(fenFile.c_str());
+      ifstream file(fenFile.c_str());
 
-      if (f.is_open())
+      if (!file.is_open())
       {
-          fenList.clear();
+          cerr << "Unable to open file " << fenFile << endl;
-
+          return;
-          while (getline(f, fen))
-              if (!fen.empty())
-                  fenList.push_back(fen);
-
-          f.close();
-      }
-      else
-      {
-          cerr << "Unable to open FEN file " << fenFile << endl;
-          exit(EXIT_FAILURE);
       }
+
+      while (getline(file, fen))
+          if (!fen.empty())
+              fens.push_back(fen);
+
+      file.close();
   }
 
-  // Ok, let's start the benchmark !
+  int64_t nodes = 0;
-  totalNodes = 0;
+  Search::StateStackPtr st;
-  time = get_system_time();
+  Time::point elapsed = Time::now();
 
-  for (size_t i = 0; i < fenList.size(); i++)
+  for (size_t i = 0; i < fens.size(); i++)
   {
-      Move moves[] = { MOVE_NONE };
+      Position pos(fens[i], Options["UCI_Chess960"], Threads.main());
-      Position pos(fenList[i], false, 0);
 
-      cerr << "\nBench position: " << i + 1 << '/' << fenList.size() << endl;
+      cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
 
-      if (valType == "perft")
+      if (limitType == "perft")
       {
-          int64_t cnt = perft(pos, limits.maxDepth * ONE_PLY);
+          size_t cnt = Search::perft(pos, limits.depth * ONE_PLY);
-          totalNodes += cnt;
+          cerr << "\nPerft " << limits.depth  << " leaf nodes: " << cnt << endl;
-
+          nodes += cnt;
-          cerr << "\nPerft " << limits.maxDepth << " nodes counted: " << cnt << endl;
       }
       else
       {
-          if (!think(pos, limits, moves))
+          Threads.start_thinking(pos, limits, vector<Move>(), st);
-              break;
+          Threads.wait_for_think_finished();
-
+          nodes += Search::RootPos.nodes_searched();
-          totalNodes += pos.nodes_searched();
       }
   }
 
-  time = get_system_time() - time;
+  elapsed = Time::now() - elapsed + 1; // Assure positive to avoid a 'divide by zero'
 
-  cerr << "\n==============================="
+  cerr << "\n==========================="
-       << "\nTotal time (ms) : " << time
+       << "\nTotal time (ms) : " << elapsed
-       << "\nNodes searched  : " << totalNodes
+       << "\nNodes searched  : " << nodes
-       << "\nNodes/second    : " << (int)(totalNodes / (time / 1000.0)) << endl << endl;
+       << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
-
-  // MS Visual C++ debug window always unconditionally closes when program
-  // exits, this is bad because we want to read results before.
-  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
-  cerr << "Press any key to exit" << endl;
-  cin >> time;
-  #endif
 }

src/bitbase.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -18,267 +18,158 @@
 */
 
 #include <cassert>
+#include <vector>
 
 #include "bitboard.h"
 #include "types.h"
 
 namespace {
 
-  enum Result {
-    RESULT_UNKNOWN,
-    RESULT_INVALID,
-    RESULT_WIN,
-    RESULT_LOSS,
-    RESULT_DRAW
-  };
-
-  struct KPKPosition {
-    void from_index(int index);
-    bool is_legal() const;
-    bool is_immediate_draw() const;
-    bool is_immediate_win() const;
-    Bitboard wk_attacks()   const { return StepAttacksBB[WK][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttacksBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
-
-    Square whiteKingSquare, blackKingSquare, pawnSquare;
-    Color sideToMove;
-  };
-
   // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
-  const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq
+  const unsigned IndexMax = 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];
 
-  Result classify_wtm(const KPKPosition& pos, const Result bb[]);
+  // A KPK bitbase index is an integer in [0, IndexMax] range
-  Result classify_btm(const KPKPosition& pos, const Result bb[]);
+  //
-  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
+  // Information is mapped in a way that minimizes 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)
-uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
+  // bit    12: side to move (WHITE or BLACK)
-
+  // bit 13-14: white pawn file (from FILE_A to FILE_D)
-  int index = compute_index(wksq, bksq, wpsq, stm);
+  // 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 KPKBitbase[index / 32] & (1 << (index & 31));
+    return wksq + (bksq << 6) + (us << 12) + (file_of(psq) << 13) + ((RANK_7 - rank_of(psq)) << 15);
-}
-
-
-void init_kpk_bitbase() {
-
-  Result bb[IndexMax];
-  KPKPosition pos;
-  bool repeat;
-
-  // Initialize table
-  for (int i = 0; i < IndexMax; i++)
-  {
-      pos.from_index(i);
-      bb[i] = !pos.is_legal()          ? RESULT_INVALID
-             : pos.is_immediate_draw() ? RESULT_DRAW
-             : pos.is_immediate_win()  ? RESULT_WIN : RESULT_UNKNOWN;
   }
 
-  // Iterate until all positions are classified (30 cycles needed)
+  enum Result {
-  do {
+    INVALID = 0,
-      repeat = false;
+    UNKNOWN = 1,
+    DRAW    = 2,
+    WIN     = 4
+  };
 
-      for (int i = 0; i < IndexMax; i++)
+  inline Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
-          if (bb[i] == RESULT_UNKNOWN)
-          {
-              pos.from_index(i);
 
-              bb[i] = (pos.sideToMove == WHITE) ? classify_wtm(pos, bb)
+  struct KPKPosition {
-                                                : classify_btm(pos, bb);
-              if (bb[i] != RESULT_UNKNOWN)
-                  repeat = true;
-          }
 
-  } while (repeat);
+    operator Result() const { return res; }
+    Result classify_leaf(unsigned idx);
+    Result classify(const std::vector<KPKPosition>& db)
+    { return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }
 
-  // Map 32 position results into one KPKBitbase[] entry
+  private:
-  for (int i = 0; i < IndexMax / 32; i++)
+    template<Color Us> Result classify(const std::vector<KPKPosition>& db);
-      for (int j = 0; j < 32; j++)
+
-          if (bb[32 * i + j] == RESULT_WIN || bb[32 * i + j] == RESULT_LOSS)
+    Color us;
-              KPKBitbase[i] |= (1 << j);
+    Square bksq, wksq, psq;
+    Result res;
+  };
+
+} // namespace
+
+
+bool Bitbases::probe_kpk(Square wksq, Square wpsq, Square bksq, Color us) {
+
+  assert(file_of(wpsq) <= FILE_D);
+
+  unsigned idx = index(us, bksq, wksq, wpsq);
+  return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));
+}
+
+
+void Bitbases::init_kpk() {
+
+  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);
+
+  // Iterate through the positions until no more 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;
+
+  // Map 32 results into one KPKBitbase[] entry
+  for (idx = 0; idx < IndexMax; idx++)
+      if (db[idx] == WIN)
+          KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
 }
 
 
 namespace {
 
- // A KPK bitbase index is an integer in [0, IndexMax] range
+  Result KPKPosition::classify_leaf(unsigned idx) {
- //
- // Information is mapped in this way
- //
- // bit     0: side to move (WHITE or BLACK)
- // bit  1- 6: black king square (from SQ_A1 to SQ_H8)
- // bit  7-12: white king square (from SQ_A1 to SQ_H8)
- // bit 13-14: white pawn file (from FILE_A to FILE_D)
- // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
 
-  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) {
+    wksq = Square((idx >>  0) & 0x3F);
+    bksq = Square((idx >>  6) & 0x3F);
+    us   = Color ((idx >> 12) & 0x01);
+    psq  = File  ((idx >> 13) & 0x03) | Rank(RANK_7 - (idx >> 15));
 
-    assert(square_file(wpsq) <= FILE_D);
+    // 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;
 
-    int p = int(square_file(wpsq)) + 4 * int(square_rank(wpsq) - 1);
+    if (us == WHITE)
-    int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p;
-
-    assert(r >= 0 && r < IndexMax);
-
-    return r;
-  }
-
-  void KPKPosition::from_index(int index) {
-
-    int s = (index / 8192) % 24;
-
-    sideToMove = Color(index % 2);
-    blackKingSquare = Square((index / 2) % 64);
-    whiteKingSquare = Square((index / 128) % 64);
-    pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
-  }
-
-  bool KPKPosition::is_legal() const {
-
-    if (   whiteKingSquare == pawnSquare
-        || whiteKingSquare == blackKingSquare
-        || blackKingSquare == pawnSquare)
-        return false;
-
-    if (sideToMove == WHITE)
     {
-        if (   bit_is_set(wk_attacks(), blackKingSquare)
+        // Immediate win if pawn can be promoted without getting captured
-            || bit_is_set(pawn_attacks(), blackKingSquare))
+        if (   rank_of(psq) == RANK_7
-            return false;
+            && wksq != psq + DELTA_N
+            && (   square_distance(bksq, psq + DELTA_N) > 1
+                ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N))))
+            return res = WIN;
     }
-    else if (bit_is_set(bk_attacks(), whiteKingSquare))
+    // Immediate draw if is stalemate or king captures undefended pawn
-        return false;
+    else if (  !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq]))
+             || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq]))
+        return res = DRAW;
 
-    return true;
+    return res = UNKNOWN;
   }
 
-  bool KPKPosition::is_immediate_draw() const {
+  template<Color Us>
+  Result KPKPosition::classify(const std::vector<KPKPosition>& db) {
 
-    if (sideToMove == BLACK)
+    // 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
+    // position is classified as UNKNOWN.
+    //
+    // 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.
+
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+    Result r = INVALID;
+    Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq];
+
+    while (b)
+        r |= Us == WHITE ? db[index(Them, bksq, pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), wksq, psq)];
+
+    if (Us == WHITE && rank_of(psq) < RANK_7)
     {
-        Bitboard wka = wk_attacks();
+        Square s = psq + DELTA_N;
-        Bitboard bka = bk_attacks();
+        r |= db[index(BLACK, bksq, wksq, s)]; // Single push
 
-        // Case 1: Stalemate
+        if (rank_of(s) == RANK_3 && s != wksq && s != bksq)
-        if ((bka & ~(wka | pawn_attacks())) == EmptyBoardBB)
+            r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push
-            return true;
-
-        // Case 2: King can capture pawn
-        if (bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
-            return true;
     }
+
+    if (Us == WHITE)
+        return res = r & WIN  ? WIN  : r & UNKNOWN ? UNKNOWN : DRAW;
     else
-    {
+        return res = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN;
-        // Case 1: Stalemate (possible pawn files are only from A to D)
-        if (   whiteKingSquare == SQ_A8
-            && pawnSquare == SQ_A7
-            && (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
-            return true;
-    }
-    return false;
   }
 
-  bool KPKPosition::is_immediate_win() const {
+} // namespace
-
-    // The position is an immediate win if it is white to move and the
-    // white pawn can be promoted without getting captured.
-    return   sideToMove == WHITE
-          && square_rank(pawnSquare) == RANK_7
-          && whiteKingSquare != pawnSquare + DELTA_N
-          && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
-              || bit_is_set(wk_attacks(), pawnSquare + DELTA_N));
-  }
-
-  Result classify_wtm(const KPKPosition& pos, const Result bb[]) {
-
-    // If one move leads to a position classified as RESULT_LOSS, the result
-    // of the current position is RESULT_WIN. If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
-    // otherwise the current position is classified as RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = pos.wk_attacks();
-    while (b)
-    {
-        s = pop_1st_bit(&b);
-        r = bb[compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK)];
-
-        if (r == RESULT_LOSS)
-            return RESULT_WIN;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-    }
-
-    // Pawn moves
-    if (square_rank(pos.pawnSquare) < RANK_7)
-    {
-        s = pos.pawnSquare + DELTA_N;
-        r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
-
-        if (r == RESULT_LOSS)
-            return RESULT_WIN;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-
-        // Double pawn push
-        if (   square_rank(s) == RANK_3
-            && s != pos.whiteKingSquare
-            && s != pos.blackKingSquare)
-        {
-            s += DELTA_N;
-            r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
-
-            if (r == RESULT_LOSS)
-                return RESULT_WIN;
-
-            if (r == RESULT_UNKNOWN)
-                unknownFound = true;
-        }
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
-  }
-
-
-  Result classify_btm(const KPKPosition& pos, const Result bb[]) {
-
-    // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW. If all moves lead to positions
-    // classified as RESULT_WIN, the current position is classified as
-    // RESULT_LOSS. Otherwise, the current position is classified as
-    // RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = pos.bk_attacks();
-    while (b)
-    {
-        s = pop_1st_bit(&b);
-        r = bb[compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE)];
-
-        if (r == RESULT_DRAW)
-            return RESULT_DRAW;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS;
-  }
-
-}

src/bitboard.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,470 +17,323 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
+#include <cstring>
 #include <iostream>
 
 #include "bitboard.h"
 #include "bitcount.h"
+#include "misc.h"
+#include "rkiss.h"
 
-#if defined(IS_64BIT)
+CACHE_LINE_ALIGNMENT
 
-const uint64_t BMult[64] = {
+Bitboard RMasks[SQUARE_NB];
-  0x0440049104032280ULL, 0x1021023C82008040ULL, 0x0404040082000048ULL,
+Bitboard RMagics[SQUARE_NB];
-  0x48C4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
+Bitboard* RAttacks[SQUARE_NB];
-  0x0181011002E06040ULL, 0x9101004104200E00ULL, 0x1240848848310401ULL,
+unsigned RShifts[SQUARE_NB];
-  0x2000142828050024ULL, 0x00001004024D5000ULL, 0x0102044400800200ULL,
-  0x8108108820112000ULL, 0xA880818210C00046ULL, 0x4008008801082000ULL,
-  0x0060882404049400ULL, 0x0104402004240810ULL, 0x000A002084250200ULL,
-  0x00100B0880801100ULL, 0x0004080201220101ULL, 0x0044008080A00000ULL,
-  0x0000202200842000ULL, 0x5006004882D00808ULL, 0x0000200045080802ULL,
-  0x0086100020200601ULL, 0xA802080A20112C02ULL, 0x0080411218080900ULL,
-  0x000200A0880080A0ULL, 0x9A01010000104000ULL, 0x0028008003100080ULL,
-  0x0211021004480417ULL, 0x0401004188220806ULL, 0x00825051400C2006ULL,
-  0x00140C0210943000ULL, 0x0000242800300080ULL, 0x00C2208120080200ULL,
-  0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL,
-  0x0000822081014405ULL, 0x800C049E40400804ULL, 0x4A0404028A000820ULL,
-  0x0022060201041200ULL, 0x0360904200840801ULL, 0x0881A08208800400ULL,
-  0x0060202C00400420ULL, 0x1204440086061400ULL, 0x0008184042804040ULL,
-  0x0064040315300400ULL, 0x0C01008801090A00ULL, 0x0808010401140C00ULL,
-  0x04004830C2020040ULL, 0x0080005002020054ULL, 0x40000C14481A0490ULL,
-  0x0010500101042048ULL, 0x1010100200424000ULL, 0x0000640901901040ULL,
-  0x00000A0201014840ULL, 0x00840082AA011002ULL, 0x010010840084240AULL,
-  0x0420400810420608ULL, 0x8D40230408102100ULL, 0x4A00200612222409ULL,
-  0x0A08520292120600ULL
-};
 
-const uint64_t RMult[64] = {
+Bitboard BMasks[SQUARE_NB];
-  0x0A8002C000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+Bitboard BMagics[SQUARE_NB];
-  0x0380180080141000ULL, 0x1A00060008211044ULL, 0x410001000A0C0008ULL,
+Bitboard* BAttacks[SQUARE_NB];
-  0x9500060004008100ULL, 0x0100024284A20700ULL, 0x0000802140008000ULL,
+unsigned BShifts[SQUARE_NB];
-  0x0080C01002A00840ULL, 0x0402004282011020ULL, 0x9862000820420050ULL,
-  0x0001001448011100ULL, 0x6432800200800400ULL, 0x040100010002000CULL,
-  0x0002800D0010C080ULL, 0x90C0008000803042ULL, 0x4010004000200041ULL,
-  0x0003010010200040ULL, 0x0A40828028001000ULL, 0x0123010008000430ULL,
-  0x0024008004020080ULL, 0x0060040001104802ULL, 0x00582200028400D1ULL,
-  0x4000802080044000ULL, 0x0408208200420308ULL, 0x0610038080102000ULL,
-  0x3601000900100020ULL, 0x0000080080040180ULL, 0x00C2020080040080ULL,
-  0x0080084400100102ULL, 0x4022408200014401ULL, 0x0040052040800082ULL,
-  0x0B08200280804000ULL, 0x008A80A008801000ULL, 0x4000480080801000ULL,
-  0x0911808800801401ULL, 0x822A003002001894ULL, 0x401068091400108AULL,
-  0x000004A10A00004CULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
-  0x000100A000D50041ULL, 0x00810050020B0020ULL, 0x0204000800808004ULL,
-  0x00020048100A000CULL, 0x0112000831020004ULL, 0x0009000040810002ULL,
-  0x0440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
-  0x4B824A2010010100ULL, 0x04080801810C0080ULL, 0x00000400802A0080ULL,
-  0x8224080110026400ULL, 0x40002C4104088200ULL, 0x01002100104A0282ULL,
-  0x1208400811048021ULL, 0x3201014A40D02001ULL, 0x0005100019200501ULL,
-  0x0101000208001005ULL, 0x0002008450080702ULL, 0x001002080301D00CULL,
-  0x410201CE5C030092ULL
-};
 
-const int BShift[64] = {
+Bitboard SquareBB[SQUARE_NB];
-  58, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 59, 59,
+Bitboard FileBB[FILE_NB];
-  59, 59, 57, 57, 57, 57, 59, 59, 59, 59, 57, 55, 55, 57, 59, 59,
+Bitboard RankBB[RANK_NB];
-  59, 59, 57, 55, 55, 57, 59, 59, 59, 59, 57, 57, 57, 57, 59, 59,
+Bitboard AdjacentFilesBB[FILE_NB];
-  59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
+Bitboard InFrontBB[COLOR_NB][RANK_NB];
-};
+Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
-
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
-const int RShift[64] = {
+Bitboard DistanceRingsBB[SQUARE_NB][8];
-  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
+Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
-  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
-};
-
-#else // if !defined(IS_64BIT)
-
-const uint64_t BMult[64] = {
-  0x54142844C6A22981ULL, 0x710358A6EA25C19EULL, 0x704F746D63A4A8DCULL,
-  0xBFED1A0B80F838C5ULL, 0x90561D5631E62110ULL, 0x2804260376E60944ULL,
-  0x84A656409AA76871ULL, 0xF0267F64C28B6197ULL, 0x70764EBB762F0585ULL,
-  0x92AA09E0CFE161DEULL, 0x41EE1F6BB266F60EULL, 0xDDCBF04F6039C444ULL,
-  0x5A3FAB7BAC0D988AULL, 0xD3727877FA4EAA03ULL, 0xD988402D868DDAAEULL,
-  0x812B291AFA075C7CULL, 0x94FAF987B685A932ULL, 0x3ED867D8470D08DBULL,
-  0x92517660B8901DE8ULL, 0x2D97E43E058814B4ULL, 0x880A10C220B25582ULL,
-  0xC7C6520D1F1A0477ULL, 0xDBFC7FBCD7656AA6ULL, 0x78B1B9BFB1A2B84FULL,
-  0x2F20037F112A0BC1ULL, 0x657171EA2269A916ULL, 0xC08302B07142210EULL,
-  0x0880A4403064080BULL, 0x3602420842208C00ULL, 0x852800DC7E0B6602ULL,
-  0x595A3FBBAA0F03B2ULL, 0x9F01411558159D5EULL, 0x2B4A4A5F88B394F2ULL,
-  0x4AFCBFFC292DD03AULL, 0x4A4094A3B3F10522ULL, 0xB06F00B491F30048ULL,
-  0xD5B3820280D77004ULL, 0x8B2E01E7C8E57A75ULL, 0x2D342794E886C2E6ULL,
-  0xC302C410CDE21461ULL, 0x111F426F1379C274ULL, 0xE0569220ABB31588ULL,
-  0x5026D3064D453324ULL, 0xE2076040C343CD8AULL, 0x93EFD1E1738021EEULL,
-  0xB680804BED143132ULL, 0x44E361B21986944CULL, 0x44C60170EF5C598CULL,
-  0xF4DA475C195C9C94ULL, 0xA3AFBB5F72060B1DULL, 0xBC75F410E41C4FFCULL,
-  0xB51C099390520922ULL, 0x902C011F8F8EC368ULL, 0x950B56B3D6F5490AULL,
-  0x3909E0635BF202D0ULL, 0x5744F90206EC10CCULL, 0xDC59FD76317ABBC1ULL,
-  0x881C7C67FCBFC4F6ULL, 0x47CA41E7E440D423ULL, 0xEB0C88112048D004ULL,
-  0x51C60E04359AEF1AULL, 0x1AA1FE0E957A5554ULL, 0xDD9448DB4F5E3104ULL,
-  0xDC01F6DCA4BEBBDCULL,
-};
-
-const uint64_t RMult[64] = {
-  0xD7445CDEC88002C0ULL, 0xD0A505C1F2001722ULL, 0xE065D1C896002182ULL,
-  0x9A8C41E75A000892ULL, 0x8900B10C89002AA8ULL, 0x9B28D1C1D60005A2ULL,
-  0x015D6C88DE002D9AULL, 0xB1DBFC802E8016A9ULL, 0x149A1042D9D60029ULL,
-  0xB9C08050599E002FULL, 0x132208C3AF300403ULL, 0xC1000CE2E9C50070ULL,
-  0x9D9AA13C99020012ULL, 0xB6B078DAF71E0046ULL, 0x9D880182FB6E002EULL,
-  0x52889F467E850037ULL, 0xDA6DC008D19A8480ULL, 0x468286034F902420ULL,
-  0x7140AC09DC54C020ULL, 0xD76FFFFA39548808ULL, 0xEA901C4141500808ULL,
-  0xC91004093F953A02ULL, 0x02882AFA8F6BB402ULL, 0xAEBE335692442C01ULL,
-  0x0E904A22079FB91EULL, 0x13A514851055F606ULL, 0x76C782018C8FE632ULL,
-  0x1DC012A9D116DA06ULL, 0x3C9E0037264FFFA6ULL, 0x2036002853C6E4A2ULL,
-  0xE3FE08500AFB47D4ULL, 0xF38AF25C86B025C2ULL, 0xC0800E2182CF9A40ULL,
-  0x72002480D1F60673ULL, 0x2500200BAE6E9B53ULL, 0xC60018C1EEFCA252ULL,
-  0x0600590473E3608AULL, 0x46002C4AB3FE51B2ULL, 0xA200011486BCC8D2ULL,
-  0xB680078095784C63ULL, 0x2742002639BF11AEULL, 0xC7D60021A5BDB142ULL,
-  0xC8C04016BB83D820ULL, 0xBD520028123B4842ULL, 0x9D1600344AC2A832ULL,
-  0x6A808005631C8A05ULL, 0x604600A148D5389AULL, 0xE2E40103D40DEA65ULL,
-  0x945B5A0087C62A81ULL, 0x012DC200CD82D28EULL, 0x2431C600B5F9EF76ULL,
-  0xFB142A006A9B314AULL, 0x06870E00A1C97D62ULL, 0x2A9DB2004A2689A2ULL,
-  0xD3594600CAF5D1A2ULL, 0xEE0E4900439344A7ULL, 0x89C4D266CA25007AULL,
-  0x3E0013A2743F97E3ULL, 0x0180E31A0431378AULL, 0x3A9E465A4D42A512ULL,
-  0x98D0A11A0C0D9CC2ULL, 0x8E711C1ABA19B01EULL, 0x8DCDC836DD201142ULL,
-  0x5AC08A4735370479ULL,
-};
-
-const int BShift[64] = {
-  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
-  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
-  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
-};
-
-const int RShift[64] = {
-  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
-};
-
-#endif // defined(IS_64BIT)
-
-// Global bitboards definitions with static storage duration are
-// automatically set to zero before enter main().
-Bitboard RMask[64];
-int RAttackIndex[64];
-Bitboard RAttacks[0x19000];
-
-Bitboard BMask[64];
-int BAttackIndex[64];
-Bitboard BAttacks[0x1480];
-
-Bitboard SetMaskBB[65];
-Bitboard ClearMaskBB[65];
-
-Bitboard SquaresByColorBB[2];
-Bitboard FileBB[8];
-Bitboard RankBB[8];
-Bitboard NeighboringFilesBB[8];
-Bitboard ThisAndNeighboringFilesBB[8];
-Bitboard InFrontBB[2][8];
-Bitboard StepAttacksBB[16][64];
-Bitboard BetweenBB[64][64];
-Bitboard SquaresInFrontMask[2][64];
-Bitboard PassedPawnMask[2][64];
-Bitboard AttackSpanMask[2][64];
-
-Bitboard BishopPseudoAttacks[64];
-Bitboard RookPseudoAttacks[64];
-Bitboard QueenPseudoAttacks[64];
-
-uint8_t BitCount8Bit[256];
 
+int SquareDistance[SQUARE_NB][SQUARE_NB];
 
 namespace {
 
-  void init_masks();
+  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
-  void init_step_attacks();
+  const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
-  void init_pseudo_attacks();
+  const uint32_t DeBruijn_32 = 0x783A9B23;
-  void init_between_bitboards();
+
-  Bitboard index_to_bitboard(int index, Bitboard mask);
+  CACHE_LINE_ALIGNMENT
-  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
+
-                           int fmin, int fmax, int rmin, int rmax);
+  int MS1BTable[256];
-  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
+  Square BSFTable[SQUARE_NB];
-                            const int shift[], const Bitboard mult[], int deltas[][2]);
+  Bitboard RTable[0x19000]; // Storage space for rook attacks
+  Bitboard BTable[0x1480];  // Storage space for bishop attacks
+
+  typedef unsigned (Fn)(Square, Bitboard);
+
+  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
+
+  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;
+  }
 }
 
+/// 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.
 
-/// print_bitboard() prints a bitboard in an easily readable format to the
+#ifndef USE_BSFQ
+
+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 msb(Bitboard b) {
+
+  unsigned b32;
+  int result = 0;
+
+  if (b > 0xFFFFFFFF)
+  {
+      b >>= 32;
+      result = 32;
+  }
+
+  b32 = unsigned(b);
+
+  if (b32 > 0xFFFF)
+  {
+      b32 >>= 16;
+      result += 16;
+  }
+
+  if (b32 > 0xFF)
+  {
+      b32 >>= 8;
+      result += 8;
+  }
+
+  return (Square)(result + MS1BTable[b32]);
+}
+
+#endif // ifndef USE_BSFQ
+
+
+/// Bitboards::print() prints a bitboard in an easily readable format to the
 /// standard output. This is sometimes useful for debugging.
 
-void print_bitboard(Bitboard b) {
+void Bitboards::print(Bitboard b) {
 
-  for (Rank r = RANK_8; r >= RANK_1; r--)
+  sync_cout;
+
+  for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {
       std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
-      for (File f = FILE_A; f <= FILE_H; f++)
+
-          std::cout << "| " << (bit_is_set(b, make_square(f, r)) ? 'X' : ' ') << ' ';
+      for (File file = FILE_A; file <= FILE_H; file++)
+          std::cout << "| " << (b & (file | rank) ? "X " : "  ");
 
       std::cout << "|\n";
   }
-  std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
+  std::cout << "+---+---+---+---+---+---+---+---+" << sync_endl;
 }
 
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// Bitboards::init() initializes various bitboard arrays. It is called during
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
-#if defined(IS_64BIT) && !defined(USE_BSFQ)
-
-static CACHE_LINE_ALIGNMENT
-const int BitTable[64] = {
-   0,  1,  2,  7,  3, 13,  8, 19,  4, 25, 14, 28,  9, 34, 20, 40,  5, 17, 26,
-  38, 15, 46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63,  6, 12, 18, 24, 27,
-  33, 39, 16, 37, 45, 47, 30, 53, 49, 56, 62, 11, 23, 32, 36, 44, 52, 55, 61,
-  22, 43, 51, 60, 42, 59, 58
-};
-
-Square first_1(Bitboard b) {
-  return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
-}
-
-Square pop_1st_bit(Bitboard* b) {
-  Bitboard bb = *b;
-  *b &= (*b - 1);
-  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
-}
-
-#elif !defined(USE_BSFQ)
-
-static CACHE_LINE_ALIGNMENT
-const int BitTable[64] = {
-  63, 30,  3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29,  2,
-  51, 21, 43, 45, 10, 18, 47,  1, 54,  9, 57,  0, 35, 62, 31, 40,  4, 49,  5,
-  52, 26, 60,  6, 23, 44, 46, 27, 56, 16,  7, 39, 48, 24, 59, 14, 12, 55, 38,
-  28, 58, 20, 37, 17, 36, 8
-};
-
-Square first_1(Bitboard b) {
-
-  b ^= (b - 1);
-  uint32_t fold = int(b) ^ int(b >> 32);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-// Use type-punning
-union b_union {
-
-    Bitboard b;
-    struct {
-#if defined (BIGENDIAN)
-        uint32_t h;
-        uint32_t l;
-#else
-        uint32_t l;
-        uint32_t h;
-#endif
-    } dw;
-};
-
-Square pop_1st_bit(Bitboard* bb) {
-
-   b_union u;
-   Square ret;
-
-   u.b = *bb;
-
-   if (u.dw.l)
-   {
-       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
-       u.dw.l &= (u.dw.l - 1);
-       *bb = u.b;
-       return ret;
-   }
-   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
-   u.dw.h &= (u.dw.h - 1);
-   *bb = u.b;
-   return ret;
-}
-
-#endif // !defined(USE_BSFQ)
-
-
-/// init_bitboards() initializes various bitboard arrays. It is called during
 /// program initialization.
 
-void init_bitboards() {
+void Bitboards::init() {
 
-  int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+  for (int k = 0, i = 0; i < 8; i++)
-  int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
+      while (k < (2 << i))
+          MS1BTable[k++] = i;
 
-  init_masks();
+  for (int i = 0; i < 64; i++)
-  init_step_attacks();
+      BSFTable[bsf_index(1ULL << i)] = Square(i);
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
+
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
+  for (Square s = SQ_A1; s <= SQ_H8; s++)
-  init_pseudo_attacks();
+      SquareBB[s] = 1ULL << s;
-  init_between_bitboards();
+
+  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;
+  }
+
+  for (File f = FILE_A; f <= FILE_H; f++)
+      AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+
+  for (Rank r = RANK_1; r < RANK_8; r++)
+      InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
+
+  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)];
+          PawnAttackSpan[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+          PassedPawnMask[c][s] = ForwardBB[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));
+          if (s1 != s2)
+             DistanceRingsBB[s1][SquareDistance[s1][s2] - 1] |= s2;
+      }
+
+  int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
+                     {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
+
+  for (Color c = WHITE; c <= BLACK; c++)
+      for (PieceType pt = PAWN; pt <= KING; pt++)
+          for (Square s = SQ_A1; s <= SQ_H8; s++)
+              for (int k = 0; steps[pt][k]; k++)
+              {
+                  Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
+
+                  if (is_ok(to) && square_distance(s, to) < 3)
+                      StepAttacksBB[make_piece(c, pt)][s] |= to;
+              }
+
+  Square RDeltas[] = { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  };
+  Square BDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
+
+  init_magics(RTable, RAttacks, RMagics, RMasks, RShifts, RDeltas, magic_index<ROOK>);
+  init_magics(BTable, BAttacks, BMagics, BMasks, BShifts, BDeltas, magic_index<BISHOP>);
+
+  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  {
+      PseudoAttacks[QUEEN][s]  = PseudoAttacks[BISHOP][s] = attacks_bb<BISHOP>(s, 0);
+      PseudoAttacks[QUEEN][s] |= PseudoAttacks[  ROOK][s] = attacks_bb<  ROOK>(s, 0);
+  }
+
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+          if (PseudoAttacks[QUEEN][s1] & s2)
+          {
+              Square delta = (s2 - s1) / square_distance(s1, s2);
+
+              for (Square s = s1 + delta; s != s2; s += delta)
+                  BetweenBB[s1][s2] |= s;
+          }
 }
 
+
 namespace {
 
-  // All functions below are used to precompute various bitboards during
+  Bitboard sliding_attack(Square deltas[], Square sq, Bitboard occupied) {
-  // program initialization.  Some of the functions may be difficult to
-  // understand, but they all seem to work correctly, and it should never
-  // be necessary to touch any of them.
 
-  void init_masks() {
+    Bitboard attack = 0;
-
-    SquaresByColorBB[DARK]  =  0xAA55AA55AA55AA55ULL;
-    SquaresByColorBB[LIGHT] = ~SquaresByColorBB[DARK];
-
-    FileBB[FILE_A] = FileABB;
-    RankBB[RANK_1] = Rank1BB;
-
-    for (int f = FILE_B; f <= FILE_H; f++)
-    {
-        FileBB[f] = FileBB[f - 1] << 1;
-        RankBB[f] = RankBB[f - 1] << 8;
-    }
-
-    for (int f = FILE_A; f <= FILE_H; f++)
-    {
-        NeighboringFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
-        ThisAndNeighboringFilesBB[f] = FileBB[f] | NeighboringFilesBB[f];
-    }
-
-    for (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
-    {
-        InFrontBB[WHITE][rw] = InFrontBB[WHITE][rw + 1] | RankBB[rw + 1];
-        InFrontBB[BLACK][rb] = InFrontBB[BLACK][rb - 1] | RankBB[rb - 1];
-    }
-
-    SetMaskBB[SQ_NONE] = EmptyBoardBB;
-    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
-
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
-    {
-        SetMaskBB[s] = (1ULL << s);
-        ClearMaskBB[s] = ~SetMaskBB[s];
-    }
-
-    for (Color c = WHITE; c <= BLACK; c++)
-        for (Square s = SQ_A1; s <= SQ_H8; s++)
-        {
-            SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
-            PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s);
-            AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
-        }
-
-    for (Bitboard b = 0; b < 256; b++)
-        BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
-  }
-
-  void init_step_attacks() {
-
-    const int step[][9] =  {
-      {0},
-      {7,9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
-      {9,7,-7,-9,8,1,-1,-8,0}, {0}, {0},
-      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
-      {9,7,-7,-9,8,1,-1,-8,0}
-    };
-
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
-        for (Piece pc = WP; pc <= BK; pc++)
-            for (int k = 0; step[pc][k] != 0; k++)
-            {
-                Square to = s + Square(step[pc][k]);
-
-                if (square_is_ok(to) && square_distance(s, to) < 3)
-                    set_bit(&StepAttacksBB[pc][s], to);
-           }
-  }
-
-  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
-                           int fmin, int fmax, int rmin, int rmax) {
-    int dx, dy, f, r;
-    int rk = sq / 8;
-    int fl = sq % 8;
-    Bitboard attacks = EmptyBoardBB;
 
     for (int i = 0; i < 4; i++)
-    {
+        for (Square s = sq + deltas[i];
-        dx = deltas[i][0];
+             is_ok(s) && square_distance(s, s - deltas[i]) == 1;
-        dy = deltas[i][1];
+             s += deltas[i])
-        f = fl + dx;
-        r = rk + dy;
-
-        while (   (dx == 0 || (f >= fmin && f <= fmax))
-               && (dy == 0 || (r >= rmin && r <= rmax)))
         {
-            attacks |= (1ULL << (f + r * 8));
+            attack |= s;
 
-            if (occupied & (1ULL << (f + r * 8)))
+            if (occupied & s)
                 break;
-
-            f += dx;
-            r += dy;
         }
-    }
+
-    return attacks;
+    return attack;
   }
 
-  Bitboard index_to_bitboard(int index, Bitboard mask) {
 
-    Bitboard result = EmptyBoardBB;
+  Bitboard pick_random(RKISS& rk, int booster) {
-    int sq, cnt = 0;
 
-    while (mask)
+    // Values s1 and s2 are used to rotate the candidate magic of a
-    {
+    // quantity known to be the optimal to quickly find the magics.
-        sq = pop_1st_bit(&mask);
+    int s1 = booster & 63, s2 = (booster >> 6) & 63;
 
-        if (index & (1 << cnt++))
+    Bitboard m = rk.rand<Bitboard>();
-            result |= (1ULL << sq);
+    m = (m >> s1) | (m << (64 - s1));
-    }
+    m &= rk.rand<Bitboard>();
-    return result;
+    m = (m >> s2) | (m << (64 - s2));
+    return m & rk.rand<Bitboard>();
   }
 
-  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
-                            const int shift[], const Bitboard mult[], int deltas[][2]) {
-    Bitboard b, v;
-    int i, j, index;
 
-    for (i = index = 0; i < 64; i++)
+  // 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
-        attackIndex[i] = index;
+  // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
-        mask[i] = sliding_attacks(i, 0, deltas, 1, 6, 1, 6);
+  // use the so called "fancy" approach.
-        j = 1 << ((CpuIs64Bit ? 64 : 32) - shift[i]);
 
-        for (int k = 0; k < j; k++)
+  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-        {
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
-            b = index_to_bitboard(k, mask[i]);
-            v = CpuIs64Bit ? b * mult[i] : unsigned(b * mult[i] ^ (b >> 32) * (mult[i] >> 32));
-            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, deltas, 0, 7, 0, 7);
-        }
-        index += j;
-    }
-  }
 
-  void init_pseudo_attacks() {
+    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;
+
+    // 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++)
     {
-        BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
+        // Board edges are not considered in the relevant occupancies
-        RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
+        edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
-        QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);
+
+        // Given a square 's', the mask is the bitboard of sliding attacks from
+        // 's' computed on an empty board. The index must be big enough to contain
+        // 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]);
+
+        // 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];
+        } 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;
+
+        booster = MagicBoosters[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);
+
+            std::memset(attacks[s], 0, size * sizeof(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++)
+            {
+                Bitboard& attack = attacks[s][index(s, occupancy[i])];
+
+                if (attack && attack != reference[i])
+                    break;
+
+                assert(reference[i] != 0);
+
+                attack = reference[i];
+            }
+        } while (i != size);
     }
   }
-
-  void init_between_bitboards() {
-
-    Square s1, s2, s3, d;
-    int f, r;
-
-    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
-        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
-            if (bit_is_set(QueenPseudoAttacks[s1], s2))
-            {
-                f = file_distance(s1, s2);
-                r = rank_distance(s1, s2);
-
-                d = (s2 - s1) / Max(f, r);
-
-                for (s3 = s1 + d; s3 != s2; s3 += d)
-                    set_bit(&(BetweenBB[s1][s2]), s3);
-            }
-  }
-
 }

src/bitboard.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -18,12 +18,24 @@
   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 "types.h"
 
-const Bitboard EmptyBoardBB = 0;
+namespace Bitboards {
+
+void init();
+void print(Bitboard b);
+
+}
+
+namespace Bitbases {
+
+void init_kpk();
+bool probe_kpk(Square wksq, Square wpsq, Square bksq, Color us);
+
+}
 
 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = FileABB << 1;
@@ -43,67 +55,84 @@ const Bitboard Rank6BB = Rank1BB << (8 * 5);
 const Bitboard Rank7BB = Rank1BB << (8 * 6);
 const Bitboard Rank8BB = Rank1BB << (8 * 7);
 
-extern Bitboard SquaresByColorBB[2];
+CACHE_LINE_ALIGNMENT
-extern Bitboard FileBB[8];
-extern Bitboard NeighboringFilesBB[8];
-extern Bitboard ThisAndNeighboringFilesBB[8];
-extern Bitboard RankBB[8];
-extern Bitboard InFrontBB[2][8];
 
-extern Bitboard SetMaskBB[65];
+extern Bitboard RMasks[SQUARE_NB];
-extern Bitboard ClearMaskBB[65];
+extern Bitboard RMagics[SQUARE_NB];
+extern Bitboard* RAttacks[SQUARE_NB];
+extern unsigned RShifts[SQUARE_NB];
 
-extern Bitboard StepAttacksBB[16][64];
+extern Bitboard BMasks[SQUARE_NB];
-extern Bitboard BetweenBB[64][64];
+extern Bitboard BMagics[SQUARE_NB];
+extern Bitboard* BAttacks[SQUARE_NB];
+extern unsigned BShifts[SQUARE_NB];
 
-extern Bitboard SquaresInFrontMask[2][64];
+extern Bitboard SquareBB[SQUARE_NB];
-extern Bitboard PassedPawnMask[2][64];
+extern Bitboard FileBB[FILE_NB];
-extern Bitboard AttackSpanMask[2][64];
+extern Bitboard RankBB[RANK_NB];
+extern Bitboard AdjacentFilesBB[FILE_NB];
+extern Bitboard InFrontBB[COLOR_NB][RANK_NB];
+extern Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+extern Bitboard DistanceRingsBB[SQUARE_NB][8];
+extern Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
 
-extern const uint64_t RMult[64];
+extern int SquareDistance[SQUARE_NB][SQUARE_NB];
-extern const int RShift[64];
-extern Bitboard RMask[64];
-extern int RAttackIndex[64];
-extern Bitboard RAttacks[0x19000];
 
-extern const uint64_t BMult[64];
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
-extern const int BShift[64];
-extern Bitboard BMask[64];
-extern int BAttackIndex[64];
-extern Bitboard BAttacks[0x1480];
 
-extern Bitboard BishopPseudoAttacks[64];
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
-extern Bitboard RookPseudoAttacks[64];
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
-extern Bitboard QueenPseudoAttacks[64];
 
-extern uint8_t BitCount8Bit[256];
+inline Bitboard operator&(Bitboard b, Square s) {
-
+  return b & SquareBB[s];
-
-/// Functions for testing whether a given bit is set in a bitboard, and for
-/// setting and clearing bits.
-
-inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & SetMaskBB[s];
 }
 
-inline void set_bit(Bitboard *b, Square s) {
+inline Bitboard& operator|=(Bitboard& b, Square s) {
-  *b |= SetMaskBB[s];
+  return b |= SquareBB[s];
 }
 
-inline void clear_bit(Bitboard *b, Square s) {
+inline Bitboard& operator^=(Bitboard& b, Square s) {
-  *b &= ClearMaskBB[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 bool more_than_one(Bitboard b) {
+  return b & (b - 1);
+}
+
+inline int square_distance(Square s1, Square s2) {
+  return SquareDistance[s1][s2];
+}
+
+inline int file_distance(Square s1, Square s2) {
+  return abs(file_of(s1) - file_of(s2));
+}
+
+inline int rank_distance(Square s1, Square s2) {
+  return abs(rank_of(s1) - rank_of(s2));
 }
 
 
-/// Functions used to update a bitboard after a move. This is faster
+/// shift_bb() moves bitboard one step along direction Delta. Mainly for pawns.
-/// then calling a sequence of clear_bit() + set_bit()
 
-inline Bitboard make_move_bb(Square from, Square to) {
+template<Square Delta>
-  return SetMaskBB[from] | SetMaskBB[to];
+inline Bitboard shift_bb(Bitboard b) {
-}
 
-inline void do_move_bb(Bitboard *b, Bitboard move_bb) {
+  return  Delta == DELTA_N  ?  b             << 8 : Delta == DELTA_S  ?  b             >> 8
-  *b ^= move_bb;
+        : Delta == DELTA_NE ? (b & ~FileHBB) << 9 : Delta == DELTA_SE ? (b & ~FileHBB) >> 7
+        : Delta == DELTA_NW ? (b & ~FileABB) << 7 : Delta == DELTA_SW ? (b & ~FileABB) >> 9
+        : 0;
 }
 
 
@@ -115,7 +144,7 @@ inline Bitboard rank_bb(Rank r) {
 }
 
 inline Bitboard rank_bb(Square s) {
-  return RankBB[square_rank(s)];
+  return RankBB[rank_of(s)];
 }
 
 inline Bitboard file_bb(File f) {
@@ -123,173 +152,171 @@ inline Bitboard file_bb(File f) {
 }
 
 inline Bitboard file_bb(Square s) {
-  return FileBB[square_file(s)];
+  return FileBB[file_of(s)];
 }
 
 
-/// neighboring_files_bb takes a file or a square as input and returns a
+/// adjacent_files_bb() takes a file as input and returns a bitboard representing
-/// bitboard representing all squares on the neighboring files.
+/// all squares on the adjacent files.
 
-inline Bitboard neighboring_files_bb(File f) {
+inline Bitboard adjacent_files_bb(File f) {
-  return NeighboringFilesBB[f];
+  return AdjacentFilesBB[f];
-}
-
-inline Bitboard neighboring_files_bb(Square s) {
-  return NeighboringFilesBB[square_file(s)];
 }
 
 
-/// this_and_neighboring_files_bb takes a file or a square as input and returns
+/// in_front_bb() takes a color and a rank as input, and returns a bitboard
-/// a bitboard representing all squares on the given and neighboring files.
+/// representing all the squares on all ranks in front of the rank, from the
-
+/// given color's point of view. For instance, in_front_bb(BLACK, RANK_3) will
-inline Bitboard this_and_neighboring_files_bb(File f) {
+/// give all squares on ranks 1 and 2.
-  return ThisAndNeighboringFilesBB[f];
-}
-
-inline Bitboard this_and_neighboring_files_bb(Square s) {
-  return ThisAndNeighboringFilesBB[square_file(s)];
-}
-
-
-/// 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][square_rank(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.
 
-/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
+inline Bitboard between_bb(Square s1, Square s2) {
-/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
-/// bitboard of occupied squares as input, and return a bitboard representing
-/// all squares attacked by a rook, bishop or queen on the given square.
-
-#if defined(IS_64BIT)
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
-}
-
-#else // if !defined(IS_64BIT)
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] +
-        (unsigned(int(b) * int(RMult[s]) ^ int(b >> 32) * int(RMult[s] >> 32)) >> RShift[s])];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] +
-        (unsigned(int(b) * int(BMult[s]) ^ int(b >> 32) * int(BMult[s] >> 32)) >> BShift[s])];
-}
-
-#endif
-
-inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
-  return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
-}
-
-
-/// squares_between returns a bitboard representing all squares between
-/// two squares.  For instance, squares_between(SQ_C4, SQ_F7) returns a
-/// bitboard with the bits for square d5 and e6 set.  If s1 and s2 are not
-/// on the same line, file or diagonal, EmptyBoardBB is returned.
-
-inline Bitboard squares_between(Square s1, Square s2) {
   return BetweenBB[s1][s2];
 }
 
 
-/// squares_in_front_of takes a color and a square as input, and returns a
+/// forward_bb() takes a color and a square as input, and returns a bitboard
-/// bitboard representing all squares along the line in front of the square,
+/// representing all squares along the line in front of the square, from the
-/// from the point of view of the given color. Definition of the table is:
+/// point of view of the given color. Definition of the table is:
-/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
+/// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
 
-inline Bitboard squares_in_front_of(Color c, Square s) {
+inline Bitboard forward_bb(Color c, Square s) {
-  return SquaresInFrontMask[c][s];
+  return ForwardBB[c][s];
 }
 
 
-/// passed_pawn_mask takes a color and a square as input, and returns a
+/// pawn_attack_span() 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:
+/// PawnAttackSpan[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
+
+inline Bitboard pawn_attack_span(Color c, Square s) {
+  return PawnAttackSpan[c][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_neighboring_files_bb(s)
+/// PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_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
+/// squares_of_color() returns a bitboard representing all squares with the same
-/// representing all squares that can be attacked by a pawn of the given color
+/// color of the given square.
-/// when it moves along its file starting from the given square. Definition is:
-/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
 
-inline Bitboard attack_span_mask(Color c, Square s) {
+inline Bitboard squares_of_color(Square s) {
-  return AttackSpanMask[c][s];
+  return DarkSquares & s ? DarkSquares : ~DarkSquares;
 }
 
 
-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// squares_aligned() returns true if the squares s1, s2 and s3 are aligned
 /// either on a straight or on a diagonal line.
 
 inline bool squares_aligned(Square s1, Square s2, Square s3) {
   return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
-        & ((1ULL << s1) | (1ULL << s2) | (1ULL << s3));
+        & (     SquareBB[s1] |      SquareBB[s2] |      SquareBB[s3]);
 }
 
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// Functions for computing sliding attack bitboards. Function attacks_bb() takes
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
+/// a square and a bitboard of occupied squares as input, and returns a bitboard
-/// nonzero 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) {
 
-#if defined(USE_BSFQ)
+  Bitboard* const Masks  = Pt == ROOK ? RMasks  : BMasks;
+  Bitboard* const Magics = Pt == ROOK ? RMagics : BMagics;
+  unsigned* const Shifts = Pt == ROOK ? RShifts : BShifts;
 
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+  if (Is64Bit)
+      return unsigned(((occ & Masks[s]) * Magics[s]) >> Shifts[s]);
 
-FORCE_INLINE Square first_1(Bitboard b) {
+  unsigned lo = unsigned(occ) & unsigned(Masks[s]);
-   unsigned long index;
+  unsigned hi = unsigned(occ >> 32) & unsigned(Masks[s] >> 32);
-   _BitScanForward64(&index, b);
+  return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
-   return (Square) index;
 }
-#else
 
-FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
+template<PieceType Pt>
-  Bitboard dummy;
+inline Bitboard attacks_bb(Square s, Bitboard occ) {
-  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
+  return (Pt == ROOK ? RAttacks : BAttacks)[s][magic_index<Pt>(s, occ)];
-  return (Square) dummy;
 }
-#endif
 
-FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
+
-  const Square s = first_1(*b);
+/// lsb()/msb() finds the least/most significant bit in a nonzero bitboard.
-  *b &= ~(1ULL<<s);
+/// pop_lsb() finds and clears the least significant bit in a nonzero bitboard.
+
+#ifdef USE_BSFQ
+
+#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+
+FORCE_INLINE Square lsb(Bitboard b) {
+  unsigned long index;
+  _BitScanForward64(&index, b);
+  return (Square) index;
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+  unsigned long index;
+  _BitScanReverse64(&index, b);
+  return (Square) index;
+}
+
+#  elif defined(__arm__)
+
+FORCE_INLINE int lsb32(uint32_t v) {
+  __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
+  return __builtin_clz(v);
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+  return (Square) (63 - __builtin_clzll(b));
+}
+
+FORCE_INLINE Square lsb(Bitboard b) {
+  return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+}
+
+#  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;
+}
+
+FORCE_INLINE Square msb(Bitboard b) {
+  Bitboard index;
+  __asm__("bsrq %1, %0": "=r"(index): "rm"(b) );
+  return (Square) index;
+}
+
+#  endif
+
+FORCE_INLINE Square pop_lsb(Bitboard* b) {
+  const Square s = lsb(*b);
+  *b &= *b - 1;
   return s;
 }
 
-#else // if !defined(USE_BSFQ)
+#else // if defined(USE_BSFQ)
 
-extern Square first_1(Bitboard b);
+extern Square msb(Bitboard b);
-extern Square pop_1st_bit(Bitboard* b);
+extern Square lsb(Bitboard b);
+extern Square pop_lsb(Bitboard* b);
 
 #endif
 
-
+#endif // #ifndef BITBOARD_H_INCLUDED
-extern void print_bitboard(Bitboard b);
-extern void init_bitboards();
-
-#endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -18,81 +18,88 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(BITCOUNT_H_INCLUDED)
+#ifndef BITCOUNT_H_INCLUDED
 #define BITCOUNT_H_INCLUDED
 
+#include <cassert>
 #include "types.h"
 
 enum BitCountType {
-    CNT64,
+  CNT_64,
-    CNT64_MAX15,
+  CNT_64_MAX15,
-    CNT32,
+  CNT_32,
-    CNT32_MAX15,
+  CNT_32_MAX15,
-    CNT_POPCNT
+  CNT_HW_POPCNT
 };
 
-/// count_1s() counts the number of nonzero bits in a bitboard.
+/// Determine at compile time the best popcount<> specialization according if
-/// We have different optimized versions according if platform
+/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count
-/// is 32 or 64 bits, and to the maximum number of nonzero bits.
+/// and if hardware popcnt instruction is available.
-/// We also support hardware popcnt instruction. See Readme.txt
+const BitCountType Full  = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64 : CNT_32;
-/// on how to pgo compile with popcnt support.
+const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;
-template<BitCountType> inline int count_1s(Bitboard);
+
+
+/// popcount() counts the number of nonzero bits in a bitboard
+template<BitCountType> inline int popcount(Bitboard);
 
 template<>
-inline int count_1s<CNT64>(Bitboard b) {
+inline int popcount<CNT_64>(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  b  = ((b >> 4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
+  return (b * 0x0101010101010101ULL) >> 56;
-  return int(b >> 56);
 }
 
 template<>
-inline int count_1s<CNT64_MAX15>(Bitboard b) {
+inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
+  b -=  (b >> 1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
+  return (b * 0x1111111111111111ULL) >> 60;
-  return int(b >> 60);
 }
 
 template<>
-inline int count_1s<CNT32>(Bitboard b) {
+inline int popcount<CNT_32>(Bitboard b) {
   unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  v -=  (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
+  w -=  (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  v  = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  w  = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
+  v  = ((v >> 4) + v + (w >> 4) + w) & 0x0F0F0F0F;
-  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  return (v * 0x01010101) >> 24;
-  v *= 0x01010101; // mul is fast on amd procs
-  return int(v >> 24);
 }
 
 template<>
-inline int count_1s<CNT32_MAX15>(Bitboard b) {
+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
+  v -=  (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
+  w -=  (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  v  = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  w  = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v += w; // 0-8 in 4 bits
+  return ((v + w) * 0x11111111) >> 28;
-  v *= 0x11111111;
-  return int(v >> 28);
 }
 
 template<>
-inline int count_1s<CNT_POPCNT>(Bitboard b) {
+inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
-#if !defined(USE_POPCNT)
+
-  return int(b != 0); // Avoid 'b not used' warning
+#ifndef 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);
-#elif defined(__GNUC__)
+
-  unsigned long ret;
+#else
-  __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b));
+
-  return ret;
+  __asm__("popcnt %1, %0" : "=r" (b) : "r" (b));
+  return b;
+
 #endif
 }
 
-#endif // !defined(BITCOUNT_H_INCLUDED)
+#endif // #ifndef BITCOUNT_H_INCLUDED

src/book.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,25 +17,44 @@
   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 uint64_t Random64[781] = {
+  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,
@@ -297,229 +316,163 @@ namespace {
     0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
     0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
     0xF8D626AAAF278509ULL
-  };
+  }};
 
-  // Indices to the Random64[] array
+  // polyglot_key() returns the PolyGlot hash key of the given position
-  const int PieceIdx     = 0;
+  Key polyglot_key(const Position& pos) {
-  const int CastleIdx    = 768;
-  const int EnPassantIdx = 772;
-  const int TurnIdx      = 780;
 
-  // book_key() builds up a PolyGlot hash key out of a position
+    Key key = 0;
-  uint64_t book_key(const Position& pos) {
+    Bitboard b = pos.pieces();
-
-    // Piece offset is calculated as (64 * PolyPieceType + square), where
-    // PolyPieceType is: BP = 0, WP = 1, BN = 2, WN = 3 .... BK = 10, WK = 11
-    static const int PieceToPoly[] = { 0, 1, 3, 5, 7, 9, 11, 0, 0, 0, 2, 4, 6, 8, 10 };
-
-    uint64_t result = 0;
-    Bitboard b = pos.occupied_squares();
 
     while (b)
     {
-        Square s = pop_1st_bit(&b);
+        Square s = pop_lsb(&b);
-        int p = PieceToPoly[int(pos.piece_on(s))];
+        Piece p = pos.piece_on(s);
-        result ^= Random64[PieceIdx + 64 * p + int(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];
     }
 
-    if (pos.can_castle_kingside(WHITE))
+    b = pos.can_castle(ALL_CASTLES);
-        result ^= Random64[CastleIdx + 0];
 
-    if (pos.can_castle_queenside(WHITE))
+    while (b)
-        result ^= Random64[CastleIdx + 1];
+        key ^= PG.Zobrist.castle[pop_lsb(&b)];
-
-    if (pos.can_castle_kingside(BLACK))
-        result ^= Random64[CastleIdx + 2];
-
-    if (pos.can_castle_queenside(BLACK))
-        result ^= Random64[CastleIdx + 3];
 
     if (pos.ep_square() != SQ_NONE)
-        result ^= Random64[EnPassantIdx + square_file(pos.ep_square())];
+        key ^= PG.Zobrist.enpassant[file_of(pos.ep_square())];
 
     if (pos.side_to_move() == WHITE)
-        result ^= Random64[TurnIdx];
+        key ^= PG.Zobrist.turn;
 
-    return result;
+    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;
 }
 
 
-/// Book c'tor. Make random number generation less deterministic, for book moves
+/// open() tries to open a book file with the given name after closing any
-Book::Book() {
+/// exsisting one.
 
-  for (int i = abs(get_system_time() % 10000); i > 0; i--)
+bool PolyglotBook::open(const char* fName) {
-      RKiss.rand<unsigned>();
+
+  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();
 }
 
 
-/// Book destructor. Be sure file is closed before we leave.
+/// 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.
 
-Book::~Book() {
+Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) {
 
-  close();
+  if (fileName != fName && !open(fName.c_str()))
-}
-
-
-/// Book::close() closes the file only if it is open, otherwise
-/// we can end up in a little mess due to how std::ifstream works.
-
-void Book::close() {
-
-  if (bookFile.is_open())
-      bookFile.close();
-
-  bookName = "";
-}
-
-
-/// Book::open() opens a book file with a given file name
-
-void Book::open(const string& fileName) {
-
-  // Close old file before opening the new
-  close();
-
-  bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary);
-
-  // Silently return when asked to open a non-exsistent file
-  if (!bookFile.is_open())
-      return;
-
-  // Get the book size in number of entries
-  bookFile.seekg(0, ios::end);
-  bookSize = long(bookFile.tellg()) / sizeof(BookEntry);
-
-  if (!bookFile.good())
-  {
-      cerr << "Failed to open book file " << fileName << endl;
-      exit(EXIT_FAILURE);
-  }
-
-  // Set only if successful
-  bookName = fileName;
-}
-
-
-/// Book::get_move() gets a book move for a given position. Returns
-/// MOVE_NONE if no book move is found. If findBestMove is true then
-/// return always the highest rated book move.
-
-Move Book::get_move(const Position& pos, bool findBestMove) {
-
-  if (!bookFile.is_open() || bookSize == 0)
       return MOVE_NONE;
 
-  BookEntry entry;
+  Entry e;
-  int bookMove = MOVE_NONE;
+  uint16_t best = 0;
-  unsigned score, scoresSum = 0, bestScore = 0;
+  unsigned sum = 0;
-  uint64_t key = book_key(pos);
+  Move move = MOVE_NONE;
+  Key key = polyglot_key(pos);
 
-  // Choose a book move among the possible moves for the given position
+  seekg(find_first(key) * sizeof(Entry), ios_base::beg);
-  for (int idx = find_entry(key); idx < bookSize; idx++)
+
+  while (*this >> e, e.key == key && good())
   {
-      entry = read_entry(idx);
+      best = max(best, e.count);
+      sum += e.count;
 
-      if (entry.key != key)
+      // Choose book move according to its score. If a move has a very
-          break;
+      // high score it has higher probability to be choosen than a move
-
+      // with lower score. Note that first entry is always chosen.
-      score = entry.count;
+      if (   (sum && rkiss.rand<unsigned>() % sum < e.count)
-
+          || (pickBest && e.count == best))
-      if (!findBestMove)
+          move = Move(e.move);
-      {
-          // Choose book move according to its score. If a move has a very
-          // high score it has more probability to be choosen then a one with
-          // lower score. Note that first entry is always chosen.
-          scoresSum += score;
-          if (RKiss.rand<unsigned>() % scoresSum < score)
-              bookMove = entry.move;
-      }
-      else if (score > bestScore)
-      {
-          bestScore = score;
-          bookMove = entry.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-13-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
+  // bit 12-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
   //
-  // Castling moves follow "king captures rook" representation. So in case
+  // Castling moves follow "king captures rook" representation. So in case book
-  // book move is a promotion we have to convert to our representation, in
+  // move is a promotion we have to convert to our representation, in all the
-  // all other cases we can directly compare with a Move after having
+  // other cases we can directly compare with a Move after having masked out
-  // masked out special Move's flags that are not supported by PolyGlot.
+  // the special Move's flags (bit 14-15) that are not supported by PolyGlot.
-  int p = (bookMove >> 12) & 7;
+  int pt = (move >> 12) & 7;
+  if (pt)
+      move = make<PROMOTION>(from_sq(move), to_sq(move), PieceType(pt + 1));
 
-  if (p)
+  // Add 'special move' flags and verify it is legal
-      bookMove = int(make_promotion_move(move_from(Move(bookMove)),
+  for (MoveList<LEGAL> it(pos); *it; ++it)
-                 move_to(Move(bookMove)), PieceType(p + 1)));
+      if (move == (*it ^ type_of(*it)))
-
+          return *it;
-  // Verify the book move (if any) is legal
-  MoveStack mlist[MAX_MOVES];
-  MoveStack* last = generate<MV_LEGAL>(pos, mlist);
-  for (MoveStack* cur = mlist; cur != last; cur++)
-      if ((int(cur->move) & ~(3 << 14)) == bookMove) // Mask out special flags
-          return cur->move;
 
   return MOVE_NONE;
 }
 
 
-/// Book::find_entry() takes a book key as input, and does a binary search
+/// find_first() takes a book key as input, and does a binary search through
-/// through the book file for the given key. The index to the first book
+/// the book file for the given key. Returns the index of the leftmost book
-/// entry with the same key as the input is returned. When the key is not
+/// entry with the same key as the input.
-/// found in the book file, bookSize is returned.
 
-int Book::find_entry(uint64_t key) {
+size_t PolyglotBook::find_first(Key key) {
 
-  int left, right, mid;
+  seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size
 
-  // Binary search (finds the leftmost entry)
+  size_t low = 0, mid, high = (size_t)tellg() / sizeof(Entry) - 1;
-  left = 0;
+  Entry e;
-  right = bookSize - 1;
 
-  assert(left <= right);
+  assert(low <= high);
 
-  while (left < right)
+  while (low < high && good())
   {
-      mid = (left + right) / 2;
+      mid = (low + high) / 2;
 
-      assert(mid >= left && mid < right);
+      assert(mid >= low && mid < high);
 
-      if (key <= read_entry(mid).key)
+      seekg(mid * sizeof(Entry), ios_base::beg);
-          right = mid;
+      *this >> e;
+
+      if (key <= e.key)
+          high = mid;
       else
-          left = mid + 1;
+          low = mid + 1;
   }
 
-  assert(left == right);
+  assert(low == high);
 
-  return read_entry(left).key == key ? left : bookSize;
+  return low;
-}
-
-
-/// Book::read_entry() takes an integer index, and returns the BookEntry
-/// at the given index in the book file.
-
-BookEntry Book::read_entry(int idx) {
-
-  assert(idx >= 0 && idx < bookSize);
-  assert(bookFile.is_open());
-
-  BookEntry e;
-
-  bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg);
-
-  *this >> e.key >> e.move >> e.count >> e.learn;
-
-  if (!bookFile.good())
-  {
-      cerr << "Failed to read book entry at index " << idx << endl;
-      exit(EXIT_FAILURE);
-  }
-  return e;
 }

src/book.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,55 +17,29 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(BOOK_H_INCLUDED)
+#ifndef BOOK_H_INCLUDED
 #define BOOK_H_INCLUDED
 
 #include <fstream>
 #include <string>
 
-#include "move.h"
 #include "position.h"
 #include "rkiss.h"
 
-
+class PolyglotBook : private std::ifstream {
-// A Polyglot book is a series of "entries" of 16 bytes. All integers are
-// stored highest byte first (regardless of size). The entries are ordered
-// according to key. Lowest key first.
-struct BookEntry {
-  uint64_t key;
-  uint16_t move;
-  uint16_t count;
-  uint32_t learn;
-};
-
-class Book {
 public:
-  Book();
+  PolyglotBook();
-  ~Book();
+ ~PolyglotBook();
-  void open(const std::string& fileName);
+  Move probe(const Position& pos, const std::string& fName, bool pickBest);
-  void close();
-  Move get_move(const Position& pos, bool findBestMove);
-  const std::string name() const { return bookName; }
 
 private:
-  // read n chars from the file stream and converts them in an
+  template<typename T> PolyglotBook& operator>>(T& n);
-  // integer number. Integers are stored with highest byte first.
-  template<int n> uint64_t get_int();
 
-  template<typename T>
+  bool open(const char* fName);
-  Book& operator>>(T& n) { n = (T)get_int<sizeof(T)>(); return *this; }
+  size_t find_first(Key key);
 
-  BookEntry read_entry(int idx);
+  RKISS rkiss;
-  int find_entry(uint64_t key);
+  std::string fileName;
-
-  std::ifstream bookFile;
-  std::string bookName;
-  int bookSize;
-  RKISS RKiss;
 };
 
-// Yes, we indulge a bit here ;-)
+#endif // #ifndef BOOK_H_INCLUDED
-template<int n> inline uint64_t Book::get_int() { return 256 * get_int<n-1>() + bookFile.get(); }
-template<> inline uint64_t Book::get_int<1>() { return bookFile.get(); }
-
-#endif // !defined(BOOK_H_INCLUDED)

src/endgame.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,11 +17,11 @@
   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 <string>
 #include <map>
+#include <string>
 
 #include "position.h"
 #include "types.h"
@@ -33,19 +33,24 @@ enum EndgameType {
 
   // Evaluation functions
 
+  KK,    // K vs K
+  KBK,   // KB vs K
+  KNK,   // KN vs K
+  KNNK,  // KNN vs K
   KXK,   // Generic "mate lone king" eval
   KBNK,  // KBN vs K
   KPK,   // KP vs K
   KRKP,  // KR vs KP
   KRKB,  // KR vs KB
   KRKN,  // KR vs KN
+  KQKP,  // KQ vs KP
   KQKR,  // KQ vs KR
   KBBKN, // KBB vs KN
-  KNNK,  // KNN vs K
   KmmKm, // K and two minors vs K and one or two minors
 
 
   // Scaling functions
+  SCALE_FUNS,
 
   KBPsK,   // KB+pawns vs K
   KQKRPs,  // KQ vs KR+pawns
@@ -56,29 +61,36 @@ enum EndgameType {
   KBPPKB,  // KBPP vs KB
   KBPKN,   // KBP vs KN
   KNPK,    // KNP vs K
+  KNPKB,   // KNP vs KB
   KPKP     // KP vs KP
 };
 
 
+/// 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; };
+
+
 /// Base and derived templates for endgame evaluation and scaling functions
 
 template<typename T>
 struct EndgameBase {
 
-  typedef EndgameBase<T> Base;
-
   virtual ~EndgameBase() {}
   virtual Color color() const = 0;
-  virtual T apply(const Position&) const = 0;
+  virtual T operator()(const Position&) const = 0;
 };
 
 
-template<typename T, EndgameType>
+template<EndgameType E, typename T = typename eg_fun<(E > SCALE_FUNS)>::type>
 struct Endgame : public EndgameBase<T> {
 
-  explicit Endgame(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
+  explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {}
   Color color() const { return strongerSide; }
-  T apply(const Position&) const;
+  T operator()(const Position&) const;
 
 private:
   Color strongerSide, weakerSide;
@@ -87,26 +99,27 @@ private:
 
 /// 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 apply() method that is virtual.
+/// endgame function calling its operator() that is virtual.
 
 class Endgames {
 
-  typedef std::map<Key, EndgameBase<Value>* > EFMap;
+  typedef std::map<Key, EndgameBase<eg_fun<0>::type>*> M1;
-  typedef std::map<Key, EndgameBase<ScaleFactor>* > SFMap;
+  typedef std::map<Key, EndgameBase<eg_fun<1>::type>*> M2;
+
+  M1 m1;
+  M2 m2;
+
+  M1& map(M1::mapped_type) { return m1; }
+  M2& map(M2::mapped_type) { return m2; }
+
+  template<EndgameType E> void add(const std::string& code);
 
 public:
   Endgames();
-  ~Endgames();
+ ~Endgames();
-  template<class T> T* get(Key key) const;
 
-private:
+  template<typename T> T probe(Key key, T& eg)
-  template<class T> void add(const std::string& keyCode);
+  { return eg = map(eg).count(key) ? map(eg)[key] : NULL; }
-
-  // Here we store two maps, for evaluate and scaling functions...
-  std::pair<EFMap, SFMap> maps;
-
-  // ...and here is the accessing template function
-  template<typename T> const std::map<Key, T*>& get() const;
 };
 
-#endif // !defined(ENDGAME_H_INCLUDED)
+#endif // #ifndef ENDGAME_H_INCLUDED

src/evaluate.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,15 +17,19 @@
   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 "types.h"
 
 class Position;
 
-extern Value evaluate(const Position& pos, Value& margin);
+namespace Eval {
-extern std::string trace_evaluate(const Position& pos);
-extern void read_evaluation_uci_options(Color sideToMove);
 
-#endif // !defined(EVALUATE_H_INCLUDED)
+extern void init();
+extern Value evaluate(const Position& pos, Value& margin);
+extern std::string trace(const Position& pos);
+
+}
+
+#endif // #ifndef EVALUATE_H_INCLUDED

src/history.h

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

src/lock.h

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

src/main.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,71 +17,36 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// To profile with callgrind uncomment following line
-//#define USE_CALLGRIND
-
-#include <cstdio>
 #include <iostream>
 #include <string>
 
 #include "bitboard.h"
 #include "evaluate.h"
 #include "position.h"
-#include "thread.h"
 #include "search.h"
+#include "thread.h"
+#include "tt.h"
 #include "ucioption.h"
 
-#ifdef USE_CALLGRIND
-#include <valgrind/callgrind.h>
-#endif
-
-using namespace std;
-
-extern bool execute_uci_command(const string& cmd);
-extern void benchmark(int argc, char* argv[]);
-extern void init_kpk_bitbase();
-
 int main(int argc, char* argv[]) {
 
-  // Disable IO buffering for C and C++ standard libraries
+  std::cout << engine_info() << std::endl;
-  setvbuf(stdin, NULL, _IONBF, 0);
-  setvbuf(stdout, NULL, _IONBF, 0);
-  cout.rdbuf()->pubsetbuf(NULL, 0);
-  cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  // Startup initializations
+  UCI::init(Options);
-  init_bitboards();
+  Bitboards::init();
-  Position::init_zobrist();
+  Position::init();
-  Position::init_piece_square_tables();
+  Bitbases::init_kpk();
-  init_kpk_bitbase();
+  Search::init();
-  init_search();
+  Eval::init();
   Threads.init();
+  TT.set_size(Options["Hash"]);
 
-#ifdef USE_CALLGRIND
+  std::string args;
-  CALLGRIND_START_INSTRUMENTATION;
-#endif
 
-  if (argc < 2)
+  for (int i = 1; i < argc; i++)
-  {
+      args += std::string(argv[i]) + " ";
-      // Print copyright notice
-      cout << engine_name() << " by " << engine_authors() << endl;
 
-      if (CpuHasPOPCNT)
+  UCI::loop(args);
-          cout << "Good! CPU has hardware POPCNT." << endl;
-
-      // Wait for a command from the user, and passes this command to
-      // execute_uci_command() and also intercepts EOF from stdin to
-      // ensure that we exit gracefully if the GUI dies unexpectedly.
-      string cmd;
-      while (getline(cin, cmd) && execute_uci_command(cmd)) {}
-  }
-  else if (string(argv[1]) == "bench" && argc < 8)
-      benchmark(argc, argv);
-  else
-      cout << "Usage: stockfish bench [hash size = 128] [threads = 1] "
-           << "[limit = 12] [fen positions file = default] "
-           << "[limited by depth, time, nodes or perft = depth]" << endl;
 
   Threads.exit();
-  return 0;
 }

src/material.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,6 +17,7 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>  // For std::min
 #include <cassert>
 #include <cstring>
 
@@ -34,116 +35,156 @@ namespace {
   const int NoPawnsSF[4] = { 6, 12, 32 };
 
   // Polynomial material balance parameters
-  const Value RedundantQueenPenalty = Value(320);
+  const Value RedundantQueen = Value(320);
-  const Value RedundantRookPenalty  = Value(554);
+  const Value RedundantRook  = Value(554);
 
-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+  //                                  pair  pawn knight bishop rook queen
+  const int LinearCoefficients[6] = { 1617, -162, -1172, -190,  105,  26 };
 
-  const int QuadraticCoefficientsSameColor[][8] = {
+  const int QuadraticCoefficientsSameColor[][PIECE_TYPE_NB] = {
-  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
+    // pair pawn knight bishop rook queen
-  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
+    {   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
+  };
 
-  const int QuadraticCoefficientsOppositeColor[][8] = {
+  const int QuadraticCoefficientsOppositeColor[][PIECE_TYPE_NB] = {
-  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
+    //           THEIR PIECES
-  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+    // 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
+  };
 
   // Endgame evaluation and scaling functions accessed direcly and not through
   // the function maps because correspond to more then one material hash key.
-  Endgame<Value, KmmKm> EvaluateKmmKm[] = { Endgame<Value, KmmKm>(WHITE), Endgame<Value, KmmKm>(BLACK) };
+  Endgame<KmmKm> EvaluateKmmKm[] = { Endgame<KmmKm>(WHITE), Endgame<KmmKm>(BLACK) };
-  Endgame<Value, KXK>   EvaluateKXK[]   = { Endgame<Value, KXK>(WHITE),   Endgame<Value, KXK>(BLACK) };
+  Endgame<KXK>   EvaluateKXK[]   = { Endgame<KXK>(WHITE),   Endgame<KXK>(BLACK) };
 
-  Endgame<ScaleFactor, KBPsK>  ScaleKBPsK[]  = { Endgame<ScaleFactor, KBPsK>(WHITE),  Endgame<ScaleFactor, KBPsK>(BLACK) };
+  Endgame<KBPsK>  ScaleKBPsK[]  = { Endgame<KBPsK>(WHITE),  Endgame<KBPsK>(BLACK) };
-  Endgame<ScaleFactor, KQKRPs> ScaleKQKRPs[] = { Endgame<ScaleFactor, KQKRPs>(WHITE), Endgame<ScaleFactor, KQKRPs>(BLACK) };
+  Endgame<KQKRPs> ScaleKQKRPs[] = { Endgame<KQKRPs>(WHITE), Endgame<KQKRPs>(BLACK) };
-  Endgame<ScaleFactor, KPsK>   ScaleKPsK[]   = { Endgame<ScaleFactor, KPsK>(WHITE),   Endgame<ScaleFactor, KPsK>(BLACK) };
+  Endgame<KPsK>   ScaleKPsK[]   = { Endgame<KPsK>(WHITE),   Endgame<KPsK>(BLACK) };
-  Endgame<ScaleFactor, KPKP>   ScaleKPKP[]   = { Endgame<ScaleFactor, KPKP>(WHITE),   Endgame<ScaleFactor, KPKP>(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
+    return  !pos.count<PAWN>(Them)
-          && pos.piece_count(Them, PAWN) == 0
+          && pos.non_pawn_material(Them) == VALUE_ZERO
-          && pos.non_pawn_material(Us)   >= RookValueMidgame;
+          && pos.non_pawn_material(Us) >= RookValueMg;
   }
 
   template<Color Us> bool is_KBPsKs(const Position& pos) {
-    return   pos.non_pawn_material(Us)   == BishopValueMidgame
+    return   pos.non_pawn_material(Us) == BishopValueMg
-          && pos.piece_count(Us, BISHOP) == 1
+          && pos.count<BISHOP>(Us) == 1
-          && pos.piece_count(Us, PAWN)   >= 1;
+          && pos.count<PAWN  >(Us) >= 1;
   }
 
   template<Color Us> bool is_KQKRPs(const Position& pos) {
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.piece_count(Us, PAWN)    == 0
+    return  !pos.count<PAWN>(Us)
-          && pos.non_pawn_material(Us)    == QueenValueMidgame
+          && pos.non_pawn_material(Us) == QueenValueMg
-          && pos.piece_count(Us, QUEEN)   == 1
+          && pos.count<QUEEN>(Us)  == 1
-          && pos.piece_count(Them, ROOK)  == 1
+          && pos.count<ROOK>(Them) == 1
-          && pos.piece_count(Them, PAWN)  >= 1;
+          && pos.count<PAWN>(Them) >= 1;
+  }
+
+  /// imbalance() calculates imbalance comparing 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;
+
+    // Redundancy of major pieces, formula based on Kaufman's paper
+    // "The Evaluation of Material Imbalances in Chess"
+    if (pieceCount[Us][ROOK] > 0)
+        value -=  RedundantRook * (pieceCount[Us][ROOK] - 1)
+                + RedundantQueen * pieceCount[Us][QUEEN];
+
+    // Second-degree polynomial material imbalance by Tord Romstad
+    for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+    {
+        pc = pieceCount[Us][pt1];
+        if (!pc)
+            continue;
+
+        v = LinearCoefficients[pt1];
+
+        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+            v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+                + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+
+        value += pc * v;
+    }
+    return value;
   }
 
 } // namespace
 
+namespace Material {
 
-/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
+/// 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.
 
-void MaterialInfoTable::init() { Base::init(); if (!funcs) funcs = new Endgames(); }
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {
-MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
 
+  Key key = pos.material_key();
+  Entry* e = entries[key];
 
-/// MaterialInfoTable::get_material_info() takes a position object as input,
+  // If e->key matches the position's material hash key, it means that we
-/// computes or looks up a MaterialInfo object, and returns a pointer to it.
-/// If the material configuration is not already present in the table, it
-/// is stored there, so we don't have to recompute everything when the
-/// same material configuration occurs again.
-
-MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
-
-  Key key = pos.get_material_key();
-  MaterialInfo* mi = probe(key);
-
-  // If mi->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 (mi->key == key)
+  if (e->key == key)
-      return mi;
+      return e;
 
-  // Initialize MaterialInfo entry
+  std::memset(e, 0, sizeof(Entry));
-  memset(mi, 0, sizeof(MaterialInfo));
+  e->key = key;
-  mi->key = key;
+  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
+  e->gamePhase = game_phase(pos);
-
-  // Store game phase
-  mi->gamePhase = MaterialInfoTable::game_phase(pos);
 
   // Let's look if we have a specialized evaluation function for this
   // particular material configuration. First we look for a fixed
   // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
+  if (endgames.probe(key, e->evaluationFunction))
-      return mi;
+      return e;
 
   if (is_KXK<WHITE>(pos))
   {
-      mi->evaluationFunction = &EvaluateKXK[WHITE];
+      e->evaluationFunction = &EvaluateKXK[WHITE];
-      return mi;
+      return e;
   }
 
   if (is_KXK<BLACK>(pos))
   {
-      mi->evaluationFunction = &EvaluateKXK[BLACK];
+      e->evaluationFunction = &EvaluateKXK[BLACK];
-      return mi;
+      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(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
+      assert((pos.pieces(WHITE, KNIGHT) | pos.pieces(WHITE, BISHOP)));
-      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
+      assert((pos.pieces(BLACK, KNIGHT) | pos.pieces(BLACK, BISHOP)));
 
-      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+      if (   pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE) <= 2
-          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+          && pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK) <= 2)
       {
-          mi->evaluationFunction = &EvaluateKmmKm[WHITE];
+          e->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
-          return mi;
+          return e;
       }
   }
 
@@ -154,128 +195,92 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
   // scaling functions and we need to decide which one to use.
   EndgameBase<ScaleFactor>* sf;
 
-  if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
+  if (endgames.probe(key, sf))
   {
-      mi->scalingFunction[sf->color()] = sf;
+      e->scalingFunction[sf->color()] = sf;
-      return mi;
+      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))
-      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
+      e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
 
   if (is_KBPsKs<BLACK>(pos))
-      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
+      e->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
 
   if (is_KQKRPs<WHITE>(pos))
-      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
+      e->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
 
   else if (is_KQKRPs<BLACK>(pos))
-      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
+      e->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
 
   Value npm_w = pos.non_pawn_material(WHITE);
   Value npm_b = pos.non_pawn_material(BLACK);
 
   if (npm_w + npm_b == VALUE_ZERO)
   {
-      if (pos.piece_count(BLACK, PAWN) == 0)
+      if (!pos.count<PAWN>(BLACK))
       {
-          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          assert(pos.count<PAWN>(WHITE) >= 2);
-          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+          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);
-          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+          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.
-          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
-          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
+          e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
   }
 
   // No pawns makes it difficult to win, even with a material advantage
-  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMidgame)
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
   {
-      mi->factor[WHITE] = uint8_t
+      e->factor[WHITE] = (uint8_t)
-      (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(WHITE, BISHOP), 2)]);
+      (npm_w == npm_b || npm_w < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(WHITE), 2)]);
   }
 
-  if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMidgame)
+  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
   {
-      mi->factor[BLACK] = uint8_t
+      e->factor[BLACK] = (uint8_t)
-      (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(BLACK, BISHOP), 2)]);
+      (npm_w == npm_b || npm_b < RookValueMg ? 0 : NoPawnsSF[std::min(pos.count<BISHOP>(BLACK), 2)]);
   }
 
   // Compute the space weight
-  if (npm_w + npm_b >= 2 * QueenValueMidgame + 4 * RookValueMidgame + 2 * KnightValueMidgame)
+  if (npm_w + npm_b >= 2 * QueenValueMg + 4 * RookValueMg + 2 * KnightValueMg)
   {
-      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
+      int minorPieceCount =  pos.count<KNIGHT>(WHITE) + pos.count<BISHOP>(WHITE)
-                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+                           + pos.count<KNIGHT>(BLACK) + pos.count<BISHOP>(BLACK);
 
-      mi->spaceWeight = minorPieceCount * minorPieceCount;
+      e->spaceWeight = make_score(minorPieceCount * minorPieceCount, 0);
   }
 
   // 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
   // in defining bishop pair bonuses.
-  const int pieceCount[2][8] = {
+  const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
-  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
-    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
-  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
-    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
 
-  mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
+  e->value = (int16_t)((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
-  return mi;
+  return e;
 }
 
 
-/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
+/// Material::game_phase() calculates the phase given the current
-/// piece type for both colors.
-
-template<Color Us>
-int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
-
-  const Color Them = (Us == WHITE ? BLACK : WHITE);
-
-  int pt1, pt2, pc, v;
-  int value = 0;
-
-  // Redundancy of major pieces, formula based on Kaufman's paper
-  // "The Evaluation of Material Imbalances in Chess"
-  if (pieceCount[Us][ROOK] > 0)
-      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
-              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
-
-  // Second-degree polynomial material imbalance by Tord Romstad
-  for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
-  {
-      pc = pieceCount[Us][pt1];
-      if (!pc)
-          continue;
-
-      v = LinearCoefficients[pt1];
-
-      for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
-          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
-              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
-
-      value += pc * v;
-  }
-  return value;
-}
-
-
-/// MaterialInfoTable::game_phase() calculates the phase given the current
 /// position. Because the phase is strictly a function of the material, it
-/// is stored in MaterialInfo.
+/// is stored in MaterialEntry.
 
-Phase MaterialInfoTable::game_phase(const Position& pos) {
+Phase game_phase(const Position& pos) {
 
   Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
 
@@ -283,3 +288,5 @@ Phase MaterialInfoTable::game_phase(const Position& pos) {
         : npm <= EndgameLimit ? PHASE_ENDGAME
         : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
 }
+
+} // namespace Material

src/material.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,101 +17,61 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(MATERIAL_H_INCLUDED)
+#ifndef MATERIAL_H_INCLUDED
 #define MATERIAL_H_INCLUDED
 
 #include "endgame.h"
+#include "misc.h"
 #include "position.h"
-#include "tt.h"
 #include "types.h"
 
-const int MaterialTableSize = 8192;
+namespace Material {
 
-/// MaterialInfo is a class which contains various information about a
+/// Material::Entry contains various information about a material configuration.
-/// material configuration. It contains a material balance evaluation,
+/// It contains a material balance evaluation, a function pointer to a special
-/// a function pointer to a special endgame evaluation function (which in
+/// endgame evaluation function (which in most cases is NULL, meaning that the
-/// most cases is NULL, meaning that the standard evaluation function will
+/// standard evaluation function will be used), and "scale factors".
-/// be used), and "scale factors" for black and white.
 ///
 /// 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.
 
-class MaterialInfo {
+struct Entry {
 
-  friend class MaterialInfoTable;
+  Score material_value() const { return make_score(value, value); }
-
+  Score space_weight() const { return spaceWeight; }
-public:
+  Phase game_phase() const { return gamePhase; }
-  Score material_value() const;
+  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;
-  int space_weight() const;
-  Phase game_phase() const;
-  bool specialized_eval_exists() const;
-  Value evaluate(const Position& pos) const;
 
-private:
   Key key;
   int16_t value;
-  uint8_t factor[2];
+  uint8_t factor[COLOR_NB];
   EndgameBase<Value>* evaluationFunction;
-  EndgameBase<ScaleFactor>* scalingFunction[2];
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB];
-  int spaceWeight;
+  Score spaceWeight;
   Phase gamePhase;
 };
 
+typedef HashTable<Entry, 8192> Table;
 
-/// The MaterialInfoTable class represents a pawn hash table. The most important
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames);
-/// method is get_material_info, which returns a pointer to a MaterialInfo object.
+Phase game_phase(const Position& pos);
 
-class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
+/// Material::scale_factor takes a position and a color as input, and
-public:
-  ~MaterialInfoTable();
-  void init();
-  MaterialInfo* get_material_info(const Position& pos) const;
-  static Phase game_phase(const Position& pos);
-
-private:
-  template<Color Us>
-  static int imbalance(const int pieceCount[][8]);
-
-  Endgames* funcs;
-};
-
-
-/// MaterialInfo::scale_factor takes a position and a color as input, and
 /// returns a scale factor for the given color. We have to provide the
 /// position in addition to the color, because the scale factor need not
 /// to be a constant: It can also be a function which should be applied to
 /// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.
 
-inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
+inline ScaleFactor Entry::scale_factor(const Position& pos, Color c) const {
 
-  if (!scalingFunction[c])
+  return !scalingFunction[c] || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE
-      return ScaleFactor(factor[c]);
+        ? ScaleFactor(factor[c]) : (*scalingFunction[c])(pos);
-
-  ScaleFactor sf = scalingFunction[c]->apply(pos);
-  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
 }
 
-inline Value MaterialInfo::evaluate(const Position& pos) const {
-  return evaluationFunction->apply(pos);
 }
 
-inline Score MaterialInfo::material_value() const {
+#endif // #ifndef MATERIAL_H_INCLUDED
-  return make_score(value, value);
-}
-
-inline int MaterialInfo::space_weight() const {
-  return spaceWeight;
-}
-
-inline Phase MaterialInfo::game_phase() const {
-  return gamePhase;
-}
-
-inline bool MaterialInfo::specialized_eval_exists() const {
-  return evaluationFunction != NULL;
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)

src/misc.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,239 +17,170 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(_MSC_VER)
-
-#  include <sys/time.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  if defined(__hpux)
-#     include <sys/pstat.h>
-#  endif
-
-#else
-
-#define _CRT_SECURE_NO_DEPRECATE
-#include <windows.h>
-#include <sys/timeb.h>
-
-#endif
-
-#if !defined(NO_PREFETCH)
-#  include <xmmintrin.h>
-#endif
-
-#include <cassert>
-#include <cstdio>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 
-#include "bitcount.h"
 #include "misc.h"
 #include "thread.h"
 
 using namespace std;
 
-/// Version number. If EngineVersion is left empty, then AppTag plus
+/// Version number. If Version is left empty, then compile date, in the
-/// current date (in the format YYMMDD) is used as a version number.
+/// format DD-MM-YY, is shown in engine_info.
-
+static const string Version = "4";
-static const string AppName = "Stockfish";
-static const string EngineVersion = "2.1";
-static const string AppTag  = "";
 
 
-/// engine_name() returns the full name of the current Stockfish version.
+/// engine_info() returns the full name of the current Stockfish version. This
-/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
-/// the program was compiled) or "Stockfish <version number>", depending
+/// the program was compiled) or "Stockfish <Version>", depending on whether
-/// on whether the constant EngineVersion is empty.
+/// Version is empty.
 
-const string engine_name() {
+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(CpuIs64Bit ? " 64bit" : "");
-
-  if (!EngineVersion.empty())
-      return AppName + " " + EngineVersion + cpu64;
-
-  stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"
   string month, day, year;
+  stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"
 
-  date >> month >> day >> year;
+  s << "Stockfish " << Version << setfill('0');
 
-  s << setfill('0') << AppName + " " + AppTag + " "
+  if (Version.empty())
-    << year.substr(2, 2) << setw(2)
+  {
-    << (1 + months.find(month) / 4) << setw(2)
+      date >> month >> day >> year;
-    << day << cpu64;
+      s << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
+  }
+
+  s << (Is64Bit ? " 64" : "")
+    << (HasPopCnt ? " SSE4.2" : "")
+    << (to_uci ? "\nid author ": " by ")
+    << "Tord Romstad, Marco Costalba and Joona Kiiski";
 
   return s.str();
 }
 
 
-/// Our brave developers! Required by UCI
+/// Debug functions used mainly to collect run-time statistics
 
-const string engine_authors() {
+static uint64_t hits[2], means[2];
-
-  return "Tord Romstad, Marco Costalba and Joona Kiiski";
-}
-
-
-/// Debug stuff. Helper functions used mainly for debugging purposes
-
-static uint64_t dbg_hit_cnt0;
-static uint64_t dbg_hit_cnt1;
-static uint64_t dbg_mean_cnt0;
-static uint64_t dbg_mean_cnt1;
-
-void dbg_print_hit_rate() {
-
-  if (dbg_hit_cnt0)
-      cout << "Total " << dbg_hit_cnt0 << " Hit " << dbg_hit_cnt1
-           << " hit rate (%) " << 100 * dbg_hit_cnt1 / dbg_hit_cnt0 << endl;
-}
-
-void dbg_print_mean() {
-
-  if (dbg_mean_cnt0)
-      cout << "Total " << dbg_mean_cnt0 << " Mean "
-           << (float)dbg_mean_cnt1 / dbg_mean_cnt0 << endl;
-}
-
-void dbg_mean_of(int v) {
-
-  dbg_mean_cnt0++;
-  dbg_mean_cnt1 += v;
-}
-
-void dbg_hit_on(bool b) {
-
-  dbg_hit_cnt0++;
-  if (b)
-      dbg_hit_cnt1++;
-}
 
+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_before() { dbg_hit_on(false); }
+void dbg_mean_of(int v) { means[0]++; means[1] += v; }
-void dbg_after()  { dbg_hit_on(true); dbg_hit_cnt0--; }
 
+void dbg_print() {
 
-/// get_system_time() returns the current system time, measured in milliseconds
+  if (hits[0])
+      cerr << "Total " << hits[0] << " Hits " << hits[1]
+           << " hit rate (%) " << 100 * hits[1] / hits[0] << endl;
 
-int get_system_time() {
+  if (means[0])
-
+      cerr << "Total " << means[0] << " Mean "
-#if defined(_MSC_VER)
+           << (float)means[1] / means[0] << endl;
-  struct _timeb t;
-  _ftime(&t);
-  return int(t.time * 1000 + t.millitm);
-#else
-  struct timeval t;
-  gettimeofday(&t, NULL);
-  return t.tv_sec * 1000 + t.tv_usec / 1000;
-#endif
 }
 
 
-/// cpu_count() tries to detect the number of CPU cores
+/// 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
 
-int cpu_count() {
+struct Tie: public streambuf { // MSVC requires splitted streambuf for cin and cout
 
-#if defined(_MSC_VER)
+  Tie(streambuf* b, ofstream* f) : buf(b), file(f) {}
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return Min(s.dwNumberOfProcessors, MAX_THREADS);
-#else
 
-#  if defined(_SC_NPROCESSORS_ONLN)
+  int sync() { return file->rdbuf()->pubsync(), buf->pubsync(); }
-  return Min(sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
+  int overflow(int c) { return log(buf->sputc((char)c), "<< "); }
-#  elif defined(__hpux)
+  int underflow() { return buf->sgetc(); }
-  struct pst_dynamic psd;
+  int uflow() { return log(buf->sbumpc(), ">> "); }
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-  return Min(psd.psd_proc_cnt, MAX_THREADS);
-#  else
-  return 1;
-#  endif
 
-#endif
+  streambuf* buf;
-}
+  ofstream* file;
 
+  int log(int c, const char* prefix) {
 
-/// Check for console input. Original code from Beowulf, Olithink and Greko
+    static int last = '\n';
 
-#ifndef _WIN32
+    if (last == '\n')
+        file->rdbuf()->sputn(prefix, 3);
 
-int input_available() {
+    return last = file->rdbuf()->sputc((char)c);
-
-  fd_set readfds;
-  struct timeval  timeout;
-
-  FD_ZERO(&readfds);
-  FD_SET(fileno(stdin), &readfds);
-  timeout.tv_sec = 0; // Set to timeout immediately
-  timeout.tv_usec = 0;
-  select(16, &readfds, 0, 0, &timeout);
-
-  return (FD_ISSET(fileno(stdin), &readfds));
-}
-
-#else
-
-int input_available() {
-
-  static HANDLE inh = NULL;
-  static bool usePipe = false;
-  INPUT_RECORD rec[256];
-  DWORD nchars, recCnt;
-
-  if (!inh)
-  {
-      inh = GetStdHandle(STD_INPUT_HANDLE);
-      if (GetConsoleMode(inh, &nchars))
-      {
-          SetConsoleMode(inh, nchars & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
-          FlushConsoleInputBuffer(inh);
-      } else
-          usePipe = true;
   }
+};
 
-  // When using Standard C input functions, also check if there
+class Logger {
-  // is anything in the buffer. After a call to such functions,
-  // the input waiting in the pipe will be copied to the buffer,
-  // and the call to PeekNamedPipe can indicate no input available.
-  // Setting stdin to unbuffered was not enough. [from Greko]
-  if (stdin->_cnt > 0)
-      return 1;
 
-  // When running under a GUI the input commands are sent to us
+  Logger() : in(cin.rdbuf(), &file), out(cout.rdbuf(), &file) {}
-  // directly over the internal pipe. If PeekNamedPipe() returns 0
+ ~Logger() { start(false); }
-  // then something went wrong. Probably the parent program exited.
-  // Returning 1 will make the next call to the input function
-  // return EOF, where this should be catched then.
-  if (usePipe)
-      return PeekNamedPipe(inh, NULL, 0, NULL, &nchars, NULL) ? nchars : 1;
 
-  // Count the number of unread input records, including keyboard,
+  ofstream file;
-  // mouse, and window-resizing input records.
+  Tie in, out;
-  GetNumberOfConsoleInputEvents(inh, &nchars);
 
-  // Read data from console without removing it from the buffer
+public:
-  if (nchars <= 0 || !PeekConsoleInput(inh, rec, Min(nchars, 256), &recCnt))
+  static void start(bool b) {
-      return 0;
 
-  // Search for at least one keyboard event
+    static Logger l;
-  for (DWORD i = 0; i < recCnt; i++)
-      if (rec[i].EventType == KEY_EVENT)
-          return 1;
 
-  return 0;
+    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
+/// the same time.
+
+std::ostream& operator<<(std::ostream& os, SyncCout sc) {
+
+  static Mutex m;
+
+  if (sc == io_lock)
+      m.lock();
+
+  if (sc == io_unlock)
+      m.unlock();
+
+  return os;
 }
 
+
+/// Trampoline helper to avoid moving Logger to misc.h
+void start_logger(bool b) { Logger::start(b); }
+
+
+/// 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) {
+
+#ifdef _WIN32
+  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)
+#ifdef NO_PREFETCH
 
 void prefetch(char*) {}
 
@@ -257,14 +188,17 @@ void prefetch(char*) {}
 
 void prefetch(char* addr) {
 
-#if defined(__INTEL_COMPILER) || defined(__ICL)
+#  if defined(__INTEL_COMPILER)
    // This hack prevents prefetches to be optimized away by
    // Intel compiler. Both MSVC and gcc seems not affected.
    __asm__ ("");
-#endif
+#  endif
 
-  _mm_prefetch(addr, _MM_HINT_T2);
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
+  _mm_prefetch(addr, _MM_HINT_T0);
+#  else
+  __builtin_prefetch(addr);
+#  endif
 }
 
 #endif

src/misc.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,25 +17,52 @@
   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 <string>
+#include <vector>
+
 #include "types.h"
 
-extern const std::string engine_name();
+extern const std::string engine_info(bool to_uci = false);
-extern const std::string engine_authors();
+extern void timed_wait(WaitCondition&, Lock&, int);
-extern int get_system_time();
-extern int cpu_count();
-extern int input_available();
 extern void prefetch(char* addr);
+extern void start_logger(bool b);
 
 extern void dbg_hit_on(bool b);
 extern void dbg_hit_on_c(bool c, bool b);
-extern void dbg_before();
-extern void dbg_after();
 extern void dbg_mean_of(int v);
-extern void dbg_print_hit_rate();
+extern void dbg_print();
-extern void dbg_print_mean();
 
-#endif // !defined(MISC_H_INCLUDED)
+
+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;
+  inline point now() { return system_time_to_msec(); }
+}
+
+
+template<class Entry, int Size>
+struct HashTable {
+  HashTable() : e(Size, Entry()) {}
+  Entry* operator[](Key k) { return &e[(uint32_t)k & (Size - 1)]; }
+
+private:
+  std::vector<Entry> e;
+};
+
+
+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
+
+#endif // #ifndef MISC_H_INCLUDED

src/move.cpp

@@ -1,258 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <cassert>
-#include <cstring>
-#include <iomanip>
-#include <string>
-#include <sstream>
-
-#include "move.h"
-#include "movegen.h"
-#include "search.h"
-
-using std::string;
-
-namespace {
-  const string time_string(int milliseconds);
-  const string score_string(Value v);
-}
-
-
-/// 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.
-
-const string move_to_uci(Move m, bool chess960) {
-
-  Square from = move_from(m);
-  Square to = move_to(m);
-  string promotion;
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "0000";
-
-  if (move_is_short_castle(m) && !chess960)
-      return from == SQ_E1 ? "e1g1" : "e8g8";
-
-  if (move_is_long_castle(m) && !chess960)
-      return from == SQ_E1 ? "e1c1" : "e8c8";
-
-  if (move_is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(move_promotion_piece(m))));
-
-  return square_to_string(from) + square_to_string(to) + promotion;
-}
-
-
-/// move_from_uci() takes a position and a string representing a move in
-/// simple coordinate notation and returns an equivalent Move if any.
-/// Moves are guaranteed to be legal.
-
-Move move_from_uci(const Position& pos, const string& str) {
-
-  MoveStack mlist[MAX_MOVES];
-  MoveStack* last = generate<MV_LEGAL>(pos, mlist);
-
-  for (MoveStack* cur = mlist; cur != last; cur++)
-      if (str == move_to_uci(cur->move, pos.is_chess960()))
-          return cur->move;
-
-  return MOVE_NONE;
-}
-
-
-/// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move from the position. The return value is
-/// a string containing the move in short algebraic notation.
-
-const string move_to_san(Position& pos, Move m) {
-
-  assert(pos.is_ok());
-  assert(move_is_ok(m));
-
-  MoveStack mlist[MAX_MOVES];
-  Square from = move_from(m);
-  Square to = move_to(m);
-  PieceType pt = pos.type_of_piece_on(from);
-  string san;
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "(null)";
-
-  if (move_is_long_castle(m))
-      san = "O-O-O";
-  else if (move_is_short_castle(m))
-      san = "O-O";
-  else
-  {
-      if (pt != PAWN)
-      {
-          san = piece_type_to_char(pt);
-
-          // Collect all legal moves of piece type 'pt' with destination 'to'
-          MoveStack* last = generate<MV_LEGAL>(pos, mlist);
-          int f = 0, r = 0;
-
-          for (MoveStack* cur = mlist; cur != last; cur++)
-              if (   move_to(cur->move) == to
-                  && pos.type_of_piece_on(move_from(cur->move)) == pt)
-              {
-                  if (square_file(move_from(cur->move)) == square_file(from))
-                      f++;
-
-                  if (square_rank(move_from(cur->move)) == square_rank(from))
-                      r++;
-              }
-
-          assert(f > 0 && r > 0);
-
-          // Disambiguation if we have more then one piece with destination 'to'
-          if (f == 1 && r > 1)
-              san += file_to_char(square_file(from));
-          else if (f > 1 && r == 1)
-              san += rank_to_char(square_rank(from));
-          else if (f > 1 && r > 1)
-              san += square_to_string(from);
-      }
-
-      if (pos.move_is_capture(m))
-      {
-          if (pt == PAWN)
-              san += file_to_char(square_file(from));
-
-          san += 'x';
-      }
-
-      san += square_to_string(to);
-
-      if (move_is_promotion(m))
-      {
-          san += '=';
-          san += piece_type_to_char(move_promotion_piece(m));
-      }
-  }
-
-  // The move gives check? We don't use pos.move_gives_check() here
-  // because we need to test for a mate after the move is done.
-  StateInfo st;
-  pos.do_move(m, st);
-  if (pos.in_check())
-      san += pos.is_mate() ? "#" : "+";
-  pos.undo_move(m);
-
-  return san;
-}
-
-
-/// pretty_pv() creates a human-readable string from a position and a PV.
-/// It is used to write search information to the log file (which is created
-/// when the UCI parameter "Use Search Log" is "true").
-
-const string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) {
-
-  const int64_t K = 1000;
-  const int64_t M = 1000000;
-  const int startColumn = 28;
-  const size_t maxLength = 80 - startColumn;
-  const string lf = string("\n") + string(startColumn, ' ');
-
-  StateInfo state[PLY_MAX_PLUS_2], *st = state;
-  Move* m = pv;
-  string san;
-  std::stringstream s;
-  size_t length = 0;
-
-  // First print depth, score, time and searched nodes...
-  s << std::setw(2) << depth
-    << std::setw(8) << score_string(score)
-    << std::setw(8) << time_string(time);
-
-  if (pos.nodes_searched() < M)
-      s << std::setw(8) << pos.nodes_searched() / 1 << "  ";
-  else if (pos.nodes_searched() < K * M)
-      s << std::setw(7) << pos.nodes_searched() / K << "K  ";
-  else
-      s << std::setw(7) << pos.nodes_searched() / M << "M  ";
-
-  // ...then print the full PV line in short algebraic notation
-  while (*m != MOVE_NONE)
-  {
-      san = move_to_san(pos, *m);
-      length += san.length() + 1;
-
-      if (length > maxLength)
-      {
-          length = san.length() + 1;
-          s << lf;
-      }
-      s << san << ' ';
-
-      pos.do_move(*m++, *st++);
-  }
-
-  // Restore original position before to leave
-  while (m != pv) pos.undo_move(*--m);
-
-  return s.str();
-}
-
-
-namespace {
-
-  const string time_string(int millisecs) {
-
-    const int MSecMinute = 1000 * 60;
-    const int MSecHour   = 1000 * 60 * 60;
-
-    int hours = millisecs / MSecHour;
-    int minutes =  (millisecs % MSecHour) / MSecMinute;
-    int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
-
-    std::stringstream s;
-
-    if (hours)
-        s << hours << ':';
-
-    s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
-    return s.str();
-  }
-
-
-  const string score_string(Value v) {
-
-    std::stringstream s;
-
-    if (v >= VALUE_MATE - 200)
-        s << "#" << (VALUE_MATE - v + 1) / 2;
-    else if (v <= -VALUE_MATE + 200)
-        s << "-#" << (VALUE_MATE + v) / 2;
-    else
-        s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
-
-    return s.str();
-  }
-}

src/move.h

@@ -1,195 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 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(MOVE_H_INCLUDED)
-#define MOVE_H_INCLUDED
-
-#include <string>
-
-#include "misc.h"
-#include "types.h"
-
-// Maximum number of allowed moves per position
-const int MAX_MOVES = 256;
-
-/// 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)
-///
-/// 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, 0 and 1 respectively.
-
-enum Move {
-  MOVE_NONE = 0,
-  MOVE_NULL = 65
-};
-
-
-struct MoveStack {
-  Move move;
-  int score;
-};
-
-inline bool operator<(const MoveStack& f, const MoveStack& s) { return f.score < s.score; }
-
-// An helper insertion sort implementation, works with pointers and iterators
-template<typename T, typename K>
-inline void insertion_sort(K firstMove, K lastMove)
-{
-    T value;
-    K cur, p, d;
-
-    if (firstMove != lastMove)
-        for (cur = firstMove + 1; cur != lastMove; cur++)
-        {
-            p = d = cur;
-            value = *p--;
-            if (*p < value)
-            {
-                do *d = *p;
-                while (--d != firstMove && *--p < value);
-                *d = value;
-            }
-        }
-}
-
-// Our dedicated sort in range [firstMove, lastMove), first splits
-// positive scores from ramining then order seaprately the two sets.
-template<typename T>
-inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
-{
-    T tmp;
-    T *p, *d;
-
-    d = lastMove;
-    p = firstMove - 1;
-
-    d->score = -1; // right guard
-
-    // Split positives vs non-positives
-    do {
-        while ((++p)->score > 0) {}
-
-        if (p != d)
-        {
-            while (--d != p && d->score <= 0) {}
-
-            tmp = *p;
-            *p = *d;
-            *d = tmp;
-        }
-
-    } while (p != d);
-
-    // Sort just positive scored moves, remaining only when we get there
-    insertion_sort<T, T*>(firstMove, p);
-    *lastPositive = p;
-}
-
-// Picks up the best move in range [curMove, lastMove), one per cycle.
-// It is faster then sorting all the moves in advance when moves are few,
-// as normally are the possible captures. Note that is not a stable alghoritm.
-template<typename T>
-inline T pick_best(T* curMove, T* lastMove)
-{
-    T bestMove, tmp;
-
-    bestMove = *curMove;
-    while (++curMove != lastMove)
-    {
-        if (bestMove < *curMove)
-        {
-            tmp = *curMove;
-            *curMove = bestMove;
-            bestMove = tmp;
-        }
-    }
-    return bestMove;
-}
-
-
-inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 0x3F);
-}
-
-inline Square move_to(Move m) {
-  return Square(m & 0x3F);
-}
-
-inline bool move_is_special(Move m) {
-  return m & (3 << 14);
-}
-
-inline bool move_is_promotion(Move m) {
-  return (m & (3 << 14)) == (1 << 14);
-}
-
-inline int move_is_ep(Move m) {
-  return (m & (3 << 14)) == (2 << 14);
-}
-
-inline int move_is_castle(Move m) {
-  return (m & (3 << 14)) == (3 << 14);
-}
-
-inline bool move_is_short_castle(Move m) {
-  return move_is_castle(m) && (move_to(m) > move_from(m));
-}
-
-inline bool move_is_long_castle(Move m) {
-  return move_is_castle(m) && (move_to(m) < move_from(m));
-}
-
-inline PieceType move_promotion_piece(Move m) {
-  return move_is_promotion(m) ? PieceType(((int(m) >> 12) & 3) + 2) : PIECE_TYPE_NONE;
-}
-
-inline Move make_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6));
-}
-
-inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
-  return Move(int(to) | (int(from) << 6) | ((int(promotion) - 2) << 12) | (1 << 14));
-}
-
-inline Move make_ep_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (2 << 14));
-}
-
-inline Move make_castle_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (3 << 14));
-}
-
-inline bool move_is_ok(Move m) {
-  return move_from(m) != move_to(m); // Catches also MOVE_NONE
-}
-
-class Position;
-
-extern const std::string move_to_uci(Move m, bool chess960);
-extern Move move_from_uci(const Position& pos, const std::string& str);
-extern const std::string move_to_san(Position& pos, Move m);
-extern const std::string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]);
-
-#endif // !defined(MOVE_H_INCLUDED)

src/movegen.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -19,524 +19,405 @@
 
 #include <cassert>
 
-#include "bitcount.h"
 #include "movegen.h"
+#include "position.h"
 
-// Simple macro to wrap a very common while loop, no facny, no flexibility,
+/// Simple macro to wrap a very common while loop, no facny, no flexibility,
-// hardcoded list name 'mlist' and from square 'from'.
+/// hardcoded names 'mlist' and 'from'.
-#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
+#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_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
 
+/// 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 {
 
-  enum CastlingSide {
+  template<CastlingSide Side, bool Checks, bool Chess960>
-    KING_SIDE,
+  ExtMove* generate_castle(const Position& pos, ExtMove* mlist, Color us) {
-    QUEEN_SIDE
-  };
 
-  template<CastlingSide>
+    if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
-  MoveStack* generate_castle_moves(const Position&, MoveStack*, Color us);
-
-  template<Color, MoveType>
-  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard, Square);
-
-  template<PieceType Pt>
-  inline MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
-
-    assert(Pt != QUEEN);
-
-    Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
-    if (Pt == KING)
-    {
-        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
-        b &= ~QueenPseudoAttacks[ksq];
-    }
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
-
-  template<PieceType Pt>
-  inline MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
-                                           Bitboard dc, Square ksq) {
-    assert(Pt != KING);
-
-    Bitboard checkSqs, b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
-
-    if ((from = *ptr++) == SQ_NONE)
         return mlist;
 
-    checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();
+    // 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);
+    Bitboard enemies = pos.pieces(~us);
 
-    do
+    assert(!pos.checkers());
-    {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
-            continue;
 
-        if (dc && bit_is_set(dc, from))
+    const int K = Chess960 ? kto > kfrom ? -1 : 1
-            continue;
+                           : Side == KING_SIDE ? -1 : 1;
 
-        b = pos.attacks_from<Pt>(from) & checkSqs;
+    for (Square s = kto; s != kfrom; s += (Square)K)
-        SERIALIZE_MOVES(b);
+        if (pos.attackers_to(s) & enemies)
+            return mlist;
 
-    } while ((from = *ptr++) != SQ_NONE);
+    // 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;
+
+    (mlist++)->move = make<CASTLE>(kfrom, rfrom);
+
+    if (Checks && !pos.move_gives_check((mlist - 1)->move, CheckInfo(pos)))
+        mlist--;
 
     return mlist;
   }
 
-  template<>
-  FORCE_INLINE MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
 
-    return (us == WHITE ? generate_pawn_moves<WHITE, MV_CHECK>(p, m, dc, ksq)
+  template<GenType Type, Square Delta>
-                        : generate_pawn_moves<BLACK, MV_CHECK>(p, m, dc, ksq));
+  inline ExtMove* generate_promotions(ExtMove* mlist, Bitboard pawnsOn7,
-  }
+                                      Bitboard target, const CheckInfo* ci) {
 
-  template<PieceType Pt, MoveType Type>
+    Bitboard b = shift_bb<Delta>(pawnsOn7) & target;
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
 
-    assert(Pt == PAWN);
+    while (b)
-    assert(Type == MV_CAPTURE || Type == MV_NON_CAPTURE || Type == MV_EVASION);
-
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
-  }
-
-  template<PieceType Pt>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from;
-    const Square* ptr = pos.piece_list_begin(us, Pt);
-
-    if (*ptr != SQ_NONE)
     {
-        do {
+        Square to = pop_lsb(&b);
-            from = *ptr;
+
-            b = pos.attacks_from<Pt>(from) & target;
+        if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
-            SERIALIZE_MOVES(b);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, QUEEN);
-        } while (*++ptr != SQ_NONE);
+
+        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
     }
+
     return mlist;
   }
 
-  template<>
-  FORCE_INLINE MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
-    Bitboard b;
+  template<Color Us, GenType Type>
-    Square from = pos.king_square(us);
+  ExtMove* generate_pawn_moves(const Position& pos, ExtMove* mlist,
+                               Bitboard target, const CheckInfo* ci) {
+
+    // 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);
+
+    Bitboard b1, b2, dc1, dc2, emptySquares;
+
+    Bitboard pawnsOn7    = pos.pieces(Us, PAWN) &  TRank7BB;
+    Bitboard pawnsNotOn7 = pos.pieces(Us, PAWN) & ~TRank7BB;
+
+    Bitboard enemies = (Type == EVASIONS ? pos.pieces(Them) & target:
+                        Type == CAPTURES ? target : pos.pieces(Them));
+
+    // Single and double pawn pushes, no promotions
+    if (Type != CAPTURES)
+    {
+        emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces());
+
+        b1 = shift_bb<Up>(pawnsNotOn7)   & emptySquares;
+        b2 = shift_bb<Up>(b1 & TRank3BB) & emptySquares;
+
+        if (Type == EVASIONS) // Consider only blocking squares
+        {
+            b1 &= target;
+            b2 &= target;
+        }
+
+        if (Type == QUIET_CHECKS)
+        {
+            b1 &= pos.attacks_from<PAWN>(ci->ksq, Them);
+            b2 &= pos.attacks_from<PAWN>(ci->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)
+            {
+                dc1 = shift_bb<Up>(pawnsNotOn7 & ci->dcCandidates) & emptySquares & ~file_bb(ci->ksq);
+                dc2 = shift_bb<Up>(dc1 & TRank3BB) & emptySquares;
+
+                b1 |= dc1;
+                b2 |= dc2;
+            }
+        }
+
+        SERIALIZE_PAWNS(b1, Up);
+        SERIALIZE_PAWNS(b2, Up + Up);
+    }
+
+    // Promotions and underpromotions
+    if (pawnsOn7 && (Type != EVASIONS || (target & TRank8BB)))
+    {
+        if (Type == CAPTURES)
+            emptySquares = ~pos.pieces();
+
+        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);
+    }
+
+    // Standard and en-passant captures
+    if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+    {
+        b1 = shift_bb<Right>(pawnsNotOn7) & enemies;
+        b2 = shift_bb<Left >(pawnsNotOn7) & enemies;
+
+        SERIALIZE_PAWNS(b1, Right);
+        SERIALIZE_PAWNS(b2, Left);
+
+        if (pos.ep_square() != SQ_NONE)
+        {
+            assert(rank_of(pos.ep_square()) == relative_rank(Us, RANK_6));
+
+            // An en passant capture can be an evasion only if the checking piece
+            // is the double pushed pawn and so is in the target. Otherwise this
+            // is a discovery check and we are forced to do otherwise.
+            if (Type == EVASIONS && !(target & (pos.ep_square() - Up)))
+                return mlist;
+
+            b1 = pawnsNotOn7 & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+
+            assert(b1);
+
+            while (b1)
+                (mlist++)->move = make<ENPASSANT>(pop_lsb(&b1), pos.ep_square());
+        }
+    }
 
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
     return mlist;
   }
 
-}
+
+  template<PieceType Pt, bool Checks> FORCE_INLINE
+  ExtMove* generate_moves(const Position& pos, ExtMove* mlist, Color us,
+                          Bitboard target, const CheckInfo* ci) {
+
+    assert(Pt != KING && Pt != PAWN);
+
+    const Square* pl = pos.list<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]))
+                continue;
+
+            if (unlikely(ci->dcCandidates) && (ci->dcCandidates & from))
+                continue;
+        }
+
+        Bitboard b = pos.attacks_from<Pt>(from) & target;
+
+        if (Checks)
+            b &= ci->checkSq[Pt];
+
+        SERIALIZE(b);
+    }
+
+    return mlist;
+  }
 
 
-/// generate<MV_CAPTURE> generates all pseudo-legal captures and queen
+  template<Color Us, GenType Type> FORCE_INLINE
+  ExtMove* generate_all(const Position& pos, ExtMove* mlist, Bitboard target,
+                        const CheckInfo* ci = NULL) {
+
+    const bool Checks = Type == QUIET_CHECKS;
+
+    mlist = generate_pawn_moves<Us, 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);
+
+    if (Type != QUIET_CHECKS && Type != EVASIONS)
+    {
+        Square from = pos.king_square(Us);
+        Bitboard b = pos.attacks_from<KING>(from) & target;
+        SERIALIZE(b);
+    }
+
+    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);
+        }
+        else
+        {
+            mlist = generate_castle< KING_SIDE, Checks, false>(pos, mlist, Us);
+            mlist = generate_castle<QUEEN_SIDE, Checks, false>(pos, mlist, Us);
+        }
+    }
+
+    return mlist;
+  }
+
+
+} // namespace
+
+
+/// generate<CAPTURES> generates all pseudo-legal captures and queen
 /// promotions. Returns a pointer to the end of the move list.
 ///
-/// generate<MV_NON_CAPTURE> generates all pseudo-legal non-captures and
+/// generate<QUIETS> generates all pseudo-legal non-captures and
 /// underpromotions. Returns a pointer to the end of the move list.
 ///
-/// generate<MV_NON_EVASION> generates all pseudo-legal captures and
+/// generate<NON_EVASIONS> generates all pseudo-legal captures and
 /// non-captures. Returns a pointer to the end of the move list.
 
-template<MoveType Type>
+template<GenType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
+ExtMove* generate(const Position& pos, ExtMove* mlist) {
 
-  assert(pos.is_ok());
+  assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
-  assert(!pos.in_check());
+  assert(!pos.checkers());
 
   Color us = pos.side_to_move();
-  Bitboard target;
 
-  if (Type == MV_CAPTURE || Type == MV_NON_EVASION)
+  Bitboard target = Type == CAPTURES     ?  pos.pieces(~us)
-      target = pos.pieces_of_color(opposite_color(us));
+                  : Type == QUIETS       ? ~pos.pieces()
-  else if (Type == MV_NON_CAPTURE)
+                  : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;
-      target = pos.empty_squares();
-  else
-      assert(false);
 
-  if (Type == MV_NON_EVASION)
+  return us == WHITE ? generate_all<WHITE, Type>(pos, mlist, target)
-  {
+                     : generate_all<BLACK, Type>(pos, mlist, target);
-      mlist = generate_piece_moves<PAWN, MV_CAPTURE>(pos, mlist, us, target);
-      mlist = generate_piece_moves<PAWN, MV_NON_CAPTURE>(pos, mlist, us, pos.empty_squares());
-      target |= pos.empty_squares();
-  }
-  else
-      mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
-
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KING>(pos, mlist, us, target);
-
-  if (Type != MV_CAPTURE)
-  {
-      if (pos.can_castle_kingside(us))
-          mlist = generate_castle_moves<KING_SIDE>(pos, mlist, us);
-
-      if (pos.can_castle_queenside(us))
-          mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist, us);
-  }
-
-  return mlist;
 }
 
 // Explicit template instantiations
-template MoveStack* generate<MV_CAPTURE>(const Position& pos, MoveStack* mlist);
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
-template MoveStack* generate<MV_NON_CAPTURE>(const Position& pos, MoveStack* mlist);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
-template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mlist);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
 
 
-/// generate_non_capture_checks() generates all pseudo-legal non-captures and knight
+/// 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<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* mlist) {
 
-  assert(pos.is_ok());
+  assert(!pos.checkers());
-  assert(!pos.in_check());
 
-  Bitboard b, dc;
-  Square from;
   Color us = pos.side_to_move();
-  Square ksq = pos.king_square(opposite_color(us));
+  CheckInfo ci(pos);
+  Bitboard dc = ci.dcCandidates;
 
-  assert(pos.piece_on(ksq) == make_piece(opposite_color(us), KING));
+  while (dc)
-
-  // Discovered non-capture checks
-  b = dc = pos.discovered_check_candidates(us);
-
-  while (b)
   {
-     from = pop_1st_bit(&b);
+     Square from = pop_lsb(&dc);
-     switch (pos.type_of_piece_on(from))
+     PieceType pt = type_of(pos.piece_on(from));
-     {
+
-      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
+     if (pt == PAWN)
-      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
+         continue; // Will be generated togheter with direct checks
-      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, mlist, from); break;
+
-      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, mlist, from);   break;
+     Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.pieces();
-      case KING:   mlist = generate_discovered_checks<KING>(pos, mlist, from);   break;
+
-      default: assert(false); break;
+     if (pt == KING)
-     }
+         b &= ~PseudoAttacks[QUEEN][ci.ksq];
+
+     SERIALIZE(b);
   }
 
-  // Direct non-capture checks
+  return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci)
-  mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
+                     : generate_all<BLACK, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci);
-  mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<ROOK>(pos, mlist, us, dc, ksq);
-  return  generate_direct_checks<QUEEN>(pos, mlist, us, dc, ksq);
 }
 
 
-/// generate_evasions() generates all pseudo-legal check evasions when
+/// generate<EVASIONS> generates all pseudo-legal check evasions when the side
-/// the side to move is in check. Returns a pointer to the end of the move list.
+/// to move is in check. Returns a pointer to the end of the move list.
 template<>
-MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* mlist) {
 
-  assert(pos.is_ok());
+  assert(pos.checkers());
-  assert(pos.in_check());
 
-  Bitboard b, target;
-  Square from, checksq;
   int checkersCnt = 0;
   Color us = pos.side_to_move();
-  Square ksq = pos.king_square(us);
+  Square ksq = pos.king_square(us), from = ksq /* For SERIALIZE */, checksq;
-  Bitboard checkers = pos.checkers();
+  Bitboard sliderAttacks = 0;
-  Bitboard sliderAttacks = EmptyBoardBB;
+  Bitboard b = pos.checkers();
 
-  assert(pos.piece_on(ksq) == make_piece(us, KING));
+  assert(pos.checkers());
-  assert(checkers);
 
-  // Find squares attacked by slider checkers, we will remove
+  // Find squares attacked by slider checkers, we will remove them from the king
-  // them from the king evasions set so to early skip known
+  // evasions so to skip known illegal moves avoiding useless legality check later.
-  // illegal moves and avoid an useless legality check later.
-  b = checkers;
   do
   {
       checkersCnt++;
-      checksq = pop_1st_bit(&b);
+      checksq = pop_lsb(&b);
 
-      assert(pos.color_of_piece_on(checksq) == opposite_color(us));
+      assert(color_of(pos.piece_on(checksq)) == ~us);
 
-      switch (pos.type_of_piece_on(checksq))
+      switch (type_of(pos.piece_on(checksq)))
       {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
+      case BISHOP: sliderAttacks |= PseudoAttacks[BISHOP][checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
+      case ROOK:   sliderAttacks |= PseudoAttacks[ROOK][checksq];   break;
       case QUEEN:
-          // In case of a queen remove also squares attacked in the other direction to
+          // If queen and king are far or not on a diagonal line we can safely
-          // avoid possible illegal moves when queen and king are on adjacent squares.
+          // remove all the squares attacked in the other direction becuase are
-          if (RookPseudoAttacks[checksq] & (1ULL << ksq))
+          // not reachable by the king anyway.
-              sliderAttacks |= RookPseudoAttacks[checksq] | pos.attacks_from<BISHOP>(checksq);
+          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 |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
+              sliderAttacks |= PseudoAttacks[BISHOP][checksq] | pos.attacks_from<ROOK>(checksq);
+
       default:
           break;
       }
   } while (b);
 
   // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
+  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
-  from = ksq;
+  SERIALIZE(b);
-  SERIALIZE_MOVES(b);
 
-  // Generate evasions for other pieces only if not double check
   if (checkersCnt > 1)
-      return mlist;
+      return mlist; // Double check, only a king move can save the day
 
-  // Find squares where a blocking evasion or a capture of the
+  // Generate blocking evasions or captures of the checking piece
-  // checker piece is possible.
+  Bitboard target = between_bb(checksq, ksq) | checksq;
-  target = squares_between(checksq, ksq) | checkers;
 
-  mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
+  return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, mlist, target)
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
+                     : generate_all<BLACK, EVASIONS>(pos, mlist, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  return  generate_piece_moves<QUEEN>(pos, mlist, us, target);
 }
 
 
-/// generate<MV_LEGAL / MV_PSEUDO_LEGAL> computes a complete list of legal
+/// generate<LEGAL> generates all the legal moves in the given position
-/// or pseudo-legal moves in the current position.
-template<>
-MoveStack* generate<MV_PSEUDO_LEGAL>(const Position& pos, MoveStack* mlist) {
-
-  assert(pos.is_ok());
-
-  return pos.in_check() ? generate<MV_EVASION>(pos, mlist)
-                        : generate<MV_NON_EVASION>(pos, mlist);
-}
 
 template<>
-MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* mlist) {
 
-  assert(pos.is_ok());
+  ExtMove *end, *cur = mlist;
+  Bitboard pinned = pos.pinned_pieces();
+  Square ksq = pos.king_square(pos.side_to_move());
 
-  MoveStack *last, *cur = mlist;
+  end = pos.checkers() ? generate<EVASIONS>(pos, mlist)
-  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+                       : generate<NON_EVASIONS>(pos, mlist);
-
+  while (cur != end)
-  last = generate<MV_PSEUDO_LEGAL>(pos, mlist);
+      if (   (pinned || from_sq(cur->move) == ksq || type_of(cur->move) == ENPASSANT)
-
+          && !pos.pl_move_is_legal(cur->move, pinned))
-  // Remove illegal moves from the list
+          cur->move = (--end)->move;
-  while (cur != last)
-      if (!pos.pl_move_is_legal(cur->move, pinned))
-          cur->move = (--last)->move;
       else
           cur++;
 
-  return last;
+  return end;
 }
-
-
-namespace {
-
-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
-
-    return Delta == DELTA_N  ? p << 8 : Delta == DELTA_S  ? p >> 8 :
-           Delta == DELTA_NE ? p << 9 : Delta == DELTA_SE ? p >> 7 :
-           Delta == DELTA_NW ? p << 7 : Delta == DELTA_SW ? p >> 9 : p;
-  }
-
-  template<MoveType Type, Square Delta>
-  inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
-    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
-    SERIALIZE_MOVES_D(b, -Delta);
-    return mlist;
-  }
-
-  template<Color Us, MoveType Type, Square Delta>
-  inline MoveStack* generate_promotions(const Position& pos, MoveStack* mlist, Bitboard pawnsOn7, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Promotions and under-promotions, both captures and non-captures
-    b = move_pawns<Delta>(pawnsOn7) & target;
-
-    if (Delta != DELTA_N && Delta != DELTA_S)
-        b &= ~TFileABB;
-
-    while (b)
-    {
-        to = pop_1st_bit(&b);
-
-        if (Type == MV_CAPTURE || Type == MV_EVASION)
-            (*mlist++).move = make_promotion_move(to - Delta, to, QUEEN);
-
-        if (Type == MV_NON_CAPTURE || Type == MV_EVASION)
-        {
-            (*mlist++).move = make_promotion_move(to - Delta, to, ROOK);
-            (*mlist++).move = make_promotion_move(to - Delta, to, BISHOP);
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        }
-
-        // This is the only possible under promotion that can give a check
-        // not already included in the queen-promotion.
-        if (   Type == MV_CHECK
-            && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(opposite_color(Us))))
-            (*mlist++).move = make_promotion_move(to - Delta, to, KNIGHT);
-        else (void)pos; // Silence a warning under MSVC
-    }
-    return mlist;
-  }
-
-  template<Color Us, MoveType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq) {
-
-    // Calculate our parametrized parameters at compile time, named
-    // according to the point of view of white side.
-    const Color    Them      = (Us == WHITE ? BLACK    : WHITE);
-    const Bitboard TRank7BB  = (Us == WHITE ? Rank7BB  : Rank2BB);
-    const Bitboard TRank3BB  = (Us == WHITE ? Rank3BB  : Rank6BB);
-    const Square   TDELTA_N  = (Us == WHITE ? DELTA_N  : DELTA_S);
-    const Square   TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
-    const Square   TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
-
-    Square to;
-    Bitboard b1, b2, dc1, dc2, pawnPushes, emptySquares;
-    Bitboard pawns = pos.pieces(PAWN, Us);
-    Bitboard pawnsOn7 = pawns & TRank7BB;
-    Bitboard enemyPieces = (Type == MV_CAPTURE ? target : pos.pieces_of_color(Them));
-
-    // Pre-calculate pawn pushes before changing emptySquares definition
-    if (Type != MV_CAPTURE)
-    {
-        emptySquares = (Type == MV_NON_CAPTURE ? target : pos.empty_squares());
-        pawnPushes = move_pawns<TDELTA_N>(pawns & ~TRank7BB) & emptySquares;
-    }
-
-    if (Type == MV_EVASION)
-    {
-        emptySquares &= target; // Only blocking squares
-        enemyPieces  &= target; // Capture only the checker piece
-    }
-
-    // Promotions and underpromotions
-    if (pawnsOn7)
-    {
-        if (Type == MV_CAPTURE)
-            emptySquares = pos.empty_squares();
-
-        pawns &= ~TRank7BB;
-        mlist = generate_promotions<Us, Type, TDELTA_NE>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Us, Type, TDELTA_NW>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Us, Type, TDELTA_N >(pos, mlist, pawnsOn7, emptySquares);
-    }
-
-    // Standard captures
-    if (Type == MV_CAPTURE || Type == MV_EVASION)
-    {
-        mlist = generate_pawn_captures<Type, TDELTA_NE>(mlist, pawns, enemyPieces);
-        mlist = generate_pawn_captures<Type, TDELTA_NW>(mlist, pawns, enemyPieces);
-    }
-
-    // Single and double pawn pushes
-    if (Type != MV_CAPTURE)
-    {
-        b1 = pawnPushes & emptySquares;
-        b2 = move_pawns<TDELTA_N>(pawnPushes & TRank3BB) & emptySquares;
-
-        if (Type == MV_CHECK)
-        {
-            // Consider only pawn moves which give direct checks
-            b1 &= pos.attacks_from<PAWN>(ksq, Them);
-            b2 &= pos.attacks_from<PAWN>(ksq, Them);
-
-            // Add pawn moves which gives discovered check. This is possible only
-            // if the pawn is not on the same file as the enemy king, because we
-            // don't generate captures.
-            if (pawns & target) // For CHECK type target is dc bitboard
-            {
-                dc1 = move_pawns<TDELTA_N>(pawns & target & ~file_bb(ksq)) & emptySquares;
-                dc2 = move_pawns<TDELTA_N>(dc1 & TRank3BB) & emptySquares;
-
-                b1 |= dc1;
-                b2 |= dc2;
-            }
-        }
-        SERIALIZE_MOVES_D(b1, -TDELTA_N);
-        SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
-    }
-
-    // En passant captures
-    if ((Type == MV_CAPTURE || Type == MV_EVASION) && pos.ep_square() != SQ_NONE)
-    {
-        assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
-        assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
-
-        // An en passant capture can be an evasion only if the checking piece
-        // is the double pushed pawn and so is in the target. Otherwise this
-        // is a discovery check and we are forced to do otherwise.
-        if (Type == MV_EVASION && !bit_is_set(target, pos.ep_square() - TDELTA_N))
-            return mlist;
-
-        b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
-
-        assert(b1 != EmptyBoardBB);
-
-        while (b1)
-        {
-            to = pop_1st_bit(&b1);
-            (*mlist++).move = make_ep_move(to, pos.ep_square());
-        }
-    }
-    return mlist;
-  }
-
-  template<CastlingSide Side>
-  MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
-
-    Color them = opposite_color(us);
-    Square ksq = pos.king_square(us);
-
-    assert(pos.piece_on(ksq) == make_piece(us, KING));
-
-    Square rsq = (Side == KING_SIDE ? pos.initial_kr_square(us) : pos.initial_qr_square(us));
-    Square s1 = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-    Square s2 = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-    Square s;
-    bool illegal = false;
-
-    assert(pos.piece_on(rsq) == make_piece(us, ROOK));
-
-    // It is a bit complicated to correctly handle Chess960
-    for (s = Min(ksq, s1); s <= Max(ksq, s1); s++)
-        if (  (s != ksq && s != rsq && pos.square_is_occupied(s))
-            ||(pos.attackers_to(s) & pos.pieces_of_color(them)))
-            illegal = true;
-
-    for (s = Min(rsq, s2); s <= Max(rsq, s2); s++)
-        if (s != ksq && s != rsq && pos.square_is_occupied(s))
-            illegal = true;
-
-    if (   Side == QUEEN_SIDE
-        && square_file(rsq) == FILE_B
-        && (   pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, ROOK)
-            || pos.piece_on(relative_square(us, SQ_A1)) == make_piece(them, QUEEN)))
-        illegal = true;
-
-    if (!illegal)
-        (*mlist++).move = make_castle_move(ksq, rsq);
-
-    return mlist;
-  }
-
-} // namespace

src/movegen.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,24 +17,42 @@
   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 "move.h"
+#include "types.h"
-#include "position.h"
 
-enum MoveType {
+enum GenType {
-  MV_CAPTURE,
+  CAPTURES,
-  MV_NON_CAPTURE,
+  QUIETS,
-  MV_CHECK,
+  QUIET_CHECKS,
-  MV_NON_CAPTURE_CHECK,
+  EVASIONS,
-  MV_EVASION,
+  NON_EVASIONS,
-  MV_NON_EVASION,
+  LEGAL
-  MV_LEGAL,
-  MV_PSEUDO_LEGAL
 };
 
-template<MoveType>
+class Position;
-MoveStack* generate(const Position& pos, MoveStack* mlist);
 
-#endif // !defined(MOVEGEN_H_INCLUDED)
+template<GenType>
+ExtMove* generate(const Position& pos, ExtMove* mlist);
+
+/// The MoveList struct is a simple wrapper around generate(), sometimes comes
+/// 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)) { last->move = MOVE_NONE; }
+  void operator++() { cur++; }
+  Move operator*() const { return cur->move; }
+  size_t size() const { return last - mlist; }
+  bool contains(Move m) const {
+    for (const ExtMove* it(mlist); it != last; ++it) if (it->move == m) return true;
+    return false;
+  }
+
+private:
+  ExtMove mlist[MAX_MOVES];
+  ExtMove *cur, *last;
+};
+
+#endif // #ifndef MOVEGEN_H_INCLUDED

src/movepick.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -20,174 +20,130 @@
 
 #include <cassert>
 
-#include "movegen.h"
 #include "movepick.h"
-#include "search.h"
+#include "thread.h"
-#include "types.h"
 
 namespace {
 
-  enum MovegenPhase {
+  enum Stages {
-    PH_TT_MOVES,      // Transposition table move and mate killer
+    MAIN_SEARCH, CAPTURES_S1, KILLERS_S1, QUIETS_1_S1, QUIETS_2_S1, BAD_CAPTURES_S1,
-    PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= 0
+    EVASION,     EVASIONS_S2,
-    PH_KILLERS,       // Killer moves from the current ply
+    QSEARCH_0,   CAPTURES_S3, QUIET_CHECKS_S3,
-    PH_NONCAPTURES,   // Non-captures and underpromotions
+    QSEARCH_1,   CAPTURES_S4,
-    PH_BAD_CAPTURES,  // Queen promotions and captures with SEE values < 0
+    PROBCUT,     CAPTURES_S5,
-    PH_EVASIONS,      // Check evasions
+    RECAPTURE,   CAPTURES_S6,
-    PH_QCAPTURES,     // Captures in quiescence search
+    STOP
-    PH_QCHECKS,       // Non-capture checks in quiescence search
-    PH_STOP
   };
 
-  CACHE_LINE_ALIGNMENT
+  // Our insertion sort, guaranteed to be stable, as is needed
-  const uint8_t MainSearchTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP };
+  void insertion_sort(ExtMove* begin, ExtMove* end)
-  const uint8_t EvasionTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP };
+  {
-  const uint8_t QsearchWithChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP };
+    ExtMove tmp, *p, *q;
-  const uint8_t QsearchWithoutChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP };
+
+    for (p = begin + 1; p < end; ++p)
+    {
+        tmp = *p;
+        for (q = p; 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 ExtMove& ms) { return ms.score > 0; }
+
+  // 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 ExtMove* pick_best(ExtMove* begin, ExtMove* end)
+  {
+      std::swap(*begin, *std::max_element(begin, end));
+      return begin;
+  }
 }
 
 
-/// Constructor for the MovePicker class. Apart from the position for which
+/// Constructors of the MovePicker class. As arguments we pass information
-/// it is asked to pick legal moves, MovePicker also wants some information
 /// to help it to return the presumably good moves first, to decide which
 /// moves to return (in the quiescence search, for instance, we only want to
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
-                       SearchStack* ss, Value beta) : pos(p), H(h) {
+                       Move* cm, Search::Stack* s) : pos(p), history(h), depth(d) {
-  int searchTT = ttm;
-  ttMoves[0].move = ttm;
-  badCaptureThreshold = 0;
-  badCaptures = moves + MAX_MOVES;
 
   assert(d > DEPTH_ZERO);
 
-  pinned = p.pinned_pieces(pos.side_to_move());
+  cur = end = moves;
+  endBadCaptures = moves + MAX_MOVES - 1;
+  countermoves = cm;
+  ss = s;
+
+  if (p.checkers())
+      stage = EVASION;
 
-  if (p.in_check())
-  {
-      ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
-      phasePtr = EvasionTable;
-  }
   else
-  {
+      stage = MAIN_SEARCH;
-      ttMoves[1].move = (ss->mateKiller == ttm) ? MOVE_NONE : ss->mateKiller;
-      searchTT |= ttMoves[1].move;
-      killers[0].move = ss->killers[0];
-      killers[1].move = ss->killers[1];
 
-      // Consider sligtly negative captures as good if at low
+  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-      // depth and far from beta.
+  end += (ttMove != MOVE_NONE);
-      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
-          badCaptureThreshold = -PawnValueMidgame;
-
-      phasePtr = MainSearchTable;
-  }
-
-  phasePtr += int(!searchTT) - 1;
-  go_next_phase();
 }
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h)
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
-                      : pos(p), H(h) {
+                       Square sq) : pos(p), history(h), cur(moves), end(moves) {
-  int searchTT = ttm;
-  ttMoves[0].move = ttm;
-  ttMoves[1].move = MOVE_NONE;
 
   assert(d <= DEPTH_ZERO);
 
-  pinned = p.pinned_pieces(pos.side_to_move());
+  if (p.checkers())
+      stage = EVASION;
 
-  if (p.in_check())
+  else if (d > DEPTH_QS_NO_CHECKS)
-      phasePtr = EvasionTable;
+      stage = QSEARCH_0;
-  else if (d >= DEPTH_QS_CHECKS)
+
-      phasePtr = QsearchWithChecksTable;
+  else if (d > DEPTH_QS_RECAPTURES)
+  {
+      stage = QSEARCH_1;
+
+      // 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
   {
-      phasePtr = QsearchWithoutChecksTable;
+      stage = RECAPTURE;
-
+      recaptureSquare = sq;
-      // Skip TT move if is not a capture or a promotion, this avoids
+      ttm = MOVE_NONE;
-      // qsearch tree explosion due to a possible perpetual check or
-      // similar rare cases when TT table is full.
-      if (ttm != MOVE_NONE && !pos.move_is_capture_or_promotion(ttm))
-          searchTT = ttMoves[0].move = MOVE_NONE;
   }
 
-  phasePtr += int(!searchTT) - 1;
+  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  go_next_phase();
+  end += (ttMove != MOVE_NONE);
+}
+
+MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, PieceType pt)
+                       : pos(p), history(h), cur(moves), end(moves) {
+
+  assert(!pos.checkers());
+
+  stage = PROBCUT;
+
+  // 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);
 }
 
 
-/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
+/// score() assign a numerical move ordering score to each move in a move list.
-/// of moves when there are no more moves to try for the current phase.
+/// The moves with highest scores will be picked first.
-
+template<>
-void MovePicker::go_next_phase() {
+void MovePicker::score<CAPTURES>() {
-
-  curMove = moves;
-  phase = *(++phasePtr);
-  switch (phase) {
-
-  case PH_TT_MOVES:
-      curMove = ttMoves;
-      lastMove = curMove + 2;
-      return;
-
-  case PH_GOOD_CAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_KILLERS:
-      curMove = killers;
-      lastMove = curMove + 2;
-      return;
-
-  case PH_NONCAPTURES:
-      lastMove = generate<MV_NON_CAPTURE>(pos, moves);
-      score_noncaptures();
-      sort_moves(moves, lastMove, &lastGoodNonCapture);
-      return;
-
-  case PH_BAD_CAPTURES:
-      // Bad captures SEE value is already calculated so just pick
-      // them in order to get SEE move ordering.
-      curMove = badCaptures;
-      lastMove = moves + MAX_MOVES;
-      return;
-
-  case PH_EVASIONS:
-      assert(pos.in_check());
-      lastMove = generate<MV_EVASION>(pos, moves);
-      score_evasions();
-      return;
-
-  case PH_QCAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_QCHECKS:
-      lastMove = generate<MV_NON_CAPTURE_CHECK>(pos, moves);
-      return;
-
-  case PH_STOP:
-      lastMove = curMove + 1; // Avoid another go_next_phase() call
-      return;
-
-  default:
-      assert(false);
-      return;
-  }
-}
-
-
-/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
-/// MovePicker::score_evasions() assign a numerical move ordering score
-/// to each move in a move list.  The moves with highest scores will be
-/// picked first by get_next_move().
-
-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
@@ -203,148 +159,219 @@ void MovePicker::score_captures() {
   // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
   Move m;
 
-  // Use MVV/LVA ordering
+  for (ExtMove* it = moves; it != end; ++it)
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
   {
-      m = cur->move;
+      m = it->move;
-      if (move_is_promotion(m))
+      it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
-          cur->score = QueenValueMidgame;
+                 - type_of(pos.piece_moved(m));
-      else
+
-          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
+      if (type_of(m) == PROMOTION)
-                      - pos.type_of_piece_on(move_from(m));
+          it->score += PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN];
+
+      else if (type_of(m) == ENPASSANT)
+          it->score += PieceValue[MG][PAWN];
   }
 }
 
-void MovePicker::score_noncaptures() {
+template<>
+void MovePicker::score<QUIETS>() {
 
   Move m;
-  Square from;
 
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  for (ExtMove* it = moves; it != end; ++it)
   {
-      m = cur->move;
+      m = it->move;
-      from = move_from(m);
+      it->score = history[pos.piece_moved(m)][to_sq(m)];
-      cur->score = H.value(pos.piece_on(from), move_to(m));
   }
 }
 
-void MovePicker::score_evasions() {
+template<>
-  // Try good captures ordered by MVV/LVA, then non-captures if
+void MovePicker::score<EVASIONS>() {
-  // destination square is not under attack, ordered by history
+  // Try good captures ordered by MVV/LVA, then non-captures if destination square
-  // value, and at the end bad-captures and non-captures with a
+  // is not under attack, ordered by history value, then bad-captures and quiet
-  // negative SEE. This last group is ordered by the SEE score.
+  // moves with a negative SEE. This last group is ordered by the SEE score.
   Move m;
   int seeScore;
 
-  // Skip if we don't have at least two moves to order
+  for (ExtMove* it = moves; it != end; ++it)
-  if (lastMove < moves + 2)
-      return;
-
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
   {
-      m = cur->move;
+      m = it->move;
       if ((seeScore = pos.see_sign(m)) < 0)
-          cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
+          it->score = seeScore - HistoryStats::Max; // At the bottom
-      else if (pos.move_is_capture(m))
+
-          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
+      else if (pos.is_capture(m))
-                      - pos.type_of_piece_on(move_from(m)) + History::MaxValue;
+          it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                     - type_of(pos.piece_moved(m)) + HistoryStats::Max;
       else
-          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
+          it->score = history[pos.piece_moved(m)][to_sq(m)];
   }
 }
 
-/// MovePicker::get_next_move() is the most important method of the MovePicker
-/// class. It returns a new legal move every time it 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 to return the tt move if has already been
-/// searched previously. Note that this function is not thread safe so should be
-/// lock protected by caller when accessed through a shared MovePicker object.
 
-Move MovePicker::get_next_move() {
+/// 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 (++stage) {
+
+  case CAPTURES_S1: case CAPTURES_S3: case CAPTURES_S4: case CAPTURES_S5: case CAPTURES_S6:
+      end = generate<CAPTURES>(pos, moves);
+      score<CAPTURES>();
+      return;
+
+  case KILLERS_S1:
+      cur = killers;
+      end = cur + 2;
+
+      killers[0].move = ss->killers[0];
+      killers[1].move = ss->killers[1];
+      killers[2].move = killers[3].move = MOVE_NONE;
+
+      // Be sure countermoves are different from killers
+      for (int i = 0; i < 2; i++)
+          if (countermoves[i] != cur->move && countermoves[i] != (cur+1)->move)
+              (end++)->move = countermoves[i];
+
+      if (countermoves[1] && countermoves[1] == countermoves[0]) // Due to SMP races
+          killers[3].move = MOVE_NONE;
+
+      return;
+
+  case QUIETS_1_S1:
+      endQuiets = end = generate<QUIETS>(pos, moves);
+      score<QUIETS>();
+      end = std::partition(cur, end, has_positive_score);
+      insertion_sort(cur, end);
+      return;
+
+  case QUIETS_2_S1:
+      cur = end;
+      end = endQuiets;
+      if (depth >= 3 * ONE_PLY)
+          insertion_sort(cur, end);
+      return;
+
+  case BAD_CAPTURES_S1:
+      // Just pick them in reverse order to get MVV/LVA ordering
+      cur = moves + MAX_MOVES - 1;
+      end = endBadCaptures;
+      return;
+
+  case EVASIONS_S2:
+      end = generate<EVASIONS>(pos, moves);
+      if (end > moves + 1)
+          score<EVASIONS>();
+      return;
+
+  case QUIET_CHECKS_S3:
+      end = generate<QUIET_CHECKS>(pos, moves);
+      return;
+
+  case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: case RECAPTURE:
+      stage = STOP;
+  case STOP:
+      end = cur + 1; // Avoid another next_phase() call
+      return;
+
+  default:
+      assert(false);
+  }
+}
+
+
+/// 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 (curMove == lastMove)
+      while (cur == end)
-          go_next_phase();
+          generate_next();
 
-      switch (phase) {
+      switch (stage) {
 
-      case PH_TT_MOVES:
+      case MAIN_SEARCH: case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT:
-          move = (curMove++)->move;
+          cur++;
-          if (   move != MOVE_NONE
+          return ttMove;
-              && pos.move_is_legal(move, pinned))
-              return move;
-          break;
 
-      case PH_GOOD_CAPTURES:
+      case CAPTURES_S1:
-          move = pick_best(curMove++, lastMove).move;
+          move = pick_best(cur++, end)->move;
-          if (   move != ttMoves[0].move
+          if (move != ttMove)
-              && move != ttMoves[1].move
-              && pos.pl_move_is_legal(move, pinned))
           {
-              // Check for a non negative SEE now
+              if (pos.see_sign(move) >= 0)
-              int seeValue = pos.see_sign(move);
-              if (seeValue >= badCaptureThreshold)
                   return move;
 
-              // Losing capture, move it to the tail of the array, note
+              // Losing capture, move it to the tail of the array
-              // that move has now been already checked for legality.
+              (endBadCaptures--)->move = move;
-              (--badCaptures)->move = move;
-              badCaptures->score = seeValue;
           }
           break;
 
-      case PH_KILLERS:
+      case KILLERS_S1:
-          move = (curMove++)->move;
+          move = (cur++)->move;
-          if (   move != MOVE_NONE
+          if (    move != MOVE_NONE
-              && pos.move_is_legal(move, pinned)
+              &&  pos.is_pseudo_legal(move)
-              && move != ttMoves[0].move
+              &&  move != ttMove
-              && move != ttMoves[1].move
+              && !pos.is_capture(move))
-              && !pos.move_is_capture(move))
               return move;
           break;
 
-      case PH_NONCAPTURES:
+      case QUIETS_1_S1: case QUIETS_2_S1:
-          // Sort negative scored moves only when we get there
+          move = (cur++)->move;
-          if (curMove == lastGoodNonCapture)
+          if (   move != ttMove
-              insertion_sort<MoveStack>(lastGoodNonCapture, lastMove);
-
-          move = (curMove++)->move;
-          if (   move != ttMoves[0].move
-              && move != ttMoves[1].move
               && move != killers[0].move
               && move != killers[1].move
-              && pos.pl_move_is_legal(move, pinned))
+              && move != killers[2].move
+              && move != killers[3].move)
               return move;
           break;
 
-      case PH_BAD_CAPTURES:
+      case BAD_CAPTURES_S1:
-          move = pick_best(curMove++, lastMove).move;
+          return (cur--)->move;
-          return move;
 
-      case PH_EVASIONS:
+      case EVASIONS_S2: case CAPTURES_S3: case CAPTURES_S4:
-      case PH_QCAPTURES:
+          move = pick_best(cur++, end)->move;
-          move = pick_best(curMove++, lastMove).move;
+          if (move != ttMove)
-          if (   move != ttMoves[0].move
-              && pos.pl_move_is_legal(move, pinned))
               return move;
           break;
 
-      case PH_QCHECKS:
+      case CAPTURES_S5:
-          move = (curMove++)->move;
+           move = pick_best(cur++, end)->move;
-          if (   move != ttMoves[0].move
+           if (move != ttMove && pos.see(move) > captureThreshold)
-              && pos.pl_move_is_legal(move, pinned))
+               return move;
+           break;
+
+      case CAPTURES_S6:
+          move = pick_best(cur++, end)->move;
+          if (to_sq(move) == recaptureSquare)
               return move;
           break;
 
-      case PH_STOP:
+      case QUIET_CHECKS_S3:
+          move = (cur++)->move;
+          if (move != ttMove)
+              return move;
+          break;
+
+      case STOP:
           return MOVE_NONE;
 
       default:
           assert(false);
-          break;
       }
   }
 }
+
+
+/// 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,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,47 +17,94 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined MOVEPICK_H_INCLUDED
+#ifndef MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED
 
-#include "history.h"
+#include <algorithm> // For std::max
-#include "move.h"
+#include <cstring>   // For std::memset
+
+#include "movegen.h"
 #include "position.h"
+#include "search.h"
 #include "types.h"
 
-struct SearchStack;
 
-/// MovePicker is a class which is used to pick one legal move at a time from
+/// The Stats struct stores moves statistics. According to the template parameter
-/// the current position. It is initialized with a Position object and a few
+/// the class can store History, Gains and Countermoves. History records how often
-/// moves we have reason to believe are good. The most important method is
+/// different moves have been successful or unsuccessful during the current search
-/// MovePicker::get_next_move(), which returns a new legal move each time it
+/// and is used for reduction and move ordering decisions. Gains records the move's
-/// is called, until there are no legal moves left, when MOVE_NONE is returned.
+/// best evaluation gain from one ply to the next and is used for pruning decisions.
-/// In order to improve the efficiency of the alpha beta algorithm, MovePicker
+/// Countermoves store the move that refute a previous one. Entries are stored
-/// attempts to return the moves which are most likely to get a cut-off first.
+/// according only to moving piece and destination square, hence two moves with
+/// different origin but same destination and piece will be considered identical.
+template<bool Gain, typename T>
+struct Stats {
+
+  static const Value Max = Value(2000);
+
+  const T* operator[](Piece p) const { return table[p]; }
+  void clear() { std::memset(table, 0, sizeof(table)); }
+
+  void update(Piece p, Square to, Move m) {
+
+    if (m == table[p][to].first)
+        return;
+
+    table[p][to].second = table[p][to].first;
+    table[p][to].first = m;
+  }
+
+  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;
+  }
+
+private:
+  T table[PIECE_NB][SQUARE_NB];
+};
+
+typedef Stats< true, Value> GainsStats;
+typedef Stats<false, Value> HistoryStats;
+typedef Stats<false, std::pair<Move, Move> > CountermovesStats;
+
+
+/// MovePicker class is used to pick one pseudo legal move at a time from the
+/// current position. The most important method is next_move(), which returns a
+/// new pseudo legal move each time it is called, until there are no moves left,
+/// when MOVE_NONE is returned. In order to improve the efficiency of the alpha
+/// beta algorithm, MovePicker attempts to return the moves which are most likely
+/// to get a cut-off first.
 
 class MovePicker {
 
   MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
 
 public:
-  MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value);
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Square);
-  MovePicker(const Position&, Move, Depth, const History&);
+  MovePicker(const Position&, Move, const HistoryStats&, PieceType);
-  Move get_next_move();
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Move*, Search::Stack*);
+
+  template<bool SpNode> Move next_move();
 
 private:
-  void score_captures();
+  template<GenType> void score();
-  void score_noncaptures();
+  void generate_next();
-  void score_evasions();
-  void go_next_phase();
 
   const Position& pos;
-  const History& H;
+  const HistoryStats& history;
-  Bitboard pinned;
+  Search::Stack* ss;
-  MoveStack ttMoves[2], killers[2];
+  Move* countermoves;
-  int badCaptureThreshold, phase;
+  Depth depth;
-  const uint8_t* phasePtr;
+  Move ttMove;
-  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *badCaptures;
+  ExtMove killers[4];
-  MoveStack moves[MAX_MOVES];
+  Square recaptureSquare;
+  int captureThreshold, stage;
+  ExtMove *cur, *end, *endQuiets, *endBadCaptures;
+  ExtMove moves[MAX_MOVES];
 };
 
-#endif // !defined(MOVEPICK_H_INCLUDED)
+#endif // #ifndef MOVEPICK_H_INCLUDED

src/notation.cpp

@@ -0,0 +1,263 @@
+/*
+  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> it(pos); *it; ++it)
+      if (str == move_to_uci(*it, pos.is_chess960()))
+          return *it;
+
+  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

@@ -0,0 +1,35 @@
+/*
+  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/>.
+*/
+
+#ifndef 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 // #ifndef NOTATION_H_INCLUDED

src/pawns.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,6 +17,7 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>
 #include <cassert>
 
 #include "bitboard.h"
@@ -26,218 +27,255 @@
 
 namespace {
 
+  #define V Value
   #define S(mg, eg) make_score(mg, eg)
 
   // Doubled pawn penalty by opposed flag and file
-  const Score DoubledPawnPenalty[2][8] = {
+  const Score Doubled[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 by opposed flag and file
-  const Score IsolatedPawnPenalty[2][8] = {
+  const Score Isolated[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 by opposed flag and file
-  const Score BackwardPawnPenalty[2][8] = {
+  const Score Backward[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) }};
 
   // Pawn chain membership bonus by file
-  const Score ChainBonus[8] = {
+  const Score ChainMember[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)
   };
 
   // Candidate passed pawn bonus by rank
-  const Score CandidateBonus[8] = {
+  const Score CandidatePassed[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)
   };
 
-  const Score PawnStructureWeight = S(233, 201);
+  // Weakness of our pawn shelter in front of the king indexed by [rank]
+  const Value ShelterWeakness[RANK_NB] =
+  { V(100), V(0), V(27), V(73), V(92), V(101), V(101) };
+
+  // Danger of enemy pawns moving toward our king indexed by
+  // [no friendly pawn | pawn unblocked | pawn blocked][rank of enemy pawn]
+  const Value StormDanger[3][RANK_NB] = {
+  { V( 0),  V(64), V(128), V(51), V(26) },
+  { V(26),  V(32), V( 96), V(38), V(20) },
+  { V( 0),  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);
 
   #undef S
+  #undef V
 
-  inline Score apply_weight(Score v, Score w) {
+  template<Color Us>
-    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
+  Score evaluate(const Position& pos, Pawns::Entry* e) {
-                      (int(eg_value(v)) * eg_value(w)) / 0x100);
+
+    const Color  Them  = (Us == WHITE ? BLACK    : WHITE);
+    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);
+
+    Bitboard b;
+    Square s;
+    File f;
+    Rank r;
+    bool passed, isolated, doubled, opposed, chain, backward, candidate;
+    Score value = SCORE_ZERO;
+    const Square* pl = pos.list<PAWN>(Us);
+
+    Bitboard ourPawns = pos.pieces(Us, PAWN);
+    Bitboard theirPawns = pos.pieces(Them, PAWN);
+
+    e->passedPawns[Us] = 0;
+    e->kingSquares[Us] = SQ_NONE;
+    e->semiopenFiles[Us] = 0xFF;
+    e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
+    e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(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);
+
+        // This file cannot be semi-open
+        e->semiopenFiles[Us] &= ~(1 << f);
+
+        // 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 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 & pawn_attack_span(Them, s))
+            && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
+        {
+            // 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);
+
+            // 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)))
+                b = shift_bb<Up>(b);
+
+            // 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 | shift_bb<Up>(b)) & theirPawns;
+        }
+
+        assert(opposed | passed | (pawn_attack_span(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 = pawn_attack_span(Them, s + pawn_push(Us)) & ourPawns) != 0
+                   &&  popcount<Max15>(b) >= popcount<Max15>(pawn_attack_span(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)
+            e->passedPawns[Us] |= s;
+
+        // Score this pawn
+        if (isolated)
+            value -= Isolated[opposed][f];
+
+        if (doubled)
+            value -= Doubled[opposed][f];
+
+        if (backward)
+            value -= Backward[opposed][f];
+
+        if (chain)
+            value += ChainMember[f];
+
+        if (candidate)
+            value += CandidatePassed[relative_rank(Us, s)];
+    }
+
+    return value;
   }
+
+} // 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.
+
+Entry* probe(const Position& pos, Table& entries) {
+
+  Key key = pos.pawn_key();
+  Entry* e = entries[key];
+
+  if (e->key == key)
+      return e;
+
+  e->key = key;
+  e->value = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
+  return e;
 }
 
 
-/// PawnInfoTable::get_pawn_info() takes a position object as input, computes
+/// Entry::shelter_storm() calculates shelter and storm penalties for the file
-/// a PawnInfo object, and returns a pointer to it. The result is also stored
+/// the king is on, as well as the two adjacent files.
-/// in an hash table, so we don't have to recompute everything when the same
-/// pawn structure occurs again.
-
-PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
-
-  assert(pos.is_ok());
-
-  Key key = pos.get_pawn_key();
-  PawnInfo* pi = probe(key);
-
-  // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return
-  // the information we found the last time instead of recomputing it.
-  if (pi->key == key)
-      return pi;
-
-  // Initialize PawnInfo entry
-  pi->key = key;
-  pi->passedPawns[WHITE] = pi->passedPawns[BLACK] = 0;
-  pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
-  pi->halfOpenFiles[WHITE] = pi->halfOpenFiles[BLACK] = 0xFF;
-
-  // Calculate pawn attacks
-  Bitboard wPawns = pos.pieces(PAWN, WHITE);
-  Bitboard bPawns = pos.pieces(PAWN, BLACK);
-  pi->pawnAttacks[WHITE] = ((wPawns << 9) & ~FileABB) | ((wPawns << 7) & ~FileHBB);
-  pi->pawnAttacks[BLACK] = ((bPawns >> 7) & ~FileABB) | ((bPawns >> 9) & ~FileHBB);
-
-  // Evaluate pawns for both colors and weight the result
-  pi->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, pi)
-             - evaluate_pawns<BLACK>(pos, bPawns, wPawns, pi);
-
-  pi->value = apply_weight(pi->value, PawnStructureWeight);
-
-  return pi;
-}
-
-
-/// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
 
 template<Color Us>
-Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
+Value Entry::shelter_storm(const Position& pos, Square ksq) {
-                                    Bitboard theirPawns, PawnInfo* pi) {
 
-  const BitCountType Max15 = CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
   const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-  Bitboard b;
+  Value safety = MaxSafetyBonus;
-  Square s;
+  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq));
-  File f;
+  Bitboard ourPawns = b & pos.pieces(Us);
-  Rank r;
+  Bitboard theirPawns = b & pos.pieces(Them);
-  bool passed, isolated, doubled, opposed, chain, backward, candidate;
+  Rank rkUs, rkThem;
-  Score value = SCORE_ZERO;
+  File kf = file_of(ksq);
-  const Square* ptr = pos.piece_list_begin(Us, PAWN);
 
-  // Loop through all pawns of the current color and score each pawn
+  kf = (kf == FILE_A) ? FILE_B : (kf == FILE_H) ? FILE_G : kf;
-  while ((s = *ptr++) != SQ_NONE)
+
+  for (int f = kf - 1; f <= kf + 1; f++)
   {
-      assert(pos.piece_on(s) == make_piece(Us, PAWN));
+      b = ourPawns & FileBB[f];
+      rkUs = b ? relative_rank(Us, Us == WHITE ? lsb(b) : msb(b)) : RANK_1;
+      safety -= ShelterWeakness[rkUs];
 
-      f = square_file(s);
+      b  = theirPawns & FileBB[f];
-      r = square_rank(s);
+      rkThem = b ? relative_rank(Us, Us == WHITE ? lsb(b) : msb(b)) : RANK_1;
-
+      safety -= StormDanger[rkUs == RANK_1 ? 0 : rkThem == rkUs + 1 ? 2 : 1][rkThem];
-      // This file cannot be half open
-      pi->halfOpenFiles[Us] &= ~(1 << f);
-
-      // 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 as passed, isolated, doubled or member of a pawn
-      // chain (but not the backward one).
-      passed   = !(theirPawns & passed_pawn_mask(Us, s));
-      doubled  =   ourPawns   & squares_in_front_of(Us, s);
-      opposed  =   theirPawns & squares_in_front_of(Us, s);
-      isolated = !(ourPawns   & neighboring_files_bb(f));
-      chain    =   ourPawns   & neighboring_files_bb(f) & b;
-
-      // Test for backward pawn
-      backward = false;
-
-      // If the pawn is passed, isolated, or member of a pawn chain it cannot
-      // be backward. If there are friendly pawns behind on neighboring files
-      // or if can capture an enemy pawn it cannot be backward either.
-      if (   !(passed | isolated | chain)
-          && !(ourPawns & attack_span_mask(Them, s))
-          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
-      {
-          // We now know that there are no friendly pawns beside or behind this
-          // pawn on neighboring files. We now check whether the pawn is
-          // backward by looking in the forward direction on the neighboring
-          // files, and seeing whether we meet a friendly or an enemy pawn first.
-          b = pos.attacks_from<PAWN>(s, Us);
-
-          // Note that we are sure to find something because pawn is not passed
-          // nor isolated, so loop is potentially infinite, but it isn't.
-          while (!(b & (ourPawns | theirPawns)))
-              Us == WHITE ? b <<= 8 : b >>= 8;
-
-          // 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(opposed | passed | (attack_span_mask(Us, s) & theirPawns));
-
-      // A not passed pawn is a candidate to become passed if it is free to
-      // advance and if the number of friendly pawns beside or behind this
-      // pawn on neighboring files is higher or equal than the number of
-      // enemy pawns in the forward direction on the neighboring files.
-      candidate =   !(opposed | passed | backward | isolated)
-                 && (b = attack_span_mask(Them, s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
-                 &&  count_1s<Max15>(b) >= count_1s<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)
-          set_bit(&(pi->passedPawns[Us]), s);
-
-      // Score this pawn
-      if (isolated)
-          value -= IsolatedPawnPenalty[opposed][f];
-
-      if (doubled)
-          value -= DoubledPawnPenalty[opposed][f];
-
-      if (backward)
-          value -= BackwardPawnPenalty[opposed][f];
-
-      if (chain)
-          value += ChainBonus[f];
-
-      if (candidate)
-          value += CandidateBonus[relative_rank(Us, s)];
   }
-  return value;
+
+  return safety;
 }
 
 
-/// PawnInfo::updateShelter() calculates and caches king shelter. It is called
+/// Entry::update_safety() calculates and caches a bonus for king safety. It is
-/// only when king square changes, about 20% of total king_shelter() calls.
+/// called only when king square changes, about 20% of total king_safety() calls.
+
 template<Color Us>
-Score PawnInfo::updateShelter(const Position& pos, Square ksq) {
+Score Entry::update_safety(const Position& pos, Square ksq) {
 
-  const int Shift = (Us == WHITE ? 8 : -8);
-
-  Bitboard pawns;
-  int r, shelter = 0;
-
-  if (relative_rank(Us, ksq) <= RANK_4)
-  {
-      pawns = pos.pieces(PAWN, Us) & this_and_neighboring_files_bb(ksq);
-      r = ksq & (7 << 3);
-      for (int i = 0; i < 3; i++)
-      {
-          r += Shift;
-          shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (64 >> i);
-      }
-  }
   kingSquares[Us] = ksq;
-  kingShelters[Us] = make_score(shelter, 0);
+  castleRights[Us] = pos.can_castle(Us);
-  return kingShelters[Us];
+  minKPdistance[Us] = 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]);
+
+  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)))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_G1)));
+
+  if (pos.can_castle(make_castle_right(Us, QUEEN_SIDE)))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
+
+  return kingSafety[Us] = make_score(bonus, -16 * minKPdistance[Us]);
 }
 
 // Explicit template instantiation
-template Score PawnInfo::updateShelter<WHITE>(const Position& pos, Square ksq);
+template Score Entry::update_safety<WHITE>(const Position& pos, Square ksq);
-template Score PawnInfo::updateShelter<BLACK>(const Position& pos, Square ksq);
+template Score Entry::update_safety<BLACK>(const Position& pos, Square ksq);
+
+} // namespace Pawns

src/pawns.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,91 +17,62 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(PAWNS_H_INCLUDED)
+#ifndef PAWNS_H_INCLUDED
 #define PAWNS_H_INCLUDED
 
+#include "misc.h"
 #include "position.h"
-#include "tt.h"
 #include "types.h"
 
-const int PawnTableSize = 16384;
+namespace Pawns {
 
-/// PawnInfo is a class which contains various information about a pawn
+/// Pawns::Entry contains various information about a pawn structure. Currently,
-/// structure. Currently, it only includes a middle game and an end game
+/// it only includes a middle game and end game pawn structure evaluation, and a
-/// pawn structure evaluation, and a bitboard of passed pawns. We may want
+/// bitboard of passed pawns. We may want to add further information in the future.
-/// to add further information in the future. A lookup to the pawn hash table
+/// A lookup to the pawn hash table (performed by calling the probe function)
-/// (performed by calling the get_pawn_info method in a PawnInfoTable object)
+/// returns a pointer to an Entry object.
-/// returns a pointer to a PawnInfo object.
 
-class PawnInfo {
+struct Entry {
 
-  friend class PawnInfoTable;
+  Score pawns_value() const { return value; }
+  Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
+  Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
+  int pawns_on_same_color_squares(Color c, Square s) const { return pawnsOnSquares[c][!!(DarkSquares & s)]; }
+  int semiopen(Color c, File f) const { return semiopenFiles[c] & (1 << int(f)); }
+  int semiopen_on_side(Color c, File f, bool left) const {
 
-public:
+    return semiopenFiles[c] & (left ? ((1 << int(f)) - 1) : ~((1 << int(f+1)) - 1));
-  Score pawns_value() const;
+  }
-  Bitboard pawn_attacks(Color c) const;
-  Bitboard passed_pawns(Color c) const;
-  int file_is_half_open(Color c, File f) const;
-  int has_open_file_to_left(Color c, File f) const;
-  int has_open_file_to_right(Color c, File f) const;
 
   template<Color Us>
-  Score king_shelter(const Position& pos, Square ksq);
+  Score king_safety(const Position& pos, Square ksq)  {
+
+    return kingSquares[Us] == ksq && castleRights[Us] == pos.can_castle(Us)
+         ? kingSafety[Us] : update_safety<Us>(pos, ksq);
+  }
 
-private:
   template<Color Us>
-  Score updateShelter(const Position& pos, Square ksq);
+  Score update_safety(const Position& pos, Square ksq);
+
+  template<Color Us>
+  Value shelter_storm(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns[2];
+  Bitboard passedPawns[COLOR_NB];
-  Bitboard pawnAttacks[2];
+  Bitboard pawnAttacks[COLOR_NB];
-  Square kingSquares[2];
+  Square kingSquares[COLOR_NB];
+  int minKPdistance[COLOR_NB];
+  int castleRights[COLOR_NB];
   Score value;
-  int halfOpenFiles[2];
+  int semiopenFiles[COLOR_NB];
-  Score kingShelters[2];
+  Score kingSafety[COLOR_NB];
+  int pawnsOnSquares[COLOR_NB][COLOR_NB];
 };
 
+typedef HashTable<Entry, 16384> Table;
 
-/// The PawnInfoTable class represents a pawn hash table. The most important
+Entry* probe(const Position& pos, Table& entries);
-/// method is get_pawn_info, which returns a pointer to a PawnInfo object.
 
-class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
-public:
-  PawnInfo* get_pawn_info(const Position& pos) const;
-
-private:
-  template<Color Us>
-  static Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
-};
-
-
-inline Score PawnInfo::pawns_value() const {
-  return value;
 }
 
-inline Bitboard PawnInfo::pawn_attacks(Color c) const {
+#endif // #ifndef PAWNS_H_INCLUDED
-  return pawnAttacks[c];
-}
-
-inline Bitboard PawnInfo::passed_pawns(Color c) const {
-  return passedPawns[c];
-}
-
-inline int PawnInfo::file_is_half_open(Color c, File f) const {
-  return halfOpenFiles[c] & (1 << int(f));
-}
-
-inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
-  return halfOpenFiles[c] & ((1 << int(f)) - 1);
-}
-
-inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
-  return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
-}
-
-template<Color Us>
-inline Score PawnInfo::king_shelter(const Position& pos, Square ksq) {
-  return kingSquares[Us] == ksq ? kingShelters[Us] : updateShelter<Us>(pos, ksq);
-}
-
-#endif // !defined(PAWNS_H_INCLUDED)

src/platform.h

@@ -0,0 +1,116 @@
+/*
+  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/>.
+*/
+
+#ifndef PLATFORM_H_INCLUDED
+#define PLATFORM_H_INCLUDED
+
+#ifdef _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>
+#endif
+
+#ifndef _WIN32 // Linux - Unix
+
+#  include <sys/time.h>
+
+inline int64_t system_time_to_msec() {
+  timeval t;
+  gettimeofday(&t, NULL);
+  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>
+
+inline int64_t system_time_to_msec() {
+  _timeb t;
+  _ftime(&t);
+  return t.time * 1000LL + t.millitm;
+}
+
+#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
+
+// 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()))
+#  define thread_join(x) { WaitForSingleObject(x, INFINITE); CloseHandle(x); }
+
+#endif
+
+#endif // #ifndef PLATFORM_H_INCLUDED

src/position.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,69 +17,56 @@
   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 "bitboard.h"
-#include "move.h"
 #include "types.h"
 
-/// Maximum number of plies per game (220 should be enough, because the
-/// maximum search depth is 100, and during position setup we reset the
-/// move counter for every non-reversible move).
-const int MaxGameLength = 220;
 
+/// 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 is initialized at c'tor time and keeps
-/// info used to detect if a move gives check.
 
 struct CheckInfo {
 
-    explicit CheckInfo(const Position&);
+  explicit CheckInfo(const Position&);
 
-    Bitboard dcCandidates;
+  Bitboard dcCandidates;
-    Bitboard checkSq[8];
+  Bitboard pinned;
-    Square ksq;
+  Bitboard checkSq[PIECE_TYPE_NB];
-};
+  Square ksq;
-
-/// Castle rights, encoded as bit fields
-
-enum CastleRights {
-  CASTLES_NONE = 0,
-  WHITE_OO     = 1,
-  BLACK_OO     = 2,
-  WHITE_OOO    = 4,
-  BLACK_OOO    = 8,
-  ALL_CASTLES  = 15
-};
-
-/// Game phase
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
 };
 
 
 /// The StateInfo struct stores information we need to restore a Position
 /// object to its previous state when we retract a move. Whenever a move
-/// is made on the board (by calling Position::do_move), an StateInfo object
+/// is made on the board (by calling Position::do_move), a StateInfo object
 /// must be passed as a parameter.
 
 struct StateInfo {
   Key pawnKey, materialKey;
-  int castleRights, rule50, gamePly, pliesFromNull;
+  Value npMaterial[COLOR_NB];
+  int castleRights, rule50, pliesFromNull;
+  Score psq;
   Square epSquare;
-  Score value;
-  Value npMaterial[2];
 
-  PieceType capturedType;
   Key key;
   Bitboard checkersBB;
+  PieceType capturedType;
   StateInfo* previous;
 };
 
 
+/// 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;
+
+
 /// The position data structure. A position consists of the following data:
 ///
 ///    * For each piece type, a bitboard representing the squares occupied
@@ -103,107 +90,68 @@ struct StateInfo {
 ///    * A counter for detecting 50 move rule draws.
 
 class Position {
-
-  Position(); // No default or copy c'tor allowed
-  Position(const Position& pos);
-
 public:
-  enum GamePhase {
+  Position() {}
-      MidGame,
+  Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
-      EndGame
+  Position(const std::string& f, bool c960, Thread* t) { set(f, c960, t); }
-  };
+  Position& operator=(const Position&);
-
+  static void init();
-  // Constructors
-  Position(const Position& pos, int threadID);
-  Position(const std::string& fen, bool isChess960, int threadID);
 
   // Text input/output
-  void from_fen(const std::string& fen, bool isChess960);
+  void set(const std::string& fen, bool isChess960, Thread* th);
-  const std::string to_fen() const;
+  const std::string fen() const;
-  void print(Move m = MOVE_NONE) const;
+  const std::string pretty(Move m = MOVE_NONE) const;
 
-  // Copying
+  // Position representation
-  void flip();
+  Bitboard pieces() const;
-
-  // The piece on a given square
-  Piece piece_on(Square s) const;
-  PieceType type_of_piece_on(Square s) const;
-  Color color_of_piece_on(Square s) const;
-  bool square_is_empty(Square s) const;
-  bool square_is_occupied(Square s) const;
-  Value midgame_value_of_piece_on(Square s) const;
-  Value endgame_value_of_piece_on(Square s) const;
-
-  // Side to move
-  Color side_to_move() const;
-
-  // Bitboard representation of the position
-  Bitboard empty_squares() const;
-  Bitboard occupied_squares() const;
-  Bitboard pieces_of_color(Color c) const;
   Bitboard pieces(PieceType pt) const;
-  Bitboard pieces(PieceType pt, Color c) const;
   Bitboard pieces(PieceType pt1, PieceType pt2) const;
-  Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
+  Bitboard pieces(Color c) const;
-
+  Bitboard pieces(Color c, PieceType pt) const;
-  // Number of pieces of each color and type
+  Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
-  int piece_count(Color c, PieceType pt) const;
+  Piece piece_on(Square s) const;
-
-  // The en passant square
-  Square ep_square() const;
-
-  // Current king position for each color
   Square king_square(Color c) const;
+  Square ep_square() const;
+  bool is_empty(Square s) const;
+  template<PieceType Pt> int count(Color c) const;
+  template<PieceType Pt> const Square* list(Color c) const;
 
-  // Castling rights
+  // Castling
-  bool can_castle_kingside(Color c) const;
+  int can_castle(CastleRight f) const;
-  bool can_castle_queenside(Color c) const;
+  int can_castle(Color c) const;
-  bool can_castle(Color c) const;
+  bool castle_impeded(Color c, CastlingSide s) const;
-  Square initial_kr_square(Color c) const;
+  Square castle_rook_square(Color c, CastlingSide s) const;
-  Square initial_qr_square(Color c) const;
 
-  // Bitboards for pinned pieces and discovered check candidates
+  // Checking
-  Bitboard discovered_check_candidates(Color c) const;
-  Bitboard pinned_pieces(Color c) const;
-
-  // Checking pieces and under check information
   Bitboard checkers() const;
-  bool in_check() const;
+  Bitboard discovered_check_candidates() const;
+  Bitboard pinned_pieces() const;
 
-  // Piece lists
+  // Attacks to/from a given square
-  Square piece_list(Color c, PieceType pt, int index) const;
-  const Square* piece_list_begin(Color c, PieceType pt) const;
-
-  // Information about attacks to or from a given square
   Bitboard attackers_to(Square s) const;
+  Bitboard attackers_to(Square s, Bitboard occ) const;
   Bitboard attacks_from(Piece p, Square s) const;
   static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
   template<PieceType> Bitboard attacks_from(Square s) const;
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool pl_move_is_legal(Move m, Bitboard pinned) const;
-  bool pl_move_is_evasion(Move m, Bitboard pinned) const;
-  bool move_is_legal(const Move m) const;
-  bool move_is_legal(const Move m, Bitboard pinned) const;
-  bool move_gives_check(Move m) const;
   bool move_gives_check(Move m, const CheckInfo& ci) const;
-  bool move_is_capture(Move m) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
-  bool move_is_capture_or_promotion(Move m) const;
+  bool is_pseudo_legal(const Move m) const;
-  bool move_is_passed_pawn_push(Move m) const;
+  bool is_capture(Move m) const;
-  bool move_attacks_square(Move m, Square s) const;
+  bool is_capture_or_promotion(Move m) const;
-
+  bool is_passed_pawn_push(Move m) const;
-  // Piece captured with previous moves
+  Piece piece_moved(Move m) const;
   PieceType captured_piece_type() const;
 
-  // Information about pawns
+  // Piece specific
   bool pawn_is_passed(Color c, Square s) const;
-
+  bool pawn_on_7th(Color c) const;
-  // Weak squares
+  bool opposite_bishops() const;
-  bool square_is_weak(Square s, Color c) const;
+  bool bishop_pair(Color c) const;
 
   // Doing and undoing moves
-  void do_setup_move(Move m);
   void do_move(Move m, StateInfo& st);
   void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
   void undo_move(Move m);
@@ -211,64 +159,43 @@ public:
   void undo_null_move();
 
   // Static exchange evaluation
-  int see(Square from, Square to) const;
+  int see(Move m, int asymmThreshold = 0) const;
-  int see(Move m) const;
   int see_sign(Move m) const;
 
   // Accessing hash keys
-  Key get_key() const;
+  Key key() const;
-  Key get_exclusion_key() const;
+  Key exclusion_key() const;
-  Key get_pawn_key() const;
+  Key pawn_key() const;
-  Key get_material_key() const;
+  Key material_key() const;
 
-  // Incremental evaluation
+  // Incremental piece-square evaluation
-  Score value() const;
+  Score psq_score() const;
   Value non_pawn_material(Color c) const;
-  static Score pst_delta(Piece piece, Square from, Square to);
-
-  // Game termination checks
-  bool is_mate() const;
-  bool is_draw() const;
-
-  // Number of plies from starting position
-  int startpos_ply_counter() const;
 
   // Other properties of the position
-  bool opposite_colored_bishops() const;
+  Color side_to_move() const;
-  bool has_pawn_on_7th(Color c) const;
+  int game_ply() const;
   bool is_chess960() const;
-
+  Thread* this_thread() const;
-  // Current thread ID searching on the position
-  int thread() const;
-
   int64_t nodes_searched() const;
   void set_nodes_searched(int64_t n);
+  bool is_draw() const;
 
   // Position consistency check, for debugging
-  bool is_ok(int* failedStep = NULL) const;
+  bool pos_is_ok(int* failedStep = NULL) const;
-
+  void flip();
-  // Static member functions
-  static void init_zobrist();
-  static void init_piece_square_tables();
 
 private:
-
+  // Initialization helpers (used while setting up a position)
-  // Initialization helper functions (used while setting up a position)
   void clear();
-  void detach();
+  void set_castle_right(Color c, Square rfrom);
-  void put_piece(Piece p, Square s);
-  void do_allow_oo(Color c);
-  void do_allow_ooo(Color c);
-  bool set_castling_rights(char token);
 
-  // Helper functions for doing and undoing moves
+  // Helper functions
-  void do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep);
+  void do_castle(Square kfrom, Square kto, Square rfrom, Square rto);
-  void do_castle_move(Move m);
+  Bitboard hidden_checkers(Square ksq, Color c) const;
-  void undo_castle_move(Move m);
+  void put_piece(Square s, Color c, PieceType pt);
-  void find_checkers();
+  void remove_piece(Square s, Color c, PieceType pt);
-
+  void move_piece(Square from, Square to, Color c, PieceType pt);
-  template<bool FindPinned>
-  Bitboard hidden_checkers(Color c) const;
 
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
@@ -276,45 +203,28 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  static Score pst(Color c, PieceType pt, Square s);
+  Score compute_psq_score() const;
-  Score compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
-  // Board
+  // Board and pieces
-  Piece board[64];
+  Piece board[SQUARE_NB];
-
+  Bitboard byTypeBB[PIECE_TYPE_NB];
-  // Bitboards
+  Bitboard byColorBB[COLOR_NB];
-  Bitboard byTypeBB[8], byColorBB[2];
+  int pieceCount[COLOR_NB][PIECE_TYPE_NB];
-
+  Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
-  // Piece counts
+  int index[SQUARE_NB];
-  int pieceCount[2][8]; // [color][pieceType]
-
-  // Piece lists
-  Square pieceList[2][8][16]; // [color][pieceType][index]
-  int index[64]; // [square]
 
   // Other info
-  Color sideToMove;
+  int castleRightsMask[SQUARE_NB];
-  Key history[MaxGameLength];
+  Square castleRookSquare[COLOR_NB][CASTLING_SIDE_NB];
-  int castleRightsMask[64];
+  Bitboard castlePath[COLOR_NB][CASTLING_SIDE_NB];
   StateInfo startState;
-  File initialKFile, initialKRFile, initialQRFile;
-  bool chess960;
-  int startPosPlyCounter;
-  int threadID;
   int64_t nodes;
+  int gamePly;
+  Color sideToMove;
+  Thread* thisThread;
   StateInfo* st;
-
+  int chess960;
-  // Static variables
-  static Key zobrist[2][8][64];
-  static Key zobEp[64];
-  static Key zobCastle[16];
-  static Key zobSideToMove;
-  static Score PieceSquareTable[16][64];
-  static Key zobExclusion;
-  static const Value seeValues[8];
-  static const Value PieceValueMidgame[17];
-  static const Value PieceValueEndgame[17];
 };
 
 inline int64_t Position::nodes_searched() const {
@@ -329,72 +239,48 @@ inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
-inline Color Position::color_of_piece_on(Square s) const {
+inline Piece Position::piece_moved(Move m) const {
-  return color_of_piece(piece_on(s));
+  return board[from_sq(m)];
 }
 
-inline PieceType Position::type_of_piece_on(Square s) const {
+inline bool Position::is_empty(Square s) const {
-  return type_of_piece(piece_on(s));
+  return board[s] == NO_PIECE;
-}
-
-inline bool Position::square_is_empty(Square s) const {
-  return piece_on(s) == PIECE_NONE;
-}
-
-inline bool Position::square_is_occupied(Square s) const {
-  return !square_is_empty(s);
-}
-
-inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return PieceValueMidgame[piece_on(s)];
-}
-
-inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return PieceValueEndgame[piece_on(s)];
 }
 
 inline Color Position::side_to_move() const {
   return sideToMove;
 }
 
-inline Bitboard Position::occupied_squares() const {
+inline Bitboard Position::pieces() const {
-  return byTypeBB[0];
+  return byTypeBB[ALL_PIECES];
-}
-
-inline Bitboard Position::empty_squares() const {
-  return ~occupied_squares();
-}
-
-inline Bitboard Position::pieces_of_color(Color c) const {
-  return byColorBB[c];
 }
 
 inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces(PieceType pt, Color c) const {
-  return byTypeBB[pt] & byColorBB[c];
-}
-
 inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
   return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
+inline Bitboard Position::pieces(Color c) const {
-  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
+  return byColorBB[c];
 }
 
-inline int Position::piece_count(Color c, PieceType pt) const {
+inline Bitboard Position::pieces(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+  return byColorBB[c] & byTypeBB[pt];
 }
 
-inline Square Position::piece_list(Color c, PieceType pt, int idx) const {
+inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
-  return pieceList[c][pt][idx];
+  return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
 }
 
-inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
+template<PieceType Pt> inline int Position::count(Color c) const {
-  return pieceList[c][pt];
+  return pieceCount[c][Pt];
+}
+
+template<PieceType Pt> inline const Square* Position::list(Color c) const {
+  return pieceList[c][Pt];
 }
 
 inline Square Position::ep_square() const {
@@ -405,24 +291,28 @@ inline Square Position::king_square(Color c) const {
   return pieceList[c][KING][0];
 }
 
-inline bool Position::can_castle_kingside(Color side) const {
+inline int Position::can_castle(CastleRight f) const {
-  return st->castleRights & (1+int(side));
+  return st->castleRights & f;
 }
 
-inline bool Position::can_castle_queenside(Color side) const {
+inline int Position::can_castle(Color c) const {
-  return st->castleRights & (4+4*int(side));
+  return st->castleRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
 }
 
-inline bool Position::can_castle(Color side) const {
+inline bool Position::castle_impeded(Color c, CastlingSide s) const {
-  return can_castle_kingside(side) || can_castle_queenside(side);
+  return byTypeBB[ALL_PIECES] & castlePath[c][s];
 }
 
-inline Square Position::initial_kr_square(Color c) const {
+inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
-  return relative_square(c, make_square(initialKRFile, RANK_1));
+  return castleRookSquare[c][s];
 }
 
-inline Square Position::initial_qr_square(Color c) const {
+template<PieceType Pt>
-  return relative_square(c, make_square(initialQRFile, RANK_1));
+inline Bitboard Position::attacks_from(Square s) const {
+
+  return  Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, pieces())
+        : Pt == QUEEN  ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
+        : StepAttacksBB[Pt][s];
 }
 
 template<>
@@ -430,125 +320,140 @@ inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
   return StepAttacksBB[make_piece(c, PAWN)][s];
 }
 
-template<PieceType Piece> // Knight and King and white pawns
+inline Bitboard Position::attacks_from(Piece p, Square s) const {
-inline Bitboard Position::attacks_from(Square s) const {
+  return attacks_from(p, s, byTypeBB[ALL_PIECES]);
-  return StepAttacksBB[Piece][s];
 }
 
-template<>
+inline Bitboard Position::attackers_to(Square s) const {
-inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
+  return attackers_to(s, byTypeBB[ALL_PIECES]);
-  return bishop_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<ROOK>(Square s) const {
-  return rook_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
 }
 
 inline Bitboard Position::checkers() const {
   return st->checkersBB;
 }
 
-inline bool Position::in_check() const {
+inline Bitboard Position::discovered_check_candidates() const {
-  return st->checkersBB != EmptyBoardBB;
+  return hidden_checkers(king_square(~sideToMove), sideToMove);
+}
+
+inline Bitboard Position::pinned_pieces() const {
+  return hidden_checkers(king_square(sideToMove), ~sideToMove);
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
 }
 
-inline bool Position::square_is_weak(Square s, Color c) const {
+inline Key Position::key() const {
-  return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
-}
-
-inline Key Position::get_key() const {
   return st->key;
 }
 
-inline Key Position::get_exclusion_key() const {
+inline Key Position::pawn_key() const {
-  return st->key ^ zobExclusion;
-}
-
-inline Key Position::get_pawn_key() const {
   return st->pawnKey;
 }
 
-inline Key Position::get_material_key() const {
+inline Key Position::material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::pst(Color c, PieceType pt, Square s) {
+inline Score Position::psq_score() const {
-  return PieceSquareTable[make_piece(c, pt)][s];
+  return st->psq;
-}
-
-inline Score Position::pst_delta(Piece piece, Square from, Square to) {
-  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
-}
-
-inline Score Position::value() const {
-  return st->value;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
   return st->npMaterial[c];
 }
 
-inline bool Position::move_is_passed_pawn_push(Move m) const {
+inline bool Position::is_passed_pawn_push(Move m) const {
 
-  Color c = side_to_move();
+  return   type_of(piece_moved(m)) == PAWN
-  return   piece_on(move_from(m)) == make_piece(c, PAWN)
+        && pawn_is_passed(sideToMove, to_sq(m));
-        && pawn_is_passed(c, move_to(m));
 }
 
-inline int Position::startpos_ply_counter() const {
+inline int Position::game_ply() const {
-  return startPosPlyCounter;
+  return gamePly;
 }
 
-inline bool Position::opposite_colored_bishops() const {
+inline bool Position::opposite_bishops() const {
 
-  return   piece_count(WHITE, BISHOP) == 1 && piece_count(BLACK, BISHOP) == 1
+  return   pieceCount[WHITE][BISHOP] == 1
-        && opposite_color_squares(piece_list(WHITE, BISHOP, 0), piece_list(BLACK, BISHOP, 0));
+        && pieceCount[BLACK][BISHOP] == 1
+        && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
 }
 
-inline bool Position::has_pawn_on_7th(Color c) const {
+inline bool Position::bishop_pair(Color c) const {
-  return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
+
+  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));
 }
 
 inline bool Position::is_chess960() const {
   return chess960;
 }
 
-inline bool Position::move_is_capture(Move m) const {
+inline bool Position::is_capture_or_promotion(Move m) const {
 
-  // Move must not be MOVE_NONE !
+  assert(is_ok(m));
-  return (m & (3 << 15)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+  return type_of(m) ? type_of(m) != CASTLE : !is_empty(to_sq(m));
 }
 
-inline bool Position::move_is_capture_or_promotion(Move m) const {
+inline bool Position::is_capture(Move m) const {
 
-  // Move must not be MOVE_NONE !
+  // Note that castle is coded as "king captures the rook"
-  return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+  assert(is_ok(m));
+  return (!is_empty(to_sq(m)) && type_of(m) != CASTLE) || type_of(m) == ENPASSANT;
 }
 
 inline PieceType Position::captured_piece_type() const {
   return st->capturedType;
 }
 
-inline int Position::thread() const {
+inline Thread* Position::this_thread() const {
-  return threadID;
+  return thisThread;
 }
 
-inline void Position::do_allow_oo(Color c) {
+inline void Position::put_piece(Square s, Color c, PieceType pt) {
-  st->castleRights |= (1 + int(c));
+
+  board[s] = make_piece(c, pt);
+  byTypeBB[ALL_PIECES] |= s;
+  byTypeBB[pt] |= s;
+  byColorBB[c] |= s;
+  index[s] = pieceCount[c][pt]++;
+  pieceList[c][pt][index[s]] = s;
 }
 
-inline void Position::do_allow_ooo(Color c) {
+inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) {
-  st->castleRights |= (4 + 4*int(c));
+
+  // 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[pt] ^= from_to_bb;
+  byColorBB[c] ^= from_to_bb;
+  board[from] = NO_PIECE;
+  board[to] = make_piece(c, pt);
+  index[to] = index[from];
+  pieceList[c][pt][index[to]] = to;
 }
 
-#endif // !defined(POSITION_H_INCLUDED)
+inline void Position::remove_piece(Square s, Color c, PieceType pt) {
+
+  // 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 guaranteed to be invariant to a do_move() + undo_move() sequence.
+  byTypeBB[ALL_PIECES] ^= s;
+  byTypeBB[pt] ^= s;
+  byColorBB[c] ^= s;
+  /* board[s] = NO_PIECE; */ // Not needed, will be overwritten by capturing
+  Square lastSquare = pieceList[c][pt][--pieceCount[c][pt]];
+  index[lastSquare] = index[s];
+  pieceList[c][pt][index[lastSquare]] = lastSquare;
+  pieceList[c][pt][pieceCount[c][pt]] = SQ_NONE;
+}
+
+#endif // #ifndef POSITION_H_INCLUDED

src/psqtab.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,169 +17,82 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(PSQTAB_H_INCLUDED)
+#ifndef PSQTAB_H_INCLUDED
 #define PSQTAB_H_INCLUDED
 
 #include "types.h"
 
-namespace {
+#define S(mg, eg) make_score(mg, eg)
 
-////
-//// Constants modified by Joona Kiiski
-////
 
-const Value MP = PawnValueMidgame;
+/// PSQT[PieceType][Square] contains Piece-Square scores. For each piece type on
-const Value MK = KnightValueMidgame;
+/// a given square a (midgame, endgame) score pair is assigned. PSQT is defined
-const Value MB = BishopValueMidgame;
+/// for white side, for black side the tables are symmetric.
-const Value MR = RookValueMidgame;
-const Value MQ = QueenValueMidgame;
 
-const Value EP = PawnValueEndgame;
+static const Score PSQT[][SQUARE_NB] = {
-const Value EK = KnightValueEndgame;
-const Value EB = BishopValueEndgame;
-const Value ER = RookValueEndgame;
-const Value EQ = QueenValueEndgame;
-
-const int MgPST[][64] = {
   { },
-  {// Pawn
+  { // Pawn
-   // A      B      C     D      E      F      G     H
+   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0),
-        0,    0,     0,     0,     0,     0,    0,     0,
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
+   S(-20,-8), S(-6,-8), S( 9,-8), S(34,-8), S(34,-8), S( 9,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+ 9, MP+36, MP+36, MP+ 9, MP-6, MP-28,
+   S(-20,-8), S(-6,-8), S(17,-8), S(54,-8), S(54,-8), S(17,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+17, MP+58, MP+58, MP+17, MP-6, MP-28,
+   S(-20,-8), S(-6,-8), S(17,-8), S(34,-8), S(34,-8), S(17,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+17, MP+36, MP+36, MP+17, MP-6, MP-28,
+   S(-20,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+ 9, MP+14, MP+14, MP+ 9, MP-6, MP-28,
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
-    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
+   S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0)
-        0,    0,     0,     0,     0,     0,    0,     0
   },
-  {// Knight
+  { // Knight
-   //  A      B       C      D      E      F      G       H
+   S(-135,-104), S(-107,-79), S(-80,-55), S(-67,-42), S(-67,-42), S(-80,-55), S(-107,-79), S(-135,-104),
-    MK-135, MK-107, MK-80, MK-67, MK-67, MK-80, MK-107, MK-135,
+   S( -93, -79), S( -67,-55), S(-39,-30), S(-25,-17), S(-25,-17), S(-39,-30), S( -67,-55), S( -93, -79),
-    MK- 93, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK- 93,
+   S( -53, -55), S( -25,-30), S(  1, -6), S( 13,  5), S( 13,  5), S(  1, -6), S( -25,-30), S( -53, -55),
-    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
+   S( -25, -42), S(   1,-17), S( 27,  5), S( 41, 18), S( 41, 18), S( 27,  5), S(   1,-17), S( -25, -42),
-    MK- 25, MK+  1, MK+27, MK+41, MK+41, MK+27, MK+  1, MK- 25,
+   S( -11, -42), S(  13,-17), S( 41,  5), S( 55, 18), S( 55, 18), S( 41,  5), S(  13,-17), S( -11, -42),
-    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
+   S( -11, -55), S(  13,-30), S( 41, -6), S( 55,  5), S( 55,  5), S( 41, -6), S(  13,-30), S( -11, -55),
-    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
+   S( -53, -79), S( -25,-55), S(  1,-30), S( 13,-17), S( 13,-17), S(  1,-30), S( -25,-55), S( -53, -79),
-    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
+   S(-193,-104), S( -67,-79), S(-39,-55), S(-25,-42), S(-25,-42), S(-39,-55), S( -67,-79), S(-193,-104)
-    MK-193, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK-193
   },
-  {// Bishop
+  { // Bishop
-   // A      B      C      D      E      F      G      H
+   S(-40,-59), S(-40,-42), S(-35,-35), S(-30,-26), S(-30,-26), S(-35,-35), S(-40,-42), S(-40,-59),
-    MB-40, MB-40, MB-35, MB-30, MB-30, MB-35, MB-40, MB-40,
+   S(-17,-42), S(  0,-26), S( -4,-18), S(  0,-11), S(  0,-11), S( -4,-18), S(  0,-26), S(-17,-42),
-    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
+   S(-13,-35), S( -4,-18), S(  8,-11), S(  4, -4), S(  4, -4), S(  8,-11), S( -4,-18), S(-13,-35),
-    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
+   S( -8,-26), S(  0,-11), S(  4, -4), S( 17,  4), S( 17,  4), S(  4, -4), S(  0,-11), S( -8,-26),
-    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
+   S( -8,-26), S(  0,-11), S(  4, -4), S( 17,  4), S( 17,  4), S(  4, -4), S(  0,-11), S( -8,-26),
-    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
+   S(-13,-35), S( -4,-18), S(  8,-11), S(  4, -4), S(  4, -4), S(  8,-11), S( -4,-18), S(-13,-35),
-    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
+   S(-17,-42), S(  0,-26), S( -4,-18), S(  0,-11), S(  0,-11), S( -4,-18), S(  0,-26), S(-17,-42),
-    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
+   S(-17,-59), S(-17,-42), S(-13,-35), S( -8,-26), S( -8,-26), S(-13,-35), S(-17,-42), S(-17,-59)
-    MB-17, MB-17, MB-13, MB- 8, MB- 8, MB-13, MB-17, MB-17
   },
-  {// Rook
+  { // Rook
-   // A      B     C     D     E     F     G     H
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3),
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+   S(-12, 3), S(-7, 3), S(-2, 3), S(2, 3), S(2, 3), S(-2, 3), S(-7, 3), S(-12, 3)
-    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12
   },
-  {// Queen
+  { // Queen
-   // A     B     C     D     E     F     G     H
+   S(8,-80), S(8,-54), S(8,-42), S(8,-30), S(8,-30), S(8,-42), S(8,-54), S(8,-80),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-54), S(8,-30), S(8,-18), S(8, -6), S(8, -6), S(8,-18), S(8,-30), S(8,-54),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-42), S(8,-18), S(8, -6), S(8,  6), S(8,  6), S(8, -6), S(8,-18), S(8,-42),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-30), S(8, -6), S(8,  6), S(8, 18), S(8, 18), S(8,  6), S(8, -6), S(8,-30),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-30), S(8, -6), S(8,  6), S(8, 18), S(8, 18), S(8,  6), S(8, -6), S(8,-30),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-42), S(8,-18), S(8, -6), S(8,  6), S(8,  6), S(8, -6), S(8,-18), S(8,-42),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-54), S(8,-30), S(8,-18), S(8, -6), S(8, -6), S(8,-18), S(8,-30), S(8,-54),
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+   S(8,-80), S(8,-54), S(8,-42), S(8,-30), S(8,-30), S(8,-42), S(8,-54), S(8,-80)
-    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8
   },
-  {// King
+  { // King
-   //A    B    C    D    E    F    G    H
+   S(287, 18), S(311, 77), S(262,105), S(214,135), S(214,135), S(262,105), S(311, 77), S(287, 18),
-    287, 311, 262, 214, 214, 262, 311, 287,
+   S(262, 77), S(287,135), S(238,165), S(190,193), S(190,193), S(238,165), S(287,135), S(262, 77),
-    262, 287, 238, 190, 190, 238, 287, 262,
+   S(214,105), S(238,165), S(190,193), S(142,222), S(142,222), S(190,193), S(238,165), S(214,105),
-    214, 238, 190, 142, 142, 190, 238, 214,
+   S(190,135), S(214,193), S(167,222), S(119,251), S(119,251), S(167,222), S(214,193), S(190,135),
-    190, 214, 167, 119, 119, 167, 214, 190,
+   S(167,135), S(190,193), S(142,222), S( 94,251), S( 94,251), S(142,222), S(190,193), S(167,135),
-    167, 190, 142,  94,  94, 142, 190, 167,
+   S(142,105), S(167,165), S(119,193), S( 69,222), S( 69,222), S(119,193), S(167,165), S(142,105),
-    142, 167, 119,  69,  69, 119, 167, 142,
+   S(119, 77), S(142,135), S( 94,165), S( 46,193), S( 46,193), S( 94,165), S(142,135), S(119, 77),
-    119, 142,  94,  46,  46,  94, 142, 119,
+   S(94,  18), S(119, 77), S( 69,105), S( 21,135), S( 21,135), S( 69,105), S(119, 77), S( 94, 18)
-     94, 119,  69,  21,  21,  69, 119,  94
   }
 };
 
-const int EgPST[][64] = {
+#undef S
-  { },
-  {// Pawn
-   // A     B     C     D     E     F     G     H
-       0,    0,    0,    0,    0,    0,    0,    0,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-       0,    0,    0,    0,    0,    0,    0,    0
-  },
-  {// Knight
-   // A       B      C      D      E      F      G      H
-    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104,
-    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
-    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
-    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104
-  },
-  {// Bishop
-   // A      B      C      D      E      F      G      H
-    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59,
-    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
-    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
-    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59
-  },
-  {// Rook
-   // A     B     C     D     E     F     G     H
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3
-  },
-  {// Queen
-   // A      B      C      D      E      F      G      H
-    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80,
-    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
-    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
-    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80
-  },
-  {// King
-   //A    B    C    D    E    F    G    H
-     18,  77, 105, 135, 135, 105,  77,  18,
-     77, 135, 165, 193, 193, 165, 135,  77,
-    105, 165, 193, 222, 222, 193, 165, 105,
-    135, 193, 222, 251, 251, 222, 193, 135,
-    135, 193, 222, 251, 251, 222, 193, 135,
-    105, 165, 193, 222, 222, 193, 165, 105,
-     77, 135, 165, 193, 193, 165, 135,  77,
-     18,  77, 105, 135, 135, 105,  77,  18
-  }
-};
 
-} // namespace
+#endif // #ifndef PSQTAB_H_INCLUDED
-
-#endif // !defined(PSQTAB_H_INCLUDED)

src/rkiss.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -20,36 +20,35 @@
   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.
-
- ** George Marsaglia invented the RNG-Kiss-family in the early 90's.
- ** This is a specific version that Heinz van Saanen derived and
- ** tested from some public domain code by Bob Jenkins:
- **
- ** 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
 */
 
-#if !defined(RKISS_H_INCLUDED)
+#ifndef 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; // 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
@@ -60,18 +59,16 @@ class RKISS {
     return s.d = e + s.a;
   }
 
-  // Init seed and scramble a few rounds
+public:
-  void raninit() {
+  RKISS(int seed = 73) {
 
     s.a = 0xf1ea5eed;
     s.b = s.c = s.d = 0xd4e12c77;
-    for (int i = 0; i < 73; i++)
+    for (int i = 0; i < seed; i++) // Scramble a few rounds
         rand64();
   }
 
-public:
-  RKISS() { raninit(); }
   template<typename T> T rand() { return T(rand64()); }
 };
 
-#endif // !defined(RKISS_H_INCLUDED)
+#endif // #ifndef RKISS_H_INCLUDED

src/search.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,57 +17,96 @@
   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 "move.h"
+#include "misc.h"
+#include "position.h"
 #include "types.h"
 
-class Position;
 struct SplitPoint;
 
-/// The SearchStack struct keeps track of the information we need to remember
+namespace Search {
-/// from nodes shallower and deeper in the tree during the search.  Each
-/// search thread has its own array of SearchStack objects, indexed by the
-/// current ply.
 
-struct SearchStack {
+/// 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.
+
+struct Stack {
+  SplitPoint* splitPoint;
   int ply;
   Move currentMove;
-  Move mateKiller;
   Move excludedMove;
-  Move bestMove;
   Move killers[2];
   Depth reduction;
-  Value eval;
+  Value staticEval;
   Value evalMargin;
-  bool skipNullMove;
+  int skipNullMove;
-  SplitPoint* sp;
+  int futilityMoveCount;
 };
 
 
-/// The SearchLimits struct stores information sent by GUI about available time
+/// RootMove struct is used for moves at the root of the tree. For each root
+/// move 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.
+struct RootMove {
+
+  RootMove(Move m) : score(-VALUE_INFINITE), prevScore(-VALUE_INFINITE) {
+    pv.push_back(m); pv.push_back(MOVE_NONE);
+  }
+
+  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;
+  std::vector<Move> pv;
+};
+
+
+/// 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.
 
-struct SearchLimits {
+struct LimitsType {
 
-  SearchLimits() { memset(this, 0, sizeof(SearchLimits)); }
+  LimitsType() { std::memset(this, 0, sizeof(LimitsType)); }
+  bool use_time_management() const { return !(mate | movetime | depth | nodes | infinite); }
 
-  SearchLimits(int t, int i, int mtg, int mt, int md, int mn, bool inf, bool pon)
+  int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, nodes, movetime, mate, infinite, ponder;
-              : time(t), increment(i), movesToGo(mtg), maxTime(mt), maxDepth(md),
-                maxNodes(mn), infinite(inf), ponder(pon) {}
-
-  bool useTimeManagement() const { return !(maxTime | maxDepth | maxNodes | int(infinite)); }
-
-  int time, increment, movesToGo, maxTime, maxDepth, maxNodes;
-  bool infinite, ponder;
 };
 
-extern void init_search();
-extern int64_t perft(Position& pos, Depth depth);
-extern bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]);
 
-#endif // !defined(SEARCH_H_INCLUDED)
+/// 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();
+
+} // namespace Search
+
+#endif // #ifndef SEARCH_H_INCLUDED

src/thread.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,329 +17,378 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <iostream>
+#include <algorithm> // For std::count
+#include <cassert>
 
+#include "movegen.h"
+#include "search.h"
 #include "thread.h"
 #include "ucioption.h"
 
-ThreadsManager Threads; // Global object definition
+using namespace Search;
 
-namespace { extern "C" {
+ThreadPool Threads; // Global object
+
+namespace {
 
  // start_routine() is the C function which is called when a new thread
- // is launched. It simply calls idle_loop() with the supplied threadID.
+ // is launched. It is a wrapper to the virtual function idle_loop().
- // There are two versions of this function; one for POSIX threads and
- // one for Windows threads.
 
-#if defined(_MSC_VER)
+ extern "C" { long start_routine(ThreadBase* th) { th->idle_loop(); return 0; } }
-
-  DWORD WINAPI start_routine(LPVOID threadID) {
-
-    Threads.idle_loop(*(int*)threadID, NULL);
-    return 0;
-  }
-
-#else
-
-  void* start_routine(void* threadID) {
-
-    Threads.idle_loop(*(int*)threadID, NULL);
-    return NULL;
-  }
-
-#endif
-
-} }
 
 
-// wake_up() wakes up the thread, normally at the beginning of the search or,
+ // Helpers to launch a thread after creation and joining before delete. Must be
-// if "sleeping threads" is used, when there is some work to do.
+ // outside Thread c'tor and d'tor because object shall be fully initialized
+ // when start_routine (and hence virtual idle_loop) is called and when joining.
 
-void Thread::wake_up() {
+ template<typename T> T* new_thread() {
+   T* th = new T();
+   thread_create(th->handle, start_routine, th); // Will go to sleep
+   return th;
+ }
+
+ void delete_thread(ThreadBase* th) {
+   th->exit = true; // Search must be already finished
+   th->notify_one();
+   thread_join(th->handle); // Wait for thread termination
+   delete th;
+ }
 
-  lock_grab(&sleepLock);
-  cond_signal(&sleepCond);
-  lock_release(&sleepLock);
 }
 
 
-// cutoff_occurred() checks whether a beta cutoff has occurred in
+// ThreadBase::notify_one() wakes up the thread when there is some work to do
-// the thread's currently active split point, or in some ancestor of
+
-// the current split point.
+void ThreadBase::notify_one() {
+
+  mutex.lock();
+  sleepCondition.notify_one();
+  mutex.unlock();
+}
+
+
+// ThreadBase::wait_for() set the thread to sleep until condition 'b' turns true
+
+void ThreadBase::wait_for(volatile const bool& b) {
+
+  mutex.lock();
+  while (!b) sleepCondition.wait(mutex);
+  mutex.unlock();
+}
+
+
+// Thread c'tor just inits data but does not launch any thread of execution that
+// instead will be started only upon c'tor returns.
+
+Thread::Thread() /* : splitPoints() */ { // Value-initialization bug in MSVC
+
+  searching = false;
+  maxPly = splitPointsSize = 0;
+  activeSplitPoint = NULL;
+  activePosition = NULL;
+  idx = Threads.size();
+}
+
+
+// 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();
+
+void TimerThread::idle_loop() {
+
+  while (!exit)
+  {
+      mutex.lock();
+
+      if (!exit)
+          sleepCondition.wait_for(mutex, msec ? msec : INT_MAX);
+
+      mutex.unlock();
+
+      if (msec)
+          check_time();
+  }
+}
+
+
+// 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.
+
+void MainThread::idle_loop() {
+
+  while (true)
+  {
+      mutex.lock();
+
+      thinking = false;
+
+      while (!thinking && !exit)
+      {
+          Threads.sleepCondition.notify_one(); // Wake up UI thread if needed
+          sleepCondition.wait(mutex);
+      }
+
+      mutex.unlock();
+
+      if (exit)
+          return;
+
+      searching = true;
+
+      Search::think();
+
+      assert(searching);
+
+      searching = false;
+  }
+}
+
+
+// Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the
+// current active split point, or in some ancestor of the split point.
 
 bool Thread::cutoff_occurred() const {
 
-  for (SplitPoint* sp = splitPoint; sp; sp = sp->parent)
+  for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
-      if (sp->is_betaCutoff)
+      if (sp->cutoff)
           return true;
+
   return false;
 }
 
 
-// is_available_to() checks whether the thread is available to help the thread with
+// Thread::is_available_to() checks whether the thread is available to help the
-// threadID "master" at a split point. An obvious requirement is that thread must be
+// thread 'master' at a split point. An obvious requirement is that thread must
-// idle. With more than two threads, this is not by itself sufficient: If the thread
+// be idle. With more than two threads, this is not sufficient: If the thread is
-// is the master of some active split point, it is only available as a slave to the
+// the master of some split point, it is only available as a slave to the slaves
-// threads which are busy searching the split point at the top of "slave"'s split
+// which are busy searching the split point at the top of slaves split point
-// point stack (the "helpful master concept" in YBWC terminology).
+// stack (the "helpful master concept" in YBWC terminology).
 
-bool Thread::is_available_to(int master) const {
+bool Thread::is_available_to(const Thread* master) const {
 
-  if (state != AVAILABLE)
+  if (searching)
       return false;
 
   // 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 localActiveSplitPoints = activeSplitPoints;
+  int size = splitPointsSize;
 
-  // No active split points means that the thread is available as a slave for any
+  // No split points means that the thread is available as a slave for any
   // other thread otherwise apply the "helpful master" concept if possible.
-  if (   !localActiveSplitPoints
+  return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
-      || splitPoints[localActiveSplitPoints - 1].is_slave[master])
-      return true;
-
-  return false;
 }
 
 
-// read_uci_options() updates number of active threads and other internal
+// init() is called at startup to create and launch requested threads, that will
-// parameters according to the UCI options values. It is called before
+// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
-// to start a new search.
+// 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 ThreadsManager::read_uci_options() {
+void ThreadPool::init() {
 
-  maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
+  sleepWhileIdle = true;
-  minimumSplitDepth       = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
+  timer = new_thread<TimerThread>();
-  useSleepingThreads      = Options["Use Sleeping Threads"].value<bool>();
+  push_back(new_thread<MainThread>());
-  activeThreads           = Options["Threads"].value<int>();
+  read_uci_options();
 }
 
 
-// init() is called during startup. Initializes locks and condition variables
+// exit() cleanly terminates the threads before the program exits
-// and launches all threads sending them immediately to sleep.
 
-void ThreadsManager::init() {
+void ThreadPool::exit() {
 
-  int threadID[MAX_THREADS];
+  delete_thread(timer); // As first because check_time() accesses threads data
 
-  // This flag is needed to properly end the threads when program exits
+  for (iterator it = begin(); it != end(); ++it)
-  allThreadsShouldExit = false;
+      delete_thread(*it);
+}
 
-  // Threads will sent to sleep as soon as created, only main thread is kept alive
-  activeThreads = 1;
-  threads[0].state = Thread::SEARCHING;
 
-  // Allocate pawn and material hash tables for main thread
+// read_uci_options() updates internal threads parameters from the corresponding
-  init_hash_tables();
+// 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.
 
-  lock_init(&mpLock);
+void ThreadPool::read_uci_options() {
 
-  // Initialize thread and split point locks
+  maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
-  for (int i = 0; i < MAX_THREADS; i++)
+  minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
+  size_t requested        = Options["Threads"];
+
+  assert(requested > 0);
+
+  // Value 0 has a special meaning: We determine the optimal minimum split depth
+  // automatically. Anyhow the minimumSplitDepth should never be under 4 plies.
+  if (!minimumSplitDepth)
+      minimumSplitDepth = (requested < 8 ? 4 : 7) * ONE_PLY;
+  else
+      minimumSplitDepth = std::max(4 * ONE_PLY, minimumSplitDepth);
+
+  while (size() < requested)
+      push_back(new_thread<Thread>());
+
+  while (size() > requested)
   {
-      lock_init(&threads[i].sleepLock);
+      delete_thread(back());
-      cond_init(&threads[i].sleepCond);
+      pop_back();
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_init(&(threads[i].splitPoints[j].lock));
-  }
-
-  // Create and startup all the threads but the main that is already running
-  for (int i = 1; i < MAX_THREADS; i++)
-  {
-      threads[i].state = Thread::INITIALIZING;
-      threadID[i] = i;
-
-#if defined(_MSC_VER)
-      bool ok = (CreateThread(NULL, 0, start_routine, (LPVOID)&threadID[i], 0, NULL) != NULL);
-#else
-      pthread_t pthreadID;
-      bool ok = (pthread_create(&pthreadID, NULL, start_routine, (void*)&threadID[i]) == 0);
-      pthread_detach(pthreadID);
-#endif
-      if (!ok)
-      {
-          std::cout << "Failed to create thread number " << i << std::endl;
-          ::exit(EXIT_FAILURE);
-      }
-
-      // Wait until the thread has finished launching and is gone to sleep
-      while (threads[i].state == Thread::INITIALIZING) {}
   }
 }
 
 
-// exit() is called to cleanly exit the threads when the program finishes
+// slave_available() tries to find an idle thread which is available as a slave
+// for the thread 'master'.
 
-void ThreadsManager::exit() {
+Thread* ThreadPool::available_slave(const Thread* master) const {
 
-  // Force the woken up threads to exit idle_loop() and hence terminate
+  for (const_iterator it = begin(); it != end(); ++it)
-  allThreadsShouldExit = true;
+      if ((*it)->is_available_to(master))
+          return *it;
 
-  for (int i = 0; i < MAX_THREADS; i++)
+  return NULL;
-  {
-      // Wake up all the threads and waits for termination
-      if (i != 0)
-      {
-          threads[i].wake_up();
-          while (threads[i].state != Thread::TERMINATED) {}
-      }
-
-      // Now we can safely destroy the locks and wait conditions
-      lock_destroy(&threads[i].sleepLock);
-      cond_destroy(&threads[i].sleepCond);
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_destroy(&(threads[i].splitPoints[j].lock));
-  }
-
-  lock_destroy(&mpLock);
-}
-
-
-// init_hash_tables() dynamically allocates pawn and material hash tables
-// according to the number of active threads. This avoids preallocating
-// memory for all possible threads if only few are used as, for instance,
-// on mobile devices where memory is scarce and allocating for MAX_THREADS
-// threads could even result in a crash.
-
-void ThreadsManager::init_hash_tables() {
-
-  for (int i = 0; i < activeThreads; i++)
-  {
-      threads[i].pawnTable.init();
-      threads[i].materialTable.init();
-  }
-}
-
-
-// available_slave_exists() tries to find an idle thread which is available as
-// a slave for the thread with threadID "master".
-
-bool ThreadsManager::available_slave_exists(int master) const {
-
-  assert(master >= 0 && master < activeThreads);
-
-  for (int i = 0; i < activeThreads; i++)
-      if (i != master && threads[i].is_available_to(master))
-          return true;
-
-  return false;
 }
 
 
 // split() does the actual work of distributing the work at a node between
-// several available threads. If it does not succeed in splitting the
+// several available threads. If it does not succeed in splitting the node
-// node (because no idle threads are available, or because we have no unused
+// (because no idle threads are available), the function immediately returns.
-// split point objects), the function immediately returns. If splitting is
+// If splitting is possible, a SplitPoint object is initialized with all the
-// possible, a SplitPoint object is initialized with all the data that must be
+// data that must be copied to the helper threads and then helper threads are
-// copied to the helper threads and we tell our helper threads that they have
+// told that they have been assigned work. This will cause them to instantly
-// been assigned work. This will cause them to instantly leave their idle loops and
+// leave their idle loops and call search(). When all threads have returned from
-// call search().When all threads have returned from search() then split() returns.
+// search() then split() returns.
 
 template <bool Fake>
-void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const Value beta,
+void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue,
-                           Value* bestValue, Depth depth, Move threatMove,
+                   Move* bestMove, Depth depth, Move threatMove, int moveCount,
-                           int moveCount, MovePicker* mp, bool pvNode) {
+                   MovePicker* movePicker, int nodeType, bool cutNode) {
-  assert(pos.is_ok());
-  assert(*bestValue >= -VALUE_INFINITE);
-  assert(*bestValue <= *alpha);
-  assert(*alpha < beta);
-  assert(beta <= VALUE_INFINITE);
-  assert(depth > DEPTH_ZERO);
-  assert(pos.thread() >= 0 && pos.thread() < activeThreads);
-  assert(activeThreads > 1);
 
-  int i, master = pos.thread();
+  assert(pos.pos_is_ok());
-  Thread& masterThread = threads[master];
+  assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
+  assert(*bestValue > -VALUE_INFINITE);
+  assert(depth >= Threads.minimumSplitDepth);
+  assert(searching);
+  assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD);
 
-  lock_grab(&mpLock);
+  // Pick the next available split point from the split point stack
+  SplitPoint& sp = splitPoints[splitPointsSize];
 
-  // If no other thread is available to help us, or if we have too many
+  sp.masterThread = this;
-  // active split points, don't split.
+  sp.parentSplitPoint = activeSplitPoint;
-  if (   !available_slave_exists(master)
+  sp.slavesMask = 1ULL << idx;
-      || masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
+  sp.depth = depth;
+  sp.bestValue = *bestValue;
+  sp.bestMove = *bestMove;
+  sp.threatMove = threatMove;
+  sp.alpha = alpha;
+  sp.beta = beta;
+  sp.nodeType = nodeType;
+  sp.cutNode = cutNode;
+  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)
   {
-      lock_release(&mpLock);
+      sp.slavesMask |= 1ULL << slave->idx;
-      return;
+      slave->activeSplitPoint = &sp;
+      slave->searching = true; // Slave leaves idle_loop()
+      slave->notify_one(); // Could be sleeping
   }
 
-  // Pick the next available split point object from the split point stack
+  // Everything is set up. The master thread enters the idle loop, from which
-  SplitPoint& splitPoint = masterThread.splitPoints[masterThread.activeSplitPoints++];
+  // 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();
 
-  // Initialize the split point object
+      Thread::idle_loop(); // Force a call to base class idle_loop()
-  splitPoint.parent = masterThread.splitPoint;
-  splitPoint.master = master;
-  splitPoint.is_betaCutoff = false;
-  splitPoint.depth = depth;
-  splitPoint.threatMove = threatMove;
-  splitPoint.alpha = *alpha;
-  splitPoint.beta = beta;
-  splitPoint.pvNode = pvNode;
-  splitPoint.bestValue = *bestValue;
-  splitPoint.mp = mp;
-  splitPoint.moveCount = moveCount;
-  splitPoint.pos = &pos;
-  splitPoint.nodes = 0;
-  splitPoint.ss = ss;
-  for (i = 0; i < activeThreads; i++)
-      splitPoint.is_slave[i] = false;
 
-  masterThread.splitPoint = &splitPoint;
+      // 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);
 
-  // If we are here it means we are not available
+      // We have returned from the idle loop, which means that all threads are
-  assert(masterThread.state != Thread::AVAILABLE);
+      // 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();
+  }
 
-  int workersCnt = 1; // At least the master is included
+  searching = true;
+  splitPointsSize--;
+  activeSplitPoint = sp.parentSplitPoint;
+  activePosition = &pos;
+  pos.set_nodes_searched(pos.nodes_searched() + sp.nodes);
+  *bestMove = sp.bestMove;
+  *bestValue = sp.bestValue;
 
-  // Allocate available threads setting state to THREAD_BOOKED
+  sp.mutex.unlock();
-  for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
+  Threads.mutex.unlock();
-      if (i != master && threads[i].is_available_to(master))
-      {
-          threads[i].state = Thread::BOOKED;
-          threads[i].splitPoint = &splitPoint;
-          splitPoint.is_slave[i] = true;
-          workersCnt++;
-      }
-
-  assert(Fake || workersCnt > 1);
-
-  // We can release the lock because slave threads are already booked and master is not available
-  lock_release(&mpLock);
-
-  // Tell the threads that they have work to do. This will make them leave
-  // their idle loop.
-  for (i = 0; i < activeThreads; i++)
-      if (i == master || splitPoint.is_slave[i])
-      {
-          assert(i == master || threads[i].state == Thread::BOOKED);
-
-          threads[i].state = Thread::WORKISWAITING; // This makes the slave to exit from idle_loop()
-
-          if (useSleepingThreads && i != master)
-              threads[i].wake_up();
-      }
-
-  // Everything is set up. The master thread enters the idle loop, from
-  // which it will instantly launch a search, because its state is
-  // THREAD_WORKISWAITING.  We send the split point as a second parameter to the
-  // idle loop, which means that the main thread will return from the idle
-  // loop when all threads have finished their work at this split point.
-  idle_loop(master, &splitPoint);
-
-  // We have returned from the idle loop, which means that all threads are
-  // finished. Update alpha and bestValue, and return.
-  lock_grab(&mpLock);
-
-  *alpha = splitPoint.alpha;
-  *bestValue = splitPoint.bestValue;
-  masterThread.activeSplitPoints--;
-  masterThread.splitPoint = splitPoint.parent;
-  pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes);
-
-  lock_release(&mpLock);
 }
 
 // Explicit template instantiations
-template void ThreadsManager::split<false>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);
+template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
-template void ThreadsManager::split<true>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);
+template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
+
+
+// wait_for_think_finished() waits for main thread to go to sleep then returns
+
+void ThreadPool::wait_for_think_finished() {
+
+  MainThread* t = main();
+  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;
+
+  RootMoves.clear();
+  RootPos = pos;
+  Limits = limits;
+  if (states.get()) // If we don't set a new position, preserve current state
+  {
+      SetupStates = states; // Ownership transfer here
+      assert(!states.get());
+  }
+
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (   searchMoves.empty()
+          || std::count(searchMoves.begin(), searchMoves.end(), *it))
+          RootMoves.push_back(RootMove(*it));
+
+  main()->thinking = true;
+  main()->notify_one(); // Starts main thread
+}

src/thread.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,116 +17,162 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(THREAD_H_INCLUDED)
+#ifndef THREAD_H_INCLUDED
 #define THREAD_H_INCLUDED
 
-#include <cstring>
+#include <vector>
 
-#include "lock.h"
 #include "material.h"
 #include "movepick.h"
 #include "pawns.h"
 #include "position.h"
+#include "search.h"
 
-const int MAX_THREADS = 32;
+const int MAX_THREADS = 64; // Because SplitPoint::slavesMask is a uint64_t
-const int MAX_ACTIVE_SPLIT_POINTS = 8;
+const int MAX_SPLITPOINTS_PER_THREAD = 8;
+
+struct Mutex {
+  Mutex() { lock_init(l); }
+ ~Mutex() { lock_destroy(l); }
+
+  void lock() { lock_grab(l); }
+  void unlock() { lock_release(l); }
+
+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 splitPoint has been setup
+  // Const data after split point has been setup
-  SplitPoint* parent;
   const Position* pos;
+  const Search::Stack* ss;
+  Thread* masterThread;
   Depth depth;
-  bool pvNode;
   Value beta;
-  int ply;
+  int nodeType;
-  int master;
   Move threatMove;
+  bool cutNode;
 
   // Const pointers to shared data
-  MovePicker* mp;
+  MovePicker* movePicker;
-  SearchStack* ss;
+  SplitPoint* parentSplitPoint;
 
   // Shared data
-  Lock lock;
+  Mutex mutex;
+  volatile uint64_t slavesMask;
   volatile int64_t nodes;
   volatile Value alpha;
   volatile Value bestValue;
+  volatile Move bestMove;
   volatile int moveCount;
-  volatile bool is_betaCutoff;
+  volatile bool cutoff;
-  volatile bool is_slave[MAX_THREADS];
 };
 
 
-/// Thread struct is used to keep together all the thread related stuff like locks,
+/// ThreadBase struct is the base of the hierarchy from where we derive all the
-/// state and especially split points. We also use per-thread pawn and material hash
+/// specialized thread classes.
-/// 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 {
+struct ThreadBase {
 
-  enum ThreadState
+  ThreadBase() : exit(false) {}
-  {
+  virtual ~ThreadBase() {}
-    INITIALIZING,  // Thread is initializing itself
+  virtual void idle_loop() = 0;
-    SEARCHING,     // Thread is performing work
+  void notify_one();
-    AVAILABLE,     // Thread is waiting for work
+  void wait_for(volatile const bool& b);
-    BOOKED,        // Other thread (master) has booked us as a slave
-    WORKISWAITING, // Master has ordered us to start
-    TERMINATED     // We are quitting and thread is terminated
-  };
 
-  void wake_up();
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  NativeHandle handle;
+  volatile bool exit;
+};
+
+
+/// 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 : public ThreadBase {
+
+  Thread();
+  virtual void idle_loop();
   bool cutoff_occurred() const;
-  bool is_available_to(int master) const;
+  bool is_available_to(const Thread* master) const;
-
-  MaterialInfoTable materialTable;
-  PawnInfoTable pawnTable;
-  int maxPly;
-  Lock sleepLock;
-  WaitCondition sleepCond;
-  volatile ThreadState state;
-  SplitPoint* volatile splitPoint;
-  volatile int activeSplitPoints;
-  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
-};
-
-
-/// ThreadsManager class is used to handle all the threads related stuff like init,
-/// starting, parking and, the most important, launching a slave thread at a split
-/// point. All the access to shared thread data is done through this class.
-
-class ThreadsManager {
-  /* As long as the single ThreadsManager object is defined as a global we don't
-     need to explicitly initialize to zero its data members because variables with
-     static storage duration are automatically set to zero before enter main()
-  */
-public:
-  Thread& operator[](int threadID) { return threads[threadID]; }
-  void init();
-  void exit();
-  void init_hash_tables();
-
-  int min_split_depth() const { return minimumSplitDepth; }
-  int size() const { return activeThreads; }
-  void set_size(int cnt) { activeThreads = cnt; }
-
-  void read_uci_options();
-  bool available_slave_exists(int master) const;
-  void idle_loop(int threadID, SplitPoint* sp);
 
   template <bool Fake>
-  void split(Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,
+  void split(Position& pos, const Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
-             Depth depth, Move threatMove, int moveCount, MovePicker* mp, bool pvNode);
+             Depth depth, Move threatMove, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode);
-private:
+
-  Lock mpLock;
+  SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
-  Depth minimumSplitDepth;
+  Material::Table materialTable;
-  int maxThreadsPerSplitPoint;
+  Endgames endgames;
-  bool useSleepingThreads;
+  Pawns::Table pawnsTable;
-  int activeThreads;
+  Position* activePosition;
-  volatile bool allThreadsShouldExit;
+  size_t idx;
-  Thread threads[MAX_THREADS];
+  int maxPly;
+  SplitPoint* volatile activeSplitPoint;
+  volatile int splitPointsSize;
+  volatile bool searching;
 };
 
-extern ThreadsManager Threads;
 
-#endif // !defined(THREAD_H_INCLUDED)
+/// MainThread and TimerThread are derived classes used to characterize the two
+/// special threads: the main one and the recurring timer.
+
+struct MainThread : public Thread {
+  MainThread() : thinking(true) {} // Avoid a race with start_thinking()
+  virtual void idle_loop();
+  volatile bool thinking;
+};
+
+struct TimerThread : public ThreadBase {
+  TimerThread() : msec(0) {}
+  virtual void idle_loop();
+  int msec;
+};
+
+
+/// 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.
+
+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.
+
+  MainThread* main() { return static_cast<MainThread*>((*this)[0]); }
+  void read_uci_options();
+  Thread* available_slave(const Thread* master) const;
+  void wait_for_think_finished();
+  void start_thinking(const Position&, const Search::LimitsType&,
+                      const std::vector<Move>&, Search::StateStackPtr&);
+
+  bool sleepWhileIdle;
+  Depth minimumSplitDepth;
+  size_t maxThreadsPerSplitPoint;
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  TimerThread* timer;
+};
+
+extern ThreadPool Threads;
+
+#endif // #ifndef THREAD_H_INCLUDED

src/timeman.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -18,8 +18,8 @@
 */
 
 #include <cmath>
+#include <algorithm>
 
-#include "misc.h"
 #include "search.h"
 #include "timeman.h"
 #include "ucioption.h"
@@ -29,7 +29,7 @@ namespace {
   /// Constants
 
   const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
-  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
+  const float 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
 
 
@@ -64,7 +64,7 @@ namespace {
     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[Min(ply, 511)]; }
+  int move_importance(int ply) { return MoveImportance[std::min(ply, 511)]; }
 
 
   /// Function Prototypes
@@ -72,18 +72,18 @@ namespace {
   enum TimeType { OptimumTime, MaxTime };
 
   template<TimeType>
-  int remaining(int myTime, int movesToGo, int currentPly);
+  int remaining(int myTime, int movesToGo, int fullMoveNumber, int slowMover);
 }
 
 
 void TimeManager::pv_instability(int curChanges, int prevChanges) {
 
-    unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
+  unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
-                         + prevChanges * (optimumSearchTime / 3);
+                       + prevChanges * (optimumSearchTime / 3);
 }
 
 
-void TimeManager::init(const SearchLimits& limits, int currentPly)
+void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color us)
 {
   /* We support four different kind of time controls:
 
@@ -103,51 +103,52 @@ void TimeManager::init(const SearchLimits& limits, int currentPly)
   int hypMTG, hypMyTime, t1, t2;
 
   // Read uci parameters
-  int emergencyMoveHorizon = Options["Emergency Move Horizon"].value<int>();
+  int emergencyMoveHorizon = Options["Emergency Move Horizon"];
-  int emergencyBaseTime    = Options["Emergency Base Time"].value<int>();
+  int emergencyBaseTime    = Options["Emergency Base Time"];
-  int emergencyMoveTime    = Options["Emergency Move Time"].value<int>();
+  int emergencyMoveTime    = Options["Emergency Move Time"];
-  int minThinkingTime      = Options["Minimum Thinking Time"].value<int>();
+  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;
+  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 ? Min(limits.movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
+  for (hypMTG = 1; hypMTG <= (limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon); hypMTG++)
   {
       // Calculate thinking time for hypothetic "moves to go"-value
-      hypMyTime =  limits.time
+      hypMyTime =  limits.time[us]
-                 + limits.increment * (hypMTG - 1)
+                 + limits.inc[us] * (hypMTG - 1)
                  - emergencyBaseTime
-                 - emergencyMoveTime * Min(hypMTG, emergencyMoveHorizon);
+                 - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon);
 
-      hypMyTime = Max(hypMyTime, 0);
+      hypMyTime = std::max(hypMyTime, 0);
 
-      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
+      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly, slowMover);
-      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly, slowMover);
 
-      optimumSearchTime = Min(optimumSearchTime, t1);
+      optimumSearchTime = std::min(optimumSearchTime, t1);
-      maximumSearchTime = Min(maximumSearchTime, t2);
+      maximumSearchTime = std::min(maximumSearchTime, t2);
   }
 
-  if (Options["Ponder"].value<bool>())
+  if (Options["Ponder"])
       optimumSearchTime += optimumSearchTime / 4;
 
   // Make sure that maxSearchTime is not over absoluteMaxSearchTime
-  optimumSearchTime = Min(optimumSearchTime, maximumSearchTime);
+  optimumSearchTime = std::min(optimumSearchTime, maximumSearchTime);
 }
 
 
 namespace {
 
   template<TimeType T>
-  int remaining(int myTime, int movesToGo, int currentPly)
+  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);
+    int thisMoveImportance = move_importance(currentPly) * slowMover / 100;
     int otherMovesImportance = 0;
 
     for (int i = 1; i < movesToGo; i++)
@@ -156,6 +157,6 @@ namespace {
     float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
     float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
 
-    return int(floor(myTime * Min(ratio1, ratio2)));
+    return int(floor(myTime * std::min(ratio1, ratio2)));
   }
 }

src/timeman.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,15 +17,15 @@
   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
 
-struct SearchLimits;
+/// The TimeManager class computes the optimal time to think depending on the
+/// maximum available time, the move game number and other parameters.
 
 class TimeManager {
 public:
-
+  void init(const Search::LimitsType& limits, int currentPly, Color us);
-  void init(const SearchLimits& limits, int currentPly);
   void pv_instability(int curChanges, int prevChanges);
   int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
   int maximum_time() const { return maximumSearchTime; }
@@ -36,4 +36,4 @@ private:
   int unstablePVExtraTime;
 };
 
-#endif // !defined(TIMEMAN_H_INCLUDED)
+#endif // #ifndef TIMEMAN_H_INCLUDED

src/tt.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,53 +17,40 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cassert>
 #include <cstring>
 #include <iostream>
 
+#include "bitboard.h"
 #include "tt.h"
 
 TranspositionTable TT; // Our global transposition table
 
-TranspositionTable::TranspositionTable() {
-
-  size = generation = 0;
-  entries = NULL;
-}
-
-TranspositionTable::~TranspositionTable() {
-
-  delete [] entries;
-}
-
 
 /// TranspositionTable::set_size() sets the size of the transposition table,
-/// measured in megabytes.
+/// 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) {
 
-  size_t newSize = 1024;
+  assert(msb((mbSize << 20) / sizeof(TTEntry)) < 32);
 
-  // Transposition table consists of clusters and each cluster consists
+  uint32_t size = ClusterSize << msb((mbSize << 20) / sizeof(TTEntry[ClusterSize]));
-  // of ClusterSize number of TTEntries. Each non-empty entry contains
-  // information of exactly one position and newSize is the number of
-  // clusters we are going to allocate.
-  while (2ULL * newSize * sizeof(TTCluster) <= (mbSize << 20))
-      newSize *= 2;
 
-  if (newSize == size)
+  if (hashMask == size - ClusterSize)
       return;
 
-  size = newSize;
+  hashMask = size - ClusterSize;
-  delete [] entries;
+  free(mem);
-  entries = new (std::nothrow) TTCluster[size];
+  mem = calloc(size * sizeof(TTEntry) + CACHE_LINE_SIZE - 1, 1);
-  if (!entries)
+
+  if (!mem)
   {
       std::cerr << "Failed to allocate " << mbSize
-                << " MB for transposition table." << std::endl;
+                << "MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
   }
-  clear();
+
+  table = (TTEntry*)((uintptr_t(mem) + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1));
 }
 
 
@@ -73,7 +60,24 @@ void TranspositionTable::set_size(size_t mbSize) {
 
 void TranspositionTable::clear() {
 
-  memset(entries, 0, size * sizeof(TTCluster));
+  std::memset(table, 0, (hashMask + ClusterSize) * sizeof(TTEntry));
+}
+
+
+/// TranspositionTable::probe() looks up the current position in the
+/// transposition table. Returns a pointer to the TTEntry or NULL if
+/// position is not found.
+
+const TTEntry* TranspositionTable::probe(const Key key) const {
+
+  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;
 }
 
 
@@ -85,60 +89,33 @@ void TranspositionTable::clear() {
 /// 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.
 
-void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
+void TranspositionTable::store(const Key key, Value v, Bound b, Depth d, Move m, Value statV, Value evalM) {
 
   int c1, c2, c3;
   TTEntry *tte, *replace;
-  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key inside the cluster
+  uint32_t key32 = key >> 32; // Use the high 32 bits as key inside the cluster
 
-  tte = replace = first_entry(posKey);
+  tte = replace = first_entry(key);
 
-  for (int i = 0; i < ClusterSize; i++, tte++)
+  for (unsigned i = 0; i < ClusterSize; i++, tte++)
   {
-      if (!tte->key() || tte->key() == posKey32) // Empty or overwrite old
+      if (!tte->key() || tte->key() == key32) // Empty or overwrite old
       {
-          // Preserve any existing ttMove
+          if (!m)
-          if (m == MOVE_NONE)
+              m = tte->move(); // Preserve any existing ttMove
-              m = tte->move();
 
-          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
+          replace = tte;
-          return;
+          break;
       }
 
       // Implement replace strategy
       c1 = (replace->generation() == generation ?  2 : 0);
-      c2 = (tte->generation() == generation || tte->type() == VALUE_TYPE_EXACT ? -2 : 0);
+      c2 = (tte->generation() == generation || tte->bound() == BOUND_EXACT ? -2 : 0);
       c3 = (tte->depth() < replace->depth() ?  1 : 0);
 
       if (c1 + c2 + c3 > 0)
           replace = tte;
   }
-  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
+
-}
+  replace->save(key32, v, b, d, m, generation, statV, evalM);
-
-
-/// TranspositionTable::probe() looks up the current position in the
-/// transposition table. Returns a pointer to the TTEntry or NULL if
-/// position is not found.
-
-TTEntry* TranspositionTable::probe(const Key posKey) const {
-
-  uint32_t posKey32 = posKey >> 32;
-  TTEntry* tte = first_entry(posKey);
-
-  for (int i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == posKey32)
-          return tte;
-
-  return NULL;
-}
-
-
-/// TranspositionTable::new_search() is called at the beginning of every new
-/// search. It increments the "generation" variable, which is used to
-/// distinguish transposition table entries from previous searches from
-/// entries from the current search.
-
-void TranspositionTable::new_search() {
-  generation++;
 }

src/tt.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,102 +17,81 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TT_H_INCLUDED)
+#ifndef TT_H_INCLUDED
 #define TT_H_INCLUDED
 
-#include <iostream>
+#include "misc.h"
-
-#include "move.h"
 #include "types.h"
 
+/// The TTEntry is the 128 bit transposition table entry, defined as below:
+///
+/// key: 32 bit
+/// move: 16 bit
+/// bound type: 8 bit
+/// generation: 8 bit
+/// value: 16 bit
+/// depth: 16 bit
+/// static value: 16 bit
+/// static margin: 16 bit
 
-/// The TTEntry is the class of transposition table entries
+struct TTEntry {
-///
-/// 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
 
-class TTEntry {
+  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev, Value em) {
-
-public:
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
 
     key32        = (uint32_t)k;
     move16       = (uint16_t)m;
-    valueType    = (uint8_t)t;
+    bound8       = (uint8_t)b;
     generation8  = (uint8_t)g;
     value16      = (int16_t)v;
     depth16      = (int16_t)d;
-    staticValue  = (int16_t)statV;
+    evalValue    = (int16_t)ev;
-    staticMargin = (int16_t)statM;
+    evalMargin   = (int16_t)em;
   }
-  void set_generation(int g) { generation8 = (uint8_t)g; }
+  void set_generation(uint8_t g) { generation8 = g; }
 
-  uint32_t key() const              { return key32; }
+  uint32_t key() const      { return key32; }
-  Depth depth() const               { return (Depth)depth16; }
+  Depth depth() const       { return (Depth)depth16; }
-  Move move() const                 { return (Move)move16; }
+  Move move() const         { return (Move)move16; }
-  Value value() const               { return (Value)value16; }
+  Value value() const       { return (Value)value16; }
-  ValueType type() const            { return (ValueType)valueType; }
+  Bound bound() const       { return (Bound)bound8; }
-  int generation() const            { return (int)generation8; }
+  int generation() const    { return (int)generation8; }
-  Value static_value() const        { return (Value)staticValue; }
+  Value eval_value() const  { return (Value)evalValue; }
-  Value static_value_margin() const { return (Value)staticMargin; }
+  Value eval_margin() const { return (Value)evalMargin; }
 
 private:
   uint32_t key32;
   uint16_t move16;
-  uint8_t valueType, generation8;
+  uint8_t bound8, generation8;
-  int16_t value16, depth16, staticValue, staticMargin;
+  int16_t value16, depth16, evalValue, evalMargin;
 };
 
 
-/// This is the number of TTEntry slots for each cluster
+/// A TranspositionTable consists of a power of 2 number of clusters and each
-const int ClusterSize = 4;
+/// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
-
+/// contains information of exactly one position. Size of a cluster shall not be
-
+/// bigger than a cache line size. In case it is less, it should be padded to
-/// TTCluster consists of ClusterSize number of TTEntries. Size of TTCluster
+/// guarantee always aligned accesses.
-/// must not be bigger than a cache line size. In case it is less, it should
-/// be padded to guarantee always aligned accesses.
-
-struct TTCluster {
-  TTEntry data[ClusterSize];
-};
-
-
-/// The transposition table class. This is basically just a huge array containing
-/// TTCluster objects, and a few methods for writing and reading entries.
 
 class TranspositionTable {
 
-  TranspositionTable(const TranspositionTable&);
+  static const unsigned ClusterSize = 4; // A cluster is 64 Bytes
-  TranspositionTable& operator=(const TranspositionTable&);
 
 public:
-  TranspositionTable();
+ ~TranspositionTable() { free(mem); }
-  ~TranspositionTable();
+  void new_search() { generation++; }
+
+  const 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);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+  void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
-  TTEntry* probe(const Key posKey) const;
-  void new_search();
-  TTEntry* first_entry(const Key posKey) const;
-  void refresh(const TTEntry* tte) const;
 
 private:
-  size_t size;
+  uint32_t hashMask;
-  TTCluster* entries;
+  TTEntry* table;
-  uint8_t generation; // Size must be not bigger then TTEntry::generation8
+  void* mem;
+  uint8_t generation; // Size must be not bigger than TTEntry::generation8
 };
 
 extern TranspositionTable TT;
@@ -122,9 +101,9 @@ extern TranspositionTable TT;
 /// a cluster given a position. The lowest order bits of the key are used to
 /// get the index of the cluster.
 
-inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
+inline TTEntry* TranspositionTable::first_entry(const Key key) const {
 
-  return entries[((uint32_t)posKey) & (size - 1)].data;
+  return table + ((uint32_t)key & hashMask);
 }
 
 
@@ -136,38 +115,4 @@ inline void TranspositionTable::refresh(const TTEntry* tte) const {
   const_cast<TTEntry*>(tte)->set_generation(generation);
 }
 
-
+#endif // #ifndef TT_H_INCLUDED
-/// A simple fixed size hash table used to store pawns and material
-/// configurations. It is basically just an array of Entry objects.
-/// Without cluster concept or overwrite policy.
-
-template<class Entry, int HashSize>
-struct SimpleHash {
-
-  typedef SimpleHash<Entry, HashSize> Base;
-
-  void init() {
-
-    if (entries)
-        return;
-
-    entries = new (std::nothrow) Entry[HashSize];
-    if (!entries)
-    {
-        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
-                  << " bytes for hash table." << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    memset(entries, 0, HashSize * sizeof(Entry));
-  }
-
-  virtual ~SimpleHash() { delete [] entries; }
-
-  Entry* probe(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
-  void prefetch(Key key) const { ::prefetch((char*)probe(key)); }
-
-protected:
-  Entry* entries;
-};
-
-#endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,155 +17,138 @@
   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'.
+///
+/// For Windows, part of the configuration is detected automatically, but some
+/// switches need to be set manually:
+///
+/// -DNDEBUG      | Disable debugging mode. Use always.
+///
+/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want
+///               | the executable 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.
+
+#include <cassert>
+#include <cctype>
 #include <climits>
 #include <cstdlib>
 
-#if defined(_MSC_VER)
+#include "platform.h"
 
-// Disable some silly and noisy warning from MSVC compiler
+#define unlikely(x) (x) // For code annotation purposes
-#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
-#pragma warning(disable: 4127) // Conditional expression is constant
-#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
-
-// 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>
 
+#if defined(_WIN64) && !defined(IS_64BIT)
+#  include <intrin.h> // MSVC popcnt and bsfq instrinsics
+#  define IS_64BIT
+#  define USE_BSFQ
 #endif
 
-#define Min(x, y) (((x) < (y)) ? (x) : (y))
-#define Max(x, y) (((x) < (y)) ? (y) : (x))
-
-////
-//// Configuration
-////
-
-//// For Linux and OSX configuration is done automatically using Makefile.
-//// To get started type "make help".
-////
-//// For windows part of the configuration is detected automatically, but
-//// some switches need to be set manually:
-////
-//// -DNDEBUG       | Disable debugging mode. Use always.
-////
-//// -DNO_PREFETCH  | Disable use of prefetch asm-instruction. A must if you want the
-////                | executable 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. Around 4% speed-up.
-////
-//// -DOLD_LOCKS    | By default under Windows are used the fast Slim Reader/Writer (SRW)
-////                | Locks and Condition Variables: these are not supported by Windows XP
-////                | and older, to compile for those platforms you should enable OLD_LOCKS.
-
-// Automatic detection for 64-bit under Windows
-#if defined(_WIN64)
-#define IS_64BIT
-#endif
-
-// Automatic detection for use of bsfq asm-instruction under Windows
-#if defined(_WIN64)
-#define USE_BSFQ
-#endif
-
-// Intel header for _mm_popcnt_u64() intrinsic
 #if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
-#include <nmmintrin.h>
+#  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
 #endif
 
-// Cache line alignment specification
+#  if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#   include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
+#  endif
+
+#define CACHE_LINE_SIZE 64
 #if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#  define CACHE_LINE_ALIGNMENT __declspec(align(CACHE_LINE_SIZE))
 #else
-#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(CACHE_LINE_SIZE)))
 #endif
 
-// Define a __cpuid() function for gcc compilers, for Intel and MSVC
+#ifdef _MSC_VER
-// is already available as an intrinsic.
+#  define FORCE_INLINE  __forceinline
-#if defined(_MSC_VER)
-#include <intrin.h>
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
-inline void __cpuid(int CPUInfo[4], int InfoType)
-{
-  int* eax = CPUInfo + 0;
-  int* ebx = CPUInfo + 1;
-  int* ecx = CPUInfo + 2;
-  int* edx = CPUInfo + 3;
-
-  *eax = InfoType;
-  *ecx = 0;
-  __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
-                  : "0" (*eax), "2" (*ecx));
-}
-#else
-inline void __cpuid(int CPUInfo[4], int)
-{
-   CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0;
-}
-#endif
-
-// Define FORCE_INLINE macro to force inlining overriding compiler choice
-#if defined(_MSC_VER)
-#define FORCE_INLINE  __forceinline
 #elif defined(__GNUC__)
-#define FORCE_INLINE  inline __attribute__((always_inline))
+#  define FORCE_INLINE  inline __attribute__((always_inline))
 #else
-#define FORCE_INLINE  inline
+#  define FORCE_INLINE  inline
 #endif
 
-/// cpu_has_popcnt() detects support for popcnt instruction at runtime
+#ifdef USE_POPCNT
-inline bool cpu_has_popcnt() {
+const bool HasPopCnt = true;
-
-  int CPUInfo[4] = {-1};
-  __cpuid(CPUInfo, 0x00000001);
-  return (CPUInfo[2] >> 23) & 1;
-}
-
-/// CpuHasPOPCNT is a global constant initialized at startup that
-/// is set to true if CPU on which application runs supports popcnt
-/// hardware instruction. Unless USE_POPCNT is not defined.
-#if defined(USE_POPCNT)
-const bool CpuHasPOPCNT = cpu_has_popcnt();
 #else
-const bool CpuHasPOPCNT = false;
+const bool HasPopCnt = false;
 #endif
 
-
+#ifdef IS_64BIT
-/// CpuIs64Bit is a global constant initialized at compile time that
+const bool Is64Bit = true;
-/// is set to true if CPU on which application runs is a 64 bits.
-#if defined(IS_64BIT)
-const bool CpuIs64Bit = true;
 #else
-const bool CpuIs64Bit = false;
+const bool Is64Bit = false;
 #endif
 
-#include <string>
-
 typedef uint64_t Key;
 typedef uint64_t Bitboard;
 
-const int PLY_MAX = 100;
+const int MAX_MOVES      = 192;
-const int PLY_MAX_PLUS_2 = PLY_MAX + 2;
+const int MAX_PLY        = 100;
+const int MAX_PLY_PLUS_6 = MAX_PLY + 6;
 
-enum ValueType {
+/// A move needs 16 bits to be stored
-  VALUE_TYPE_NONE  = 0,
+///
-  VALUE_TYPE_UPPER = 1,
+/// bit  0- 5: destination square (from 0 to 63)
-  VALUE_TYPE_LOWER = 2,
+/// bit  6-11: origin square (from 0 to 63)
-  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+/// 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)
+///
+/// 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,
+  MOVE_NULL = 65
+};
+
+enum MoveType {
+  NORMAL,
+  PROMOTION = 1 << 14,
+  ENPASSANT = 2 << 14,
+  CASTLE    = 3 << 14
+};
+
+enum CastleRight {  // Defined as in PolyGlot book hash key
+  CASTLES_NONE,
+  WHITE_OO,
+  WHITE_OOO   = WHITE_OO << 1,
+  BLACK_OO    = WHITE_OO << 2,
+  BLACK_OOO   = WHITE_OO << 3,
+  ALL_CASTLES = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
+  CASTLE_RIGHT_NB = 16
+};
+
+enum CastlingSide {
+  KING_SIDE,
+  QUEEN_SIDE,
+  CASTLING_SIDE_NB = 2
+};
+
+enum Phase {
+  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
+};
+
+enum Bound {
+  BOUND_NONE,
+  BOUND_UPPER,
+  BOUND_LOWER,
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
 enum Value {
@@ -176,34 +159,44 @@ enum Value {
   VALUE_INFINITE  = 30001,
   VALUE_NONE      = 30002,
 
-  VALUE_MATE_IN_PLY_MAX  =  VALUE_MATE - PLY_MAX,
+  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - MAX_PLY,
-  VALUE_MATED_IN_PLY_MAX = -VALUE_MATE + PLY_MAX,
+  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + MAX_PLY,
 
   VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
-  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN
+  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN,
+
+  PawnValueMg   = 198,   PawnValueEg   = 258,
+  KnightValueMg = 817,   KnightValueEg = 846,
+  BishopValueMg = 836,   BishopValueEg = 857,
+  RookValueMg   = 1270,  RookValueEg   = 1278,
+  QueenValueMg  = 2521,  QueenValueEg  = 2558
 };
 
 enum PieceType {
-  PIECE_TYPE_NONE = 0,
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+  ALL_PIECES = 0,
+  PIECE_TYPE_NB = 8
 };
 
 enum Piece {
-  PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
+  NO_PIECE,
-  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
+  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, COLOR_NONE
+  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
 };
 
 enum Depth {
 
   ONE_PLY = 2,
 
-  DEPTH_ZERO         =  0 * ONE_PLY,
+  DEPTH_ZERO          =  0 * ONE_PLY,
-  DEPTH_QS_CHECKS    = -1 * ONE_PLY,
+  DEPTH_QS_CHECKS     = -1 * ONE_PLY,
-  DEPTH_QS_NO_CHECKS = -2 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS  = -2 * ONE_PLY,
+  DEPTH_QS_RECAPTURES = -7 * ONE_PLY,
 
   DEPTH_NONE = -127 * ONE_PLY
 };
@@ -219,6 +212,8 @@ 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,
@@ -233,49 +228,61 @@ enum Square {
 };
 
 enum File {
-  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H
+  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB
 };
 
 enum Rank {
-  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB
-};
-
-enum SquareColor {
-  DARK, LIGHT
-};
-
-enum ScaleFactor {
-  SCALE_FACTOR_ZERO   = 0,
-  SCALE_FACTOR_NORMAL = 64,
-  SCALE_FACTOR_MAX    = 128,
-  SCALE_FACTOR_NONE   = 255
 };
 
 
-/// Score enum keeps a midgame and an endgame value in a single
+/// Score enum keeps a midgame and an endgame value in a single integer (enum),
-/// integer (enum), first LSB 16 bits are used to store endgame
+/// first LSB 16 bits are used to store endgame value, while upper bits are used
-/// value, while upper bits are used for midgame value. Compiler
+/// for midgame value. Compiler is free to choose the enum type as long as can
-/// is free to choose the enum type as long as can keep its data,
+/// keep its data, so ensure Score to be an integer type.
-/// so ensure Score to be an integer type.
 enum Score {
-    SCORE_ZERO = 0,
+  SCORE_ZERO,
-    SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+  SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
-    SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
+  SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
 };
 
-#define ENABLE_OPERATORS_ON(T) \
+inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
-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)); } \
+/// Extracting the signed lower and upper 16 bits it not so trivial because
-inline T operator* (int i, const T d) {  return T(i * int(d)); } \
+/// according to the standard a simple cast to short is implementation defined
-inline T operator* (const T d, int i) {  return T(int(d) * i); } \
+/// and so is a right shift of a signed integer.
-inline T operator/ (const T d, int i) { return T(int(d) / i); } \
+inline Value mg_value(Score s) { return Value(((s + 0x8000) & ~0xffff) / 0x10000); }
-inline T operator- (const T d) { return T(-int(d)); } \
+
-inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \
+/// On Intel 64 bit we have a small speed regression with the standard conforming
-inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \
+/// version, so use a faster code in this case that, although not 100% standard
-inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \
+/// compliant it seems to work for Intel and MSVC.
-inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \
+#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
-inline void operator*= (T& d, int i) { d = T(int(d) * i); } \
+
-inline void operator/= (T& d, int i) { d = T(int(d) / i); }
+inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
+
+#else
+
+inline Value eg_value(Score s) {
+  return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u));
+}
+
+#endif
+
+#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; }
+
+#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; }
 
 ENABLE_OPERATORS_ON(Value)
 ENABLE_OPERATORS_ON(PieceType)
@@ -286,185 +293,151 @@ ENABLE_OPERATORS_ON(Square)
 ENABLE_OPERATORS_ON(File)
 ENABLE_OPERATORS_ON(Rank)
 
-#undef ENABLE_OPERATORS_ON
+/// 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); }
 
-// Extra operators for adding integers to a Value
+ENABLE_SAFE_OPERATORS_ON(Score)
-inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
-inline Value operator- (Value v, int i) { return Value(int(v) - i); }
 
-// Extracting the _signed_ lower and upper 16 bits it not so trivial
+/// Only declared but not defined. We don't want to multiply two scores due to
-// because according to the standard a simple cast to short is
+/// a very high risk of overflow. So user should explicitly convert to integer.
-// implementation defined and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); }
-
-// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in
-// this case, although not 100% standard compliant it seems to work for Intel and MSVC.
-#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
-inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
-#else
-inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); }
-#endif
-
-inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
-
-// Division 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); }
-
-// 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);
 
-// Remaining Score operators are standard
+/// Division of a Score must be handled separately for each term
-inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); }
+inline Score operator/(Score s, int i) {
-inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); }
+  return make_score(mg_value(s) / i, eg_value(s) / i);
-inline Score operator* (int i, const Score d) {  return Score(i * int(d)); }
+}
-inline Score operator* (const Score d, int i) {  return Score(int(d) * i); }
-inline Score operator- (const Score d) { return Score(-int(d)); }
-inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; }
-inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; }
-inline void operator*= (Score& d, int i) { d = Score(int(d) * i); }
-inline void operator/= (Score& d, int i) { d = Score(int(d) / i); }
 
-const Value PawnValueMidgame   = Value(0x0C6);
+#undef ENABLE_OPERATORS_ON
-const Value PawnValueEndgame   = Value(0x102);
+#undef ENABLE_SAFE_OPERATORS_ON
-const Value KnightValueMidgame = Value(0x331);
-const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame  = Value(0x9FE);
 
-inline Value value_mate_in(int ply) {
+extern Value PieceValue[PHASE_NB][PIECE_NB];
+
+struct ExtMove {
+  Move move;
+  int score;
+};
+
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
+  return f.score < s.score;
+}
+
+inline Color operator~(Color c) {
+  return Color(c ^ 1);
+}
+
+inline Square operator~(Square s) {
+  return Square(s ^ 56); // Vertical flip SQ_A1 -> SQ_A8
+}
+
+inline Square operator|(File f, Rank r) {
+  return Square((r << 3) | f);
+}
+
+inline Value mate_in(int ply) {
   return VALUE_MATE - ply;
 }
 
-inline Value value_mated_in(int ply) {
+inline Value mated_in(int ply) {
   return -VALUE_MATE + ply;
 }
 
 inline Piece make_piece(Color c, PieceType pt) {
-  return Piece((int(c) << 3) | int(pt));
+  return Piece((c << 3) | pt);
 }
 
-inline PieceType type_of_piece(Piece p)  {
+inline CastleRight make_castle_right(Color c, CastlingSide s) {
-  return PieceType(int(p) & 7);
+  return CastleRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
 }
 
-inline Color color_of_piece(Piece p) {
+inline PieceType type_of(Piece p)  {
-  return Color(int(p) >> 3);
+  return PieceType(p & 7);
 }
 
-inline Color opposite_color(Color c) {
+inline Color color_of(Piece p) {
-  return Color(int(c) ^ 1);
+  assert(p != NO_PIECE);
+  return Color(p >> 3);
 }
 
-inline bool color_is_ok(Color c) {
+inline bool is_ok(Square s) {
-  return c == WHITE || c == BLACK;
+  return s >= SQ_A1 && s <= SQ_H8;
 }
 
-inline bool piece_type_is_ok(PieceType pt) {
+inline File file_of(Square s) {
-  return pt >= PAWN && pt <= KING;
+  return File(s & 7);
 }
 
-inline bool piece_is_ok(Piece p) {
+inline Rank rank_of(Square s) {
-  return piece_type_is_ok(type_of_piece(p)) && color_is_ok(color_of_piece(p));
+  return Rank(s >> 3);
 }
 
-inline char piece_type_to_char(PieceType pt) {
+inline Square mirror(Square s) {
-  static const char ch[] = " PNBRQK";
+  return Square(s ^ 7); // Horizontal flip SQ_A1 -> SQ_H1
-  return ch[pt];
-}
-
-inline Square make_square(File f, Rank r) {
-  return Square((int(r) << 3) | int(f));
-}
-
-inline File square_file(Square s) {
-  return File(int(s) & 7);
-}
-
-inline Rank square_rank(Square s) {
-  return Rank(int(s) >> 3);
-}
-
-inline Square flip_square(Square s) {
-  return Square(int(s) ^ 56);
-}
-
-inline Square flop_square(Square s) {
-  return Square(int(s) ^ 7);
 }
 
 inline Square relative_square(Color c, Square s) {
-  return Square(int(s) ^ (int(c) * 56));
+  return Square(s ^ (c * 56));
 }
 
 inline Rank relative_rank(Color c, Rank r) {
-  return Rank(int(r) ^ (int(c) * 7));
+  return Rank(r ^ (c * 7));
 }
 
 inline Rank relative_rank(Color c, Square s) {
-  return relative_rank(c, square_rank(s));
+  return relative_rank(c, rank_of(s));
 }
 
-inline SquareColor square_color(Square s) {
+inline bool opposite_colors(Square s1, Square s2) {
-  return SquareColor(int(square_rank(s) + s) & 1);
-}
-
-inline bool opposite_color_squares(Square s1, Square s2) {
   int s = int(s1) ^ int(s2);
   return ((s >> 3) ^ s) & 1;
 }
 
-inline int file_distance(Square s1, Square s2) {
+inline char file_to_char(File f, bool tolower = true) {
-  return abs(square_file(s1) - square_file(s2));
+  return char(f - FILE_A + (tolower ? 'a' : 'A'));
-}
-
-inline int rank_distance(Square s1, Square s2) {
-  return abs(square_rank(s1) - square_rank(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return Max(file_distance(s1, s2), rank_distance(s1, s2));
-}
-
-inline File file_from_char(char c) {
-  return File(c - 'a') + FILE_A;
-}
-
-inline char file_to_char(File f) {
-  return char(f - FILE_A + int('a'));
-}
-
-inline Rank rank_from_char(char c) {
-  return Rank(c - '1') + RANK_1;
 }
 
 inline char rank_to_char(Rank r) {
-  return char(r - RANK_1 + int('1'));
+  return char(r - RANK_1 + '1');
-}
-
-inline const std::string square_to_string(Square s) {
-  char ch[] = { file_to_char(square_file(s)), rank_to_char(square_rank(s)), 0 };
-  return std::string(ch);
-}
-
-inline bool file_is_ok(File f) {
-  return f >= FILE_A && f <= FILE_H;
-}
-
-inline bool rank_is_ok(Rank r) {
-  return r >= RANK_1 && r <= RANK_8;
-}
-
-inline bool square_is_ok(Square s) {
-  return s >= SQ_A1 && s <= SQ_H8;
 }
 
 inline Square pawn_push(Color c) {
   return c == WHITE ? DELTA_N : DELTA_S;
 }
 
-#endif // !defined(TYPES_H_INCLUDED)
+inline Square from_sq(Move m) {
+  return Square((m >> 6) & 0x3F);
+}
+
+inline Square to_sq(Move m) {
+  return Square(m & 0x3F);
+}
+
+inline MoveType type_of(Move m) {
+  return MoveType(m & (3 << 14));
+}
+
+inline PieceType promotion_type(Move m) {
+  return PieceType(((m >> 12) & 3) + 2);
+}
+
+inline Move make_move(Square from, Square to) {
+  return Move(to | (from << 6));
+}
+
+template<MoveType T>
+inline Move make(Square from, Square to, PieceType pt = KNIGHT) {
+  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));
+}
+
+inline bool is_ok(Move m) {
+  return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE
+}
+
+#include <string>
+
+inline const std::string square_to_string(Square s) {
+  char ch[] = { file_to_char(file_of(s)), rank_to_char(rank_of(s)), 0 };
+  return ch;
+}
+
+#endif // #ifndef TYPES_H_INCLUDED

src/uci.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,231 +17,203 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cassert>
+#include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <string>
 
 #include "evaluate.h"
-#include "misc.h"
+#include "notation.h"
-#include "move.h"
 #include "position.h"
 #include "search.h"
+#include "thread.h"
 #include "ucioption.h"
 
 using namespace std;
 
+extern void benchmark(const Position& pos, istream& is);
+
 namespace {
 
-  // FEN string for the initial position
+  // FEN string of the initial position, normal chess
-  const string StartPositionFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+  const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-  // UCIParser is a class for parsing UCI input. The class
+  // Keep track of position keys along the setup moves (from start position to the
-  // is actually a string stream built on a given input string.
+  // position just before to start searching). Needed by repetition draw detection.
-  typedef istringstream UCIParser;
+  Search::StateStackPtr SetupStates;
 
-  void set_option(UCIParser& up);
+  void setoption(istringstream& up);
-  void set_position(Position& pos, UCIParser& up);
+  void position(Position& pos, istringstream& up);
-  bool go(Position& pos, UCIParser& up);
+  void go(const Position& pos, istringstream& up);
-  void perft(Position& pos, UCIParser& up);
 }
 
 
-/// execute_uci_command() takes a string as input, uses a UCIParser
+/// Wait for a command from the user, parse this text string as an UCI command,
-/// object to parse this text string as a UCI command, and calls
+/// and call the appropriate functions. Also intercepts EOF from stdin to ensure
-/// the appropriate functions. In addition to the UCI commands,
+/// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI
-/// the function also supports a few debug commands.
+/// commands, the function also supports a few debug commands.
 
-bool execute_uci_command(const string& cmd) {
+void UCI::loop(const string& args) {
 
-  static Position pos(StartPositionFEN, false, 0); // The root position
+  Position pos(StartFEN, false, Threads.main()); // The root position
+  string token, cmd = args;
 
-  UCIParser up(cmd);
+  do {
-  string token;
+      if (args.empty() && !getline(cin, cmd)) // Block here waiting for input
+          cmd = "quit";
 
-  up >> token; // operator>>() skips any whitespace
+      istringstream is(cmd);
 
-  if (token == "quit")
+      is >> skipws >> token;
-      return false;
 
-  if (token == "go")
+      if (token == "quit" || token == "stop" || token == "ponderhit")
-      return go(pos, up);
+      {
+          // 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()->notify_one(); // Could be sleeping
+          }
+          else
+              Search::Limits.ponder = false;
+      }
+      else if (token == "perft" && (is >> token)) // Read perft depth
+      {
+          stringstream ss;
 
-  if (token == "ucinewgame")
+          ss << Options["Hash"]    << " "
-      pos.from_fen(StartPositionFEN, false);
+             << Options["Threads"] << " " << token << " current perft";
 
-  else if (token == "isready")
+          benchmark(pos, ss);
-      cout << "readyok" << endl;
+      }
+      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 == "position")
+      else if (token == "uci")
-      set_position(pos, up);
+          sync_cout << "id name " << engine_info(true)
+                    << "\n"       << Options
+                    << "\nuciok"  << sync_endl;
 
-  else if (token == "setoption")
+      else if (token == "eval")
-      set_option(up);
+      {
+          Search::RootColor = pos.side_to_move(); // Ensure it is set
+          sync_cout << Eval::trace(pos) << sync_endl;
+      }
+      else if (token == "ucinewgame") { /* Avoid returning "Unknown command" */ }
+      else if (token == "go")         go(pos, is);
+      else if (token == "position")   position(pos, is);
+      else if (token == "setoption")  setoption(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
+          sync_cout << "Unknown command: " << cmd << sync_endl;
 
-  else if (token == "perft")
+  } while (token != "quit" && args.empty()); // Args have one-shot behaviour
-      perft(pos, up);
 
-  else if (token == "d")
+  Threads.wait_for_think_finished(); // Cannot quit while search is running
-      pos.print();
-
-  else if (token == "flip")
-      pos.flip();
-
-  else if (token == "eval")
-  {
-      read_evaluation_uci_options(pos.side_to_move());
-      cout << trace_evaluate(pos) << endl;
-  }
-
-  else if (token == "key")
-      cout << "key: " << hex     << pos.get_key()
-           << "\nmaterial key: " << pos.get_material_key()
-           << "\npawn key: "     << pos.get_pawn_key() << endl;
-
-  else if (token == "uci")
-      cout << "id name "     << engine_name()
-           << "\nid author " << engine_authors()
-           << "\n"           << Options.print_all()
-           << "\nuciok"      << endl;
-  else
-      cout << "Unknown command: " << cmd << endl;
-
-  return true;
 }
 
 
 namespace {
 
-  // set_position() is called when engine receives the "position" UCI
+  // position() is called when engine receives the "position" UCI command.
-  // command. The function sets up the position described in the given
+  // The function sets up the position described in the given fen string ("fen")
-  // fen string ("fen") or the starting position ("startpos") and then
+  // or the starting position ("startpos") and then makes the moves given in the
-  // makes the moves given in the following move list ("moves").
+  // following move list ("moves").
 
-  void set_position(Position& pos, UCIParser& up) {
+  void position(Position& pos, istringstream& is) {
 
+    Move m;
     string token, fen;
 
-    up >> token; // operator>>() skips any whitespace
+    is >> token;
 
     if (token == "startpos")
     {
-        pos.from_fen(StartPositionFEN, false);
+        fen = StartFEN;
-        up >> token; // Consume "moves" token if any
+        is >> token; // Consume "moves" token if any
     }
     else if (token == "fen")
-    {
+        while (is >> token && token != "moves")
-        while (up >> token && token != "moves")
             fen += token + " ";
-
-        pos.from_fen(fen, Options["UCI_Chess960"].value<bool>());
-    }
-    else return;
-
-    // Parse move list (if any)
-    while (up >> token)
-        pos.do_setup_move(move_from_uci(pos, token));
-  }
-
-
-  // set_option() is called when engine receives the "setoption" UCI
-  // command. The function updates the corresponding UCI option ("name")
-  // to the given value ("value").
-
-  void set_option(UCIParser& up) {
-
-    string token, name;
-    string value = "true"; // UCI buttons don't have a "value" field
-
-    up >> token; // Consume "name" token
-    up >> name;  // Read option name
-
-    // Handle names with included spaces
-    while (up >> token && token != "value")
-        name += " " + token;
-
-    up >> value; // Read option value
-
-    // Handle values with included spaces
-    while (up >> token)
-        value += " " + token;
-
-    if (Options.find(name) != Options.end())
-        Options[name].set_value(value);
     else
-        cout << "No such option: " << name << endl;
-  }
-
-
-  // go() is called when engine receives the "go" UCI command. The
-  // function sets the thinking time and other parameters from the input
-  // string, and then calls think(). Returns false if a quit command
-  // is received while thinking, true otherwise.
-
-  bool go(Position& pos, UCIParser& up) {
-
-    string token;
-    SearchLimits limits;
-    Move searchMoves[MAX_MOVES], *cur = searchMoves;
-    int time[] = { 0, 0 }, inc[] = { 0, 0 };
-
-    while (up >> token)
-    {
-        if (token == "infinite")
-            limits.infinite = true;
-        else if (token == "ponder")
-            limits.ponder = true;
-        else if (token == "wtime")
-            up >> time[WHITE];
-        else if (token == "btime")
-            up >> time[BLACK];
-        else if (token == "winc")
-            up >> inc[WHITE];
-        else if (token == "binc")
-            up >> inc[BLACK];
-        else if (token == "movestogo")
-            up >> limits.movesToGo;
-        else if (token == "depth")
-            up >> limits.maxDepth;
-        else if (token == "nodes")
-            up >> limits.maxNodes;
-        else if (token == "movetime")
-            up >> limits.maxTime;
-        else if (token == "searchmoves")
-            while (up >> token)
-                *cur++ = move_from_uci(pos, token);
-    }
-
-    *cur = MOVE_NONE;
-    limits.time = time[pos.side_to_move()];
-    limits.increment = inc[pos.side_to_move()];
-
-    assert(pos.is_ok());
-
-    return think(pos, limits, searchMoves);
-  }
-
-
-  // perft() is called when engine receives the "perft" command.
-  // The function calls perft() passing the required search depth
-  // then prints counted leaf nodes and elapsed time.
-
-  void perft(Position& pos, UCIParser& up) {
-
-    int depth, time;
-    int64_t n;
-
-    if (!(up >> depth))
         return;
 
-    time = get_system_time();
+    pos.set(fen, Options["UCI_Chess960"], Threads.main());
+    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());
 
-    n = perft(pos, depth * ONE_PLY);
+    // Parse move list (if any)
+    while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
+    {
+        SetupStates->push(StateInfo());
+        pos.do_move(m, SetupStates->top());
+    }
+  }
 
-    time = get_system_time() - time;
 
-    std::cout << "\nNodes " << n
+  // setoption() is called when engine receives the "setoption" UCI command. The
-              << "\nTime (ms) " << time
+  // function updates the UCI option ("name") to the given value ("value").
-              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
+
+  void setoption(istringstream& is) {
+
+    string token, name, value;
+
+    is >> token; // Consume "name" token
+
+    // Read option name (can contain spaces)
+    while (is >> token && token != "value")
+        name += string(" ", !name.empty()) + token;
+
+    // Read option value (can contain spaces)
+    while (is >> token)
+        value += string(" ", !value.empty()) + token;
+
+    if (Options.count(name))
+        Options[name] = value;
+    else
+        sync_cout << "No such option: " << name << sync_endl;
+  }
+
+
+  // go() is called when engine receives the "go" UCI command. The function sets
+  // the thinking time and other parameters from the input string, and starts
+  // the search.
+
+  void go(const Position& pos, istringstream& is) {
+
+    Search::LimitsType limits;
+    vector<Move> searchMoves;
+    string token;
+
+    while (is >> token)
+    {
+        if (token == "searchmoves")
+            while (is >> token)
+                searchMoves.push_back(move_from_uci(pos, token));
+
+        else if (token == "wtime")     is >> limits.time[WHITE];
+        else if (token == "btime")     is >> limits.time[BLACK];
+        else if (token == "winc")      is >> limits.inc[WHITE];
+        else if (token == "binc")      is >> limits.inc[BLACK];
+        else if (token == "movestogo") is >> limits.movestogo;
+        else if (token == "depth")     is >> limits.depth;
+        else if (token == "nodes")     is >> limits.nodes;
+        else if (token == "movetime")  is >> limits.movetime;
+        else if (token == "mate")      is >> limits.mate;
+        else if (token == "infinite")  limits.infinite = true;
+        else if (token == "ponder")    limits.ponder = true;
+    }
+
+    Threads.start_thinking(pos, limits, searchMoves, SetupStates);
   }
 }

src/ucioption.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,154 +17,148 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cctype>
+#include <algorithm>
-#include <iostream>
+#include <cassert>
+#include <cstdlib>
 #include <sstream>
 
+#include "evaluate.h"
 #include "misc.h"
 #include "thread.h"
+#include "tt.h"
 #include "ucioption.h"
 
 using std::string;
-using std::cout;
-using std::endl;
 
-OptionsMap Options; // Global object
+UCI::OptionsMap Options; // Global object
+
+namespace UCI {
+
+/// 'On change' actions, triggered by an option's value change
+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(); }
 
 
-// Our case insensitive less() function as required by UCI protocol
+/// 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);
-  int c1, c2;
-  size_t i = 0;
-
-  while (i < s1.size() && i < s2.size())
-  {
-      c1 = tolower(s1[i]);
-      c2 = tolower(s2[i++]);
-
-      if (c1 != c2)
-          return c1 < c2;
-  }
-  return s1.size() < s2.size();
 }
 
 
-// stringify() converts a numeric value of type T to a std::string
+/// init() initializes the UCI options to their hard coded default values
-template<typename T>
-static string stringify(const T& v) {
 
-  std::ostringstream ss;
+void init(OptionsMap& o) {
-  ss << v;
+
-  return ss.str();
+  o["Write Debug Log"]             = Option(false, on_logger);
+  o["Write 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 (Midgame)"]          = Option(100, 0, 200, on_eval);
+  o["Mobility (Endgame)"]          = Option(100, 0, 200, on_eval);
+  o["Pawn Structure (Midgame)"]    = Option(100, 0, 200, on_eval);
+  o["Pawn Structure (Endgame)"]    = Option(100, 0, 200, on_eval);
+  o["Passed Pawns (Midgame)"]      = 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(0, 0, 12, on_threads);
+  o["Max Threads per Split Point"] = Option(5, 4,  8, on_threads);
+  o["Threads"]                     = Option(1, 1, MAX_THREADS, on_threads);
+  o["Idle Threads Sleep"]          = 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);
 }
 
 
-/// OptionsMap c'tor initializes the UCI options to their hard coded default
+/// operator<<() is used to print all the options default values in chronological
-/// values and initializes the default value of "Threads" and "Minimum Split Depth"
-/// parameters according to the number of CPU cores.
-
-OptionsMap::OptionsMap() {
-
-  OptionsMap& o = *this;
-
-  o["Use Search Log"] = UCIOption(false);
-  o["Search Log Filename"] = UCIOption("SearchLog.txt");
-  o["Book File"] = UCIOption("book.bin");
-  o["Best Book Move"] = UCIOption(false);
-  o["Mobility (Middle Game)"] = UCIOption(100, 0, 200);
-  o["Mobility (Endgame)"] = UCIOption(100, 0, 200);
-  o["Passed Pawns (Middle Game)"] = UCIOption(100, 0, 200);
-  o["Passed Pawns (Endgame)"] = UCIOption(100, 0, 200);
-  o["Space"] = UCIOption(100, 0, 200);
-  o["Aggressiveness"] = UCIOption(100, 0, 200);
-  o["Cowardice"] = UCIOption(100, 0, 200);
-  o["Minimum Split Depth"] = UCIOption(4, 4, 7);
-  o["Maximum Number of Threads per Split Point"] = UCIOption(5, 4, 8);
-  o["Threads"] = UCIOption(1, 1, MAX_THREADS);
-  o["Use Sleeping Threads"] = UCIOption(false);
-  o["Hash"] = UCIOption(32, 4, 8192);
-  o["Clear Hash"] = UCIOption(false, "button");
-  o["Ponder"] = UCIOption(true);
-  o["OwnBook"] = UCIOption(true);
-  o["MultiPV"] = UCIOption(1, 1, 500);
-  o["Skill Level"] = UCIOption(20, 0, 20);
-  o["Emergency Move Horizon"] = UCIOption(40, 0, 50);
-  o["Emergency Base Time"] = UCIOption(200, 0, 30000);
-  o["Emergency Move Time"] = UCIOption(70, 0, 5000);
-  o["Minimum Thinking Time"] = UCIOption(20, 0, 5000);
-  o["UCI_Chess960"] = UCIOption(false);
-  o["UCI_AnalyseMode"] = UCIOption(false);
-
-  // Set some SMP parameters accordingly to the detected CPU count
-  UCIOption& thr = o["Threads"];
-  UCIOption& msd = o["Minimum Split Depth"];
-
-  thr.defaultValue = thr.currentValue = stringify(cpu_count());
-
-  if (cpu_count() >= 8)
-      msd.defaultValue = msd.currentValue = stringify(7);
-}
-
-
-/// OptionsMap::print_all() returns a string with all the UCI options in chronological
 /// insertion order (the idx field) and in the format defined by the UCI protocol.
 
-string OptionsMap::print_all() const {
+std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
-  std::stringstream s;
+  for (size_t idx = 0; idx < om.size(); idx++)
-
+      for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it)
-  for (size_t i = 0; i <= size(); i++)
+          if (it->second.idx == idx)
-      for (OptionsMap::const_iterator it = begin(); it != end(); ++it)
-          if (it->second.idx == i)
           {
-              const UCIOption& o = it->second;
+              const Option& o = it->second;
-              s << "\noption name " << it->first << " type " << o.type;
+              os << "\noption name " << it->first << " type " << o.type;
 
               if (o.type != "button")
-                  s << " default " << o.defaultValue;
+                  os << " default " << o.defaultValue;
 
               if (o.type == "spin")
-                  s << " min " << o.minValue << " max " << o.maxValue;
+                  os << " min " << o.min << " max " << o.max;
 
               break;
           }
-  return s.str();
+  return os;
 }
 
 
-/// Option class c'tors
+/// Option c'tors and conversion operators
 
-UCIOption::UCIOption(const char* def) : type("string"), minValue(0), maxValue(0), idx(Options.size())
+Option::Option(const char* v, Fn* f) : type("string"), min(0), max(0), idx(Options.size()), on_change(f)
-{ defaultValue = currentValue = def; }
+{ defaultValue = currentValue = v; }
 
-UCIOption::UCIOption(bool def, string t) : type(t), minValue(0), maxValue(0), idx(Options.size())
+Option::Option(bool v, Fn* f) : type("check"), min(0), max(0), idx(Options.size()), on_change(f)
-{ defaultValue = currentValue = (def ? "true" : "false"); }
+{ defaultValue = currentValue = (v ? "true" : "false"); }
 
-UCIOption::UCIOption(int def, int minv, int maxv) : type("spin"), minValue(minv), maxValue(maxv), idx(Options.size())
+Option::Option(Fn* f) : type("button"), min(0), max(0), idx(Options.size()), on_change(f)
-{ defaultValue = currentValue = stringify(def); }
+{}
+
+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(); }
 
 
-/// set_value() updates currentValue of the Option object. Normally it's up to
+Option::operator int() const {
-/// the GUI to check for option's limits, but we could receive the new value
+  assert(type == "check" || type == "spin");
-/// directly from the user by teminal window. So let's check the bounds anyway.
+  return (type == "spin" ? atoi(currentValue.c_str()) : currentValue == "true");
+}
 
-void UCIOption::set_value(const string& v) {
+Option::operator std::string() const {
+  assert(type == "string");
+  return currentValue;
+}
+
+
+/// operator=() updates currentValue and triggers on_change() action. It's up to
+/// the GUI to check for option's limits, but we could receive the new value from
+/// the user by console window, so let's check the bounds anyway.
+
+Option& Option::operator=(const string& v) {
 
   assert(!type.empty());
 
-  if (v.empty())
+  if (   (type != "button" && v.empty())
-      return;
+      || (type == "check" && v != "true" && v != "false")
+      || (type == "spin" && (atoi(v.c_str()) < min || atoi(v.c_str()) > max)))
+      return *this;
 
-  if ((type == "check" || type == "button") != (v == "true" || v == "false"))
+  if (type != "button")
-      return;
+      currentValue = v;
 
-  if (type == "spin")
+  if (on_change)
-  {
+      (*on_change)(*this);
-      int val = atoi(v.c_str());
-      if (val < minValue || val > maxValue)
-          return;
-  }
 
-  currentValue = v;
+  return *this;
 }
+
+} // namespace UCI

src/ucioption.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  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
@@ -17,69 +17,53 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(UCIOPTION_H_INCLUDED)
+#ifndef UCIOPTION_H_INCLUDED
 #define UCIOPTION_H_INCLUDED
 
-#include <cassert>
-#include <cstdlib>
 #include <map>
 #include <string>
 
-class UCIOption {
+namespace UCI {
-public:
-  UCIOption() {} // To be used in a std::map
-  UCIOption(const char* defaultValue);
-  UCIOption(bool defaultValue, std::string type = "check");
-  UCIOption(int defaultValue, int minValue, int maxValue);
 
-  void set_value(const std::string& v);
+class Option;
-  template<typename T> T value() const;
 
-private:
+/// Custom comparator because UCI options should be case insensitive
-  friend class OptionsMap;
-
-  std::string defaultValue, currentValue, type;
-  int minValue, maxValue;
-  size_t idx;
-};
-
-
-/// Custom comparator because UCI options should not be case sensitive
 struct CaseInsensitiveLess {
   bool operator() (const std::string&, const std::string&) const;
 };
 
+/// Our options container is actually a std::map
+typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
+
+/// Option class implements an option as defined by UCI protocol
+class Option {
+
+  typedef void (Fn)(const Option&);
 
-/// Our options container is actually a map with a customized c'tor
-class OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
 public:
-  OptionsMap();
+  Option(Fn* = NULL);
-  std::string print_all() const;
+  Option(bool v, Fn* = NULL);
+  Option(const char* v, Fn* = NULL);
+  Option(int v, int min, int max, Fn* = NULL);
+
+  Option& operator=(const std::string& v);
+  operator int() const;
+  operator std::string() const;
+
+private:
+  friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
+
+  std::string defaultValue, currentValue, type;
+  int min, max;
+  size_t idx;
+  Fn* on_change;
 };
 
-extern OptionsMap Options;
+void init(OptionsMap&);
+void loop(const std::string&);
 
+} // namespace UCI
 
-/// Option::value() definition and specializations
+extern UCI::OptionsMap Options;
-template<typename T>
-T UCIOption::value() const {
 
-  assert(type == "spin");
+#endif // #ifndef UCIOPTION_H_INCLUDED
-  return T(atoi(currentValue.c_str()));
-}
-
-template<>
-inline std::string UCIOption::value<std::string>() const {
-
-  assert(type == "string");
-  return currentValue;
-}
-
-template<>
-inline bool UCIOption::value<bool>() const {
-
-  assert(type == "check" || type == "button");
-  return currentValue == "true";
-}
-
-#endif // !defined(UCIOPTION_H_INCLUDED)