Stockfish DD

Stockfish bench signature is: 8596156

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

polyglot.ini

@@ -1,4 +1,3 @@
-
 [PolyGlot]
 
 EngineDir = .
@@ -15,21 +14,25 @@ ResignScore = 600
 
 [Engine]
 
-Use Search Log = false
+Write Debug Log = false
+Write Search Log = false
 Search Log Filename = SearchLog.txt
 Book File = book.bin
 Best Book Move = false
-Mobility (Middle Game) = 100
+Contempt Factor = 0
+Mobility (Midgame) = 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
-Min Split Depth = 4
+Min Split Depth = 0
 Max Threads per Split Point = 5
 Threads = 1
-Use Sleeping Threads = false
+Idle Threads Sleep = false
 Hash = 128
 Ponder = true
 OwnBook = false
@@ -39,5 +42,6 @@ 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-2012 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
 
 ### ==========================================================================
@@ -47,11 +55,11 @@ OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
 # arch = (name)       --- (-arch)          --- Target architecture
 # os = (name)         ---                  --- Target operating system
 # bits = 64/32        --- -DIS_64BIT       --- 64-/32-bit operating system
-# bigendian = yes/no  --- -DBIGENDIAN      --- big/little-endian byte order
 # prefetch = yes/no   --- -DUSE_PREFETCH   --- Use prefetch x86 asm-instruction
 # bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
 #                                              with GCC and ICC 64-bit)
 # popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
+# 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,50 @@ 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),linux-ppc-64)
+	arch = ppc64
+	os = any
+	bits = 64
+	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 +232,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 +253,44 @@ ifeq ($(comp),mingw)
 endif
 
 ifeq ($(comp),icc)
-	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+	CXXFLAGS += -diag-disable 1476,10120 -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)
+	# On Android Bionic's C library comes with its own pthread implementation bundled in
+	ifneq ($(arch),armv7)
+		# Haiku has pthreads in its libroot, so only link it in on other platforms
+		ifneq ($(UNAME),Haiku)
+			LDFLAGS += -lpthread
+		endif
+	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 +307,10 @@ ifeq ($(optimize),yes)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
 		endif
+
+		ifeq ($(arch),armv7)
+			CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
+		endif
 	endif
 
 	ifeq ($(comp),mingw)
@@ -278,7 +321,21 @@ ifeq ($(optimize),yes)
 		ifeq ($(os),osx)
 			CXXFLAGS += -fast -mdynamic-no-pic
 		else
-			CXXFLAGS += -O3
+			CXXFLAGS += -fast
+		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
@@ -288,38 +345,39 @@ ifeq ($(bits),64)
 	CXXFLAGS += -DIS_64BIT
 endif
 
-### 3.7 Endianess
-ifeq ($(bigendian),yes)
-	CXXFLAGS += -DBIGENDIAN
-endif
-
-### 3.8 prefetch
+### 3.7 prefetch
 ifeq ($(prefetch),yes)
-	CXXFLAGS += -msse
-	DEPENDFLAGS += -msse
+	ifeq ($(sse),yes)
+		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 += -msse3 -DUSE_POPCNT
 endif
 
-### 3.11 Link Time Optimization, it works since gcc 4.5 but not on mingw.
+### 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)
-	GCC_MAJOR := `gcc -dumpversion | cut -f1 -d.`
-	GCC_MINOR := `gcc -dumpversion | cut -f2 -d.`
-	ifeq (1,$(shell expr \( $(GCC_MAJOR) \> 4 \) \| \( $(GCC_MAJOR) \= 4 \& $(GCC_MINOR) \>= 5 \)))
-		CXXFLAGS += -flto
-		LDFLAGS += $(CXXFLAGS)
+	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
 
@@ -335,45 +393,47 @@ help:
 	@echo ""
 	@echo "Supported targets:"
 	@echo ""
-	@echo "build                > Build unoptimized version"
-	@echo "profile-build        > Build PGO-optimized version"
-	@echo "double-profile-build > Build PGO-optimized version with and without popcnt support"
-	@echo "strip                > Strip executable"
-	@echo "install              > Install executable"
-	@echo "clean                > Clean up"
-	@echo "testrun              > Make sample run"
+	@echo "build                   > Standard build"
+	@echo "signature-build         > Standard build with embedded signature"
+	@echo "profile-build           > PGO build"
+	@echo "signature-profile-build > PGO build with embedded signature"
+	@echo "strip                   > Strip executable"
+	@echo "install                 > Install executable"
+	@echo "clean                   > Clean up"
 	@echo ""
 	@echo "Supported archs:"
 	@echo ""
-	@echo "x86-64               > x86 64-bit"
-	@echo "x86-64-modern        > x86 64-bit with runtime support for popcnt instruction"
-	@echo "x86-32               > x86 32-bit excluding very old hardware without SSE-support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
-	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
-	@echo "general-64           > unspecified 64-bit"
-	@echo "general-32           > unspecified 32-bit"
-	@echo "bigendian-64         > unspecified 64-bit with bigendian byte order"
-	@echo "bigendian-32         > unspecified 32-bit with bigendian byte order"
+	@echo "x86-64                  > x86 64-bit"
+	@echo "x86-64-modern           > x86 64-bit with popcnt support"
+	@echo "x86-32                  > x86 32-bit with SSE support"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
+	@echo "linux-ppc-64            > PPC-Linux 64 bit"
+	@echo "osx-ppc-64              > PPC-Mac OS X 64 bit"
+	@echo "osx-ppc-32              > PPC-Mac OS X 32 bit"
+	@echo "osx-x86-64              > x86-Mac OS X 64 bit"
+	@echo "osx-x86-32              > x86-Mac OS X 32 bit"
+	@echo "armv7                   > ARMv7 32 bit"
+	@echo "general-64              > unspecified 64-bit"
+	@echo "general-32              > unspecified 32-bit"
 	@echo ""
-	@echo "Supported comps:"
+	@echo "Supported compilers:"
 	@echo ""
-	@echo "gcc                  > Gnu compiler (default)"
-	@echo "icc                  > Intel compiler"
-	@echo "mingw                > Gnu compiler with MinGW under Windows"
+	@echo "gcc                     > Gnu compiler (default)"
+	@echo "mingw                   > Gnu compiler with MinGW under Windows"
+	@echo "clang                   > LLVM Clang compiler"
+	@echo "icc                     > Intel compiler"
 	@echo ""
 	@echo "Non-standard targets:"
 	@echo ""
-	@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 profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo "make build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make build ARCH=x86-32    (This is for 32-bit systems)"
 	@echo ""
 
+.PHONY: build profile-build embed-signature
 build:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
@@ -398,33 +458,17 @@ profile-build:
 	@echo "Step 4/4. Deleting profile data ..."
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
 
-double-profile-build:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
-	@echo ""
-	@echo "Step 0/6. Preparing for profile build."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
-	@echo ""
-	@echo "Step 1/6. Building executable for benchmark (popcnt disabled)..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=x86-64 COMP=$(COMP) $(profile_make)
-	@echo ""
-	@echo "Step 2/6. Running benchmark for pgo-build (popcnt disabled)..."
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 3/6. Building executable for benchmark (popcnt enabled)..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=x86-64-modern COMP=$(COMP) $(profile_make)
-	@echo ""
-	@echo "Step 4/6. Running benchmark for pgo-build (popcnt enabled)..."
-	@$(PGOBENCH) > /dev/null
-	@echo ""
-	@echo "Step 5/6. Building final executable ..."
-	@touch *.cpp *.h
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
-	@echo ""
-	@echo "Step 6/6. Deleting profile data ..."
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
-	@echo ""
+embed-signature:
+	@echo "Running benchmark for getting the signature ..."
+	@$(SIGNBENCH) 2>&1 | sed -n 's/Nodes searched  : \(.*\)/\/string Version\/s\/"\\(.*\\)"\/"sig-\1"\//p' > sign.txt
+	@sed -f sign.txt misc.cpp > misc2.cpp
+	@mv misc2.cpp misc.cpp
+	@rm sign.txt
+
+signature-build: build embed-signature
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+signature-profile-build: build embed-signature profile-build
 
 strip:
 	strip $(EXE)
@@ -437,9 +481,6 @@ install:
 clean:
 	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
 
-testrun:
-	@$(PGOBENCH)
-
 default:
 	help
 
@@ -457,10 +498,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)"
@@ -472,14 +513,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)
@@ -531,7 +572,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-2012 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,16 +19,17 @@
 
 #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;
-using namespace Search;
 
 static const char* Defaults[] = {
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
@@ -46,7 +47,21 @@ static const char* Defaults[] = {
   "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
   "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
   "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
-  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
+  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26",
+  "6k1/6p1/6Pp/ppp5/3pn2P/1P3K2/1PP2P2/3N4 b - - 0 1",
+  "3b4/5kp1/1p1p1p1p/pP1PpP1P/P1P1P3/3KN3/8/8 w - - 0 1",
+  "2K5/p7/7P/5pR1/8/5k2/r7/8 w - - 0 1",
+  "8/6pk/1p6/8/PP3p1p/5P2/4KP1q/3Q4 w - - 0 1",
+  "7k/3p2pp/4q3/8/4Q3/5Kp1/P6b/8 w - - 0 1",
+  "8/2p5/8/2kPKp1p/2p4P/2P5/3P4/8 w - - 0 1",
+  "8/1p3pp1/7p/5P1P/2k3P1/8/2K2P2/8 w - - 0 1",
+  "8/pp2r1k1/2p1p3/3pP2p/1P1P1P1P/P5KR/8/8 w - - 0 1",
+  "8/3p4/p1bk3p/Pp6/1Kp1PpPp/2P2P1P/2P5/5B2 b - - 0 1",
+  "5k2/7R/4P2p/5K2/p1r2P1p/8/8/8 b - - 0 1",
+  "6k1/6p1/P6p/r1N5/5p2/7P/1b3PP1/4R1K1 w - - 0 1",
+  "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1",
+  "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1",
+  "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1"
 };
 
 
@@ -58,34 +73,42 @@ static const char* Defaults[] = {
 /// format (defaults are the positions defined above) and the type of the
 /// limit value: depth (default), time in secs or number of nodes.
 
-void benchmark(int argc, char* argv[]) {
+void benchmark(const Position& current, istream& is) {
 
+  string token;
+  Search::LimitsType limits;
   vector<string> fens;
-  LimitsType limits;
-  int time;
-  int64_t nodes = 0;
 
   // Assign default values to missing arguments
-  string ttSize  = argc > 2 ? argv[2] : "128";
-  string threads = argc > 3 ? argv[3] : "1";
-  string valStr  = argc > 4 ? argv[4] : "12";
-  string fenFile = argc > 5 ? argv[5] : "default";
-  string valType = argc > 6 ? argv[6] : "depth";
+  string ttSize    = (is >> token) ? token : "32";
+  string threads   = (is >> token) ? token : "1";
+  string limit     = (is >> token) ? token : "13";
+  string fenFile   = (is >> token) ? token : "default";
+  string limitType = (is >> token) ? token : "depth";
 
   Options["Hash"]    = ttSize;
   Options["Threads"] = threads;
-  Options["OwnBook"] = false;
+  TT.clear();
 
-  if (valType == "time")
-      limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
+  if (limitType == "time")
+      limits.movetime = 1000 * atoi(limit.c_str()); // movetime is in ms
 
-  else if (valType == "nodes")
-      limits.maxNodes = atoi(valStr.c_str());
+  else if (limitType == "nodes")
+      limits.nodes = atoi(limit.c_str());
+
+  else if (limitType == "mate")
+      limits.mate = atoi(limit.c_str());
 
   else
-      limits.maxDepth = atoi(valStr.c_str());
+      limits.depth = atoi(limit.c_str());
 
-  if (fenFile != "default")
+  if (fenFile == "default")
+      fens.assign(Defaults, Defaults + 30);
+
+  else if (fenFile == "current")
+      fens.push_back(current.fen());
+
+  else
   {
       string fen;
       ifstream file(fenFile.c_str());
@@ -93,7 +116,7 @@ void benchmark(int argc, char* argv[]) {
       if (!file.is_open())
       {
           cerr << "Unable to open file " << fenFile << endl;
-          exit(EXIT_FAILURE);
+          return;
       }
 
       while (getline(file, fen))
@@ -102,34 +125,35 @@ void benchmark(int argc, char* argv[]) {
 
       file.close();
   }
-  else
-      fens.assign(Defaults, Defaults + 16);
 
-  time = system_time();
+  int64_t nodes = 0;
+  Search::StateStackPtr st;
+  Time::point elapsed = Time::now();
 
-  for (size_t i = 0; i < fens.size(); i++)
+  for (size_t i = 0; i < fens.size(); ++i)
   {
-      Position pos(fens[i], false, 0);
+      Position pos(fens[i], Options["UCI_Chess960"], Threads.main());
 
       cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
 
-      if (valType == "perft")
+      if (limitType == "perft")
       {
-          int64_t cnt = perft(pos, limits.maxDepth * ONE_PLY);
-          cerr << "\nPerft " << limits.maxDepth  << " leaf nodes: " << cnt << endl;
+          size_t cnt = Search::perft(pos, limits.depth * ONE_PLY);
+          cerr << "\nPerft " << limits.depth  << " leaf nodes: " << cnt << endl;
           nodes += cnt;
       }
       else
       {
-          Threads.start_thinking(pos, limits, vector<Move>(), false);
-          nodes += RootPosition.nodes_searched();
+          Threads.start_thinking(pos, limits, vector<Move>(), st);
+          Threads.wait_for_think_finished();
+          nodes += Search::RootPos.nodes_searched();
       }
   }
 
-  time = system_time() - time;
+  elapsed = Time::now() - elapsed + 1; // Assure positive to avoid a 'divide by zero'
 
   cerr << "\n==========================="
-       << "\nTotal time (ms) : " << time
+       << "\nTotal time (ms) : " << elapsed
        << "\nNodes searched  : " << nodes
-       << "\nNodes/second    : " << int(nodes / (time / 1000.0)) << endl;
+       << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
 }

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-2012 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,254 +18,156 @@
 */
 
 #include <cassert>
+#include <vector>
 
 #include "bitboard.h"
 #include "types.h"
 
 namespace {
 
-  enum Result {
-    RESULT_UNKNOWN,
-    RESULT_INVALID,
-    RESULT_WIN,
-    RESULT_DRAW
-  };
-
-  struct KPKPosition {
-    Result classify_knowns(int index);
-    Result classify(int index, Result db[]);
-
-  private:
-    void from_index(int index);
-    Result classify_white(const Result db[]);
-    Result classify_black(const Result db[]);
-    Bitboard wk_attacks()   const { return StepAttacksBB[W_KING][whiteKingSquare]; }
-    Bitboard bk_attacks()   const { return StepAttacksBB[B_KING][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttacksBB[W_PAWN][pawnSquare]; }
-
-    Square whiteKingSquare, blackKingSquare, pawnSquare;
-    Color sideToMove;
-  };
-
   // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
-  const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq = 196608
+  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];
 
-  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
+  // A KPK bitbase index is an integer in [0, IndexMax] range
+  //
+  // Information is mapped in a way that minimizes number of iterations:
+  //
+  // bit  0- 5: white king square (from SQ_A1 to SQ_H8)
+  // bit  6-11: black king square (from SQ_A1 to SQ_H8)
+  // bit    12: side to move (WHITE or BLACK)
+  // bit 13-14: white pawn file (from FILE_A to FILE_D)
+  // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+  unsigned index(Color us, Square bksq, Square wksq, Square psq) {
+    return wksq + (bksq << 6) + (us << 12) + (file_of(psq) << 13) + ((RANK_7 - rank_of(psq)) << 15);
+  }
+
+  enum Result {
+    INVALID = 0,
+    UNKNOWN = 1,
+    DRAW    = 2,
+    WIN     = 4
+  };
+
+  inline Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+
+  struct KPKPosition {
+
+    KPKPosition(unsigned idx);
+    operator Result() const { return result; }
+    Result classify(const std::vector<KPKPosition>& db)
+    { return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }
+
+  private:
+    template<Color Us> Result classify(const std::vector<KPKPosition>& db);
+
+    Color us;
+    Square bksq, wksq, psq;
+    Result result;
+  };
+
+} // 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));
 }
 
 
-uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
+void Bitbases::init_kpk() {
 
-  int index = compute_index(wksq, bksq, wpsq, stm);
+  unsigned idx, repeat = 1;
+  std::vector<KPKPosition> db;
+  db.reserve(IndexMax);
 
-  return KPKBitbase[index / 32] & (1 << (index & 31));
-}
+  // Initialize db with known win / draw positions
+  for (idx = 0; idx < IndexMax; ++idx)
+      db.push_back(KPKPosition(idx));
 
-
-void kpk_bitbase_init() {
-
-  Result db[IndexMax];
-  KPKPosition pos;
-  int index, bit, repeat = 1;
-
-  // Initialize table
-  for (index = 0; index < IndexMax; index++)
-      db[index] = pos.classify_knowns(index);
-
-  // Iterate until all positions are classified (30 cycles needed)
+  // 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 = index = 0; index < IndexMax; index++)
-          if (   db[index] == RESULT_UNKNOWN
-              && pos.classify(index, db) != RESULT_UNKNOWN)
-              repeat = 1;
+      for (repeat = idx = 0; idx < IndexMax; ++idx)
+          repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);
 
-  // Map 32 position results into one KPKBitbase[] entry
-  for (index = 0; index < IndexMax / 32; index++)
-      for (bit = 0; bit < 32; bit++)
-          if (db[32 * index + bit] == RESULT_WIN)
-              KPKBitbase[index] |= (1 << bit);
+  // 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
-  //
-  // 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)
+  KPKPosition::KPKPosition(unsigned idx) {
 
-  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));
+    result  = UNKNOWN;
 
-    assert(file_of(wpsq) <= FILE_D);
+    // Check if two pieces are on the same square or if a king can be captured
+    if (   square_distance(wksq, bksq) <= 1 || wksq == psq || bksq == psq
+        || (us == WHITE && (StepAttacksBB[PAWN][psq] & bksq)))
+        result = INVALID;
 
-    int p = file_of(wpsq) + 4 * (rank_of(wpsq) - 1);
-    int r = stm + 2 * bksq + 128 * wksq + 8192 * p;
-
-    assert(r >= 0 && r < IndexMax);
-
-    return r;
+    else if (us == WHITE)
+    {
+        // Immediate win if pawn can be promoted without getting captured
+        if (   rank_of(psq) == RANK_7
+            && wksq != psq + DELTA_N
+            && (   square_distance(bksq, psq + DELTA_N) > 1
+                ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N))))
+            result = WIN;
+    }
+    // Immediate draw if is stalemate or king captures undefended pawn
+    else if (  !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq]))
+             || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq]))
+        result = DRAW;
   }
 
-  void KPKPosition::from_index(int index) {
+  template<Color Us>
+  Result KPKPosition::classify(const std::vector<KPKPosition>& db) {
 
-    int s = index >> 13;
-    sideToMove = Color(index & 1);
-    blackKingSquare = Square((index >> 1) & 63);
-    whiteKingSquare = Square((index >> 7) & 63);
-    pawnSquare = make_square(File(s & 3), Rank((s >> 2) + 1));
-  }
-
-  Result KPKPosition::classify_knowns(int index) {
-
-    from_index(index);
-
-    // Check if two pieces are on the same square
-    if (   whiteKingSquare == pawnSquare
-        || whiteKingSquare == blackKingSquare
-        || blackKingSquare == pawnSquare)
-        return RESULT_INVALID;
-
-    // Check if a king can be captured
-    if (    bit_is_set(wk_attacks(), blackKingSquare)
-        || (bit_is_set(pawn_attacks(), blackKingSquare) && sideToMove == WHITE))
-        return RESULT_INVALID;
-
-    // The position is an immediate win if it is white to move and the
-    // white pawn can be promoted without getting captured.
-    if (   rank_of(pawnSquare) == RANK_7
-        && sideToMove == WHITE
-        && whiteKingSquare != pawnSquare + DELTA_N
-        && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
-            || bit_is_set(wk_attacks(), pawnSquare + DELTA_N)))
-        return RESULT_WIN;
-
-    // Check for known draw positions
+    // 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.
     //
-    // Case 1: Stalemate
-    if (   sideToMove == BLACK
-        && !(bk_attacks() & ~(wk_attacks() | pawn_attacks())))
-        return RESULT_DRAW;
+    // 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.
 
-    // Case 2: King can capture pawn
-    if (   sideToMove == BLACK
-        && bit_is_set(bk_attacks(), pawnSquare) && !bit_is_set(wk_attacks(), pawnSquare))
-        return RESULT_DRAW;
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-    // Case 3: Black king in front of white pawn
-    if (   blackKingSquare == pawnSquare + DELTA_N
-        && rank_of(pawnSquare) < RANK_7)
-        return RESULT_DRAW;
+    Result r = INVALID;
+    Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq];
 
-    //  Case 4: White king in front of pawn and black has opposition
-    if (   whiteKingSquare == pawnSquare + DELTA_N
-        && blackKingSquare == pawnSquare + DELTA_N + DELTA_N + DELTA_N
-        && rank_of(pawnSquare) < RANK_5
-        && sideToMove == WHITE)
-        return RESULT_DRAW;
-
-    // Case 5: Stalemate with rook pawn
-    if (   blackKingSquare == SQ_A8
-        && file_of(pawnSquare) == FILE_A)
-        return RESULT_DRAW;
-
-    return RESULT_UNKNOWN;
-  }
-
-  Result KPKPosition::classify(int index, Result db[]) {
-
-    from_index(index);
-    db[index] = (sideToMove == WHITE ? classify_white(db) : classify_black(db));
-    return db[index];
-  }
-
-  Result KPKPosition::classify_white(const Result db[]) {
-
-    // If one move leads to a position classified as RESULT_WIN, the result
-    // of the current position is RESULT_WIN. If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
-    // otherwise the current position is classified as RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = wk_attacks();
     while (b)
+        r |= Us == WHITE ? db[index(Them, bksq, pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), wksq, psq)];
+
+    if (Us == WHITE && rank_of(psq) < RANK_7)
     {
-        s = pop_1st_bit(&b);
-        r = db[compute_index(s, blackKingSquare, pawnSquare, BLACK)];
+        Square s = psq + DELTA_N;
+        r |= db[index(BLACK, bksq, wksq, s)]; // Single push
 
-        if (r == RESULT_WIN)
-            return RESULT_WIN;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
+        if (rank_of(psq) == RANK_2 && s != wksq && s != bksq)
+            r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push
     }
 
-    // Pawn moves
-    if (rank_of(pawnSquare) < RANK_7)
-    {
-        s = pawnSquare + DELTA_N;
-        r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
-
-        if (r == RESULT_WIN)
-            return RESULT_WIN;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-
-        // Double pawn push
-        if (rank_of(s) == RANK_3 && r != RESULT_INVALID)
-        {
-            s += DELTA_N;
-            r = db[compute_index(whiteKingSquare, blackKingSquare, s, BLACK)];
-
-            if (r == RESULT_WIN)
-                return RESULT_WIN;
-
-            if (r == RESULT_UNKNOWN)
-                unknownFound = true;
-        }
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
+    if (Us == WHITE)
+        return result = r & WIN  ? WIN  : r & UNKNOWN ? UNKNOWN : DRAW;
+    else
+        return result = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN;
   }
 
-  Result KPKPosition::classify_black(const Result db[]) {
-
-    // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW. If all moves lead to positions
-    // classified as RESULT_WIN, the position is classified as RESULT_WIN.
-    // Otherwise, the current position is classified as RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    Result r;
-
-    // King moves
-    b = bk_attacks();
-    while (b)
-    {
-        s = pop_1st_bit(&b);
-        r = db[compute_index(whiteKingSquare, s, pawnSquare, WHITE)];
-
-        if (r == RESULT_DRAW)
-            return RESULT_DRAW;
-
-        if (r == RESULT_UNKNOWN)
-            unknownFound = true;
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_WIN;
-  }
-
-}
+} // namespace

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-2012 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
@@ -23,294 +23,269 @@
 
 #include "bitboard.h"
 #include "bitcount.h"
+#include "misc.h"
 #include "rkiss.h"
 
-Bitboard RMasks[64];
-Bitboard RMagics[64];
-Bitboard* RAttacks[64];
-int RShifts[64];
+CACHE_LINE_ALIGNMENT
 
-Bitboard BMasks[64];
-Bitboard BMagics[64];
-Bitboard* BAttacks[64];
-int BShifts[64];
+Bitboard RMasks[SQUARE_NB];
+Bitboard RMagics[SQUARE_NB];
+Bitboard* RAttacks[SQUARE_NB];
+unsigned RShifts[SQUARE_NB];
 
-Bitboard SetMaskBB[65];
-Bitboard ClearMaskBB[65];
+Bitboard BMasks[SQUARE_NB];
+Bitboard BMagics[SQUARE_NB];
+Bitboard* BAttacks[SQUARE_NB];
+unsigned BShifts[SQUARE_NB];
 
-Bitboard FileBB[8];
-Bitboard RankBB[8];
-Bitboard NeighboringFilesBB[8];
-Bitboard ThisAndNeighboringFilesBB[8];
-Bitboard InFrontBB[2][8];
-Bitboard StepAttacksBB[16][64];
-Bitboard BetweenBB[64][64];
-Bitboard SquaresInFrontMask[2][64];
-Bitboard PassedPawnMask[2][64];
-Bitboard AttackSpanMask[2][64];
+Bitboard SquareBB[SQUARE_NB];
+Bitboard FileBB[FILE_NB];
+Bitboard RankBB[RANK_NB];
+Bitboard AdjacentFilesBB[FILE_NB];
+Bitboard InFrontBB[COLOR_NB][RANK_NB];
+Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
+Bitboard LineBB[SQUARE_NB][SQUARE_NB];
+Bitboard DistanceRingsBB[SQUARE_NB][8];
+Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
 
-Bitboard BishopPseudoAttacks[64];
-Bitboard RookPseudoAttacks[64];
-Bitboard QueenPseudoAttacks[64];
-
-uint8_t BitCount8Bit[256];
-int SquareDistance[64][64];
+int SquareDistance[SQUARE_NB][SQUARE_NB];
 
 namespace {
 
+  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
+  const uint64_t DeBruijn_64 = 0x3F79D71B4CB0A89ULL;
+  const uint32_t DeBruijn_32 = 0x783A9B23;
+
   CACHE_LINE_ALIGNMENT
 
-  int BSFTable[64];
-  Bitboard RookTable[0x19000];  // Storage space for rook attacks
-  Bitboard BishopTable[0x1480]; // Storage space for bishop attacks
+  int MS1BTable[256];
+  Square BSFTable[SQUARE_NB];
+  Bitboard RTable[0x19000]; // Storage space for rook attacks
+  Bitboard BTable[0x1480];  // Storage space for bishop attacks
 
-  void init_magic_bitboards(PieceType pt, Bitboard* attacks[], Bitboard magics[],
-                            Bitboard masks[], int shifts[]);
+  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.
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
-#if defined(IS_64BIT) && !defined(USE_BSFQ)
-
-Square first_1(Bitboard b) {
-  return Square(BSFTable[((b & -b) * 0x218A392CD3D5DBFULL) >> 58]);
-}
-
-Square pop_1st_bit(Bitboard* b) {
-  Bitboard bb = *b;
-  *b &= (*b - 1);
-  return Square(BSFTable[((bb & -bb) * 0x218A392CD3D5DBFULL) >> 58]);
-}
-
-#elif !defined(USE_BSFQ)
-
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = unsigned(b) ^ unsigned(b >> 32);
-  return Square(BSFTable[(fold * 0x783A9B23) >> 26]);
-}
-
-// Use type-punning
-union b_union {
-
-    Bitboard b;
-    struct {
-#if defined (BIGENDIAN)
-        uint32_t h;
-        uint32_t l;
-#else
-        uint32_t l;
-        uint32_t h;
-#endif
-    } dw;
-};
-
-Square pop_1st_bit(Bitboard* bb) {
-
-   b_union u;
-   Square ret;
-
-   u.b = *bb;
-
-   if (u.dw.l)
-   {
-       ret = Square(BSFTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783A9B23) >> 26]);
-       u.dw.l &= (u.dw.l - 1);
-       *bb = u.b;
-       return ret;
-   }
-   ret = Square(BSFTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783A9B23) >> 26]);
-   u.dw.h &= (u.dw.h - 1);
-   *bb = u.b;
-   return ret;
-}
-
-#endif // !defined(USE_BSFQ)
-
-
-/// bitboards_init() initializes various bitboard arrays. It is called during
+/// Bitboards::init() initializes various bitboard arrays. It is called during
 /// program initialization.
 
-void bitboards_init() {
+void Bitboards::init() {
 
-  for (Bitboard b = 0; b < 256; b++)
-      BitCount8Bit[b] = (uint8_t)popcount<Max15>(b);
+  for (int k = 0, i = 0; i < 8; ++i)
+      while (k < (2 << i))
+          MS1BTable[k++] = i;
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
-  {
-      SetMaskBB[s] = 1ULL << s;
-      ClearMaskBB[s] = ~SetMaskBB[s];
-  }
+  for (int i = 0; i < 64; ++i)
+      BSFTable[bsf_index(1ULL << i)] = Square(i);
 
-  ClearMaskBB[SQ_NONE] = ~0ULL;
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      SquareBB[s] = 1ULL << s;
 
   FileBB[FILE_A] = FileABB;
   RankBB[RANK_1] = Rank1BB;
 
-  for (int f = FILE_B; f <= FILE_H; f++)
+  for (int i = 1; i < 8; ++i)
   {
-      FileBB[f] = FileBB[f - 1] << 1;
-      RankBB[f] = RankBB[f - 1] << 8;
+      FileBB[i] = FileBB[i - 1] << 1;
+      RankBB[i] = RankBB[i - 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 (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 (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
-  {
-      InFrontBB[WHITE][rw] = InFrontBB[WHITE][rw + 1] | RankBB[rw + 1];
-      InFrontBB[BLACK][rb] = InFrontBB[BLACK][rb - 1] | RankBB[rb - 1];
-  }
+  for (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++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
-          SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
-          PassedPawnMask[c][s]     = in_front_bb(c, s) & this_and_neighboring_files_bb(file_of(s));
-          AttackSpanMask[c][s]     = in_front_bb(c, s) & neighboring_files_bb(file_of(s));
+          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++)
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+      {
           SquareDistance[s1][s2] = std::max(file_distance(s1, s2), rank_distance(s1, s2));
-
-  for (int i = 0; i < 64; i++)
-      if (!Is64Bit) // Matt Taylor's folding trick for 32 bit systems
-      {
-          Bitboard b = 1ULL << i;
-          b ^= b - 1;
-          b ^= b >> 32;
-          BSFTable[uint32_t(b * 0x783A9B23) >> 26] = i;
+          if (s1 != s2)
+             DistanceRingsBB[s1][SquareDistance[s1][s2] - 1] |= s2;
       }
-      else
-          BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i;
 
   int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
                      {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
 
-  for (Color c = WHITE; c <= BLACK; c++)
-      for (PieceType pt = PAWN; pt <= KING; pt++)
-          for (Square s = SQ_A1; s <= SQ_H8; s++)
-              for (int k = 0; steps[pt][k]; k++)
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt = PAWN; pt <= KING; ++pt)
+          for (Square s = SQ_A1; s <= SQ_H8; ++s)
+              for (int k = 0; steps[pt][k]; ++k)
               {
                   Square to = s + Square(c == WHITE ? steps[pt][k] : -steps[pt][k]);
 
-                  if (square_is_ok(to) && square_distance(s, to) < 3)
-                      set_bit(&StepAttacksBB[make_piece(c, pt)][s], to);
+                  if (is_ok(to) && square_distance(s, to) < 3)
+                      StepAttacksBB[make_piece(c, pt)][s] |= to;
               }
 
-  init_magic_bitboards(ROOK, RAttacks, RMagics, RMasks, RShifts);
-  init_magic_bitboards(BISHOP, BAttacks, BMagics, BMasks, BShifts);
+  Square RDeltas[] = { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  };
+  Square BDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
 
-  for (Square s = SQ_A1; s <= SQ_H8; s++)
+  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)
   {
-      BishopPseudoAttacks[s] = bishop_attacks_bb(s, 0);
-      RookPseudoAttacks[s]   = rook_attacks_bb(s, 0);
-      QueenPseudoAttacks[s]  = queen_attacks_bb(s, 0);
+      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 (bit_is_set(QueenPseudoAttacks[s1], s2))
+  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)
-                  set_bit(&BetweenBB[s1][s2], s);
+                  BetweenBB[s1][s2] |= s;
+
+              PieceType pt = (PseudoAttacks[BISHOP][s1] & s2) ? BISHOP : ROOK;
+              LineBB[s1][s2] = (PseudoAttacks[pt][s1] & PseudoAttacks[pt][s2]) | s1 | s2;
           }
 }
 
 
 namespace {
 
-  Bitboard sliding_attacks(PieceType pt, Square sq, Bitboard occupied) {
+  Bitboard sliding_attack(Square deltas[], Square sq, Bitboard occupied) {
 
-    Square deltas[][4] = { { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  },
-                           { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW } };
-    Bitboard attacks = 0;
-    Square* delta = (pt == ROOK ? deltas[0] : deltas[1]);
+    Bitboard attack = 0;
 
-    for (int i = 0; i < 4; i++)
-    {
-        Square s = sq + delta[i];
-
-        while (square_is_ok(s) && square_distance(s, s - delta[i]) == 1)
+    for (int i = 0; i < 4; ++i)
+        for (Square s = sq + deltas[i];
+             is_ok(s) && square_distance(s, s - deltas[i]) == 1;
+             s += deltas[i])
         {
-            set_bit(&attacks, s);
+            attack |= s;
 
-            if (bit_is_set(occupied, s))
+            if (occupied & s)
                 break;
-
-            s += delta[i];
         }
-    }
-    return attacks;
+
+    return attack;
   }
 
 
-  Bitboard pick_random(Bitboard mask, RKISS& rk, int booster) {
-
-    Bitboard magic;
+  Bitboard pick_random(RKISS& rk, int booster) {
 
     // Values s1 and s2 are used to rotate the candidate magic of a
     // quantity known to be the optimal to quickly find the magics.
     int s1 = booster & 63, s2 = (booster >> 6) & 63;
 
-    while (true)
-    {
-        magic = rk.rand<Bitboard>();
-        magic = (magic >> s1) | (magic << (64 - s1));
-        magic &= rk.rand<Bitboard>();
-        magic = (magic >> s2) | (magic << (64 - s2));
-        magic &= rk.rand<Bitboard>();
-
-        if (BitCount8Bit[(mask * magic) >> 56] >= 6)
-            return magic;
-    }
+    Bitboard m = rk.rand<Bitboard>();
+    m = (m >> s1) | (m << (64 - s1));
+    m &= rk.rand<Bitboard>();
+    m = (m >> s2) | (m << (64 - s2));
+    return m & rk.rand<Bitboard>();
   }
 
 
-  // init_magic_bitboards() computes all rook and bishop magics at startup.
-  // Magic bitboards are used to look up attacks of sliding pieces. As reference
-  // see chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
+  // init_magics() computes all rook and bishop attacks at startup. Magic
+  // bitboards are used to look up attacks of sliding pieces. As a reference see
+  // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
   // use the so called "fancy" approach.
 
-  void init_magic_bitboards(PieceType pt, Bitboard* attacks[], Bitboard magics[],
-                            Bitboard masks[], int shifts[]) {
+  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
 
     int MagicBoosters[][8] = { { 3191, 2184, 1310, 3618, 2091, 1308, 2452, 3996 },
                                { 1059, 3608,  605, 3234, 3326,   38, 2029, 3043 } };
     RKISS rk;
     Bitboard occupancy[4096], reference[4096], edges, b;
-    int i, size, index, booster;
+    int i, size, booster;
 
     // attacks[s] is a pointer to the beginning of the attacks table for square 's'
-    attacks[SQ_A1] = (pt == ROOK ? RookTable : BishopTable);
+    attacks[SQ_A1] = table;
 
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    for (Square s = SQ_A1; s <= SQ_H8; ++s)
     {
         // Board edges are not considered in the relevant occupancies
         edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
@@ -320,15 +295,15 @@ namespace {
         // all the attacks for each possible subset of the mask and so is 2 power
         // the number of 1s of the mask. Hence we deduce the size of the shift to
         // apply to the 64 or 32 bits word to get the index.
-        masks[s]  = sliding_attacks(pt, s, 0) & ~edges;
+        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 attacks bitboard in reference[].
+        // store the corresponding sliding attack bitboard in reference[].
         b = size = 0;
         do {
             occupancy[size] = b;
-            reference[size++] = sliding_attacks(pt, s, b);
+            reference[size++] = sliding_attack(deltas, s, b);
             b = (b - masks[s]) & masks[s];
         } while (b);
 
@@ -342,23 +317,25 @@ namespace {
         // Find a magic for square 's' picking up an (almost) random number
         // until we find the one that passes the verification test.
         do {
-            magics[s] = pick_random(masks[s], rk, booster);
-            memset(attacks[s], 0, size * sizeof(Bitboard));
+            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++)
+            for (i = 0; i < size; ++i)
             {
-                index = (pt == ROOK ? rook_index(s, occupancy[i])
-                                    : bishop_index(s, occupancy[i]));
+                Bitboard& attack = attacks[s][index(s, occupancy[i])];
 
-                if (!attacks[s][index])
-                    attacks[s][index] = reference[i];
-
-                else if (attacks[s][index] != reference[i])
+                if (attack && attack != reference[i])
                     break;
+
+                assert(reference[i] != 0);
+
+                attack = reference[i];
             }
         } while (i != size);
     }

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-2012 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,69 +18,122 @@
   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"
 
-extern Bitboard FileBB[8];
-extern Bitboard NeighboringFilesBB[8];
-extern Bitboard ThisAndNeighboringFilesBB[8];
-extern Bitboard RankBB[8];
-extern Bitboard InFrontBB[2][8];
+namespace Bitboards {
 
-extern Bitboard SetMaskBB[65];
-extern Bitboard ClearMaskBB[65];
+void init();
+void print(Bitboard b);
 
-extern Bitboard StepAttacksBB[16][64];
-extern Bitboard BetweenBB[64][64];
-
-extern Bitboard SquaresInFrontMask[2][64];
-extern Bitboard PassedPawnMask[2][64];
-extern Bitboard AttackSpanMask[2][64];
-
-extern uint64_t RMagics[64];
-extern int RShifts[64];
-extern Bitboard RMasks[64];
-extern Bitboard* RAttacks[64];
-
-extern uint64_t BMagics[64];
-extern int BShifts[64];
-extern Bitboard BMasks[64];
-extern Bitboard* BAttacks[64];
-
-extern Bitboard BishopPseudoAttacks[64];
-extern Bitboard RookPseudoAttacks[64];
-extern Bitboard QueenPseudoAttacks[64];
-
-extern uint8_t BitCount8Bit[256];
-
-
-/// Functions for testing whether a given bit is set in a bitboard, and for
-/// setting and clearing bits.
-
-inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & SetMaskBB[s];
 }
 
-inline void set_bit(Bitboard* b, Square s) {
-  *b |= SetMaskBB[s];
+namespace Bitbases {
+
+void init_kpk();
+bool probe_kpk(Square wksq, Square wpsq, Square bksq, Color us);
+
 }
 
-inline void clear_bit(Bitboard* b, Square s) {
-  *b &= ClearMaskBB[s];
+const Bitboard FileABB = 0x0101010101010101ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
+
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
+
+CACHE_LINE_ALIGNMENT
+
+extern Bitboard RMasks[SQUARE_NB];
+extern Bitboard RMagics[SQUARE_NB];
+extern Bitboard* RAttacks[SQUARE_NB];
+extern unsigned RShifts[SQUARE_NB];
+
+extern Bitboard BMasks[SQUARE_NB];
+extern Bitboard BMagics[SQUARE_NB];
+extern Bitboard* BAttacks[SQUARE_NB];
+extern unsigned BShifts[SQUARE_NB];
+
+extern Bitboard SquareBB[SQUARE_NB];
+extern Bitboard FileBB[FILE_NB];
+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 LineBB[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 int SquareDistance[SQUARE_NB][SQUARE_NB];
+
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
+
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
+
+inline Bitboard operator&(Bitboard b, Square s) {
+  return b & SquareBB[s];
+}
+
+inline Bitboard& operator|=(Bitboard& b, Square s) {
+  return b |= SquareBB[s];
+}
+
+inline Bitboard& operator^=(Bitboard& b, Square s) {
+  return b ^= SquareBB[s];
+}
+
+inline Bitboard operator|(Bitboard b, Square s) {
+  return b | SquareBB[s];
+}
+
+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
-/// then calling a sequence of clear_bit() + set_bit()
+/// shift_bb() moves bitboard one step along direction Delta. Mainly for pawns.
 
-inline Bitboard make_move_bb(Square from, Square to) {
-  return SetMaskBB[from] | SetMaskBB[to];
-}
+template<Square Delta>
+inline Bitboard shift_bb(Bitboard b) {
 
-inline void do_move_bb(Bitboard* b, Bitboard move_bb) {
-  *b ^= move_bb;
+  return  Delta == DELTA_N  ?  b             << 8 : Delta == DELTA_S  ?  b             >> 8
+        : 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;
 }
 
 
@@ -104,173 +157,172 @@ inline Bitboard file_bb(Square s) {
 }
 
 
-/// neighboring_files_bb takes a file as input and returns a bitboard representing
-/// all squares on the neighboring files.
+/// adjacent_files_bb() takes a file as input and returns a bitboard representing
+/// all squares on the adjacent files.
 
-inline Bitboard neighboring_files_bb(File f) {
-  return NeighboringFilesBB[f];
+inline Bitboard adjacent_files_bb(File f) {
+  return AdjacentFilesBB[f];
 }
 
 
-/// this_and_neighboring_files_bb takes a file as input and returns a bitboard
-/// representing all squares on the given and neighboring files.
-
-inline Bitboard this_and_neighboring_files_bb(File f) {
-  return ThisAndNeighboringFilesBB[f];
-}
-
-
-/// in_front_bb() takes a color and a rank or square as input, and returns a
-/// bitboard representing all the squares on all ranks in front of the rank
-/// (or square), from the given color's point of view.  For instance,
-/// in_front_bb(WHITE, RANK_5) will give all squares on ranks 6, 7 and 8, while
-/// in_front_bb(BLACK, SQ_D3) will give all squares on ranks 1 and 2.
+/// in_front_bb() takes a color and a rank as input, and returns a bitboard
+/// 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
+/// give all squares on ranks 1 and 2.
 
 inline Bitboard in_front_bb(Color c, Rank r) {
   return InFrontBB[c][r];
 }
 
-inline Bitboard in_front_bb(Color c, Square s) {
-  return InFrontBB[c][rank_of(s)];
-}
 
+/// between_bb() returns a bitboard representing all squares between two squares.
+/// For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with the bits for
+/// square d5 and e6 set.  If s1 and s2 are not on the same line, file or diagonal,
+/// 0 is returned.
 
-/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
-/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
-/// bitboard of occupied squares as input, and return a bitboard representing
-/// all squares attacked by a rook, bishop or queen on the given square.
-
-#if defined(IS_64BIT)
-
-FORCE_INLINE unsigned rook_index(Square s, Bitboard occ) {
-  return unsigned(((occ & RMasks[s]) * RMagics[s]) >> RShifts[s]);
-}
-
-FORCE_INLINE unsigned bishop_index(Square s, Bitboard occ) {
-  return unsigned(((occ & BMasks[s]) * BMagics[s]) >> BShifts[s]);
-}
-
-#else // if !defined(IS_64BIT)
-
-FORCE_INLINE unsigned rook_index(Square s, Bitboard occ) {
-  Bitboard b = occ & RMasks[s];
-  return unsigned(int(b) * int(RMagics[s]) ^ int(b >> 32) * int(RMagics[s] >> 32)) >> RShifts[s];
-}
-
-FORCE_INLINE unsigned bishop_index(Square s, Bitboard occ) {
-  Bitboard b = occ & BMasks[s];
-  return unsigned(int(b) * int(BMagics[s]) ^ int(b >> 32) * int(BMagics[s] >> 32)) >> BShifts[s];
-}
-#endif
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard occ) {
-  return RAttacks[s][rook_index(s, occ)];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard occ) {
-  return BAttacks[s][bishop_index(s, occ)];
-}
-
-inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
-  return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
-}
-
-
-/// squares_between returns a bitboard representing all squares between
-/// two squares.  For instance, squares_between(SQ_C4, SQ_F7) returns a
-/// bitboard with the bits for square d5 and e6 set.  If s1 and s2 are not
-/// on the same line, file or diagonal, EmptyBoardBB is returned.
-
-inline Bitboard squares_between(Square s1, Square s2) {
+inline Bitboard between_bb(Square s1, Square s2) {
   return BetweenBB[s1][s2];
 }
 
 
-/// squares_in_front_of takes a color and a square as input, and returns a
-/// bitboard representing all squares along the line in front of the square,
-/// from the point of view of the given color. Definition of the table is:
-/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
+/// forward_bb() takes a color and a square as input, and returns a bitboard
+/// representing all squares along the line in front of the square, from the
+/// point of view of the given color. Definition of the table is:
+/// ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
 
-inline Bitboard squares_in_front_of(Color c, Square s) {
-  return SquaresInFrontMask[c][s];
+inline Bitboard forward_bb(Color c, Square 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
-/// representing all squares that can be attacked by a pawn of the given color
-/// when it moves along its file starting from the given square. Definition is:
-/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
+/// squares_of_color() returns a bitboard representing all squares with the same
+/// color of the given square.
 
-inline Bitboard attack_span_mask(Color c, Square s) {
-  return AttackSpanMask[c][s];
+inline Bitboard squares_of_color(Square s) {
+  return DarkSquares & s ? DarkSquares : ~DarkSquares;
 }
 
 
-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// 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])
-        & (    SetMaskBB[s1] |     SetMaskBB[s2] |     SetMaskBB[s3]);
+inline bool aligned(Square s1, Square s2, Square s3) {
+  return LineBB[s1][s2] & s3;
 }
 
 
-/// same_color_squares() returns a bitboard representing all squares with
-/// the same color of the given square.
+/// Functions for computing sliding attack bitboards. Function attacks_bb() takes
+/// a square and a bitboard of occupied squares as input, and returns a bitboard
+/// representing all squares attacked by Pt (bishop or rook) on the given square.
+template<PieceType Pt>
+FORCE_INLINE unsigned magic_index(Square s, Bitboard occ) {
 
-inline Bitboard same_color_squares(Square s) {
-  return bit_is_set(0xAA55AA55AA55AA55ULL, s) ?  0xAA55AA55AA55AA55ULL
-                                              : ~0xAA55AA55AA55AA55ULL;
+  Bitboard* const Masks  = Pt == ROOK ? RMasks  : BMasks;
+  Bitboard* const Magics = Pt == ROOK ? RMagics : BMagics;
+  unsigned* const Shifts = Pt == ROOK ? RShifts : BShifts;
+
+  if (Is64Bit)
+      return unsigned(((occ & Masks[s]) * Magics[s]) >> Shifts[s]);
+
+  unsigned lo = unsigned(occ) & unsigned(Masks[s]);
+  unsigned hi = unsigned(occ >> 32) & unsigned(Masks[s] >> 32);
+  return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
+}
+
+template<PieceType Pt>
+inline Bitboard attacks_bb(Square s, Bitboard occ) {
+  return (Pt == ROOK ? RAttacks : BAttacks)[s][magic_index<Pt>(s, occ)];
 }
 
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
+/// 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.
 
-#if defined(USE_BSFQ)
+#ifdef USE_BSFQ
 
-#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
 
-FORCE_INLINE Square first_1(Bitboard b) {
-   unsigned long index;
-   _BitScanForward64(&index, b);
-   return (Square) index;
+FORCE_INLINE Square lsb(Bitboard b) {
+  unsigned long index;
+  _BitScanForward64(&index, b);
+  return (Square) index;
 }
-#else
 
-FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
-  Bitboard dummy;
-  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
-  return (Square) dummy;
+FORCE_INLINE Square msb(Bitboard b) {
+  unsigned long index;
+  _BitScanReverse64(&index, b);
+  return (Square) index;
 }
-#endif
 
-FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
-  const Square s = first_1(*b);
-  *b &= ~(1ULL<<s);
+#  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 pop_1st_bit(Bitboard* b);
+extern Square msb(Bitboard b);
+extern Square lsb(Bitboard b);
+extern Square pop_lsb(Bitboard* b);
 
 #endif
 
+/// frontmost_sq() and backmost_sq() find the square corresponding to the
+/// most/least advanced bit relative to the given color.
 
-extern void print_bitboard(Bitboard b);
-extern void bitboards_init();
+inline Square frontmost_sq(Color c, Bitboard b) { return c == WHITE ? msb(b) : lsb(b); }
+inline Square  backmost_sq(Color c, Bitboard b) { return c == WHITE ? lsb(b) : msb(b); }
 
-#endif // !defined(BITBOARD_H_INCLUDED)
+#endif // #ifndef BITBOARD_H_INCLUDED

src/bitcount.h

@@ -1,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-2012 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,7 +18,7 @@
   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>
@@ -33,8 +33,8 @@ enum BitCountType {
 };
 
 /// Determine at compile time the best popcount<> specialization according if
-/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count or
-/// use hardware popcnt instruction when available.
+/// platform is 32 or 64 bits, to the maximum number of nonzero bits to count
+/// and if hardware popcnt instruction is available.
 const BitCountType Full  = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64 : CNT_32;
 const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;
 
@@ -44,53 +44,47 @@ template<BitCountType> inline int popcount(Bitboard);
 
 template<>
 inline int popcount<CNT_64>(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  return (b * 0x0101010101010101ULL) >> 56;
 }
 
 template<>
 inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  return (b * 0x1111111111111111ULL) >> 60;
 }
 
 template<>
 inline int popcount<CNT_32>(Bitboard b) {
   unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
-  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
-  v *= 0x01010101; // mul is fast on amd procs
-  return int(v >> 24);
+  v -=  (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -=  (w >> 1) & 0x55555555;
+  v  = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w  = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v  = ((v >> 4) + v + (w >> 4) + w) & 0x0F0F0F0F;
+  return (v * 0x01010101) >> 24;
 }
 
 template<>
 inline int popcount<CNT_32_MAX15>(Bitboard b) {
   unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v += w; // 0-8 in 4 bits
-  v *= 0x11111111;
-  return int(v >> 28);
+  v -=  (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -=  (w >> 1) & 0x55555555;
+  v  = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w  = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  return ((v + w) * 0x11111111) >> 28;
 }
 
 template<>
 inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
 
-#if !defined(USE_POPCNT)
+#ifndef USE_POPCNT
 
   assert(false);
-  return int(b != 0); // Avoid 'b not used' warning
+  return b != 0; // Avoid 'b not used' warning
 
 #elif defined(_MSC_VER) && defined(__INTEL_COMPILER)
 
@@ -102,11 +96,10 @@ inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
 
 #else
 
-  unsigned long ret;
-  __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-2012 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
@@ -35,8 +35,26 @@ 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 Key PolyGlotRandoms[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,
@@ -298,120 +316,94 @@ namespace {
     0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
     0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
     0xF8D626AAAF278509ULL
-  };
+  }};
 
-  // Offsets to the PolyGlotRandoms[] array of zobrist keys
-  const Key* ZobPiece     = PolyGlotRandoms +   0;
-  const Key* ZobCastle    = PolyGlotRandoms + 768;
-  const Key* ZobEnPassant = PolyGlotRandoms + 772;
-  const Key* ZobTurn      = PolyGlotRandoms + 780;
+  // polyglot_key() returns the PolyGlot hash key of the given position
+  Key polyglot_key(const Position& pos) {
 
-  // PieceOffset is calculated as 64 * (PolyPiece ^ 1) where PolyPiece
-  // is: BP = 0, WP = 1, BN = 2, WN = 3 ... BK = 10, WK = 11
-  const int PieceOffset[] = { 0, 64, 192, 320, 448, 576, 704, 0,
-                              0,  0, 128, 256, 384, 512, 640 };
-
-  // book_key() returns the PolyGlot hash key of the given position
-  uint64_t book_key(const Position& pos) {
-
-    uint64_t key = 0;
-    Bitboard b = pos.occupied_squares();
+    Key key = 0;
+    Bitboard b = pos.pieces();
 
     while (b)
     {
-        Square s = pop_1st_bit(&b);
-        key ^= ZobPiece[PieceOffset[pos.piece_on(s)] + s];
+        Square s = pop_lsb(&b);
+        Piece p = pos.piece_on(s);
+
+        // PolyGlot pieces are: BP = 0, WP = 1, BN = 2, ... BK = 10, WK = 11
+        key ^= PG.Zobrist.psq[2 * (type_of(p) - 1) + (color_of(p) == WHITE)][s];
     }
 
-    b =  (pos.can_castle(WHITE_OO) << 0) | (pos.can_castle(WHITE_OOO) << 1)
-       | (pos.can_castle(BLACK_OO) << 2) | (pos.can_castle(BLACK_OOO) << 3);
+    b = pos.can_castle(ALL_CASTLES);
 
     while (b)
-        key ^= ZobCastle[pop_1st_bit(&b)];
+        key ^= PG.Zobrist.castle[pop_lsb(&b)];
 
     if (pos.ep_square() != SQ_NONE)
-        key ^= ZobEnPassant[file_of(pos.ep_square())];
+        key ^= PG.Zobrist.enpassant[file_of(pos.ep_square())];
 
     if (pos.side_to_move() == WHITE)
-        key ^= ZobTurn[0];
+        key ^= PG.Zobrist.turn;
 
     return key;
   }
 
 } // namespace
 
-Book::Book() : size(0) {
+PolyglotBook::PolyglotBook() : rkiss(Time::now() % 10000) {}
 
-  for (int i = abs(system_time() % 10000); i > 0; i--)
-      RKiss.rand<unsigned>(); // Make random number generation less deterministic
-}
-
-Book::~Book() { if (is_open()) close(); }
+PolyglotBook::~PolyglotBook() { if (is_open()) close(); }
 
 
-/// Book::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
+/// 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> Book& Book::operator>>(T& n) {
+template<typename T> PolyglotBook& PolyglotBook::operator>>(T& n) {
 
   n = 0;
-  for (size_t i = 0; i < sizeof(T); i++)
+  for (size_t i = 0; i < sizeof(T); ++i)
       n = T((n << 8) + ifstream::get());
 
   return *this;
 }
 
-template<> Book& Book::operator>>(BookEntry& e) {
+template<> PolyglotBook& PolyglotBook::operator>>(Entry& e) {
   return *this >> e.key >> e.move >> e.count >> e.learn;
 }
 
 
-/// Book::open() tries to open a book file with the given name after closing
-/// any exsisting one.
+/// open() tries to open a book file with the given name after closing any
+/// exsisting one.
 
-bool Book::open(const char* fName) {
-
-  fileName = "";
+bool PolyglotBook::open(const char* fName) {
 
   if (is_open()) // Cannot close an already closed file
       close();
 
-  ifstream::open(fName, ifstream::in | ifstream::binary | ios::ate);
+  ifstream::open(fName, ifstream::in | ifstream::binary);
 
-  if (!is_open())
-      return false; // Silently fail if the file is not found
-
-  // Get the book size in number of entries, we are already at the end of file
-  size = tellg() / sizeof(BookEntry);
-
-  if (!good())
-  {
-      cerr << "Failed to open book file " << fName << endl;
-      exit(EXIT_FAILURE);
-  }
-
-  fileName = fName; // Set only if successful
-  return true;
+  fileName = is_open() ? fName : "";
+  ifstream::clear(); // Reset any error flag to allow retry ifstream::open()
+  return !fileName.empty();
 }
 
 
-/// Book::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
+/// probe() tries to find a book move for the given position. If no move is
+/// found returns MOVE_NONE. If pickBest is true returns always the highest
 /// rated move, otherwise randomly chooses one, based on the move score.
 
-Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
-
-  BookEntry e;
-  uint16_t best = 0;
-  unsigned sum = 0;
-  Move move = MOVE_NONE;
-  uint64_t key = book_key(pos);
+Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) {
 
   if (fileName != fName && !open(fName.c_str()))
       return MOVE_NONE;
 
-  binary_search(key);
+  Entry e;
+  uint16_t best = 0;
+  unsigned sum = 0;
+  Move move = MOVE_NONE;
+  Key key = polyglot_key(pos);
+
+  seekg(find_first(key) * sizeof(Entry), ios_base::beg);
 
   while (*this >> e, e.key == key && good())
   {
@@ -421,7 +413,7 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
       // Choose book move according to its score. If a move has a very
       // high score it has higher probability to be choosen than a move
       // with lower score. Note that first entry is always chosen.
-      if (   (RKiss.rand<unsigned>() % sum < e.count)
+      if (   (!pickBest && sum && rkiss.rand<unsigned>() % sum < e.count)
           || (pickBest && e.count == best))
           move = Move(e.move);
   }
@@ -441,28 +433,27 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) {
   // the special Move's flags (bit 14-15) that are not supported by PolyGlot.
   int pt = (move >> 12) & 7;
   if (pt)
-      move = make_promotion(from_sq(move), to_sq(move), PieceType(pt + 1));
+      move = make<PROMOTION>(from_sq(move), to_sq(move), PieceType(pt + 1));
 
   // Add 'special move' flags and verify it is legal
-  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
-      if (move == (ml.move() & 0x3FFF))
-          return ml.move();
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (move == (*it ^ type_of(*it)))
+          return *it;
 
   return MOVE_NONE;
 }
 
 
-/// Book::binary_search() takes a book key as input, and does a binary search
-/// through the book file for the given key. File stream current position is set
-/// to the leftmost book entry with the same key as the input.
+/// find_first() takes a book key as input, and does a binary search through
+/// the book file for the given key. Returns the index of the leftmost book
+/// entry with the same key as the input.
 
-void Book::binary_search(uint64_t key) {
+size_t PolyglotBook::find_first(Key key) {
 
-  size_t low, high, mid;
-  BookEntry e;
+  seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size
 
-  low = 0;
-  high = size - 1;
+  size_t low = 0, mid, high = (size_t)tellg() / sizeof(Entry) - 1;
+  Entry e;
 
   assert(low <= high);
 
@@ -472,7 +463,7 @@ void Book::binary_search(uint64_t key) {
 
       assert(mid >= low && mid < high);
 
-      seekg(mid * sizeof(BookEntry), ios_base::beg);
+      seekg(mid * sizeof(Entry), ios_base::beg);
       *this >> e;
 
       if (key <= e.key)
@@ -483,5 +474,5 @@ void Book::binary_search(uint64_t key) {
 
   assert(low == high);
 
-  seekg(low * sizeof(BookEntry), ios_base::beg);
+  return low;
 }

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-2012 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,7 +17,7 @@
   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>
@@ -26,33 +26,20 @@
 #include "position.h"
 #include "rkiss.h"
 
-
-/// A Polyglot book is a series of "entries" of 16 bytes. All integers are
-/// stored highest byte first (regardless of size). The entries are ordered
-/// according to key. Lowest key first.
-struct BookEntry {
-  uint64_t key;
-  uint16_t move;
-  uint16_t count;
-  uint32_t learn;
-};
-
-
-class Book : private std::ifstream {
+class PolyglotBook : private std::ifstream {
 public:
-  Book();
-  ~Book();
+  PolyglotBook();
+ ~PolyglotBook();
   Move probe(const Position& pos, const std::string& fName, bool pickBest);
 
 private:
-  template<typename T> Book& operator>>(T& n);
+  template<typename T> PolyglotBook& operator>>(T& n);
 
   bool open(const char* fName);
-  void binary_search(uint64_t key);
+  size_t find_first(Key key);
 
-  RKISS RKiss;
+  RKISS rkiss;
   std::string fileName;
-  size_t size;
 };
 
-#endif // !defined(BOOK_H_INCLUDED)
+#endif // #ifndef 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-2012 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,7 +17,7 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(ENDGAME_H_INCLUDED)
+#ifndef ENDGAME_H_INCLUDED
 #define ENDGAME_H_INCLUDED
 
 #include <map>
@@ -33,15 +33,16 @@ enum EndgameType {
 
   // Evaluation functions
 
+  KNNK,  // KNN vs K
   KXK,   // Generic "mate lone king" eval
   KBNK,  // KBN vs K
   KPK,   // KP vs K
   KRKP,  // KR vs KP
   KRKB,  // KR vs KB
   KRKN,  // KR vs KN
+  KQKP,  // KQ vs KP
   KQKR,  // KQ vs KR
   KBBKN, // KBB vs KN
-  KNNK,  // KNN vs K
   KmmKm, // K and two minors vs K and one or two minors
 
 
@@ -51,21 +52,24 @@ enum EndgameType {
   KBPsK,   // KB+pawns vs K
   KQKRPs,  // KQ vs KR+pawns
   KRPKR,   // KRP vs KR
+  KRPKB,   // KRP vs KB
   KRPPKRP, // KRPP vs KRP
   KPsK,    // King and pawns vs king
   KBPKB,   // KBP vs KB
   KBPPKB,  // KBPP vs KB
   KBPKN,   // KBP vs KN
   KNPK,    // KNP vs K
+  KNPKB,   // KNP vs KB
   KPKP     // KP vs KP
 };
 
 
-/// Some magic to detect family type of endgame from its enum value
+/// Endgame functions can be of two types 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<bool> struct bool_to_type { typedef Value type; };
-template<> struct bool_to_type<true> { typedef ScaleFactor type; };
-template<EndgameType E> struct eg_family : public bool_to_type<(E > SCALE_FUNS)> {};
+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
@@ -79,42 +83,41 @@ struct EndgameBase {
 };
 
 
-template<EndgameType E, typename T = typename eg_family<E>::type>
+template<EndgameType E, typename T = typename eg_fun<(E > SCALE_FUNS)>::type>
 struct Endgame : public EndgameBase<T> {
 
-  explicit Endgame(Color c) : strongerSide(c), weakerSide(flip(c)) {}
-  Color color() const { return strongerSide; }
+  explicit Endgame(Color c) : strongSide(c), weakSide(~c) {}
+  Color color() const { return strongSide; }
   T operator()(const Position&) const;
 
 private:
-  Color strongerSide, weakerSide;
+  const Color strongSide, weakSide;
 };
 
 
 /// Endgames class stores in two std::map the pointers to endgame evaluation
 /// and scaling base objects. Then we use polymorphism to invoke the actual
-/// endgame function calling its operator() method that is virtual.
+/// endgame function calling its operator() that is virtual.
 
 class Endgames {
 
-  typedef std::map<Key, EndgameBase<Value>*> M1;
-  typedef std::map<Key, EndgameBase<ScaleFactor>*> M2;
+  typedef std::map<Key, EndgameBase<eg_fun<0>::type>*> M1;
+  typedef std::map<Key, EndgameBase<eg_fun<1>::type>*> M2;
 
   M1 m1;
   M2 m2;
 
-  M1& map(Value*) { return m1; }
-  M2& map(ScaleFactor*) { return 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<typename T> EndgameBase<T>* get(Key key) {
-    return map((T*)0).count(key) ? map((T*)0)[key] : NULL;
-  }
+  template<typename T> T probe(Key key, T& eg)
+  { return eg = map(eg).count(key) ? map(eg)[key] : NULL; }
 };
 
-#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-2012 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);
-extern std::string trace_evaluate(const Position& pos);
-extern void read_evaluation_uci_options(Color sideToMove);
+namespace Eval {
 
-#endif // !defined(EVALUATE_H_INCLUDED)
+extern void init();
+extern Value evaluate(const Position& pos);
+extern std::string trace(const Position& pos);
+
+}
+
+#endif // #ifndef EVALUATE_H_INCLUDED

src/history.h

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

src/lock.h

@@ -1,85 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(LOCK_H_INCLUDED)
-#define LOCK_H_INCLUDED
-
-#if !defined(_MSC_VER)
-
-#  include <pthread.h>
-
-typedef pthread_mutex_t Lock;
-typedef pthread_cond_t WaitCondition;
-
-#  define lock_init(x) pthread_mutex_init(x, NULL)
-#  define lock_grab(x) pthread_mutex_lock(x)
-#  define lock_release(x) pthread_mutex_unlock(x)
-#  define lock_destroy(x) pthread_mutex_destroy(x)
-#  define cond_destroy(x) pthread_cond_destroy(x)
-#  define cond_init(x) pthread_cond_init(x, NULL)
-#  define cond_signal(x) pthread_cond_signal(x)
-#  define cond_wait(x,y) pthread_cond_wait(x,y)
-#  define cond_timedwait(x,y,z) pthread_cond_timedwait(x,y,z)
-
-#else
-
-#define NOMINMAX // disable macros min() and max()
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#undef WIN32_LEAN_AND_MEAN
-#undef NOMINMAX
-
-// Default fast and race free locks and condition variables
-#if !defined(OLD_LOCKS)
-
-typedef SRWLOCK Lock;
-typedef CONDITION_VARIABLE WaitCondition;
-
-#  define lock_init(x) InitializeSRWLock(x)
-#  define lock_grab(x) AcquireSRWLockExclusive(x)
-#  define lock_release(x) ReleaseSRWLockExclusive(x)
-#  define lock_destroy(x) (x)
-#  define cond_destroy(x) (x)
-#  define cond_init(x) InitializeConditionVariable(x)
-#  define cond_signal(x) WakeConditionVariable(x)
-#  define cond_wait(x,y) SleepConditionVariableSRW(x,y,INFINITE,0)
-#  define cond_timedwait(x,y,z) SleepConditionVariableSRW(x,y,z,0)
-
-// Fallback solution to build for Windows XP and older versions, note that
-// cond_wait() is racy between lock_release() and WaitForSingleObject().
-#else
-
-typedef CRITICAL_SECTION Lock;
-typedef HANDLE WaitCondition;
-
-#  define lock_init(x) InitializeCriticalSection(x)
-#  define lock_grab(x) EnterCriticalSection(x)
-#  define lock_release(x) LeaveCriticalSection(x)
-#  define lock_destroy(x) DeleteCriticalSection(x)
-#  define cond_init(x) { *x = CreateEvent(0, FALSE, FALSE, 0); }
-#  define cond_destroy(x) CloseHandle(*x)
-#  define cond_signal(x) SetEvent(*x)
-#  define cond_wait(x,y) { lock_release(y); WaitForSingleObject(*x, INFINITE); lock_grab(y); }
-#  define cond_timedwait(x,y,z) { lock_release(y); WaitForSingleObject(*x,z); 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-2012 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
@@ -21,37 +21,33 @@
 #include <string>
 
 #include "bitboard.h"
-#include "misc.h"
+#include "evaluate.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
-
-using namespace std;
-
-extern void uci_loop();
-extern void benchmark(int argc, char* argv[]);
-extern void kpk_bitbase_init();
+#include "tt.h"
+#include "ucioption.h"
 
 int main(int argc, char* argv[]) {
 
-  bitboards_init();
+  std::cout << engine_info() << std::endl;
+
+  UCI::init(Options);
+  Bitboards::init();
   Position::init();
-  kpk_bitbase_init();
+  Bitbases::init_kpk();
   Search::init();
+  Pawns::init();
+  Eval::init();
   Threads.init();
+  TT.set_size(Options["Hash"]);
 
-  cout << engine_info() << endl;
+  std::string args;
 
-  if (argc == 1)
-      uci_loop();
+  for (int i = 1; i < argc; ++i)
+      args += std::string(argv[i]) + " ";
 
-  else if (string(argv[1]) == "bench")
-      benchmark(argc, argv);
-
-  else
-      cerr << "\nUsage: stockfish bench [hash size = 128] [threads = 1] "
-           << "[limit = 12] [fen positions file = default] "
-           << "[limited by depth, time, nodes or perft = depth]" << endl;
+  UCI::loop(args);
 
   Threads.exit();
 }

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-2012 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,9 +17,9 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <algorithm>  // For std::min
 #include <cassert>
 #include <cstring>
-#include <algorithm>
 
 #include "material.h"
 
@@ -35,18 +35,30 @@ namespace {
   const int NoPawnsSF[4] = { 6, 12, 32 };
 
   // Polynomial material balance parameters
-  const Value RedundantQueenPenalty = Value(320);
-  const Value RedundantRookPenalty  = Value(554);
 
-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+  //                                  pair  pawn knight bishop rook queen
+  const int LinearCoefficients[6] = { 1852, -162, -1122, -183,  249, -52 };
 
-  const int QuadraticCoefficientsSameColor[][8] = {
-  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
-  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
+  const int QuadraticCoefficientsSameColor[][PIECE_TYPE_NB] = {
+    // pair pawn knight bishop rook queen
+    {   0                               }, // Bishop pair
+    {  39,    2                         }, // Pawn
+    {  35,  271,  -4                    }, // Knight
+    {   0,  105,   4,    0              }, // Bishop
+    { -27,   -2,  46,   100,  -141      }, // Rook
+    {  58,   29,  83,   148,  -163,   0 }  // Queen
+  };
 
-  const int QuadraticCoefficientsOppositeColor[][8] = {
-  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
-  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+  const int QuadraticCoefficientsOppositeColor[][PIECE_TYPE_NB] = {
+    //           THEIR PIECES
+    // pair pawn knight bishop rook queen
+    {   0                               }, // Bishop pair
+    {  37,    0                         }, // Pawn
+    {  10,   62,   0                    }, // Knight      OUR PIECES
+    {  57,   64,  39,     0             }, // Bishop
+    {  50,   40,  23,   -22,    0       }, // Rook
+    { 106,  101,   3,   151,  171,    0 }  // Queen
+  };
 
   // Endgame evaluation and scaling functions accessed direcly and not through
   // the function maps because correspond to more then one material hash key.
@@ -61,90 +73,110 @@ namespace {
   // Helper templates used to detect a given material distribution
   template<Color Us> bool is_KXK(const Position& pos) {
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.non_pawn_material(Them) == VALUE_ZERO
-          && pos.piece_count(Them, PAWN) == 0
-          && pos.non_pawn_material(Us)   >= RookValueMidgame;
+    return  !pos.count<PAWN>(Them)
+          && pos.non_pawn_material(Them) == VALUE_ZERO
+          && pos.non_pawn_material(Us) >= RookValueMg;
   }
 
   template<Color Us> bool is_KBPsKs(const Position& pos) {
-    return   pos.non_pawn_material(Us)   == BishopValueMidgame
-          && pos.piece_count(Us, BISHOP) == 1
-          && pos.piece_count(Us, PAWN)   >= 1;
+    return   pos.non_pawn_material(Us) == BishopValueMg
+          && pos.count<BISHOP>(Us) == 1
+          && pos.count<PAWN  >(Us) >= 1;
   }
 
   template<Color Us> bool is_KQKRPs(const Position& pos) {
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.piece_count(Us, PAWN)    == 0
-          && pos.non_pawn_material(Us)    == QueenValueMidgame
-          && pos.piece_count(Us, QUEEN)   == 1
-          && pos.piece_count(Them, ROOK)  == 1
-          && pos.piece_count(Them, PAWN)  >= 1;
+    return  !pos.count<PAWN>(Us)
+          && pos.non_pawn_material(Us) == QueenValueMg
+          && pos.count<QUEEN>(Us)  == 1
+          && pos.count<ROOK>(Them) == 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;
+
+    // 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(); }
-MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
-
-
-/// MaterialInfoTable::material_info() takes a position object as input,
-/// computes or looks up a MaterialInfo object, and returns a pointer to it.
-/// If the material configuration is not already present in the table, it
-/// is stored there, so we don't have to recompute everything when the
-/// same material configuration occurs again.
-
-MaterialInfo* MaterialInfoTable::material_info(const Position& pos) const {
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {
 
   Key key = pos.material_key();
-  MaterialInfo* mi = probe(key);
+  Entry* e = entries[key];
 
-  // If mi->key matches the position's material hash key, it means that we
+  // If e->key matches the position's material hash key, it means that we
   // have analysed this material configuration before, and we can simply
   // return the information we found the last time instead of recomputing it.
-  if (mi->key == key)
-      return mi;
+  if (e->key == key)
+      return e;
 
-  // Initialize MaterialInfo entry
-  memset(mi, 0, sizeof(MaterialInfo));
-  mi->key = key;
-  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-
-  // Store game phase
-  mi->gamePhase = MaterialInfoTable::game_phase(pos);
+  std::memset(e, 0, sizeof(Entry));
+  e->key = key;
+  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
+  e->gamePhase = game_phase(pos);
 
   // Let's look if we have a specialized evaluation function for this
   // particular material configuration. First we look for a fixed
   // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->get<Value>(key)) != NULL)
-      return mi;
+  if (endgames.probe(key, e->evaluationFunction))
+      return e;
 
   if (is_KXK<WHITE>(pos))
   {
-      mi->evaluationFunction = &EvaluateKXK[WHITE];
-      return mi;
+      e->evaluationFunction = &EvaluateKXK[WHITE];
+      return e;
   }
 
   if (is_KXK<BLACK>(pos))
   {
-      mi->evaluationFunction = &EvaluateKXK[BLACK];
-      return mi;
+      e->evaluationFunction = &EvaluateKXK[BLACK];
+      return e;
   }
 
   if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN))
   {
       // Minor piece endgame with at least one minor piece per side and
       // no pawns. Note that the case KmmK is already handled by KXK.
-      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
-      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
+      assert((pos.pieces(WHITE, KNIGHT) | pos.pieces(WHITE, BISHOP)));
+      assert((pos.pieces(BLACK, KNIGHT) | pos.pieces(BLACK, BISHOP)));
 
-      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
-          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      if (   pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE) <= 2
+          && pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK) <= 2)
       {
-          mi->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
-          return mi;
+          e->evaluationFunction = &EvaluateKmmKm[pos.side_to_move()];
+          return e;
       }
   }
 
@@ -155,128 +187,93 @@ MaterialInfo* MaterialInfoTable::material_info(const Position& pos) const {
   // scaling functions and we need to decide which one to use.
   EndgameBase<ScaleFactor>* sf;
 
-  if ((sf = funcs->get<ScaleFactor>(key)) != NULL)
+  if (endgames.probe(key, sf))
   {
-      mi->scalingFunction[sf->color()] = sf;
-      return mi;
+      e->scalingFunction[sf->color()] = sf;
+      return e;
   }
 
   // Generic scaling functions that refer to more then one material
   // distribution. Should be probed after the specialized ones.
   // Note that these ones don't return after setting the function.
   if (is_KBPsKs<WHITE>(pos))
-      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);
-          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+          assert(pos.count<PAWN>(WHITE) >= 2);
+          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
       }
-      else if (pos.piece_count(WHITE, PAWN) == 0)
+      else if (!pos.count<PAWN>(WHITE))
       {
-          assert(pos.piece_count(BLACK, PAWN) >= 2);
-          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+          assert(pos.count<PAWN>(BLACK) >= 2);
+          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
       }
-      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
       {
           // This is a special case because we set scaling functions
           // for both colors instead of only one.
-          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
-          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
+          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          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)
+  // No pawns makes it difficult to win, even with a material advantage. This
+  // catches some trivial draws like KK, KBK and KNK
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
   {
-      mi->factor[WHITE] = uint8_t
-      (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(WHITE, BISHOP), 2)]);
+      e->factor[WHITE] = (uint8_t)
+      (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
-      (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[std::min(pos.piece_count(BLACK, BISHOP), 2)]);
+      e->factor[BLACK] = (uint8_t)
+      (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)
-                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+      int minorPieceCount =  pos.count<KNIGHT>(WHITE) + pos.count<BISHOP>(WHITE)
+                           + 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] = {
-  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
-    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
-  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
-    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+  const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
 
-  mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
-  return mi;
+  e->value = (int16_t)((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
+  return e;
 }
 
 
-/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
-/// piece type for both colors.
-
-template<Color Us>
-int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
-
-  const Color Them = (Us == WHITE ? BLACK : WHITE);
-
-  int pt1, pt2, pc, v;
-  int value = 0;
-
-  // Redundancy of major pieces, formula based on Kaufman's paper
-  // "The Evaluation of Material Imbalances in Chess"
-  if (pieceCount[Us][ROOK] > 0)
-      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
-              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
-
-  // Second-degree polynomial material imbalance by Tord Romstad
-  for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
-  {
-      pc = pieceCount[Us][pt1];
-      if (!pc)
-          continue;
-
-      v = LinearCoefficients[pt1];
-
-      for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
-          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
-              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
-
-      value += pc * v;
-  }
-  return value;
-}
-
-
-/// MaterialInfoTable::game_phase() calculates the phase given the current
+/// Material::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);
 
@@ -284,3 +281,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-2012 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,108 +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 {
 
-/// Game phase
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-/// MaterialInfo is a class which contains various information about a
-/// material configuration. It contains a material balance evaluation,
-/// a function pointer to a special endgame evaluation function (which in
-/// most cases is NULL, meaning that the standard evaluation function will
-/// be used), and "scale factors" for black and white.
+/// Material::Entry contains various information about a material configuration.
+/// It contains a material balance evaluation, a function pointer to a special
+/// endgame evaluation function (which in most cases is NULL, meaning that the
+/// standard evaluation function will be used), and "scale factors".
 ///
 /// 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;
-
-public:
-  Score material_value() const;
+  Score material_value() const { return make_score(value, value); }
+  Score space_weight() const { return spaceWeight; }
+  Phase game_phase() const { return gamePhase; }
+  bool specialized_eval_exists() const { return evaluationFunction != NULL; }
+  Value evaluate(const Position& p) const { return (*evaluationFunction)(p); }
   ScaleFactor scale_factor(const Position& pos, Color c) const;
-  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];
-  int spaceWeight;
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB];
+  Score spaceWeight;
   Phase gamePhase;
 };
 
+typedef HashTable<Entry, 8192> Table;
 
-/// The MaterialInfoTable class represents a pawn hash table. The most important
-/// method is material_info(), which returns a pointer to a MaterialInfo object.
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames);
+Phase game_phase(const Position& pos);
 
-class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
-public:
-  ~MaterialInfoTable();
-  void init();
-  MaterialInfo* 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
+/// Material::scale_factor takes a position and a color as input, and
 /// returns a scale factor for the given color. We have to provide the
 /// position in addition to the color, because the scale factor need not
 /// to be a constant: It can also be a function which should be applied to
 /// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.
 
-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 ScaleFactor(factor[c]);
-
-  ScaleFactor sf = (*scalingFunction[c])(pos);
-  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
+  return !scalingFunction[c] || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE
+        ? ScaleFactor(factor[c]) : (*scalingFunction[c])(pos);
 }
 
-inline Value MaterialInfo::evaluate(const Position& pos) const {
-  return (*evaluationFunction)(pos);
 }
 
-inline Score MaterialInfo::material_value() const {
-  return make_score(value, value);
-}
-
-inline int MaterialInfo::space_weight() const {
-  return spaceWeight;
-}
-
-inline Phase MaterialInfo::game_phase() const {
-  return gamePhase;
-}
-
-inline bool MaterialInfo::specialized_eval_exists() const {
-  return evaluationFunction != NULL;
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)
+#endif // #ifndef 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-2012 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,75 +17,42 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if defined(_MSC_VER)
-
-#define _CRT_SECURE_NO_DEPRECATE
-#define NOMINMAX // disable macros min() and max()
-#include <windows.h>
-#include <sys/timeb.h>
-
-#else
-
-#  include <sys/time.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  if defined(__hpux)
-#     include <sys/pstat.h>
-#  endif
-
-#endif
-
-#if !defined(NO_PREFETCH)
-#  include <xmmintrin.h>
-#endif
-
-#include <algorithm>
-#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 Version is left empty, then Tag plus current
-/// date (in the format YYMMDD) is used as a version number.
-
-static const string Version = "2.2.1";
-static const string Tag = "";
+/// Version number. If Version is left empty, then compile date, in the
+/// format DD-MM-YY, is shown in engine_info.
+static const string Version = "DD";
 
 
-/// engine_info() returns the full name of the current Stockfish version.
-/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when
-/// the program was compiled) or "Stockfish <version number>", depending
-/// on whether Version is empty.
+/// engine_info() returns the full name of the current Stockfish version. This
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// Version is empty.
 
 const string engine_info(bool to_uci) {
 
   const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
-  const string cpu64(Is64Bit ? " 64bit" : "");
-  const string popcnt(HasPopCnt ? " SSE4.2" : "");
-
   string month, day, year;
   stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"
 
+  s << "Stockfish " << Version << setfill('0');
+
   if (Version.empty())
   {
       date >> month >> day >> year;
-
-      s << "Stockfish " << Tag
-        << setfill('0') << " " << year.substr(2)
-        << setw(2) << (1 + months.find(month) / 4)
-        << setw(2) << day << cpu64 << popcnt;
+      s << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
   }
-  else
-      s << "Stockfish " << Version << cpu64 << popcnt;
 
-  s << (to_uci ? "\nid author ": " by ")
+  s << (Is64Bit ? " 64" : "")
+    << (HasPopCnt ? " SSE4.2" : "")
+    << (to_uci ? "\nid author ": " by ")
     << "Tord Romstad, Marco Costalba and Joona Kiiski";
 
   return s.str();
@@ -96,9 +63,9 @@ const string engine_info(bool to_uci) {
 
 static uint64_t hits[2], means[2];
 
-void dbg_hit_on(bool b) { hits[0]++; if (b) hits[1]++; }
+void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
 void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
-void dbg_mean_of(int v) { means[0]++; means[1] += v; }
+void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
 
 void dbg_print() {
 
@@ -108,72 +75,102 @@ void dbg_print() {
 
   if (means[0])
       cerr << "Total " << means[0] << " Mean "
-           << (float)means[1] / means[0] << endl;
+           << (double)means[1] / means[0] << endl;
 }
 
 
-/// system_time() returns the current system time, measured in milliseconds
+/// 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 system_time() {
+struct Tie: public streambuf { // MSVC requires splitted streambuf for cin and cout
 
-#if defined(_MSC_VER)
-  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
+  Tie(streambuf* b, ofstream* f) : buf(b), file(f) {}
+
+  int sync() { return file->rdbuf()->pubsync(), buf->pubsync(); }
+  int overflow(int c) { return log(buf->sputc((char)c), "<< "); }
+  int underflow() { return buf->sgetc(); }
+  int uflow() { return log(buf->sbumpc(), ">> "); }
+
+  streambuf* buf;
+  ofstream* file;
+
+  int log(int c, const char* prefix) {
+
+    static int last = '\n';
+
+    if (last == '\n')
+        file->rdbuf()->sputn(prefix, 3);
+
+    return last = file->rdbuf()->sputc((char)c);
+  }
+};
+
+class Logger {
+
+  Logger() : in(cin.rdbuf(), &file), out(cout.rdbuf(), &file) {}
+ ~Logger() { start(false); }
+
+  ofstream file;
+  Tie in, out;
+
+public:
+  static void start(bool b) {
+
+    static Logger l;
+
+    if (b && !l.file.is_open())
+    {
+        l.file.open("io_log.txt", ifstream::out | ifstream::app);
+        cin.rdbuf(&l.in);
+        cout.rdbuf(&l.out);
+    }
+    else if (!b && l.file.is_open())
+    {
+        cout.rdbuf(l.out.buf);
+        cin.rdbuf(l.in.buf);
+        l.file.close();
+    }
+  }
+};
+
+
+/// Used to serialize access to std::cout to avoid multiple threads to write at
+/// 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;
 }
 
 
-/// cpu_count() tries to detect the number of CPU cores
-
-int cpu_count() {
-
-#if defined(_MSC_VER)
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return std::min(int(s.dwNumberOfProcessors), MAX_THREADS);
-#else
-
-#  if defined(_SC_NPROCESSORS_ONLN)
-  return std::min((int)sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
-#  elif defined(__hpux)
-  struct pst_dynamic psd;
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-  return std::min((int)psd.psd_proc_cnt, MAX_THREADS);
-#  else
-  return 1;
-#  endif
-
-#endif
-}
+/// 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) {
+void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) {
 
-#if defined(_MSC_VER)
+#ifdef _WIN32
   int tm = msec;
 #else
-  struct timeval t;
-  struct timespec abstime, *tm = &abstime;
+  timespec ts, *tm = &ts;
+  uint64_t ms = Time::now() + msec;
 
-  gettimeofday(&t, NULL);
-
-  abstime.tv_sec = t.tv_sec + (msec / 1000);
-  abstime.tv_nsec = (t.tv_usec + (msec % 1000) * 1000) * 1000;
-
-  if (abstime.tv_nsec > 1000000000LL)
-  {
-      abstime.tv_sec += 1;
-      abstime.tv_nsec -= 1000000000LL;
-  }
+  ts.tv_sec = ms / 1000;
+  ts.tv_nsec = (ms % 1000) * 1000000LL;
 #endif
 
   cond_timedwait(sleepCond, sleepLock, tm);
@@ -183,7 +180,7 @@ void timed_wait(WaitCondition* sleepCond, Lock* sleepLock, int msec) {
 /// 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*) {}
 
@@ -191,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
 
-  _mm_prefetch(addr, _MM_HINT_T2);
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
+  _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-2012 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,34 +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 "lock.h"
 #include "types.h"
 
 extern const std::string engine_info(bool to_uci = false);
-extern int system_time();
-extern int cpu_count();
-extern void timed_wait(WaitCondition*, Lock*, int);
+extern void timed_wait(WaitCondition&, Lock&, int);
 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_mean_of(int v);
 extern void dbg_print();
 
-class Position;
-extern Move move_from_uci(const Position& pos, const std::string& str);
-extern const std::string move_to_uci(Move m, bool chess960);
-extern const std::string move_to_san(Position& pos, Move m);
 
 struct Log : public std::ofstream {
   Log(const std::string& f = "log.txt") : std::ofstream(f.c_str(), std::ios::out | std::ios::app) {}
  ~Log() { if (is_open()) close(); }
 };
 
-#endif // !defined(MISC_H_INCLUDED)
+
+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,159 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include <cassert>
-#include <cstring>
-#include <string>
-
-#include "movegen.h"
-#include "position.h"
-
-using std::string;
-
-/// move_to_uci() converts a move to a string in coordinate notation
-/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we
-/// print in the e1g1 notation in normal chess mode, and in e1h1 notation in
-/// Chess960 mode. Instead internally Move is coded as "king captures rook".
-
-const string move_to_uci(Move m, bool chess960) {
-
-  Square from = from_sq(m);
-  Square to = to_sq(m);
-  string promotion;
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "0000";
-
-  if (is_castle(m) && !chess960)
-      to = from + (file_of(to) == FILE_H ? Square(2) : -Square(2));
-
-  if (is_promotion(m))
-      promotion = char(tolower(piece_type_to_char(promotion_piece_type(m))));
-
-  return square_to_string(from) + square_to_string(to) + promotion;
-}
-
-
-/// move_from_uci() takes a position and a string representing a move in
-/// simple coordinate notation and returns an equivalent Move if any.
-/// Moves are guaranteed to be legal.
-
-Move move_from_uci(const Position& pos, const string& str) {
-
-  for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
-      if (str == move_to_uci(ml.move(), pos.is_chess960()))
-          return ml.move();
-
-  return MOVE_NONE;
-}
-
-
-/// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move for the position. The return value is
-/// a string containing the move in short algebraic notation.
-
-const string move_to_san(Position& pos, Move m) {
-
-  if (m == MOVE_NONE)
-      return "(none)";
-
-  if (m == MOVE_NULL)
-      return "(null)";
-
-  assert(is_ok(m));
-
-  Bitboard attackers;
-  bool ambiguousMove, ambiguousFile, ambiguousRank;
-  Square sq, from = from_sq(m);
-  Square to = to_sq(m);
-  PieceType pt = type_of(pos.piece_on(from));
-  string san;
-
-  if (is_castle(m))
-      san = (to_sq(m) < from_sq(m) ? "O-O-O" : "O-O");
-  else
-  {
-      if (pt != PAWN)
-      {
-          san = piece_type_to_char(pt);
-
-          // Disambiguation if we have more then one piece with destination 'to'
-          // note that for pawns is not needed because starting file is explicit.
-          attackers = pos.attackers_to(to) & pos.pieces(pt, pos.side_to_move());
-          clear_bit(&attackers, from);
-          ambiguousMove = ambiguousFile = ambiguousRank = false;
-
-          while (attackers)
-          {
-              sq = pop_1st_bit(&attackers);
-
-              // Pinned pieces are not included in the possible sub-set
-              if (!pos.pl_move_is_legal(make_move(sq, to), pos.pinned_pieces()))
-                  continue;
-
-              if (file_of(sq) == file_of(from))
-                  ambiguousFile = true;
-
-              if (rank_of(sq) == rank_of(from))
-                  ambiguousRank = true;
-
-              ambiguousMove = true;
-          }
-
-          if (ambiguousMove)
-          {
-              if (!ambiguousFile)
-                  san += file_to_char(file_of(from));
-              else if (!ambiguousRank)
-                  san += rank_to_char(rank_of(from));
-              else
-                  san += square_to_string(from);
-          }
-      }
-
-      if (pos.is_capture(m))
-      {
-          if (pt == PAWN)
-              san += file_to_char(file_of(from));
-
-          san += 'x';
-      }
-
-      san += square_to_string(to);
-
-      if (is_promotion(m))
-      {
-          san += '=';
-          san += piece_type_to_char(promotion_piece_type(m));
-      }
-  }
-
-  // The move gives check? We don't use pos.move_gives_check() here
-  // because we need to test for a mate after the move is done.
-  StateInfo st;
-  pos.do_move(m, st);
-  if (pos.in_check())
-      san += pos.is_mate() ? "#" : "+";
-  pos.undo_move(m);
-
-  return san;
-}

src/movegen.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-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,520 +18,389 @@
 */
 
 #include <cassert>
-#include <algorithm>
 
-#include "bitcount.h"
 #include "movegen.h"
 #include "position.h"
 
-// Simple macro to wrap a very common while loop, no facny, no flexibility,
-// hardcoded list name 'mlist' and from square 'from'.
-#define SERIALIZE_MOVES(b) while (b) (*mlist++).move = make_move(from, pop_1st_bit(&b))
-
-// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
-#define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); }
+/// Simple macro to wrap a very common while loop, no facny, no flexibility,
+/// hardcoded names 'mlist' and 'from'.
+#define SERIALIZE(b) while (b) (mlist++)->move = make_move(from, pop_lsb(&b))
 
+/// Version used for pawns, where the 'from' square is given as a delta from the 'to' square
+#define SERIALIZE_PAWNS(b, d) while (b) { Square to = pop_lsb(&b); \
+                                         (mlist++)->move = make_move(to - (d), to); }
 namespace {
 
-  enum CastlingSide {
-    KING_SIDE,
-    QUEEN_SIDE
-  };
+  template<CastlingSide Side, bool Checks, bool Chess960>
+  ExtMove* generate_castle(const Position& pos, ExtMove* mlist, Color us) {
 
-  template<CastlingSide>
-  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 && Pt != PAWN);
-
-    Bitboard b = pos.attacks_from<Pt>(from) & pos.empty_squares();
-
-    if (Pt == KING)
-        b &= ~QueenPseudoAttacks[pos.king_square(flip(pos.side_to_move()))];
-
-    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 && Pt != PAWN);
-
-    Bitboard checkSqs, b;
-    Square from;
-    const Square* pl = pos.piece_list(us, Pt);
-
-    if ((from = *pl++) == SQ_NONE)
+    if (pos.castle_impeded(us, Side) || !pos.can_castle(make_castle_right(us, Side)))
         return mlist;
 
-    checkSqs = pos.attacks_from<Pt>(ksq) & pos.empty_squares();
-
-    do
-    {
-        if (   (Pt == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
-            || (Pt == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
-            || (Pt == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
-            continue;
-
-        if (dc && bit_is_set(dc, from))
-            continue;
-
-        b = pos.attacks_from<Pt>(from) & checkSqs;
-        SERIALIZE_MOVES(b);
-
-    } while ((from = *pl++) != SQ_NONE);
-
-    return mlist;
-  }
-
-  template<>
-  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)
-                        : generate_pawn_moves<BLACK, MV_CHECK>(p, m, dc, ksq));
-  }
-
-  template<PieceType Pt, MoveType Type>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
-
-    assert(Pt == PAWN);
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
-  }
-
-  template<PieceType Pt>
-  FORCE_INLINE MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from;
-    const Square* pl = pos.piece_list(us, Pt);
-
-    if (*pl != SQ_NONE)
-    {
-        do {
-            from = *pl;
-            b = pos.attacks_from<Pt>(from) & target;
-            SERIALIZE_MOVES(b);
-        } while (*++pl != SQ_NONE);
-    }
-    return mlist;
-  }
-
-  template<>
-  FORCE_INLINE MoveStack* generate_piece_moves<KING>(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
-
-    Bitboard b;
-    Square from = pos.king_square(us);
-
-    b = pos.attacks_from<KING>(from) & target;
-    SERIALIZE_MOVES(b);
-    return mlist;
-  }
-
-}
-
-
-/// generate<MV_CAPTURE> generates all pseudo-legal captures and queen
-/// promotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_CAPTURE> generates all pseudo-legal non-captures and
-/// underpromotions. Returns a pointer to the end of the move list.
-///
-/// generate<MV_NON_EVASION> generates all pseudo-legal captures and
-/// non-captures. Returns a pointer to the end of the move list.
-
-template<MoveType Type>
-MoveStack* generate(const Position& pos, MoveStack* mlist) {
-
-  assert(Type == MV_CAPTURE || Type == MV_NON_CAPTURE || Type == MV_NON_EVASION);
-  assert(!pos.in_check());
-
-  Color us = pos.side_to_move();
-  Bitboard target;
-
-  if (Type == MV_CAPTURE)
-      target = pos.pieces(flip(us));
-
-  else if (Type == MV_NON_CAPTURE)
-      target = pos.empty_squares();
-
-  else if (Type == MV_NON_EVASION)
-      target = pos.pieces(flip(us)) | pos.empty_squares();
-
-  mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KING>(pos, mlist, us, target);
-
-  if (Type != MV_CAPTURE && pos.can_castle(us))
-  {
-      if (pos.can_castle(us == WHITE ? WHITE_OO : BLACK_OO))
-          mlist = generate_castle_moves<KING_SIDE>(pos, mlist, us);
-
-      if (pos.can_castle(us == WHITE ? WHITE_OOO : BLACK_OOO))
-          mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist, us);
-  }
-
-  return mlist;
-}
-
-// Explicit template instantiations
-template MoveStack* generate<MV_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_CAPTURE>(const Position& pos, MoveStack* mlist);
-template MoveStack* generate<MV_NON_EVASION>(const Position& pos, MoveStack* mlist);
-
-
-/// generate<MV_NON_CAPTURE_CHECK> generates all pseudo-legal non-captures and knight
-/// underpromotions that give check. Returns a pointer to the end of the move list.
-template<>
-MoveStack* generate<MV_NON_CAPTURE_CHECK>(const Position& pos, MoveStack* mlist) {
-
-  assert(!pos.in_check());
-
-  Bitboard b, dc;
-  Square from;
-  Color us = pos.side_to_move();
-  Square ksq = pos.king_square(flip(us));
-
-  assert(pos.piece_on(ksq) == make_piece(flip(us), KING));
-
-  // Discovered non-capture checks
-  b = dc = pos.discovered_check_candidates();
-
-  while (b)
-  {
-     from = pop_1st_bit(&b);
-     switch (type_of(pos.piece_on(from)))
-     {
-      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
-      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
-      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, mlist, from); break;
-      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, mlist, from);   break;
-      case KING:   mlist = generate_discovered_checks<KING>(pos, mlist, from);   break;
-      default: assert(false); break;
-     }
-  }
-
-  // Direct non-capture checks
-  mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
-  mlist = generate_direct_checks<ROOK>(pos, mlist, us, dc, ksq);
-  return  generate_direct_checks<QUEEN>(pos, mlist, us, dc, ksq);
-}
-
-
-/// generate<MV_EVASION> generates all pseudo-legal check evasions when the side
-/// 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) {
-
-  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);
-  Bitboard checkers = pos.checkers();
-  Bitboard sliderAttacks = 0;
-
-  assert(pos.piece_on(ksq) == make_piece(us, KING));
-  assert(checkers);
-
-  // Find squares attacked by slider checkers, we will remove
-  // them from the king evasions set so to early skip known
-  // illegal moves and avoid an useless legality check later.
-  b = checkers;
-  do
-  {
-      checkersCnt++;
-      checksq = pop_1st_bit(&b);
-
-      assert(color_of(pos.piece_on(checksq)) == flip(us));
-
-      switch (type_of(pos.piece_on(checksq)))
-      {
-      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
-      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
-      case QUEEN:
-          // If queen and king are far we can safely remove all the squares attacked
-          // in the other direction becuase are not reachable by the king anyway.
-          if (squares_between(ksq, checksq) || (RookPseudoAttacks[checksq] & (1ULL << ksq)))
-              sliderAttacks |= QueenPseudoAttacks[checksq];
-
-          // Otherwise, if king and queen are adjacent and on a diagonal line, we need to
-          // use real rook attacks to check if king is safe to move in the other direction.
-          // For example: king in B2, queen in A1 a knight in B1, and we can safely move to C1.
-          else
-              sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
-
-      default:
-          break;
-      }
-  } while (b);
-
-  // Generate evasions for king, capture and non capture moves
-  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
-  from = ksq;
-  SERIALIZE_MOVES(b);
-
-  // Generate evasions for other pieces only if not double check
-  if (checkersCnt > 1)
-      return mlist;
-
-  // Find squares where a blocking evasion or a capture of the
-  // checker piece is possible.
-  target = squares_between(checksq, ksq) | checkers;
-
-  mlist = generate_piece_moves<PAWN, MV_EVASION>(pos, mlist, us, target);
-  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
-  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
-  return  generate_piece_moves<QUEEN>(pos, mlist, us, target);
-}
-
-
-/// generate<MV_LEGAL> computes a complete list of legal moves in the current position
-
-template<>
-MoveStack* generate<MV_LEGAL>(const Position& pos, MoveStack* mlist) {
-
-  MoveStack *last, *cur = mlist;
-  Bitboard pinned = pos.pinned_pieces();
-
-  last = pos.in_check() ? generate<MV_EVASION>(pos, mlist)
-                        : generate<MV_NON_EVASION>(pos, mlist);
-
-  // Remove illegal moves from the list
-  while (cur != last)
-      if (!pos.pl_move_is_legal(cur->move, pinned))
-          cur->move = (--last)->move;
-      else
-          cur++;
-
-  return last;
-}
-
-
-namespace {
-
-  template<Square Delta>
-  inline Bitboard move_pawns(Bitboard p) {
-
-    return Delta == DELTA_N  ? p << 8 : Delta == DELTA_S  ? p >> 8 :
-           Delta == DELTA_NE ? p << 9 : Delta == DELTA_SE ? p >> 7 :
-           Delta == DELTA_NW ? p << 7 : Delta == DELTA_SW ? p >> 9 : p;
-  }
-
-  template<Square Delta>
-  inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
-    b = move_pawns<Delta>(pawns) & target & ~TFileABB;
-    SERIALIZE_MOVES_D(b, -Delta);
-    return mlist;
-  }
-
-  template<MoveType Type, Square Delta>
-  inline MoveStack* generate_promotions(const Position& pos, MoveStack* mlist, Bitboard pawnsOn7, Bitboard target) {
-
-    const Bitboard TFileABB = (Delta == DELTA_NE || Delta == DELTA_SE ? FileABB : FileHBB);
-
-    Bitboard b;
-    Square to;
-
-    // Promotions and under-promotions, both captures and non-captures
-    b = move_pawns<Delta>(pawnsOn7) & target;
-
-    if (Delta != DELTA_N && Delta != DELTA_S)
-        b &= ~TFileABB;
-
-    while (b)
-    {
-        to = pop_1st_bit(&b);
-
-        if (Type == MV_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
-            (*mlist++).move = make_promotion(to - Delta, to, QUEEN);
-
-        if (Type == MV_NON_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
-        {
-            (*mlist++).move = make_promotion(to - Delta, to, ROOK);
-            (*mlist++).move = make_promotion(to - Delta, to, BISHOP);
-            (*mlist++).move = make_promotion(to - Delta, to, KNIGHT);
-        }
-
-        // This is the only possible under promotion that can give a check
-        // not already included in the queen-promotion.
-        if (   Type == MV_CHECK
-            && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(Delta > 0 ? BLACK : WHITE)))
-            (*mlist++).move = make_promotion(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   UP        = (Us == WHITE ? DELTA_N  : DELTA_S);
-    const Square   RIGHT_UP  = (Us == WHITE ? DELTA_NE : DELTA_SW);
-    const Square   LEFT_UP   = (Us == WHITE ? DELTA_NW : DELTA_SE);
-
-    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(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<UP>(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<Type, RIGHT_UP>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Type, LEFT_UP>(pos, mlist, pawnsOn7, enemyPieces);
-        mlist = generate_promotions<Type, UP>(pos, mlist, pawnsOn7, emptySquares);
-    }
-
-    // Standard captures
-    if (Type == MV_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
-    {
-        mlist = generate_pawn_captures<RIGHT_UP>(mlist, pawns, enemyPieces);
-        mlist = generate_pawn_captures<LEFT_UP>(mlist, pawns, enemyPieces);
-    }
-
-    // Single and double pawn pushes
-    if (Type != MV_CAPTURE)
-    {
-        b1 = (Type != MV_EVASION ? pawnPushes : pawnPushes & emptySquares);
-        b2 = move_pawns<UP>(pawnPushes & TRank3BB) & emptySquares;
-
-        if (Type == MV_CHECK)
-        {
-            // Consider only pawn moves which give direct checks
-            b1 &= pos.attacks_from<PAWN>(ksq, Them);
-            b2 &= pos.attacks_from<PAWN>(ksq, Them);
-
-            // Add pawn moves which gives discovered check. This is possible only
-            // 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<UP>(pawns & target & ~file_bb(ksq)) & emptySquares;
-                dc2 = move_pawns<UP>(dc1 & TRank3BB) & emptySquares;
-
-                b1 |= dc1;
-                b2 |= dc2;
-            }
-        }
-        SERIALIZE_MOVES_D(b1, -UP);
-        SERIALIZE_MOVES_D(b2, -UP -UP);
-    }
-
-    // En passant captures
-    if (  (Type == MV_CAPTURE || Type == MV_EVASION || Type == MV_NON_EVASION)
-        && pos.ep_square() != SQ_NONE)
-    {
-        assert(Us != WHITE || rank_of(pos.ep_square()) == RANK_6);
-        assert(Us != BLACK || rank_of(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() - UP))
-            return mlist;
-
-        b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
-
-        assert(b1);
-
-        while (b1)
-        {
-            to = pop_1st_bit(&b1);
-            (*mlist++).move = make_enpassant(to, pos.ep_square());
-        }
-    }
-    return mlist;
-  }
-
-  template<CastlingSide Side>
-  MoveStack* generate_castle_moves(const Position& pos, MoveStack* mlist, Color us) {
-
-    CastleRight f = CastleRight((Side == KING_SIDE ? WHITE_OO : WHITE_OOO) << us);
-    Color them = flip(us);
-
-    // After castling, the rook and king's final positions are exactly the same
-    // in Chess960 as they would be in standard chess.
+    // 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(f);
+    Square rfrom = pos.castle_rook_square(us, Side);
     Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
-    Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
+    Bitboard enemies = pos.pieces(~us);
 
-    assert(!pos.in_check());
-    assert(pos.piece_on(kfrom) == make_piece(us, KING));
-    assert(pos.piece_on(rfrom) == make_piece(us, ROOK));
+    assert(!pos.checkers());
 
-    // Unimpeded rule: All the squares between the king's initial and final squares
-    // (including the final square), and all the squares between the rook's initial
-    // and final squares (including the final square), must be vacant except for
-    // the king and castling rook.
-    for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); s++)
-        if (  (s != kfrom && s != rfrom && !pos.square_is_empty(s))
-            ||(pos.attackers_to(s) & pos.pieces(them)))
-            return mlist;
+    const int K = Chess960 ? kto > kfrom ? -1 : 1
+                           : Side == KING_SIDE ? -1 : 1;
 
-    for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); s++)
-        if (s != kfrom && s != rfrom && !pos.square_is_empty(s))
+    for (Square s = kto; s != kfrom; s += (Square)K)
+        if (pos.attackers_to(s) & enemies)
             return mlist;
 
     // 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 (pos.is_chess960())
-    {
-        Bitboard occ = pos.occupied_squares();
-        clear_bit(&occ, rfrom);
-        if (pos.attackers_to(kto, occ) & pos.pieces(them))
-            return mlist;
-    }
+    if (Chess960 && (attacks_bb<ROOK>(kto, pos.pieces() ^ rfrom) & pos.pieces(~us, ROOK, QUEEN)))
+        return mlist;
 
-    (*mlist++).move = make_castle(kfrom, rfrom);
+    (mlist++)->move = make<CASTLE>(kfrom, rfrom);
+
+    if (Checks && !pos.gives_check((mlist - 1)->move, CheckInfo(pos)))
+        --mlist;
 
     return mlist;
   }
 
+
+  template<GenType Type, Square Delta>
+  inline ExtMove* generate_promotions(ExtMove* mlist, Bitboard pawnsOn7,
+                                      Bitboard target, const CheckInfo* ci) {
+
+    Bitboard b = shift_bb<Delta>(pawnsOn7) & target;
+
+    while (b)
+    {
+        Square to = pop_lsb(&b);
+
+        if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, QUEEN);
+
+        if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS)
+        {
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, ROOK);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, BISHOP);
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, KNIGHT);
+        }
+
+        // Knight-promotion is the only one that can give a direct check not
+        // already included in the queen-promotion.
+        if (Type == QUIET_CHECKS && (StepAttacksBB[W_KNIGHT][to] & ci->ksq))
+            (mlist++)->move = make<PROMOTION>(to - Delta, to, KNIGHT);
+        else
+            (void)ci; // Silence a warning under MSVC
+    }
+
+    return mlist;
+  }
+
+
+  template<Color Us, GenType Type>
+  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());
+        }
+    }
+
+    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;
+  }
+
+
+  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<QUIETS> generates all pseudo-legal non-captures and
+/// underpromotions. Returns a pointer to the end of the move list.
+///
+/// generate<NON_EVASIONS> generates all pseudo-legal captures and
+/// non-captures. Returns a pointer to the end of the move list.
+
+template<GenType Type>
+ExtMove* generate(const Position& pos, ExtMove* mlist) {
+
+  assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS);
+  assert(!pos.checkers());
+
+  Color us = pos.side_to_move();
+
+  Bitboard target = Type == CAPTURES     ?  pos.pieces(~us)
+                  : Type == QUIETS       ? ~pos.pieces()
+                  : Type == NON_EVASIONS ? ~pos.pieces(us) : 0;
+
+  return us == WHITE ? generate_all<WHITE, Type>(pos, mlist, target)
+                     : generate_all<BLACK, Type>(pos, mlist, target);
+}
+
+// Explicit template instantiations
+template ExtMove* generate<CAPTURES>(const Position&, ExtMove*);
+template ExtMove* generate<QUIETS>(const Position&, ExtMove*);
+template ExtMove* generate<NON_EVASIONS>(const Position&, ExtMove*);
+
+
+/// generate<QUIET_CHECKS> generates all pseudo-legal non-captures and knight
+/// underpromotions that give check. Returns a pointer to the end of the move list.
+template<>
+ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* mlist) {
+
+  assert(!pos.checkers());
+
+  Color us = pos.side_to_move();
+  CheckInfo ci(pos);
+  Bitboard dc = ci.dcCandidates;
+
+  while (dc)
+  {
+     Square from = pop_lsb(&dc);
+     PieceType pt = type_of(pos.piece_on(from));
+
+     if (pt == PAWN)
+         continue; // Will be generated togheter with direct checks
+
+     Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.pieces();
+
+     if (pt == KING)
+         b &= ~PseudoAttacks[QUEEN][ci.ksq];
+
+     SERIALIZE(b);
+  }
+
+  return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci)
+                     : generate_all<BLACK, QUIET_CHECKS>(pos, mlist, ~pos.pieces(), &ci);
+}
+
+
+/// generate<EVASIONS> generates all pseudo-legal check evasions when the side
+/// to move is in check. Returns a pointer to the end of the move list.
+template<>
+ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* mlist) {
+
+  assert(pos.checkers());
+
+  int checkersCnt = 0;
+  Color us = pos.side_to_move();
+  Square ksq = pos.king_square(us), from = ksq /* For SERIALIZE */, checksq;
+  Bitboard sliderAttacks = 0;
+  Bitboard b = pos.checkers();
+
+  assert(pos.checkers());
+
+  // Find squares attacked by slider checkers, we will remove them from the king
+  // evasions so to skip known illegal moves avoiding useless legality check later.
+  do
+  {
+      ++checkersCnt;
+      checksq = pop_lsb(&b);
+
+      assert(color_of(pos.piece_on(checksq)) == ~us);
+
+      if (type_of(pos.piece_on(checksq)) > KNIGHT) // A slider
+          sliderAttacks |= LineBB[checksq][ksq] ^ checksq;
+
+  } while (b);
+
+  // Generate evasions for king, capture and non capture moves
+  b = pos.attacks_from<KING>(ksq) & ~pos.pieces(us) & ~sliderAttacks;
+  SERIALIZE(b);
+
+  if (checkersCnt > 1)
+      return mlist; // Double check, only a king move can save the day
+
+  // Generate blocking evasions or captures of the checking piece
+  Bitboard target = between_bb(checksq, ksq) | checksq;
+
+  return us == WHITE ? generate_all<WHITE, EVASIONS>(pos, mlist, target)
+                     : generate_all<BLACK, EVASIONS>(pos, mlist, target);
+}
+
+
+/// generate<LEGAL> generates all the legal moves in the given position
+
+template<>
+ExtMove* generate<LEGAL>(const Position& pos, ExtMove* mlist) {
+
+  ExtMove *end, *cur = mlist;
+  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
+  Square ksq = pos.king_square(pos.side_to_move());
+
+  end = pos.checkers() ? generate<EVASIONS>(pos, mlist)
+                       : generate<NON_EVASIONS>(pos, mlist);
+  while (cur != end)
+      if (   (pinned || from_sq(cur->move) == ksq || type_of(cur->move) == ENPASSANT)
+          && !pos.legal(cur->move, pinned))
+          cur->move = (--end)->move;
+      else
+          ++cur;
+
+  return end;
+}

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-2012 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,40 +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 "types.h"
 
-enum MoveType {
-  MV_CAPTURE,
-  MV_NON_CAPTURE,
-  MV_CHECK,
-  MV_NON_CAPTURE_CHECK,
-  MV_EVASION,
-  MV_NON_EVASION,
-  MV_LEGAL
+enum GenType {
+  CAPTURES,
+  QUIETS,
+  QUIET_CHECKS,
+  EVASIONS,
+  NON_EVASIONS,
+  LEGAL
 };
 
 class Position;
 
-template<MoveType>
-MoveStack* generate(const Position& pos, MoveStack* mlist);
+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<MoveType T>
+template<GenType T>
 struct MoveList {
 
-  explicit MoveList(const Position& pos) : cur(mlist), last(generate<T>(pos, mlist)) {}
-  void operator++() { cur++; }
-  bool end() const { return cur == last; }
-  Move move() const { return cur->move; }
-  int size() const { return int(last - mlist); }
+  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:
-  MoveStack mlist[MAX_MOVES];
-  MoveStack *cur, *last;
+  ExtMove mlist[MAX_MOVES];
+  ExtMove *cur, *last;
 };
 
-#endif // !defined(MOVEGEN_H_INCLUDED)
+#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-2012 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,223 +18,132 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <algorithm>
 #include <cassert>
 
-#include "movegen.h"
 #include "movepick.h"
-#include "search.h"
-#include "types.h"
+#include "thread.h"
 
 namespace {
 
-  enum MovegenPhase {
-    PH_TT_MOVE,       // Transposition table move
-    PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= captureThreshold (captureThreshold <= 0)
-    PH_GOOD_PROBCUT,  // Queen promotions and captures with SEE values > captureThreshold (captureThreshold >= 0)
-    PH_KILLERS,       // Killer moves from the current ply
-    PH_NONCAPTURES_1, // Non-captures and underpromotions with positive score
-    PH_NONCAPTURES_2, // Non-captures and underpromotions with non-positive score
-    PH_BAD_CAPTURES,  // Queen promotions and captures with SEE values < captureThreshold (captureThreshold <= 0)
-    PH_EVASIONS,      // Check evasions
-    PH_QCAPTURES,     // Captures in quiescence search
-    PH_QRECAPTURES,   // Recaptures in quiescence search
-    PH_QCHECKS,       // Non-capture checks in quiescence search
-    PH_STOP
+  enum Stages {
+    MAIN_SEARCH, CAPTURES_S1, KILLERS_S1, QUIETS_1_S1, QUIETS_2_S1, BAD_CAPTURES_S1,
+    EVASION,     EVASIONS_S2,
+    QSEARCH_0,   CAPTURES_S3, QUIET_CHECKS_S3,
+    QSEARCH_1,   CAPTURES_S4,
+    PROBCUT,     CAPTURES_S5,
+    RECAPTURE,   CAPTURES_S6,
+    STOP
   };
 
-  CACHE_LINE_ALIGNMENT
-  const uint8_t MainSearchTable[] = { PH_TT_MOVE, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES_1, PH_NONCAPTURES_2, PH_BAD_CAPTURES, PH_STOP };
-  const uint8_t EvasionTable[] = { PH_TT_MOVE, PH_EVASIONS, PH_STOP };
-  const uint8_t QsearchWithChecksTable[] = { PH_TT_MOVE, PH_QCAPTURES, PH_QCHECKS, PH_STOP };
-  const uint8_t QsearchWithoutChecksTable[] = { PH_TT_MOVE, PH_QCAPTURES, PH_STOP };
-  const uint8_t QsearchRecapturesTable[] = { PH_TT_MOVE, PH_QRECAPTURES, PH_STOP };
-  const uint8_t ProbCutTable[] = { PH_TT_MOVE, PH_GOOD_PROBCUT, PH_STOP };
+  // Our insertion sort, guaranteed to be stable, as is needed
+  void insertion_sort(ExtMove* begin, ExtMove* end)
+  {
+    ExtMove tmp, *p, *q;
+
+    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 MoveStack& move) { return move.score > 0; }
+  inline bool has_positive_score(const ExtMove& ms) { return ms.score > 0; }
 
-  // Picks and pushes to the front the best move in range [firstMove, lastMove),
+  // Picks and moves to the front the best move in the range [begin, end),
   // it is faster than sorting all the moves in advance when moves are few, as
   // normally are the possible captures.
-  inline MoveStack* pick_best(MoveStack* firstMove, MoveStack* lastMove)
+  inline ExtMove* pick_best(ExtMove* begin, ExtMove* end)
   {
-      std::swap(*firstMove, *std::max_element(firstMove, lastMove));
-      return firstMove;
+      std::swap(*begin, *std::max_element(begin, end));
+      return begin;
   }
 }
 
-/// Constructors for the MovePicker class. As arguments we pass information
+
+/// Constructors of the MovePicker class. As arguments we pass information
 /// to help it to return the presumably good moves first, to decide which
 /// moves to return (in the quiescence search, for instance, we only want to
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       Search::Stack* ss, Value beta) : pos(p), H(h), depth(d) {
-  captureThreshold = 0;
-  badCaptures = moves + MAX_MOVES;
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
+                       Move* cm, Search::Stack* s) : pos(p), history(h), depth(d) {
 
   assert(d > DEPTH_ZERO);
 
-  if (p.in_check())
-  {
-      killers[0].move = killers[1].move = MOVE_NONE;
-      phasePtr = EvasionTable;
-  }
+  cur = end = moves;
+  endBadCaptures = moves + MAX_MOVES - 1;
+  countermoves = cm;
+  ss = s;
+
+  if (p.checkers())
+      stage = EVASION;
+
   else
-  {
-      killers[0].move = ss->killers[0];
-      killers[1].move = ss->killers[1];
+      stage = MAIN_SEARCH;
 
-      // Consider sligtly negative captures as good if at low depth and far from beta
-      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
-          captureThreshold = -PawnValueMidgame;
-
-      // Consider negative captures as good if still enough to reach beta
-      else if (ss && ss->eval > beta)
-          captureThreshold = beta - ss->eval;
-
-      phasePtr = MainSearchTable;
-  }
-
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
-  go_next_phase();
+  ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE);
+  end += (ttMove != MOVE_NONE);
 }
 
-MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h, Square recaptureSq)
-                      : pos(p), H(h) {
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
+                       Square sq) : pos(p), history(h), cur(moves), end(moves) {
 
   assert(d <= DEPTH_ZERO);
 
-  if (p.in_check())
-      phasePtr = EvasionTable;
-  else if (d >= DEPTH_QS_CHECKS)
-      phasePtr = QsearchWithChecksTable;
-  else if (d >= DEPTH_QS_RECAPTURES)
-  {
-      phasePtr = QsearchWithoutChecksTable;
+  if (p.checkers())
+      stage = EVASION;
 
-      // Skip TT move if is not a capture or a promotion, this avoids
-      // qsearch tree explosion due to a possible perpetual check or
-      // similar rare cases when TT table is full.
-      if (ttm != MOVE_NONE && !pos.is_capture_or_promotion(ttm))
+  else if (d > DEPTH_QS_NO_CHECKS)
+      stage = QSEARCH_0;
+
+  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.capture_or_promotion(ttm))
           ttm = MOVE_NONE;
   }
   else
   {
-      phasePtr = QsearchRecapturesTable;
-      recaptureSquare = recaptureSq;
+      stage = RECAPTURE;
+      recaptureSquare = sq;
       ttm = MOVE_NONE;
   }
 
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
-  go_next_phase();
+  ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE);
+  end += (ttMove != MOVE_NONE);
 }
 
-MovePicker::MovePicker(const Position& p, Move ttm, const History& h, PieceType parentCapture)
-                       : pos(p), H(h) {
+MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, PieceType pt)
+                       : pos(p), history(h), cur(moves), end(moves) {
 
-  assert (!pos.in_check());
+  assert(!pos.checkers());
 
-  // In ProbCut we consider only captures better than parent's move
-  captureThreshold = PieceValueMidgame[Piece(parentCapture)];
-  phasePtr = ProbCutTable;
+  stage = PROBCUT;
 
-  if (   ttm != MOVE_NONE
-      && (!pos.is_capture(ttm) ||  pos.see(ttm) <= captureThreshold))
-      ttm = MOVE_NONE;
+  // In ProbCut we generate only captures better than parent's captured piece
+  captureThreshold = PieceValue[MG][pt];
+  ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE);
 
-  ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);
-  phasePtr += int(ttMove == MOVE_NONE) - 1;
-  go_next_phase();
+  if (ttMove && (!pos.capture(ttMove) || pos.see(ttMove) <= captureThreshold))
+      ttMove = MOVE_NONE;
+
+  end += (ttMove != MOVE_NONE);
 }
 
 
-/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
-/// of moves when there are no more moves to try for the current phase.
-
-void MovePicker::go_next_phase() {
-
-  curMove = moves;
-  phase = *(++phasePtr);
-  switch (phase) {
-
-  case PH_TT_MOVE:
-      lastMove = curMove + 1;
-      return;
-
-  case PH_GOOD_CAPTURES:
-  case PH_GOOD_PROBCUT:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_KILLERS:
-      curMove = killers;
-      lastMove = curMove + 2;
-      return;
-
-  case PH_NONCAPTURES_1:
-      lastNonCapture = lastMove = generate<MV_NON_CAPTURE>(pos, moves);
-      score_noncaptures();
-      lastMove = std::partition(curMove, lastMove, has_positive_score);
-      sort<MoveStack>(curMove, lastMove);
-      return;
-
-  case PH_NONCAPTURES_2:
-      curMove = lastMove;
-      lastMove = lastNonCapture;
-      if (depth >= 3 * ONE_PLY)
-          sort<MoveStack>(curMove, lastMove);
-      return;
-
-  case PH_BAD_CAPTURES:
-      // Bad captures SEE value is already calculated so just pick
-      // them in order to get SEE move ordering.
-      curMove = badCaptures;
-      lastMove = moves + MAX_MOVES;
-      return;
-
-  case PH_EVASIONS:
-      assert(pos.in_check());
-      lastMove = generate<MV_EVASION>(pos, moves);
-      score_evasions();
-      return;
-
-  case PH_QCAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      score_captures();
-      return;
-
-  case PH_QRECAPTURES:
-      lastMove = generate<MV_CAPTURE>(pos, moves);
-      return;
-
-  case PH_QCHECKS:
-      lastMove = generate<MV_NON_CAPTURE_CHECK>(pos, moves);
-      return;
-
-  case PH_STOP:
-      lastMove = curMove + 1; // Avoid another go_next_phase() call
-      return;
-
-  default:
-      assert(false);
-      return;
-  }
-}
-
-
-/// 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 next_move().
-
-void MovePicker::score_captures() {
+/// score() assign a numerical move ordering score to each move in a move list.
+/// The moves with highest scores will be picked first.
+template<>
+void MovePicker::score<CAPTURES>() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
   // Suprisingly, this appears to perform slightly better than SEE based
   // move ordering. The reason is probably that in a position with a winning
@@ -250,150 +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 (MoveStack* cur = moves; cur != lastMove; cur++)
+  for (ExtMove* it = moves; it != end; ++it)
   {
-      m = cur->move;
-      cur->score =  PieceValueMidgame[pos.piece_on(to_sq(m))]
-                  - type_of(pos.piece_on(from_sq(m)));
+      m = it->move;
+      it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                 - type_of(pos.moved_piece(m));
 
-      if (is_promotion(m))
-          cur->score += PieceValueMidgame[Piece(promotion_piece_type(m))];
+      if (type_of(m) == PROMOTION)
+          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;
-      from = from_sq(m);
-      cur->score = H.value(pos.piece_on(from), to_sq(m));
+      m = it->move;
+      it->score = history[pos.moved_piece(m)][to_sq(m)];
   }
 }
 
-void MovePicker::score_evasions() {
-  // Try good captures ordered by MVV/LVA, then non-captures if
-  // destination square is not under attack, ordered by history
-  // value, and at the end bad-captures and non-captures with a
-  // negative SEE. This last group is ordered by the SEE score.
+template<>
+void MovePicker::score<EVASIONS>() {
+  // Try good captures ordered by MVV/LVA, then non-captures if destination square
+  // is not under attack, ordered by history value, then bad-captures and quiet
+  // moves with a negative SEE. This last group is ordered by the SEE score.
   Move m;
   int seeScore;
 
-  // Skip if we don't have at least two moves to order
-  if (lastMove < moves + 2)
-      return;
-
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  for (ExtMove* it = moves; it != end; ++it)
   {
-      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
-      else if (pos.is_capture(m))
-          cur->score =  PieceValueMidgame[pos.piece_on(to_sq(m))]
-                      - type_of(pos.piece_on(from_sq(m))) + History::MaxValue;
+          it->score = seeScore - HistoryStats::Max; // At the bottom
+
+      else if (pos.capture(m))
+          it->score =  PieceValue[MG][pos.piece_on(to_sq(m))]
+                     - type_of(pos.moved_piece(m)) + HistoryStats::Max;
       else
-          cur->score = H.value(pos.piece_on(from_sq(m)), to_sq(m));
+          it->score = history[pos.moved_piece(m)][to_sq(m)];
   }
 }
 
-/// MovePicker::next_move() is the most important method of the MovePicker class.
-/// It returns a new pseudo legal move every time it is called, until there
-/// are no more moves left. It picks the move with the biggest 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::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)
-          go_next_phase();
+      while (cur == end)
+          generate_next();
 
-      switch (phase) {
+      switch (stage) {
 
-      case PH_TT_MOVE:
-          curMove++;
+      case MAIN_SEARCH: case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT:
+          ++cur;
           return ttMove;
-          break;
 
-      case PH_GOOD_CAPTURES:
-          move = pick_best(curMove++, lastMove)->move;
+      case CAPTURES_S1:
+          move = pick_best(cur++, end)->move;
           if (move != ttMove)
           {
-              assert(captureThreshold <= 0); // Otherwise we must use see instead of see_sign
-
-              // Check for a non negative SEE now
-              int seeValue = pos.see_sign(move);
-              if (seeValue >= captureThreshold)
+              if (pos.see_sign(move) >= 0)
                   return move;
 
               // Losing capture, move it to the tail of the array
-              (--badCaptures)->move = move;
-              badCaptures->score = seeValue;
+              (endBadCaptures--)->move = move;
           }
           break;
 
-     case PH_GOOD_PROBCUT:
-          move = pick_best(curMove++, lastMove)->move;
-          if (   move != ttMove
-              && pos.see(move) > captureThreshold)
+      case KILLERS_S1:
+          move = (cur++)->move;
+          if (    move != MOVE_NONE
+              &&  pos.pseudo_legal(move)
+              &&  move != ttMove
+              && !pos.capture(move))
               return move;
           break;
 
-      case PH_KILLERS:
-          move = (curMove++)->move;
-          if (   move != MOVE_NONE
-              && pos.is_pseudo_legal(move)
-              && move != ttMove
-              && !pos.is_capture(move))
-              return move;
-          break;
-
-      case PH_NONCAPTURES_1:
-      case PH_NONCAPTURES_2:
-          move = (curMove++)->move;
+      case QUIETS_1_S1: case QUIETS_2_S1:
+          move = (cur++)->move;
           if (   move != ttMove
               && move != killers[0].move
-              && move != killers[1].move)
+              && move != killers[1].move
+              && move != killers[2].move
+              && move != killers[3].move)
               return move;
           break;
 
-      case PH_BAD_CAPTURES:
-          move = pick_best(curMove++, lastMove)->move;
-          return move;
+      case BAD_CAPTURES_S1:
+          return (cur--)->move;
 
-      case PH_EVASIONS:
-      case PH_QCAPTURES:
-          move = pick_best(curMove++, lastMove)->move;
+      case EVASIONS_S2: case CAPTURES_S3: case CAPTURES_S4:
+          move = pick_best(cur++, end)->move;
           if (move != ttMove)
               return move;
           break;
 
-      case PH_QRECAPTURES:
-          move = (curMove++)->move;
+      case CAPTURES_S5:
+           move = pick_best(cur++, end)->move;
+           if (move != ttMove && pos.see(move) > captureThreshold)
+               return move;
+           break;
+
+      case CAPTURES_S6:
+          move = pick_best(cur++, end)->move;
           if (to_sq(move) == recaptureSquare)
               return move;
           break;
 
-      case PH_QCHECKS:
-          move = (curMove++)->move;
+      case QUIET_CHECKS_S3:
+          move = (cur++)->move;
           if (move != ttMove)
               return move;
           break;
 
-      case PH_STOP:
+      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-2012 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,48 +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 <cstring>   // For std::memset
+
+#include "movegen.h"
 #include "position.h"
 #include "search.h"
 #include "types.h"
 
-/// MovePicker is a class which is used to pick one pseudo legal move at a time
-/// from the current position. It is initialized with a Position object and a few
-/// moves we have reason to believe are good. The most important method is
-/// MovePicker::next_move(), which returns a new pseudo legal move each time
-/// it is called, until there are no moves left, when MOVE_NONE is returned.
-/// In order to improve the efficiency of the alpha beta algorithm, MovePicker
-/// attempts to return the moves which are most likely to get a cut-off first.
+
+/// The Stats struct stores moves statistics. According to the template parameter
+/// the class can store History, Gains and Countermoves. History records how often
+/// different moves have been successful or unsuccessful during the current search
+/// and is used for reduction and move ordering decisions. Gains records the move's
+/// best evaluation gain from one ply to the next and is used for pruning decisions.
+/// Countermoves store the move that refute a previous one. Entries are stored
+/// 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&, Search::Stack*, Value);
-  MovePicker(const Position&, Move, Depth, const History&, Square recaptureSq);
-  MovePicker(const Position&, Move, const History&, PieceType parentCapture);
-  Move next_move();
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Square);
+  MovePicker(const Position&, Move, const HistoryStats&, PieceType);
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Move*, Search::Stack*);
+
+  template<bool SpNode> Move next_move();
 
 private:
-  void score_captures();
-  void score_noncaptures();
-  void score_evasions();
-  void go_next_phase();
+  template<GenType> void score();
+  void generate_next();
 
   const Position& pos;
-  const History& H;
+  const HistoryStats& history;
+  Search::Stack* ss;
+  Move* countermoves;
   Depth depth;
   Move ttMove;
-  MoveStack killers[2];
+  ExtMove killers[4];
   Square recaptureSquare;
-  int captureThreshold, phase;
-  const uint8_t* phasePtr;
-  MoveStack *curMove, *lastMove, *lastNonCapture, *badCaptures;
-  MoveStack moves[MAX_MOVES];
+  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.legal(move, pos.pinned_pieces(pos.side_to_move())))
+                  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.capture(m))
+          san = file_to_char(file_of(from));
+
+      if (pos.capture(m))
+          san += 'x';
+
+      san += square_to_string(to);
+
+      if (type_of(m) == PROMOTION)
+          san += string("=") + PieceToChar[WHITE][promotion_type(m)];
+  }
+
+  if (pos.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 << double(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-2012 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,215 +27,262 @@
 
 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] = {
-  { 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) }};
+  // Doubled pawn penalty by file
+  const Score Doubled[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) };
 
   // 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) }};
+    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) }};
+    S(33, 31), S(33, 31), S(29, 31), S(20, 28) } };
 
-  // Pawn chain membership bonus by file
-  const Score ChainBonus[8] = {
-    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
-    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
-  };
+  // Pawn chain membership bonus by file and rank (initialized by formula)
+  Score ChainMember[FILE_NB][RANK_NB];
 
   // 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)
-  };
+    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 horizon.
+  const Value MaxSafetyBonus = V(263);
 
   #undef S
+  #undef V
 
-  inline Score apply_weight(Score v, Score w) {
-    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
-                      (int(eg_value(v)) * eg_value(w)) / 0x100);
+  template<Color Us>
+  Score evaluate(const Position& pos, Pawns::Entry* e) {
+
+    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;
+    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] = e->candidatePawns[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);
+
+        // This file cannot be semi-open
+        e->semiopenFiles[Us] &= ~(1 << f);
+
+        // Our rank plus previous one. Used for chain detection
+        b = rank_bb(s) | rank_bb(s - pawn_push(Us));
+
+        // 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.
+        // 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))
+            backward = false;
+        else
+        {
+            // We now know that there are no friendly pawns beside or behind this
+            // pawn on adjacent files. We now check whether the pawn is
+            // backward by looking in the forward direction on the adjacent
+            // files, and picking the closest pawn there.
+            b = pawn_attack_span(Us, s) & (ourPawns | theirPawns);
+            b = pawn_attack_span(Us, s) & rank_bb(backmost_sq(Us, b));
+
+            // If we have an enemy pawn in the same or next rank, the pawn is
+            // backward because it cannot advance without being captured.
+            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[f];
+
+        if (backward)
+            value -= Backward[opposed][f];
+
+        if (chain)
+            value += ChainMember[f][relative_rank(Us, s)];
+
+        if (candidate)
+        {
+            value += CandidatePassed[relative_rank(Us, s)];
+
+            if (!doubled)
+                e->candidatePawns[Us] |= s;
+        }
+    }
+
+    return value;
   }
+
+} // namespace
+
+namespace Pawns {
+
+/// init() initializes some tables by formula instead of hard-code their values
+
+void init() {
+
+  const int chainByFile[8] = { 1, 3, 3, 4, 4, 3, 3, 1 };
+  int bonus;
+
+  for (Rank r = RANK_1; r < RANK_8; ++r)
+      for (File f = FILE_A; f <= FILE_H; ++f)
+      {
+          bonus = r * (r-1) * (r-2) + chainByFile[f] * (r/2 + 1);
+          ChainMember[f][r] = make_score(bonus, bonus);
+      }
 }
 
 
-/// PawnInfoTable::pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it. The result is also stored
-/// in an hash table, so we don't have to recompute everything when the same
-/// pawn structure occurs again.
+/// 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.
 
-PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
+Entry* probe(const Position& pos, Table& entries) {
 
   Key key = pos.pawn_key();
-  PawnInfo* pi = probe(key);
+  Entry* e = entries[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;
+  if (e->key == key)
+      return e;
 
-  // 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;
+  e->key = key;
+  e->value = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
+  return e;
 }
 
 
-/// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
+/// Entry::shelter_storm() calculates shelter and storm penalties for the file
+/// the king is on, as well as the two adjacent files.
 
 template<Color Us>
-Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                                    Bitboard theirPawns, PawnInfo* pi) {
+Value Entry::shelter_storm(const Position& pos, Square ksq) {
 
   const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-  Bitboard b;
-  Square s;
-  File f;
-  Rank r;
-  bool passed, isolated, doubled, opposed, chain, backward, candidate;
-  Score value = SCORE_ZERO;
-  const Square* pl = pos.piece_list(Us, PAWN);
+  Value safety = MaxSafetyBonus;
+  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq));
+  Bitboard ourPawns = b & pos.pieces(Us);
+  Bitboard theirPawns = b & pos.pieces(Them);
+  Rank rkUs, rkThem;
+  File kf = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
 
-  // Loop through all pawns of the current color and score each pawn
-  while ((s = *pl++) != SQ_NONE)
+  for (File f = kf - File(1); f <= kf + File(1); ++f)
   {
-      assert(pos.piece_on(s) == make_piece(Us, PAWN));
+      b = ourPawns & file_bb(f);
+      rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
+      safety -= ShelterWeakness[rkUs];
 
-      f = file_of(s);
-      r = rank_of(s);
-
-      // 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) != 0
-                 &&  popcount<Max15>(b) >= popcount<Max15>(attack_span_mask(Us, s) & theirPawns);
-
-      // Passed pawns will be properly scored in evaluation because we need
-      // full attack info to evaluate passed pawns. Only the frontmost passed
-      // pawn on each file is considered a true passed pawn.
-      if (passed && !doubled)
-          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)];
+      b  = theirPawns & file_bb(f);
+      rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
+      safety -= StormDanger[rkUs == RANK_1 ? 0 : rkThem == rkUs + 1 ? 2 : 1][rkThem];
   }
-  return value;
+
+  return safety;
 }
 
 
-/// PawnInfo::updateShelter() calculates and caches king shelter. It is called
-/// only when king square changes, about 20% of total king_shelter() calls.
+/// Entry::update_safety() calculates and caches a bonus for king safety. It is
+/// called only when king square changes, about 20% of total king_safety() calls.
+
 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(file_of(ksq));
-      r = ksq & (7 << 3);
-      for (int i = 0; i < 3; i++)
-      {
-          r += Shift;
-          shelter += BitCount8Bit[(pawns >> r) & 0xFF] << (6 - i);
-      }
-  }
   kingSquares[Us] = ksq;
-  kingShelters[Us] = make_score(shelter, 0);
-  return kingShelters[Us];
+  castleRights[Us] = pos.can_castle(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 it 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 PawnInfo::updateShelter<BLACK>(const Position& pos, Square ksq);
+template Score Entry::update_safety<WHITE>(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-2012 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,65 @@
   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
-/// structure. Currently, it only includes a middle game and an end game
-/// pawn structure evaluation, and a bitboard of passed pawns. We may want
-/// to add further information in the future. A lookup to the pawn hash
-/// table (performed by calling the pawn_info method in a PawnInfoTable
-/// object) returns a pointer to a PawnInfo object.
+/// Pawns::Entry contains various information about a pawn structure. Currently,
+/// it only includes a middle game and end game pawn structure evaluation, and a
+/// bitboard of passed pawns. We may want to add further information in the future.
+/// A lookup to the pawn hash table (performed by calling the probe function)
+/// returns a pointer to an Entry object.
 
-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]; }
+  Bitboard candidate_pawns(Color c) const { return candidatePawns[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:
-  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;
+    return semiopenFiles[c] & (left ? ((1 << int(f)) - 1) : ~((1 << int(f+1)) - 1));
+  }
 
   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 pawnAttacks[2];
-  Square kingSquares[2];
+  Bitboard passedPawns[COLOR_NB];
+  Bitboard candidatePawns[COLOR_NB];
+  Bitboard pawnAttacks[COLOR_NB];
+  Square kingSquares[COLOR_NB];
+  int minKPdistance[COLOR_NB];
+  int castleRights[COLOR_NB];
   Score value;
-  int halfOpenFiles[2];
-  Score kingShelters[2];
+  int semiopenFiles[COLOR_NB];
+  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
-/// method is pawn_info, which returns a pointer to a PawnInfo object.
+void init();
+Entry* probe(const Position& pos, Table& entries);
 
-class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
-public:
-  PawnInfo* 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 {
-  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)
+#endif // #ifndef 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-2012 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,10 +17,11 @@
   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 "types.h"
@@ -29,6 +30,7 @@
 /// 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 {
 
@@ -36,20 +38,21 @@ struct CheckInfo {
 
   Bitboard dcCandidates;
   Bitboard pinned;
-  Bitboard checkSq[8];
+  Bitboard checkSq[PIECE_TYPE_NB];
+  Square ksq;
 };
 
 
-/// The StateInfo struct stores information we need to restore a Position
+/// The StateInfo struct stores information needed to restore a Position
 /// object to its previous state when we retract a move. Whenever a move
-/// is made on the board (by calling Position::do_move), an StateInfo object
-/// must be passed as a parameter.
+/// is made on the board (by calling Position::do_move), a StateInfo
+/// object must be passed as a parameter.
 
 struct StateInfo {
   Key pawnKey, materialKey;
-  Value npMaterial[2];
+  Value npMaterial[COLOR_NB];
   int castleRights, rule50, pliesFromNull;
-  Score value;
+  Score psq;
   Square epSquare;
 
   Key key;
@@ -59,87 +62,55 @@ struct StateInfo {
 };
 
 
-/// The position data structure. A position consists of the following data:
-///
-///    * For each piece type, a bitboard representing the squares occupied
-///      by pieces of that type.
-///    * For each color, a bitboard representing the squares occupied by
-///      pieces of that color.
-///    * A bitboard of all occupied squares.
-///    * A bitboard of all checking pieces.
-///    * A 64-entry array of pieces, indexed by the squares of the board.
-///    * The current side to move.
-///    * Information about the castling rights for both sides.
-///    * The initial files of the kings and both pairs of rooks. This is
-///      used to implement the Chess960 castling rules.
-///    * The en passant square (which is SQ_NONE if no en passant capture is
-///      possible).
-///    * The squares of the kings for both sides.
-///    * Hash keys for the position itself, the current pawn structure, and
-///      the current material situation.
-///    * Hash keys for all previous positions in the game for detecting
-///      repetition draws.
-///    * A counter for detecting 50 move rule draws.
+/// 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 class stores the information regarding the board representation
+/// like pieces, side to move, hash keys, castling info, etc. The most important
+/// methods are do_move() and undo_move(), used by the search to update node info
+/// when traversing the search tree.
 
 class Position {
-
-  // No copy c'tor or assignment operator allowed
-  Position(const Position&);
-  Position& operator=(const Position&);
-
 public:
   Position() {}
-  Position(const Position& pos, int th) { copy(pos, th); }
-  Position(const std::string& fen, bool isChess960, int th);
+  Position(const Position& p, Thread* t) { *this = p; thisThread = t; }
+  Position(const std::string& f, bool c960, Thread* t) { set(f, c960, t); }
+  Position& operator=(const Position&);
+  static void init();
 
   // Text input/output
-  void copy(const Position& pos, int th);
-  void from_fen(const std::string& fen, bool isChess960);
-  const std::string to_fen() const;
-  void print(Move m = MOVE_NONE) const;
+  void set(const std::string& fen, bool isChess960, Thread* th);
+  const std::string fen() const;
+  const std::string pretty(Move m = MOVE_NONE) const;
 
-  // The piece on a given square
-  Piece piece_on(Square s) const;
-  bool square_is_empty(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(Color c) const;
+  // Position representation
+  Bitboard pieces() 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;
-
-  // Number of pieces of each color and type
-  int piece_count(Color c, PieceType pt) const;
-
-  // The en passant square
-  Square ep_square() const;
-
-  // Current king position for each color
+  Bitboard pieces(Color c) const;
+  Bitboard pieces(Color c, PieceType pt) const;
+  Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
+  Piece piece_on(Square s) const;
   Square king_square(Color c) const;
+  Square ep_square() const;
+  bool empty(Square s) const;
+  template<PieceType Pt> int count(Color c) const;
+  template<PieceType Pt> const Square* list(Color c) const;
 
-  // Castling rights
-  bool can_castle(CastleRight f) const;
-  bool can_castle(Color c) const;
-  Square castle_rook_square(CastleRight f) const;
+  // Castling
+  int can_castle(CastleRight f) const;
+  int can_castle(Color c) const;
+  bool castle_impeded(Color c, CastlingSide s) const;
+  Square castle_rook_square(Color c, CastlingSide s) const;
 
-  // Bitboards for pinned pieces and discovered check candidates
-  Bitboard discovered_check_candidates() const;
-  Bitboard pinned_pieces() const;
-
-  // Checking pieces and under check information
+  // Checking
   Bitboard checkers() const;
-  bool in_check() const;
+  Bitboard discovered_check_candidates() const;
+  Bitboard pinned_pieces(Color toMove) const;
 
-  // Piece lists
-  const Square* piece_list(Color c, PieceType pt) const;
-
-  // Information about attacks to or from a given square
+  // Attacks to/from a given square
   Bitboard attackers_to(Square s) const;
   Bitboard attackers_to(Square s, Bitboard occ) const;
   Bitboard attacks_from(Piece p, Square s) const;
@@ -148,28 +119,30 @@ public:
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool move_gives_check(Move m, const CheckInfo& ci) const;
-  bool move_attacks_square(Move m, Square s) const;
-  bool pl_move_is_legal(Move m, Bitboard pinned) const;
-  bool is_pseudo_legal(const Move m) const;
-  bool is_capture(Move m) const;
-  bool is_capture_or_promotion(Move m) const;
-  bool is_passed_pawn_push(Move m) const;
-
-  // Piece captured with previous moves
+  bool legal(Move m, Bitboard pinned) const;
+  bool pseudo_legal(const Move m) const;
+  bool capture(Move m) const;
+  bool capture_or_promotion(Move m) const;
+  bool gives_check(Move m, const CheckInfo& ci) const;
+  bool passed_pawn_push(Move m) const;
+  Piece moved_piece(Move m) const;
   PieceType captured_piece_type() const;
 
-  // Information about pawns
-  bool pawn_is_passed(Color c, Square s) const;
+  // Piece specific
+  bool pawn_passed(Color c, Square s) const;
+  bool pawn_on_7th(Color c) const;
+  bool bishop_pair(Color c) const;
+  bool opposite_bishops() const;
 
   // Doing and undoing moves
   void do_move(Move m, StateInfo& st);
   void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
   void undo_move(Move m);
-  template<bool Do> void do_null_move(StateInfo& st);
+  void do_null_move(StateInfo& st);
+  void undo_null_move();
 
   // Static exchange evaluation
-  int see(Move m) const;
+  int see(Move m, int asymmThreshold = 0) const;
   int see_sign(Move m) const;
 
   // Accessing hash keys
@@ -178,47 +151,34 @@ public:
   Key pawn_key() const;
   Key material_key() const;
 
-  // Incremental evaluation
-  Score value() const;
+  // Incremental piece-square evaluation
+  Score psq_score() const;
   Value non_pawn_material(Color c) const;
-  Score pst_delta(Piece piece, Square from, Square to) const;
-
-  // Game termination checks
-  bool is_mate() const;
-  template<bool SkipRepetition> bool is_draw() const;
-
-  // Plies from start position to the beginning of search
-  int startpos_ply_counter() const;
 
   // Other properties of the position
-  bool opposite_colored_bishops() const;
-  bool has_pawn_on_7th(Color c) const;
+  Color side_to_move() const;
+  int game_ply() const;
   bool is_chess960() const;
-
-  // Current thread ID searching on the position
-  int thread() const;
-
+  Thread* this_thread() const;
   int64_t nodes_searched() const;
   void set_nodes_searched(int64_t n);
+  bool is_draw() const;
 
   // Position consistency check, for debugging
   bool pos_is_ok(int* failedStep = NULL) const;
-  void flip_me();
-
-  // Global initialization
-  static void init();
+  void flip();
 
 private:
-
-  // Initialization helper functions (used while setting up a position)
+  // Initialization helpers (used while setting up a position)
   void clear();
-  void put_piece(Piece p, Square s);
-  void set_castle_right(Square ksq, Square rsq);
-  bool move_is_legal(const Move m) const;
+  void set_castle_right(Color c, Square rfrom);
 
-  // Helper template functions
-  template<bool Do> void do_castle_move(Move m);
-  template<bool FindPinned> Bitboard hidden_checkers() const;
+  // Helper functions
+  void do_castle(Square kfrom, Square kto, Square rfrom, Square rto);
+  Bitboard hidden_checkers(Square ksq, Color c, Color toMove) const;
+  void put_piece(Square s, Color c, PieceType pt);
+  void remove_piece(Square s, Color c, PieceType pt);
+  void move_piece(Square from, Square to, Color c, PieceType pt);
 
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
@@ -226,43 +186,28 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  Score pst(Piece p, Square s) const;
-  Score compute_value() const;
+  Score compute_psq_score() const;
   Value compute_non_pawn_material(Color c) const;
 
-  // Board
-  Piece board[64];             // [square]
-
-  // Bitboards
-  Bitboard byTypeBB[8];        // [pieceType]
-  Bitboard byColorBB[2];       // [color]
-  Bitboard occupied;
-
-  // Piece counts
-  int pieceCount[2][8];        // [color][pieceType]
-
-  // Piece lists
-  Square pieceList[2][8][16];  // [color][pieceType][index]
-  int index[64];               // [square]
+  // Board and pieces
+  Piece board[SQUARE_NB];
+  Bitboard byTypeBB[PIECE_TYPE_NB];
+  Bitboard byColorBB[COLOR_NB];
+  int pieceCount[COLOR_NB][PIECE_TYPE_NB];
+  Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
+  int index[SQUARE_NB];
 
   // Other info
-  int castleRightsMask[64];    // [square]
-  Square castleRookSquare[16]; // [castleRight]
+  int castleRightsMask[SQUARE_NB];
+  Square castleRookSquare[COLOR_NB][CASTLING_SIDE_NB];
+  Bitboard castlePath[COLOR_NB][CASTLING_SIDE_NB];
   StateInfo startState;
   int64_t nodes;
-  int startPosPly;
+  int gamePly;
   Color sideToMove;
-  int threadID;
+  Thread* thisThread;
   StateInfo* st;
   int chess960;
-
-  // Static variables
-  static Score pieceSquareTable[16][64]; // [piece][square]
-  static Key zobrist[2][8][64];          // [color][pieceType][square]/[piece count]
-  static Key zobEp[64];                  // [square]
-  static Key zobCastle[16];              // [castleRight]
-  static Key zobSideToMove;
-  static Key zobExclusion;
 };
 
 inline int64_t Position::nodes_searched() const {
@@ -277,7 +222,11 @@ inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
-inline bool Position::square_is_empty(Square s) const {
+inline Piece Position::moved_piece(Move m) const {
+  return board[from_sq(m)];
+}
+
+inline bool Position::empty(Square s) const {
   return board[s] == NO_PIECE;
 }
 
@@ -285,40 +234,36 @@ inline Color Position::side_to_move() const {
   return sideToMove;
 }
 
-inline Bitboard Position::occupied_squares() const {
-  return occupied;
-}
-
-inline Bitboard Position::empty_squares() const {
-  return ~occupied;
-}
-
-inline Bitboard Position::pieces(Color c) const {
-  return byColorBB[c];
+inline Bitboard Position::pieces() const {
+  return byTypeBB[ALL_PIECES];
 }
 
 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 {
-  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
+inline Bitboard Position::pieces(Color c) const {
+  return byColorBB[c];
 }
 
-inline int Position::piece_count(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+inline Bitboard Position::pieces(Color c, PieceType pt) const {
+  return byColorBB[c] & byTypeBB[pt];
 }
 
-inline const Square* Position::piece_list(Color c, PieceType pt) const {
-  return pieceList[c][pt];
+inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
+  return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
+}
+
+template<PieceType Pt> inline int Position::count(Color c) const {
+  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 {
@@ -329,16 +274,28 @@ inline Square Position::king_square(Color c) const {
   return pieceList[c][KING][0];
 }
 
-inline bool Position::can_castle(CastleRight f) const {
+inline int Position::can_castle(CastleRight f) const {
   return st->castleRights & f;
 }
 
-inline bool Position::can_castle(Color c) const {
-  return st->castleRights & ((WHITE_OO | WHITE_OOO) << c);
+inline int Position::can_castle(Color c) const {
+  return st->castleRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
 }
 
-inline Square Position::castle_rook_square(CastleRight f) const {
-  return castleRookSquare[f];
+inline bool Position::castle_impeded(Color c, CastlingSide s) const {
+  return byTypeBB[ALL_PIECES] & castlePath[c][s];
+}
+
+inline Square Position::castle_rook_square(Color c, CastlingSide s) const {
+  return castleRookSquare[c][s];
+}
+
+template<PieceType Pt>
+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<>
@@ -346,62 +303,40 @@ 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(Square s) const {
-  return StepAttacksBB[Piece][s];
-}
-
-template<>
-inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
-  return bishop_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<ROOK>(Square s) const {
-  return rook_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
-}
-
 inline Bitboard Position::attacks_from(Piece p, Square s) const {
-  return attacks_from(p, s, occupied_squares());
+  return attacks_from(p, s, byTypeBB[ALL_PIECES]);
 }
 
 inline Bitboard Position::attackers_to(Square s) const {
-  return attackers_to(s, occupied_squares());
+  return attackers_to(s, byTypeBB[ALL_PIECES]);
 }
 
 inline Bitboard Position::checkers() const {
   return st->checkersBB;
 }
 
-inline bool Position::in_check() const {
-  return st->checkersBB != 0;
-}
-
 inline Bitboard Position::discovered_check_candidates() const {
-  return hidden_checkers<false>();
+  return hidden_checkers(king_square(~sideToMove), sideToMove, sideToMove);
 }
 
-inline Bitboard Position::pinned_pieces() const {
-  return hidden_checkers<true>();
+inline Bitboard Position::pinned_pieces(Color toMove) const {
+  return hidden_checkers(king_square(toMove), ~toMove, toMove);
 }
 
-inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s));
+inline bool Position::pawn_passed(Color c, Square s) const {
+  return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
+}
+
+inline bool Position::passed_pawn_push(Move m) const {
+
+  return   type_of(moved_piece(m)) == PAWN
+        && pawn_passed(sideToMove, to_sq(m));
 }
 
 inline Key Position::key() const {
   return st->key;
 }
 
-inline Key Position::exclusion_key() const {
-  return st->key ^ zobExclusion;
-}
-
 inline Key Position::pawn_key() const {
   return st->pawnKey;
 }
@@ -410,66 +345,100 @@ inline Key Position::material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::pst(Piece p, Square s) const {
-  return pieceSquareTable[p][s];
-}
-
-inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
-  return pieceSquareTable[piece][to] - pieceSquareTable[piece][from];
-}
-
-inline Score Position::value() const {
-  return st->value;
+inline Score Position::psq_score() const {
+  return st->psq;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
   return st->npMaterial[c];
 }
 
-inline bool Position::is_passed_pawn_push(Move m) const {
-
-  return   board[from_sq(m)] == make_piece(sideToMove, PAWN)
-        && pawn_is_passed(sideToMove, to_sq(m));
+inline int Position::game_ply() const {
+  return gamePly;
 }
 
-inline int Position::startpos_ply_counter() const {
-  return startPosPly + st->pliesFromNull; // HACK
-}
-
-inline bool Position::opposite_colored_bishops() const {
+inline bool Position::opposite_bishops() const {
 
   return   pieceCount[WHITE][BISHOP] == 1
         && pieceCount[BLACK][BISHOP] == 1
         && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
 }
 
-inline bool Position::has_pawn_on_7th(Color c) const {
-  return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
+inline bool Position::bishop_pair(Color c) const {
+
+  return   pieceCount[c][BISHOP] >= 2
+        && opposite_colors(pieceList[c][BISHOP][0], pieceList[c][BISHOP][1]);
+}
+
+inline bool Position::pawn_on_7th(Color c) const {
+  return pieces(c, PAWN) & rank_bb(relative_rank(c, RANK_7));
 }
 
 inline bool Position::is_chess960() const {
   return chess960;
 }
 
-inline bool Position::is_capture_or_promotion(Move m) const {
+inline bool Position::capture_or_promotion(Move m) const {
 
   assert(is_ok(m));
-  return is_special(m) ? !is_castle(m) : !square_is_empty(to_sq(m));
+  return type_of(m) ? type_of(m) != CASTLE : !empty(to_sq(m));
 }
 
-inline bool Position::is_capture(Move m) const {
+inline bool Position::capture(Move m) const {
 
   // Note that castle is coded as "king captures the rook"
   assert(is_ok(m));
-  return (!square_is_empty(to_sq(m)) && !is_castle(m)) || is_enpassant(m);
+  return (!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 {
-  return threadID;
+inline Thread* Position::this_thread() const {
+  return thisThread;
 }
 
-#endif // !defined(POSITION_H_INCLUDED)
+inline void Position::put_piece(Square s, Color c, PieceType pt) {
+
+  board[s] = make_piece(c, pt);
+  byTypeBB[ALL_PIECES] |= s;
+  byTypeBB[pt] |= s;
+  byColorBB[c] |= s;
+  pieceCount[c][ALL_PIECES]++;
+  index[s] = pieceCount[c][pt]++;
+  pieceList[c][pt][index[s]] = s;
+}
+
+inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) {
+
+  // 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;
+}
+
+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
+  pieceCount[c][ALL_PIECES]--;
+  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-2012 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,7 +17,7 @@
   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"
@@ -29,16 +29,16 @@
 /// a given square a (midgame, endgame) score pair is assigned. PSQT is defined
 /// for white side, for black side the tables are symmetric.
 
-static const Score PSQT[][64] = {
+static const Score PSQT[][SQUARE_NB] = {
   { },
   { // Pawn
    S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(36,-8), S(36,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(58,-8), S(58,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S(17,-8), S(36,-8), S(36,-8), S(17,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-28,-8),
-   S(-28,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-28,-8),
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 9,-8), S(34,-8), S(34,-8), S( 9,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S(17,-8), S(54,-8), S(54,-8), S(17,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S(17,-8), S(34,-8), S(34,-8), S(17,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 9,-8), S(14,-8), S(14,-8), S( 9,-8), S(-6,-8), S(-20,-8),
+   S(-20,-8), S(-6,-8), S( 4,-8), S(14,-8), S(14,-8), S( 4,-8), S(-6,-8), S(-20,-8),
    S(  0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0,  0), S( 0, 0), S( 0, 0), S(  0, 0)
   },
   { // Knight
@@ -95,4 +95,4 @@ static const Score PSQT[][64] = {
 
 #undef S
 
-#endif // !defined(PSQTAB_H_INCLUDED)
+#endif // #ifndef 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-2012 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
@@ -22,7 +22,7 @@
   (at your option) any later version.
 */
 
-#if !defined(RKISS_H_INCLUDED)
+#ifndef RKISS_H_INCLUDED
 #define RKISS_H_INCLUDED
 
 #include "types.h"
@@ -43,36 +43,31 @@
 
 class RKISS {
 
-  // Keep variables always together
-  struct S { uint64_t a, b, c, d; } s;
+  uint64_t a, b, c, d;
 
   uint64_t rotate(uint64_t x, uint64_t k) const {
     return (x << k) | (x >> (64 - k));
   }
 
-  // Return 64 bit unsigned integer in between [0, 2^64 - 1]
   uint64_t rand64() {
 
-    const uint64_t
-      e = s.a - rotate(s.b,  7);
-    s.a = s.b ^ rotate(s.c, 13);
-    s.b = s.c + rotate(s.d, 37);
-    s.c = s.d + e;
-    return s.d = e + s.a;
-  }
-
-  // Init seed and scramble a few rounds
-  void raninit() {
-
-    s.a = 0xf1ea5eed;
-    s.b = s.c = s.d = 0xd4e12c77;
-    for (int i = 0; i < 73; i++)
-        rand64();
+    const uint64_t e = a - rotate(b,  7);
+    a = b ^ rotate(c, 13);
+    b = c + rotate(d, 37);
+    c = d + e;
+    return d = e + a;
   }
 
 public:
-  RKISS() { raninit(); }
+  RKISS(int seed = 73) {
+
+    a = 0xF1EA5EED, b = c = d = 0xD4E12C77;
+
+    for (int i = 0; i < seed; ++i) // Scramble a few rounds
+        rand64();
+  }
+
   template<typename T> T rand() { return T(rand64()); }
 };
 
-#endif // !defined(RKISS_H_INCLUDED)
+#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-2012 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,18 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(SEARCH_H_INCLUDED)
+#ifndef SEARCH_H_INCLUDED
 #define SEARCH_H_INCLUDED
 
 #include <cstring>
+#include <memory>
+#include <stack>
 #include <vector>
 
+#include "misc.h"
+#include "position.h"
 #include "types.h"
 
-class Position;
 struct SplitPoint;
 
 namespace Search {
@@ -35,29 +38,49 @@ namespace Search {
 /// has its own array of Stack objects, indexed by the current ply.
 
 struct Stack {
-  SplitPoint* sp;
+  SplitPoint* splitPoint;
   int ply;
   Move currentMove;
   Move excludedMove;
-  Move bestMove;
   Move killers[2];
   Depth reduction;
-  Value eval;
-  Value evalMargin;
+  Value staticEval;
   int skipNullMove;
 };
 
 
+/// 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 LimitsType {
 
-  LimitsType() {  memset(this, 0, sizeof(LimitsType)); }
-  bool use_time_management() const { return !(maxTime | maxDepth | maxNodes | infinite); }
+  LimitsType() { std::memset(this, 0, sizeof(LimitsType)); }
+  bool use_time_management() const { return !(mate | movetime | depth | nodes | infinite); }
 
-  int time, increment, movesToGo, maxTime, maxDepth, maxNodes, infinite, ponder;
+  int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, nodes, movetime, mate, infinite, ponder;
 };
 
 
@@ -68,15 +91,20 @@ 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<Move> SearchMoves;
-extern Position RootPosition;
+extern std::vector<RootMove> RootMoves;
+extern Position RootPos;
+extern Color RootColor;
+extern Time::point SearchTime;
+extern StateStackPtr SetupStates;
 
 extern void init();
-extern int64_t perft(Position& pos, Depth depth);
+extern size_t perft(Position& pos, Depth depth);
 extern void think();
 
-} // namespace
+} // namespace Search
 
-#endif // !defined(SEARCH_H_INCLUDED)
+#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-2012 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,486 +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"
 
 using namespace Search;
 
-ThreadsManager Threads; // Global object
+ThreadPool Threads; // Global object
 
-namespace { extern "C" {
+namespace {
 
  // start_routine() is the C function which is called when a new thread
- // is launched. It simply calls idle_loop() of the supplied thread. The first
- // and last thread are special. First one is the main search thread while the
- // last one mimics a timer, they run in main_loop() and timer_loop().
+ // is launched. It is a wrapper to the virtual function idle_loop().
 
-#if defined(_MSC_VER)
-  DWORD WINAPI start_routine(LPVOID thread) {
-#else
-  void* start_routine(void* thread) {
-#endif
-
-    Thread* th = (Thread*)thread;
-
-    if (th->threadID == 0)
-        th->main_loop();
-
-    else if (th->threadID == MAX_THREADS)
-        th->timer_loop();
-
-    else
-        th->idle_loop(NULL);
-
-    return 0;
-  }
-
-} }
+ extern "C" { long start_routine(ThreadBase* th) { th->idle_loop(); return 0; } }
 
 
-// wake_up() wakes up the thread, normally at the beginning of the search or,
-// if "sleeping threads" is used, when there is some work to do.
+ // Helpers to launch a thread after creation and joining before delete. Must be
+ // 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 the current
-// active split point, or in some ancestor of the split point.
+// ThreadBase::notify_one() wakes up the thread when there is some work to do
+
+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, run ? Resolution : INT_MAX);
+
+      mutex.unlock();
+
+      if (run)
+          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)
-      if (sp->is_betaCutoff)
+  for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint)
+      if (sp->cutoff)
           return true;
 
   return false;
 }
 
 
-// is_available_to() checks whether the thread is available to help the thread with
-// threadID "master" at a split point. An obvious requirement is that thread must be
-// idle. With more than two threads, this is not by itself sufficient: If the thread
-// is the master of some active split point, it is only available as a slave to the
-// threads which are busy searching the split point at the top of "slave"'s split
-// point stack (the "helpful master concept" in YBWC terminology).
+// Thread::available_to() checks whether the thread is available to help the
+// thread 'master' at a split point. An obvious requirement is that thread must
+// be idle. With more than two threads, this is not sufficient: If the thread is
+// the master of some split point, it is only available as a slave to the slaves
+// which are busy searching the split point at the top of slaves split point
+// stack (the "helpful master concept" in YBWC terminology).
 
-bool Thread::is_available_to(int master) const {
+bool Thread::available_to(const Thread* master) const {
 
-  if (is_searching)
+  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
-      || splitPoints[localActiveSplitPoints - 1].is_slave[master])
-      return true;
-
-  return false;
+  return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx));
 }
 
 
-// read_uci_options() updates number of active threads and other parameters
-// according to the UCI options values. It is called before to start a new search.
+// init() is called at startup to create and launch requested threads, that will
+// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use
+// a c'tor becuase Threads is a static object and we need a fully initialized
+// engine at this point due to allocation of Endgames in Thread c'tor.
 
-void ThreadsManager::read_uci_options() {
+void ThreadPool::init() {
+
+  sleepWhileIdle = true;
+  timer = new_thread<TimerThread>();
+  push_back(new_thread<MainThread>());
+  read_uci_options();
+}
+
+
+// exit() cleanly terminates the threads before the program exits
+
+void ThreadPool::exit() {
+
+  delete_thread(timer); // As first because check_time() accesses threads data
+
+  for (iterator it = begin(); it != end(); ++it)
+      delete_thread(*it);
+}
+
+
+// read_uci_options() updates internal threads parameters from the corresponding
+// UCI options and creates/destroys threads to match the requested number. Thread
+// objects are dynamically allocated to avoid creating in advance all possible
+// threads, with included pawns and material tables, if only few are used.
+
+void ThreadPool::read_uci_options() {
 
   maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
   minimumSplitDepth       = Options["Min Split Depth"] * ONE_PLY;
-  useSleepingThreads      = Options["Use Sleeping Threads"];
+  size_t requested        = Options["Threads"];
 
-  set_size(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);
 
-// set_size() changes the number of active threads and raises do_sleep flag for
-// all the unused threads that will go immediately to sleep.
+  while (size() < requested)
+      push_back(new_thread<Thread>());
 
-void ThreadsManager::set_size(int cnt) {
-
-  assert(cnt > 0 && cnt <= MAX_THREADS);
-
-  activeThreads = cnt;
-
-  for (int i = 1; i < MAX_THREADS; i++) // Ignore main thread
-      if (i < activeThreads)
-      {
-          // Dynamically allocate pawn and material hash tables according to the
-          // number of active threads. This avoids preallocating memory for all
-          // possible threads if only few are used.
-          threads[i].pawnTable.init();
-          threads[i].materialTable.init();
-
-          threads[i].do_sleep = false;
-      }
-      else
-          threads[i].do_sleep = true;
-}
-
-
-// init() is called during startup. Initializes locks and condition variables
-// and launches all threads sending them immediately to sleep.
-
-void ThreadsManager::init() {
-
-  // Initialize sleep condition and lock used by thread manager
-  cond_init(&sleepCond);
-  lock_init(&threadsLock);
-
-  // Initialize thread's sleep conditions and split point locks
-  for (int i = 0; i <= MAX_THREADS; i++)
+  while (size() > requested)
   {
-      lock_init(&threads[i].sleepLock);
-      cond_init(&threads[i].sleepCond);
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_init(&(threads[i].splitPoints[j].lock));
-  }
-
-  // Allocate main thread tables to call evaluate() also when not searching
-  threads[0].pawnTable.init();
-  threads[0].materialTable.init();
-
-  // Create and launch all the threads, threads will go immediately to sleep
-  for (int i = 0; i <= MAX_THREADS; i++)
-  {
-      threads[i].is_searching = false;
-      threads[i].do_sleep = (i != 0); // Avoid a race with start_thinking()
-      threads[i].threadID = i;
-
-#if defined(_MSC_VER)
-      threads[i].handle = CreateThread(NULL, 0, start_routine, &threads[i], 0, NULL);
-      bool ok = (threads[i].handle != NULL);
-#else
-      bool ok = !pthread_create(&threads[i].handle, NULL, start_routine, &threads[i]);
-#endif
-
-      if (!ok)
-      {
-          std::cerr << "Failed to create thread number " << i << std::endl;
-          ::exit(EXIT_FAILURE);
-      }
+      delete_thread(back());
+      pop_back();
   }
 }
 
 
-// exit() is called to cleanly terminate 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 {
 
-  for (int i = 0; i <= MAX_THREADS; i++)
-  {
-      threads[i].do_terminate = true; // Search must be already finished
-      threads[i].wake_up();
+  for (const_iterator it = begin(); it != end(); ++it)
+      if ((*it)->available_to(master))
+          return *it;
 
-      // Wait for thread termination
-#if defined(_MSC_VER)
-      WaitForSingleObject(threads[i].handle, INFINITE);
-      CloseHandle(threads[i].handle);
-#else
-      pthread_join(threads[i].handle, NULL);
-#endif
-
-      // Now we can safely destroy associated locks and wait conditions
-      lock_destroy(&threads[i].sleepLock);
-      cond_destroy(&threads[i].sleepCond);
-
-      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
-          lock_destroy(&(threads[i].splitPoints[j].lock));
-  }
-
-  lock_destroy(&threadsLock);
-  cond_destroy(&sleepCond);
-}
-
-
-// available_slave_exists() tries to find an idle thread which is available as
-// a slave for the thread with threadID 'master'.
-
-bool ThreadsManager::available_slave_exists(int master) const {
-
-  assert(master >= 0 && master < activeThreads);
-
-  for (int i = 0; i < activeThreads; i++)
-      if (threads[i].is_available_to(master))
-          return true;
-
-  return false;
-}
-
-
-// split_point_finished() checks if all the slave threads of a given split
-// point have finished searching.
-
-bool ThreadsManager::split_point_finished(SplitPoint* sp) const {
-
-  for (int i = 0; i < activeThreads; i++)
-      if (sp->is_slave[i])
-          return false;
-
-  return true;
+  return NULL;
 }
 
 
 // split() does the actual work of distributing the work at a node between
 // several available threads. If it does not succeed in splitting the node
-// (because no idle threads are available, or because we have no unused split
-// point objects), the function immediately returns. If splitting is possible, a
-// SplitPoint object is initialized with all the data that must be copied to the
-// helper threads and then helper threads are told that they have been assigned
-// work. This will cause them to instantly leave their idle loops and call
-// search(). When all threads have returned from search() then split() returns.
+// (because no idle threads are available), the function immediately returns.
+// If splitting is possible, a SplitPoint object is initialized with all the
+// data that must be copied to the helper threads and then helper threads are
+// told that they have been assigned work. This will cause them to instantly
+// leave their idle loops and call search(). When all threads have returned from
+// search() then split() returns.
 
 template <bool Fake>
-Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
-                            Value bestValue, Depth depth, Move threatMove,
-                            int moveCount, MovePicker* mp, int nodeType) {
+void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue,
+                   Move* bestMove, Depth depth, Move threatMove, int moveCount,
+                   MovePicker* movePicker, int nodeType, bool cutNode) {
+
   assert(pos.pos_is_ok());
-  assert(bestValue > -VALUE_INFINITE);
-  assert(bestValue <= alpha);
-  assert(alpha < beta);
-  assert(beta <= VALUE_INFINITE);
-  assert(depth > DEPTH_ZERO);
-  assert(pos.thread() >= 0 && pos.thread() < activeThreads);
-  assert(activeThreads > 1);
-
-  int i, master = pos.thread();
-  Thread& masterThread = threads[master];
-
-  // If we already have too many active split points, don't split
-  if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
-      return bestValue;
+  assert(*bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE);
+  assert(*bestValue > -VALUE_INFINITE);
+  assert(depth >= Threads.minimumSplitDepth);
+  assert(searching);
+  assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD);
 
   // Pick the next available split point from the split point stack
-  SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints];
+  SplitPoint& sp = splitPoints[splitPointsSize];
 
-  // Initialize the split point
-  sp->parent = masterThread.splitPoint;
-  sp->master = master;
-  sp->is_betaCutoff = false;
-  sp->depth = depth;
-  sp->threatMove = threatMove;
-  sp->alpha = alpha;
-  sp->beta = beta;
-  sp->nodeType = nodeType;
-  sp->bestValue = bestValue;
-  sp->mp = mp;
-  sp->moveCount = moveCount;
-  sp->pos = &pos;
-  sp->nodes = 0;
-  sp->ss = ss;
-
-  for (i = 0; i < activeThreads; i++)
-      sp->is_slave[i] = false;
-
-  // If we are here it means we are not available
-  assert(masterThread.is_searching);
-
-  int workersCnt = 1; // At least the master is included
+  sp.masterThread = this;
+  sp.parentSplitPoint = activeSplitPoint;
+  sp.slavesMask = 1ULL << idx;
+  sp.depth = depth;
+  sp.bestValue = *bestValue;
+  sp.bestMove = *bestMove;
+  sp.threatMove = threatMove;
+  sp.alpha = alpha;
+  sp.beta = beta;
+  sp.nodeType = nodeType;
+  sp.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
-  // is_searching flag. This must be done under lock protection to avoid concurrent
+  // 'searching' flag. This must be done under lock protection to avoid concurrent
   // allocation of the same slave by another master.
-  lock_grab(&threadsLock);
+  Threads.mutex.lock();
+  sp.mutex.lock();
 
-  for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
-      if (threads[i].is_available_to(master))
-      {
-          workersCnt++;
-          sp->is_slave[i] = true;
-          threads[i].splitPoint = sp;
+  ++splitPointsSize;
+  activeSplitPoint = &sp;
+  activePosition = NULL;
 
-          // This makes the slave to exit from idle_loop()
-          threads[i].is_searching = true;
+  size_t slavesCnt = 1; // This thread is always included
+  Thread* slave;
 
-          if (useSleepingThreads)
-              threads[i].wake_up();
-      }
-
-  lock_release(&threadsLock);
-
-  // We failed to allocate even one slave, return
-  if (!Fake && workersCnt == 1)
-      return bestValue;
-
-  masterThread.splitPoint = sp;
-  masterThread.activeSplitPoints++;
+  while (    (slave = Threads.available_slave(this)) != NULL
+         && ++slavesCnt <= Threads.maxThreadsPerSplitPoint && !Fake)
+  {
+      sp.slavesMask |= 1ULL << slave->idx;
+      slave->activeSplitPoint = &sp;
+      slave->searching = true; // Slave leaves idle_loop()
+      slave->notify_one(); // Could be sleeping
+  }
 
   // Everything is set up. The master thread enters the idle loop, from which
-  // it will instantly launch a search, because its is_searching flag is set.
-  // We pass the split point as a parameter to the idle loop, which means that
-  // the thread will return from the idle loop when all slaves have finished
+  // 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.
-  masterThread.idle_loop(sp);
+  if (slavesCnt > 1 || Fake)
+  {
+      sp.mutex.unlock();
+      Threads.mutex.unlock();
 
-  // In helpful master concept a master can help only a sub-tree of its split
-  // point, and because here is all finished is not possible master is booked.
-  assert(!masterThread.is_searching);
+      Thread::idle_loop(); // Force a call to base class idle_loop()
 
-  // We have returned from the idle loop, which means that all threads are
-  // finished. Note that changing state and decreasing activeSplitPoints is done
-  // under lock protection to avoid a race with Thread::is_available_to().
-  lock_grab(&threadsLock);
+      // 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);
 
-  masterThread.is_searching = true;
-  masterThread.activeSplitPoints--;
+      // We have returned from the idle loop, which means that all threads are
+      // finished. Note that setting 'searching' and decreasing splitPointsSize is
+      // done under lock protection to avoid a race with Thread::available_to().
+      Threads.mutex.lock();
+      sp.mutex.lock();
+  }
 
-  lock_release(&threadsLock);
+  searching = true;
+  --splitPointsSize;
+  activeSplitPoint = sp.parentSplitPoint;
+  activePosition = &pos;
+  pos.set_nodes_searched(pos.nodes_searched() + sp.nodes);
+  *bestMove = sp.bestMove;
+  *bestValue = sp.bestValue;
 
-  masterThread.splitPoint = sp->parent;
-  pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
-
-  return sp->bestValue;
+  sp.mutex.unlock();
+  Threads.mutex.unlock();
 }
 
 // Explicit template instantiations
-template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
-template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
+template void Thread::split<false>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
+template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, Move, int, MovePicker*, int, bool);
 
 
-// Thread::timer_loop() is where the timer thread waits maxPly milliseconds and
-// then calls do_timer_event(). If maxPly is 0 thread sleeps until is woken up.
-extern void check_time();
+// wait_for_think_finished() waits for main thread to go to sleep then returns
 
-void Thread::timer_loop() {
+void ThreadPool::wait_for_think_finished() {
 
-  while (!do_terminate)
-  {
-      lock_grab(&sleepLock);
-      timed_wait(&sleepCond, &sleepLock, maxPly ? maxPly : INT_MAX);
-      lock_release(&sleepLock);
-      check_time();
-  }
+  MainThread* t = main();
+  t->mutex.lock();
+  while (t->thinking) sleepCondition.wait(t->mutex);
+  t->mutex.unlock();
 }
 
 
-// ThreadsManager::set_timer() is used to set the timer to trigger after msec
-// milliseconds. If msec is 0 then timer is stopped.
+// start_thinking() wakes up the main thread sleeping in MainThread::idle_loop()
+// so to start a new search, then returns immediately.
 
-void ThreadsManager::set_timer(int msec) {
+void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
+                                const std::vector<Move>& searchMoves, StateStackPtr& states) {
+  wait_for_think_finished();
 
-  Thread& timer = threads[MAX_THREADS];
+  SearchTime = Time::now(); // As early as possible
 
-  lock_grab(&timer.sleepLock);
-  timer.maxPly = msec;
-  cond_signal(&timer.sleepCond); // Wake up and restart the timer
-  lock_release(&timer.sleepLock);
-}
+  Signals.stopOnPonderhit = Signals.firstRootMove = false;
+  Signals.stop = Signals.failedLowAtRoot = false;
 
-
-// Thread::main_loop() is where the main thread is parked waiting to be started
-// when there is a new search. Main thread will launch all the slave threads.
-
-void Thread::main_loop() {
-
-  while (true)
-  {
-      lock_grab(&sleepLock);
-
-      do_sleep = true; // Always return to sleep after a search
-      is_searching = false;
-
-      while (do_sleep && !do_terminate)
-      {
-          cond_signal(&Threads.sleepCond); // Wake up UI thread if needed
-          cond_wait(&sleepCond, &sleepLock);
-      }
-
-      is_searching = true;
-
-      lock_release(&sleepLock);
-
-      if (do_terminate)
-          return;
-
-      think(); // This is the search entry point
-  }
-}
-
-
-// ThreadsManager::start_thinking() is used by UI thread to wake up the main
-// thread parked in main_loop() and starting a new search. If asyncMode is true
-// then function returns immediately, otherwise caller is blocked waiting for
-// the search to finish.
-
-void ThreadsManager::start_thinking(const Position& pos, const LimitsType& limits,
-                                    const std::vector<Move>& searchMoves, bool asyncMode) {
-  Thread& main = threads[0];
-
-  lock_grab(&main.sleepLock);
-
-  // Wait main thread has finished before to launch a new search
-  while (!main.do_sleep)
-      cond_wait(&sleepCond, &main.sleepLock);
-
-  // Copy input arguments to initialize the search
-  RootPosition.copy(pos, 0);
+  RootMoves.clear();
+  RootPos = pos;
   Limits = limits;
-  SearchMoves = searchMoves;
+  if (states.get()) // If we don't set a new position, preserve current state
+  {
+      SetupStates = states; // Ownership transfer here
+      assert(!states.get());
+  }
 
-  // Reset signals before to start the new search
-  memset((void*)&Signals, 0, sizeof(Signals));
+  for (MoveList<LEGAL> it(pos); *it; ++it)
+      if (   searchMoves.empty()
+          || std::count(searchMoves.begin(), searchMoves.end(), *it))
+          RootMoves.push_back(RootMove(*it));
 
-  main.do_sleep = false;
-  cond_signal(&main.sleepCond); // Wake up main thread and start searching
-
-  if (!asyncMode)
-      while (!main.do_sleep)
-          cond_wait(&sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
-}
-
-
-// ThreadsManager::stop_thinking() is used by UI thread to raise a stop request
-// and to wait for the main thread finishing the search. Needed to wait exiting
-// and terminate the threads after a 'quit' command.
-
-void ThreadsManager::stop_thinking() {
-
-  Thread& main = threads[0];
-
-  Search::Signals.stop = true;
-
-  lock_grab(&main.sleepLock);
-
-  cond_signal(&main.sleepCond); // In case is waiting for stop or ponderhit
-
-  while (!main.do_sleep)
-      cond_wait(&sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
-}
-
-
-// ThreadsManager::wait_for_stop_or_ponderhit() is called when the maximum depth
-// is reached while the program is pondering. The point is to work around a wrinkle
-// in the UCI protocol: When pondering, the engine is not allowed to give a
-// "bestmove" before the GUI sends it a "stop" or "ponderhit" command. We simply
-// wait here until one of these commands (that raise StopRequest) is sent and
-// then return, after which the bestmove and pondermove will be printed.
-
-void ThreadsManager::wait_for_stop_or_ponderhit() {
-
-  Signals.stopOnPonderhit = true;
-
-  Thread& main = threads[0];
-
-  lock_grab(&main.sleepLock);
-
-  while (!Signals.stop)
-      cond_wait(&main.sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
+  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-2012 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,45 +17,90 @@
   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_ACTIVE_SPLIT_POINTS = 8;
+const int MAX_THREADS = 64; // Because SplitPoint::slavesMask is a uint64_t
+const int MAX_SPLITPOINTS_PER_THREAD = 8;
+
+struct Mutex {
+  Mutex() { lock_init(l); }
+ ~Mutex() { lock_destroy(l); }
+
+  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
-  SplitPoint* parent;
+  // Const data after split point has been setup
   const Position* pos;
+  const Search::Stack* ss;
+  Thread* masterThread;
   Depth depth;
   Value beta;
   int nodeType;
-  int ply;
-  int master;
   Move threatMove;
+  bool cutNode;
 
   // Const pointers to shared data
-  MovePicker* mp;
-  Search::Stack* ss;
+  MovePicker* movePicker;
+  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 is_slave[MAX_THREADS];
+  volatile bool cutoff;
+};
+
+
+/// ThreadBase struct is the base of the hierarchy from where we derive all the
+/// specialized thread classes.
+
+struct ThreadBase {
+
+  ThreadBase() : exit(false) {}
+  virtual ~ThreadBase() {}
+  virtual void idle_loop() = 0;
+  void notify_one();
+  void wait_for(volatile const bool& b);
+
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  NativeHandle handle;
+  volatile bool exit;
 };
 
 
@@ -64,79 +109,71 @@ struct SplitPoint {
 /// 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 Thread : public ThreadBase {
 
-  void wake_up();
+  Thread();
+  virtual void idle_loop();
   bool cutoff_occurred() const;
-  bool is_available_to(int master) const;
-  void idle_loop(SplitPoint* sp);
-  void main_loop();
-  void timer_loop();
+  bool available_to(const Thread* master) const;
 
-  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
-  MaterialInfoTable materialTable;
-  PawnInfoTable pawnTable;
-  int threadID;
+  template <bool Fake>
+  void split(Position& pos, const Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove,
+             Depth depth, Move threatMove, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode);
+
+  SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
+  Material::Table materialTable;
+  Endgames endgames;
+  Pawns::Table pawnsTable;
+  Position* activePosition;
+  size_t idx;
   int maxPly;
-  Lock sleepLock;
-  WaitCondition sleepCond;
-  SplitPoint* volatile splitPoint;
-  volatile int activeSplitPoints;
-  volatile bool is_searching;
-  volatile bool do_sleep;
-  volatile bool do_terminate;
-
-#if defined(_MSC_VER)
-  HANDLE handle;
-#else
-  pthread_t handle;
-#endif
+  SplitPoint* volatile activeSplitPoint;
+  volatile int splitPointsSize;
+  volatile bool searching;
 };
 
 
-/// ThreadsManager class handles all the threads related stuff like init, starting,
+/// 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() : run(false) {}
+  virtual void idle_loop();
+  bool run;
+  static const int Resolution = 5; // msec between two check_time() calls
+};
+
+
+/// 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.
 
-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();
+struct ThreadPool : public std::vector<Thread*> {
 
-  bool use_sleeping_threads() const { return useSleepingThreads; }
-  int min_split_depth() const { return minimumSplitDepth; }
-  int size() const { return activeThreads; }
+  void init(); // No c'tor and d'tor, threads rely on globals that should
+  void exit(); // be initialized and valid during the whole thread lifetime.
 
-  void set_size(int cnt);
+  MainThread* main() { return static_cast<MainThread*>((*this)[0]); }
   void read_uci_options();
-  bool available_slave_exists(int master) const;
-  bool split_point_finished(SplitPoint* sp) const;
-  void set_timer(int msec);
-  void wait_for_stop_or_ponderhit();
-  void stop_thinking();
-  void start_thinking(const Position& pos, const Search::LimitsType& limits,
-                      const std::vector<Move>& searchMoves, bool asyncMode);
+  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&);
 
-  template <bool Fake>
-  Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue,
-              Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
-private:
-  friend struct Thread;
-
-  Thread threads[MAX_THREADS + 1]; // Last one is used as a timer
-  Lock threadsLock;
+  bool sleepWhileIdle;
   Depth minimumSplitDepth;
-  int maxThreadsPerSplitPoint;
-  int activeThreads;
-  bool useSleepingThreads;
-  WaitCondition sleepCond;
+  size_t maxThreadsPerSplitPoint;
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  TimerThread* timer;
 };
 
-extern ThreadsManager Threads;
+extern ThreadPool Threads;
 
-#endif // !defined(THREAD_H_INCLUDED)
+#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-2012 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,10 +17,9 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 
-#include "misc.h"
 #include "search.h"
 #include "timeman.h"
 #include "ucioption.h"
@@ -30,8 +29,8 @@ namespace {
   /// Constants
 
   const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
-  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
-  const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio
+  const double MaxRatio   = 7.0;  // When in trouble, we can step over reserved time with this ratio
+  const double StealRatio = 0.33; // However we must not steal time from remaining moves over this ratio
 
 
   // MoveImportance[] is based on naive statistical analysis of "how many games are still undecided
@@ -73,18 +72,17 @@ namespace {
   enum TimeType { OptimumTime, MaxTime };
 
   template<TimeType>
-  int remaining(int myTime, int movesToGo, int fullMoveNumber);
+  int remaining(int myTime, int movesToGo, int fullMoveNumber, int slowMover);
 }
 
 
-void TimeManager::pv_instability(int curChanges, int prevChanges) {
+void TimeManager::pv_instability(double bestMoveChanges) {
 
-  unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
-                       + prevChanges * (optimumSearchTime / 3);
+  unstablePVExtraTime = int(bestMoveChanges * optimumSearchTime / 1.4);
 }
 
 
-void TimeManager::init(const Search::LimitsType& limits, int currentPly)
+void TimeManager::init(const Search::LimitsType& limits, int currentPly, Color us)
 {
   /* We support four different kind of time controls:
 
@@ -108,25 +106,26 @@ void TimeManager::init(const Search::LimitsType& limits, int currentPly)
   int emergencyBaseTime    = Options["Emergency Base Time"];
   int emergencyMoveTime    = Options["Emergency Move Time"];
   int minThinkingTime      = Options["Minimum Thinking Time"];
+  int slowMover            = Options["Slow Mover"];
 
   // Initialize to maximum values but unstablePVExtraTime that is reset
   unstablePVExtraTime = 0;
-  optimumSearchTime = maximumSearchTime = limits.time;
+  optimumSearchTime = maximumSearchTime = limits.time[us];
 
   // We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
   // minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values.
-  for (hypMTG = 1; hypMTG <= (limits.movesToGo ? std::min(limits.movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
+  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
-                 + limits.increment * (hypMTG - 1)
+      hypMyTime =  limits.time[us]
+                 + limits.inc[us] * (hypMTG - 1)
                  - emergencyBaseTime
                  - emergencyMoveTime * std::min(hypMTG, emergencyMoveHorizon);
 
       hypMyTime = std::max(hypMyTime, 0);
 
-      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
-      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly, slowMover);
+      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly, slowMover);
 
       optimumSearchTime = std::min(optimumSearchTime, t1);
       maximumSearchTime = std::min(maximumSearchTime, t2);
@@ -143,19 +142,19 @@ void TimeManager::init(const Search::LimitsType& limits, int currentPly)
 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);
+    const double TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const double TStealRatio = (T == OptimumTime ? 0 : StealRatio);
 
-    int thisMoveImportance = move_importance(currentPly);
+    double thisMoveImportance = double(move_importance(currentPly) * slowMover) / 100;
     int otherMovesImportance = 0;
 
-    for (int i = 1; i < movesToGo; i++)
+    for (int i = 1; i < movesToGo; ++i)
         otherMovesImportance += move_importance(currentPly + 2 * i);
 
-    float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
-    float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
+    double ratio1 = (TMaxRatio * thisMoveImportance) / (TMaxRatio * thisMoveImportance + otherMovesImportance);
+    double ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / (thisMoveImportance + otherMovesImportance);
 
     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-2012 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,7 +17,7 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TIMEMAN_H_INCLUDED)
+#ifndef TIMEMAN_H_INCLUDED
 #define TIMEMAN_H_INCLUDED
 
 /// The TimeManager class computes the optimal time to think depending on the
@@ -25,8 +25,8 @@
 
 class TimeManager {
 public:
-  void init(const Search::LimitsType& limits, int currentPly);
-  void pv_instability(int curChanges, int prevChanges);
+  void init(const Search::LimitsType& limits, int currentPly, Color us);
+  void pv_instability(double bestMoveChanges);
   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-2012 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,49 +20,37 @@
 #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
-  // 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;
+  uint32_t size = ClusterSize << msb((mbSize << 20) / sizeof(TTEntry[ClusterSize]));
 
-  if (newSize == size)
+  if (hashMask == size - ClusterSize)
       return;
 
-  size = newSize;
-  delete [] entries;
-  entries = new (std::nothrow) TTCluster[size];
-  if (!entries)
+  hashMask = size - ClusterSize;
+  free(mem);
+  mem = calloc(size * sizeof(TTEntry) + CACHE_LINE_SIZE - 1, 1);
+
+  if (!mem)
   {
       std::cerr << "Failed to allocate " << mbSize
                 << "MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
   }
-  clear();
+
+  table = (TTEntry*)((uintptr_t(mem) + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1));
 }
 
 
@@ -72,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;
 }
 
 
@@ -84,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) {
 
   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 == MOVE_NONE)
-              m = tte->move();
+          if (!m)
+              m = tte->move(); // Preserve any existing ttMove
 
-          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
-          return;
+          replace = tte;
+          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);
-}
-
-
-/// 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++;
+
+  replace->save(key32, v, b, d, m, generation, statV);
 }

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-2012 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,79 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TT_H_INCLUDED)
+#ifndef TT_H_INCLUDED
 #define TT_H_INCLUDED
 
-#include <iostream>
-
 #include "misc.h"
 #include "types.h"
 
+/// 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
-///
-/// 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
+struct TTEntry {
 
-class TTEntry {
-
-public:
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
+  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev) {
 
     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;
-    staticMargin = (int16_t)statM;
+    evalValue    = (int16_t)ev;
   }
-  void set_generation(int g) { generation8 = (uint8_t)g; }
+  void set_generation(uint8_t g) { generation8 = g; }
 
-  uint32_t key() const              { return key32; }
-  Depth depth() const               { return (Depth)depth16; }
-  Move move() const                 { return (Move)move16; }
-  Value value() const               { return (Value)value16; }
-  ValueType type() const            { return (ValueType)valueType; }
-  int generation() const            { return (int)generation8; }
-  Value static_value() const        { return (Value)staticValue; }
-  Value static_value_margin() const { return (Value)staticMargin; }
+  uint32_t key() const      { return key32; }
+  Depth depth() const       { return (Depth)depth16; }
+  Move move() const         { return (Move)move16; }
+  Value value() const       { return (Value)value16; }
+  Bound bound() const       { return (Bound)bound8; }
+  int generation() const    { return (int)generation8; }
+  Value eval_value() const  { return (Value)evalValue; }
 
 private:
   uint32_t key32;
   uint16_t move16;
-  uint8_t valueType, generation8;
-  int16_t value16, depth16, staticValue, staticMargin;
+  uint8_t bound8, generation8;
+  int16_t value16, depth16, evalValue;
 };
 
 
-/// This is the number of TTEntry slots for each cluster
-const int ClusterSize = 4;
-
-
-/// TTCluster consists of ClusterSize number of TTEntries. Size of TTCluster
-/// 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.
+/// A TranspositionTable consists of a power of 2 number of clusters and each
+/// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
+/// contains information of exactly one position. Size of a cluster shall not be
+/// bigger than a cache line size. In case it is less, it should be padded to
+/// guarantee always aligned accesses.
 
 class TranspositionTable {
 
-  TranspositionTable(const TranspositionTable&);
-  TranspositionTable& operator=(const TranspositionTable&);
+  static const unsigned ClusterSize = 4; // A cluster is 64 Bytes
 
 public:
-  TranspositionTable();
-  ~TranspositionTable();
+ ~TranspositionTable() { free(mem); }
+  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);
-  TTEntry* probe(const Key posKey) const;
-  void new_search();
-  TTEntry* first_entry(const Key posKey) const;
-  void refresh(const TTEntry* tte) const;
+  void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV);
 
 private:
-  size_t size;
-  TTCluster* entries;
-  uint8_t generation; // Size must be not bigger then TTEntry::generation8
+  uint32_t hashMask;
+  TTEntry* table;
+  void* mem;
+  uint8_t generation; // Size must be not bigger than TTEntry::generation8
 };
 
 extern TranspositionTable TT;
@@ -122,9 +99,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 +113,4 @@ inline void TranspositionTable::refresh(const TTEntry* tte) const {
   const_cast<TTEntry*>(tte)->set_generation(generation);
 }
 
-
-/// A simple fixed size hash table used to store pawns and material
-/// configurations. It is basically just an array of Entry objects.
-/// Without cluster concept or overwrite policy.
-
-template<class Entry, int HashSize>
-struct SimpleHash {
-
-  typedef SimpleHash<Entry, HashSize> Base;
-
-  void init() {
-
-    if (entries)
-        return;
-
-    entries = new (std::nothrow) Entry[HashSize];
-    if (!entries)
-    {
-        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
-                  << " bytes for hash table." << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    memset(entries, 0, HashSize * sizeof(Entry));
-  }
-
-  virtual ~SimpleHash() { delete [] entries; }
-
-  Entry* probe(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
-  void prefetch(Key key) const { ::prefetch((char*)probe(key)); }
-
-protected:
-  Entry* entries;
-};
-
-#endif // !defined(TT_H_INCLUDED)
+#endif // #ifndef 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-2012 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,7 +17,7 @@
   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
@@ -34,37 +34,17 @@
 /// -DUSE_POPCNT  | Add runtime support for use of popcnt asm-instruction. Works
 ///               | only in 64-bit mode. For compiling requires hardware with
 ///               | popcnt support.
-///
-/// -DOLD_LOCKS   | 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.
 
+#include <cassert>
+#include <cctype>
 #include <climits>
 #include <cstdlib>
 
-#if defined(_MSC_VER)
+#include "platform.h"
 
-// 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'
+#define unlikely(x) (x) // For code annotation purposes
 
-// MSVC does not support <inttypes.h>
-typedef   signed __int8    int8_t;
-typedef unsigned __int8   uint8_t;
-typedef   signed __int16  int16_t;
-typedef unsigned __int16 uint16_t;
-typedef   signed __int32  int32_t;
-typedef unsigned __int32 uint32_t;
-typedef   signed __int64  int64_t;
-typedef unsigned __int64 uint64_t;
-
-#else
-#  include <inttypes.h>
-#endif
-
-#if defined(_WIN64)
+#if defined(_WIN64) && !defined(IS_64BIT)
 #  include <intrin.h> // MSVC popcnt and bsfq instrinsics
 #  define IS_64BIT
 #  define USE_BSFQ
@@ -74,13 +54,18 @@ typedef unsigned __int64 uint64_t;
 #  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
 #endif
 
+#  if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#   include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
+#  endif
+
+#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
 
-#if defined(_MSC_VER)
+#ifdef _MSC_VER
 #  define FORCE_INLINE  __forceinline
 #elif defined(__GNUC__)
 #  define FORCE_INLINE  inline __attribute__((always_inline))
@@ -88,13 +73,13 @@ typedef unsigned __int64 uint64_t;
 #  define FORCE_INLINE  inline
 #endif
 
-#if defined(USE_POPCNT)
+#ifdef USE_POPCNT
 const bool HasPopCnt = true;
 #else
 const bool HasPopCnt = false;
 #endif
 
-#if defined(IS_64BIT)
+#ifdef IS_64BIT
 const bool Is64Bit = true;
 #else
 const bool Is64Bit = false;
@@ -105,26 +90,7 @@ typedef uint64_t Bitboard;
 
 const int MAX_MOVES      = 256;
 const int MAX_PLY        = 100;
-const int MAX_PLY_PLUS_2 = MAX_PLY + 2;
-
-const Bitboard FileABB = 0x0101010101010101ULL;
-const Bitboard FileBBB = FileABB << 1;
-const Bitboard FileCBB = FileABB << 2;
-const Bitboard FileDBB = FileABB << 3;
-const Bitboard FileEBB = FileABB << 4;
-const Bitboard FileFBB = FileABB << 5;
-const Bitboard FileGBB = FileABB << 6;
-const Bitboard FileHBB = FileABB << 7;
-
-const Bitboard Rank1BB = 0xFF;
-const Bitboard Rank2BB = Rank1BB << (8 * 1);
-const Bitboard Rank3BB = Rank1BB << (8 * 2);
-const Bitboard Rank4BB = Rank1BB << (8 * 3);
-const Bitboard Rank5BB = Rank1BB << (8 * 4);
-const Bitboard Rank6BB = Rank1BB << (8 * 5);
-const Bitboard Rank7BB = Rank1BB << (8 * 6);
-const Bitboard Rank8BB = Rank1BB << (8 * 7);
-
+const int MAX_PLY_PLUS_6 = MAX_PLY + 6;
 
 /// A move needs 16 bits to be stored
 ///
@@ -138,26 +104,37 @@ const Bitboard Rank8BB = Rank1BB << (8 * 7);
 /// while MOVE_NONE and MOVE_NULL have the same origin and destination square.
 
 enum Move {
-  MOVE_NONE = 0,
+  MOVE_NONE,
   MOVE_NULL = 65
 };
 
-struct MoveStack {
-  Move move;
-  int score;
+enum MoveType {
+  NORMAL,
+  PROMOTION = 1 << 14,
+  ENPASSANT = 2 << 14,
+  CASTLE    = 3 << 14
 };
 
-inline bool operator<(const MoveStack& f, const MoveStack& s) {
-  return f.score < s.score;
-}
+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 CastleRight {
-  CASTLES_NONE = 0,
-  WHITE_OO     = 1,
-  BLACK_OO     = 2,
-  WHITE_OOO    = 4,
-  BLACK_OOO    = 8,
-  ALL_CASTLES  = 15
+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 {
@@ -167,11 +144,11 @@ enum ScaleFactor {
   SCALE_FACTOR_NONE   = 255
 };
 
-enum ValueType {
-  VALUE_TYPE_NONE  = 0,
-  VALUE_TYPE_UPPER = 1,
-  VALUE_TYPE_LOWER = 2,
-  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+enum Bound {
+  BOUND_NONE,
+  BOUND_UPPER,
+  BOUND_LOWER,
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
 enum Value {
@@ -186,22 +163,30 @@ enum Value {
   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 {
-  NO_PIECE_TYPE = 0,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
+  ALL_PIECES = 0,
+  PIECE_TYPE_NB = 8
 };
 
 enum Piece {
-  NO_PIECE = 16, // color_of(NO_PIECE) == NO_COLOR
-  W_PAWN = 1, W_KNIGHT =  2, W_BISHOP =  3, W_ROOK =  4, W_QUEEN =  5, W_KING =  6,
-  B_PAWN = 9, B_KNIGHT = 10, B_BISHOP = 11, B_ROOK = 12, B_QUEEN = 13, B_KING = 14
+  NO_PIECE,
+  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
+  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
+  PIECE_NB = 16
 };
 
 enum Color {
-  WHITE, BLACK, NO_COLOR
+  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
 };
 
 enum Depth {
@@ -209,9 +194,9 @@ enum Depth {
   ONE_PLY = 2,
 
   DEPTH_ZERO          =  0 * ONE_PLY,
-  DEPTH_QS_CHECKS     = -1 * ONE_PLY,
-  DEPTH_QS_NO_CHECKS  = -2 * ONE_PLY,
-  DEPTH_QS_RECAPTURES = -4 * ONE_PLY,
+  DEPTH_QS_CHECKS     =  0 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS  = -1 * ONE_PLY,
+  DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
 
   DEPTH_NONE = -127 * ONE_PLY
 };
@@ -227,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,
@@ -241,11 +228,11 @@ 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
 };
 
 
@@ -254,7 +241,7 @@ enum Rank {
 /// for midgame value. Compiler is free to choose the enum type as long as can
 /// keep its data, so ensure Score to be an integer type.
 enum Score {
-  SCORE_ZERO = 0,
+  SCORE_ZERO,
   SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
   SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
 };
@@ -264,7 +251,7 @@ inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
 /// Extracting the signed lower and upper 16 bits it not so trivial because
 /// according to the standard a simple cast to short is implementation defined
 /// and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((s + 32768) & ~0xffff) / 0x10000); }
+inline Value mg_value(Score s) { return Value(((s + 0x8000) & ~0xffff) / 0x10000); }
 
 /// On Intel 64 bit we have a small speed regression with the standard conforming
 /// version, so use a faster code in this case that, although not 100% standard
@@ -287,15 +274,15 @@ inline T operator-(const T d1, const T d2) { return T(int(d1) - int(d2)); } \
 inline T operator*(int i, const T d) { return T(i * int(d)); }              \
 inline T operator*(const T d, int i) { return T(int(d) * i); }              \
 inline T operator-(const T d) { return T(-int(d)); }                        \
-inline T& operator+=(T& d1, const T d2) { d1 = d1 + d2; return d1; }        \
-inline T& operator-=(T& d1, const T d2) { d1 = d1 - d2; return d1; }        \
-inline T& operator*=(T& d, int i) { d = T(int(d) * i); return d; }
+inline T& operator+=(T& d1, const T d2) { return d1 = d1 + d2; }            \
+inline T& operator-=(T& d1, const T d2) { return d1 = d1 - d2; }            \
+inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }
 
 #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++(T& d) { return d = T(int(d) + 1); }                    \
+inline T& operator--(T& d) { return d = T(int(d) - 1); }                    \
 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; }
+inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
 ENABLE_OPERATORS_ON(Value)
 ENABLE_OPERATORS_ON(PieceType)
@@ -324,20 +311,28 @@ inline Score operator/(Score s, int i) {
 #undef ENABLE_OPERATORS_ON
 #undef ENABLE_SAFE_OPERATORS_ON
 
-const Value PawnValueMidgame   = Value(0x0C6);
-const Value PawnValueEndgame   = Value(0x102);
-const Value KnightValueMidgame = Value(0x331);
-const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame  = Value(0x9FE);
+extern Value PieceValue[PHASE_NB][PIECE_NB];
 
-extern const Value PieceValueMidgame[17];
-extern const Value PieceValueEndgame[17];
-extern int SquareDistance[64][64];
+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 ^ BLACK);
+}
+
+inline Square operator~(Square s) {
+  return Square(s ^ SQ_A8); // 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;
@@ -351,23 +346,20 @@ inline Piece make_piece(Color c, PieceType pt) {
   return Piece((c << 3) | pt);
 }
 
+inline CastleRight make_castle_right(Color c, CastlingSide s) {
+  return CastleRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
+}
+
 inline PieceType type_of(Piece p)  {
   return PieceType(p & 7);
 }
 
 inline Color color_of(Piece p) {
+  assert(p != NO_PIECE);
   return Color(p >> 3);
 }
 
-inline Color flip(Color c) {
-  return Color(c ^ 1);
-}
-
-inline Square make_square(File f, Rank r) {
-  return Square((r << 3) | f);
-}
-
-inline bool square_is_ok(Square s) {
+inline bool is_ok(Square s) {
   return s >= SQ_A1 && s <= SQ_H8;
 }
 
@@ -379,14 +371,6 @@ inline Rank rank_of(Square s) {
   return Rank(s >> 3);
 }
 
-inline Square flip(Square s) {
-  return Square(s ^ 56);
-}
-
-inline Square mirror(Square s) {
-  return Square(s ^ 7);
-}
-
 inline Square relative_square(Color c, Square s) {
   return Square(s ^ (c * 56));
 }
@@ -400,32 +384,16 @@ inline Rank relative_rank(Color c, Square s) {
 }
 
 inline bool opposite_colors(Square s1, Square s2) {
-  int s = s1 ^ s2;
+  int s = int(s1) ^ int(s2);
   return ((s >> 3) ^ s) & 1;
 }
 
-inline int file_distance(Square s1, Square s2) {
-  return abs(file_of(s1) - file_of(s2));
-}
-
-inline int rank_distance(Square s1, Square s2) {
-  return abs(rank_of(s1) - rank_of(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return SquareDistance[s1][s2];
-}
-
-inline char piece_type_to_char(PieceType pt) {
-  return " PNBRQK"[pt];
-}
-
-inline char file_to_char(File f) {
-  return char(f - FILE_A + int('a'));
+inline char file_to_char(File f, bool tolower = true) {
+  return char(f - FILE_A + (tolower ? 'a' : 'A'));
 }
 
 inline char rank_to_char(Rank r) {
-  return char(r - RANK_1 + int('1'));
+  return char(r - RANK_1 + '1');
 }
 
 inline Square pawn_push(Color c) {
@@ -440,23 +408,11 @@ inline Square to_sq(Move m) {
   return Square(m & 0x3F);
 }
 
-inline bool is_special(Move m) {
-  return m & (3 << 14);
+inline MoveType type_of(Move m) {
+  return MoveType(m & (3 << 14));
 }
 
-inline bool is_promotion(Move m) {
-  return (m & (3 << 14)) == (1 << 14);
-}
-
-inline int is_enpassant(Move m) {
-  return (m & (3 << 14)) == (2 << 14);
-}
-
-inline int is_castle(Move m) {
-  return (m & (3 << 14)) == (3 << 14);
-}
-
-inline PieceType promotion_piece_type(Move m) {
+inline PieceType promotion_type(Move m) {
   return PieceType(((m >> 12) & 3) + 2);
 }
 
@@ -464,16 +420,9 @@ inline Move make_move(Square from, Square to) {
   return Move(to | (from << 6));
 }
 
-inline Move make_promotion(Square from, Square to, PieceType pt) {
-  return Move(to | (from << 6) | (1 << 14) | ((pt - 2) << 12)) ;
-}
-
-inline Move make_enpassant(Square from, Square to) {
-  return Move(to | (from << 6) | (2 << 14));
-}
-
-inline Move make_castle(Square from, Square to) {
-  return Move(to | (from << 6) | (3 << 14));
+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) {
@@ -487,26 +436,4 @@ inline const std::string square_to_string(Square s) {
   return ch;
 }
 
-/// Our insertion sort implementation, works with pointers and iterators and is
-/// guaranteed to be stable, as is needed.
-template<typename T, typename K>
-void sort(K firstMove, K lastMove)
-{
-  T value;
-  K cur, p, d;
-
-  if (firstMove != lastMove)
-      for (cur = firstMove + 1; cur != lastMove; cur++)
-      {
-          p = d = cur;
-          value = *p--;
-          if (*p < value)
-          {
-              do *d = *p;
-              while (--d != firstMove && *--p < value);
-              *d = value;
-          }
-      }
-}
-
-#endif // !defined(TYPES_H_INCLUDED)
+#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-2012 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,13 +17,13 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <iomanip>
 #include <iostream>
 #include <sstream>
 #include <string>
-#include <vector>
 
 #include "evaluate.h"
-#include "misc.h"
+#include "notation.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
@@ -31,20 +31,20 @@
 
 using namespace std;
 
+extern void benchmark(const Position& pos, istream& is);
+
 namespace {
 
   // FEN string of the initial position, normal chess
   const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
   // Keep track of position keys along the setup moves (from start position to the
-  // position just before to start searching). This is needed by draw detection
-  // where, due to 50 moves rule, we need to check at most 100 plies back.
-  StateInfo StateRingBuf[102], *SetupState = StateRingBuf;
+  // position just before to start searching). Needed by repetition draw detection.
+  Search::StateStackPtr SetupStates;
 
-  void set_option(istringstream& up);
-  void set_position(Position& pos, istringstream& up);
-  void go(Position& pos, istringstream& up);
-  void perft(Position& pos, istringstream& up);
+  void setoption(istringstream& up);
+  void position(Position& pos, istringstream& up);
+  void go(const Position& pos, istringstream& up);
 }
 
 
@@ -53,87 +53,85 @@ namespace {
 /// that we exit gracefully if the GUI dies unexpectedly. In addition to the UCI
 /// commands, the function also supports a few debug commands.
 
-void uci_loop() {
+void UCI::loop(const string& args) {
 
-  Position pos(StartFEN, false, 0); // The root position
-  string cmd, token;
+  Position pos(StartFEN, false, Threads.main()); // The root position
+  string token, cmd = args;
 
-  while (token != "quit")
-  {
-      if (!getline(cin, cmd)) // Block here waiting for input
+  do {
+      if (args.empty() && !getline(cin, cmd)) // Block here waiting for input
           cmd = "quit";
 
       istringstream is(cmd);
 
       is >> skipws >> token;
 
-      if (token == "quit" || token == "stop")
-          Threads.stop_thinking();
-
-      else if (token == "ponderhit")
+      if (token == "quit" || token == "stop" || token == "ponderhit")
       {
-          // The opponent has played the expected move. GUI sends "ponderhit" if
-          // we were told to ponder on the same move the opponent has played. We
-          // should continue searching but switching from pondering to normal search.
-          Search::Limits.ponder = false;
-
-          if (Search::Signals.stopOnPonderhit)
-              Threads.stop_thinking();
+          // 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;
 
-      else if (token == "go")
-          go(pos, is);
+          ss << Options["Hash"]    << " "
+             << Options["Threads"] << " " << token << " current perft";
 
-      else if (token == "ucinewgame")
-          pos.from_fen(StartFEN, false);
+          benchmark(pos, ss);
+      }
+      else if (token == "key")
+          sync_cout << hex << uppercase << setfill('0')
+                    << "position key: "   << setw(16) << pos.key()
+                    << "\nmaterial key: " << setw(16) << pos.material_key()
+                    << "\npawn key:     " << setw(16) << pos.pawn_key()
+                    << dec << sync_endl;
 
-      else if (token == "isready")
-          cout << "readyok" << endl;
-
-      else if (token == "position")
-          set_position(pos, is);
-
-      else if (token == "setoption")
-          set_option(is);
-
-      else if (token == "perft")
-          perft(pos, is);
-
-      else if (token == "d")
-          pos.print();
-
-      else if (token == "flip")
-          pos.flip_me();
+      else if (token == "uci")
+          sync_cout << "id name " << engine_info(true)
+                    << "\n"       << Options
+                    << "\nuciok"  << sync_endl;
 
       else if (token == "eval")
       {
-          read_evaluation_uci_options(pos.side_to_move());
-          cout << trace_evaluate(pos) << endl;
+          Search::RootColor = pos.side_to_move(); // Ensure it is set
+          sync_cout << Eval::trace(pos) << sync_endl;
       }
-
-      else if (token == "key")
-          cout << "key: " << hex     << pos.key()
-               << "\nmaterial key: " << pos.material_key()
-               << "\npawn key: "     << pos.pawn_key() << endl;
-
-      else if (token == "uci")
-          cout << "id name "     << engine_info(true)
-               << "\n"           << Options
-               << "\nuciok"      << endl;
+      else 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
-          cout << "Unknown command: " << cmd << endl;
-  }
+          sync_cout << "Unknown command: " << cmd << sync_endl;
+
+  } while (token != "quit" && args.empty()); // Args have one-shot behaviour
+
+  Threads.wait_for_think_finished(); // Cannot quit while search is running
 }
 
 
 namespace {
 
-  // set_position() is called when engine receives the "position" UCI
-  // command. The function sets up the position described in the given
-  // fen string ("fen") or the starting position ("startpos") and then
-  // makes the moves given in the following move list ("moves").
+  // position() is called when engine receives the "position" UCI command.
+  // The function sets up the position described in the given fen string ("fen")
+  // or the starting position ("startpos") and then makes the moves given in the
+  // following move list ("moves").
 
-  void set_position(Position& pos, istringstream& is) {
+  void position(Position& pos, istringstream& is) {
 
     Move m;
     string token, fen;
@@ -151,24 +149,22 @@ namespace {
     else
         return;
 
-    pos.from_fen(fen, Options["UCI_Chess960"]);
+    pos.set(fen, Options["UCI_Chess960"], Threads.main());
+    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>());
 
     // Parse move list (if any)
     while (is >> token && (m = move_from_uci(pos, token)) != MOVE_NONE)
     {
-        pos.do_move(m, *SetupState);
-
-        // Increment pointer to StateRingBuf circular buffer
-        if (++SetupState - StateRingBuf >= 102)
-            SetupState = StateRingBuf;
+        SetupStates->push(StateInfo());
+        pos.do_move(m, SetupStates->top());
     }
   }
 
 
-  // set_option() is called when engine receives the "setoption" UCI command. The
+  // setoption() is called when engine receives the "setoption" UCI command. The
   // function updates the UCI option ("name") to the given value ("value").
 
-  void set_option(istringstream& is) {
+  void setoption(istringstream& is) {
 
     string token, name, value;
 
@@ -182,81 +178,42 @@ namespace {
     while (is >> token)
         value += string(" ", !value.empty()) + token;
 
-    if (!Options.count(name))
-        cout << "No such option: " << name << endl;
-
-    else if (value.empty()) // UCI buttons don't have a value
-        Options[name] = true;
-
-    else
+    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 then starts
-  // the main searching thread.
+  // the thinking time and other parameters from the input string, and starts
+  // the search.
 
-  void go(Position& pos, istringstream& is) {
+  void go(const Position& pos, istringstream& is) {
 
-    string token;
     Search::LimitsType limits;
-    std::vector<Move> searchMoves;
-    int time[] = { 0, 0 }, inc[] = { 0, 0 };
+    vector<Move> searchMoves;
+    string token;
 
     while (is >> token)
     {
-        if (token == "infinite")
-            limits.infinite = true;
-        else if (token == "ponder")
-            limits.ponder = true;
-        else if (token == "wtime")
-            is >> time[WHITE];
-        else if (token == "btime")
-            is >> time[BLACK];
-        else if (token == "winc")
-            is >> inc[WHITE];
-        else if (token == "binc")
-            is >> inc[BLACK];
-        else if (token == "movestogo")
-            is >> limits.movesToGo;
-        else if (token == "depth")
-            is >> limits.maxDepth;
-        else if (token == "nodes")
-            is >> limits.maxNodes;
-        else if (token == "movetime")
-            is >> limits.maxTime;
-        else if (token == "searchmoves")
+        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;
     }
 
-    limits.time = time[pos.side_to_move()];
-    limits.increment = inc[pos.side_to_move()];
-
-    Threads.start_thinking(pos, limits, searchMoves, true);
-  }
-
-
-  // perft() is called when engine receives the "perft" command. The function
-  // calls perft() with the required search depth then prints counted leaf nodes
-  // and elapsed time.
-
-  void perft(Position& pos, istringstream& is) {
-
-    int depth, time;
-
-    if (!(is >> depth))
-        return;
-
-    time = system_time();
-
-    int64_t n = Search::perft(pos, depth * ONE_PLY);
-
-    time = system_time() - time;
-
-    std::cout << "\nNodes " << n
-              << "\nTime (ms) " << time
-              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
+    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-2012 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,74 +18,87 @@
 */
 
 #include <algorithm>
+#include <cassert>
+#include <cstdlib>
 #include <sstream>
 
+#include "evaluate.h"
 #include "misc.h"
 #include "thread.h"
+#include "tt.h"
 #include "ucioption.h"
 
 using std::string;
 
-OptionsMap Options; // Global object
+UCI::OptionsMap Options; // Global object
+
+namespace UCI {
+
+/// 'On change' actions, triggered by an option's value change
+void on_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
-static bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); }
+bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); }
 
 bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
-  return lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), ci_less);
+  return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), ci_less);
 }
 
 
-/// OptionsMap c'tor initializes the UCI options to their hard coded default
-/// values and initializes the default value of "Threads" and "Min Split Depth"
-/// parameters according to the number of CPU cores detected.
+/// init() initializes the UCI options to their hard coded default values
 
-OptionsMap::OptionsMap() {
+void init(OptionsMap& o) {
 
-  int cpus = std::min(cpu_count(), MAX_THREADS);
-  int msd = cpus < 8 ? 4 : 7;
-  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["Min Split Depth"]             = UCIOption(msd, 4, 7);
-  o["Max Threads per Split Point"] = UCIOption(5, 4, 8);
-  o["Threads"]                     = UCIOption(cpus, 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);
+  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(60, 0, 30000);
+  o["Emergency Move Time"]         = Option(30, 0, 5000);
+  o["Minimum Thinking Time"]       = Option(20, 0, 5000);
+  o["Slow Mover"]                  = Option(70, 10, 1000);
+  o["UCI_Chess960"]                = Option(false);
+  o["UCI_AnalyseMode"]             = Option(false, on_eval);
 }
 
 
-/// operator<<() is used to output all the UCI options in chronological insertion
-/// order (the idx field) and in the format defined by the UCI protocol.
+/// operator<<() is used to print all the options default values in chronological
+/// insertion order (the idx field) and in the format defined by the UCI protocol.
+
 std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 
-  for (size_t idx = 0; idx < om.size(); idx++)
+  for (size_t idx = 0; idx < om.size(); ++idx)
       for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it)
           if (it->second.idx == idx)
           {
-              const UCIOption& o = it->second;
+              const Option& o = it->second;
               os << "\noption name " << it->first << " type " << o.type;
 
               if (o.type != "button")
@@ -100,28 +113,52 @@ std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
 }
 
 
-/// UCIOption class c'tors
+/// Option c'tors and conversion operators
 
-UCIOption::UCIOption(const char* v) : type("string"), min(0), max(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 = v; }
 
-UCIOption::UCIOption(bool v, string t) : type(t), min(0), max(0), idx(Options.size())
+Option::Option(bool v, Fn* f) : type("check"), min(0), max(0), idx(Options.size()), on_change(f)
 { defaultValue = currentValue = (v ? "true" : "false"); }
 
-UCIOption::UCIOption(int v, int minv, int maxv) : type("spin"), min(minv), max(maxv), idx(Options.size())
+Option::Option(Fn* f) : type("button"), min(0), max(0), idx(Options.size()), on_change(f)
+{}
+
+Option::Option(int v, int minv, int maxv, Fn* f) : type("spin"), min(minv), max(maxv), idx(Options.size()), on_change(f)
 { std::ostringstream ss; ss << v; defaultValue = currentValue = ss.str(); }
 
 
-/// UCIOption::operator=() updates currentValue. Normally it's up to the GUI to
-/// check for option's limits, but we could receive the new value directly from
-/// the user by teminal window, so let's check the bounds anyway.
+Option::operator int() const {
+  assert(type == "check" || type == "spin");
+  return (type == "spin" ? atoi(currentValue.c_str()) : currentValue == "true");
+}
 
-void UCIOption::operator=(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()
-      && (type == "check" || type == "button") == (v == "true" || v == "false")
-      && (type != "spin" || (atoi(v.c_str()) >= min && atoi(v.c_str()) <= max)))
+  if (   (type != "button" && v.empty())
+      || (type == "check" && v != "true" && v != "false")
+      || (type == "spin" && (atoi(v.c_str()) < min || atoi(v.c_str()) > max)))
+      return *this;
+
+  if (type != "button")
       currentValue = v;
+
+  if (on_change)
+      (*on_change)(*this);
+
+  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-2012 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,36 +17,38 @@
   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>
 
-struct OptionsMap;
+namespace UCI {
+
+class Option;
+
+/// Custom comparator because UCI options should be case insensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
+
+/// Our options container is actually a std::map
+typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
+
+/// Option class implements an option as defined by UCI protocol
+class Option {
+
+  typedef void (Fn)(const Option&);
 
-/// UCIOption class implements an option as defined by UCI protocol
-class UCIOption {
 public:
-  UCIOption() {} // Required by std::map::operator[]
-  UCIOption(const char* v);
-  UCIOption(bool v, std::string type = "check");
-  UCIOption(int v, int min, int max);
+  Option(Fn* = NULL);
+  Option(bool v, Fn* = NULL);
+  Option(const char* v, Fn* = NULL);
+  Option(int v, int min, int max, Fn* = NULL);
 
-  void operator=(const std::string& v);
-  void operator=(bool v) { *this = std::string(v ? "true" : "false"); }
-
-  operator int() const {
-    assert(type == "check" || type == "button" || type == "spin");
-    return (type == "spin" ? atoi(currentValue.c_str()) : currentValue == "true");
-  }
-
-  operator std::string() const {
-    assert(type == "string");
-    return currentValue;
-  }
+  Option& operator=(const std::string& v);
+  operator int() const;
+  operator std::string() const;
 
 private:
   friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
@@ -54,21 +56,14 @@ private:
   std::string defaultValue, currentValue, type;
   int min, max;
   size_t idx;
+  Fn* on_change;
 };
 
+void init(OptionsMap&);
+void loop(const std::string&);
 
-/// Custom comparator because UCI options should be case insensitive
-struct CaseInsensitiveLess {
-  bool operator() (const std::string&, const std::string&) const;
-};
+} // namespace UCI
 
+extern UCI::OptionsMap Options;
 
-/// Our options container is actually a map with a customized c'tor
-struct OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
-  OptionsMap();
-};
-
-extern std::ostream& operator<<(std::ostream&, const OptionsMap&);
-extern OptionsMap Options;
-
-#endif // !defined(UCIOPTION_H_INCLUDED)
+#endif // #ifndef UCIOPTION_H_INCLUDED