Revert "Another PSQT tuning round"

At longer TC of 1'+0" patch fails:
Orig - Mod: 841 - 819 (-6 elo!)

Just before the release ;-)

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

polyglot.ini

@@ -7,7 +7,7 @@ EngineCommand = ./stockfish
 Book = false
 BookFile = book.bin
 
-Log = true
+Log = false
 LogFile = stockfish.log
 
 Resign = true
@@ -19,28 +19,18 @@ Hash = 128
 Threads = 1
 OwnBook = false
 Book File = book.bin
+Best Book Move = false
 Use Search Log = false
+Search Log Filename = SearchLog.txt
 Mobility (Middle Game) = 100
 Mobility (Endgame) = 100
 Pawn Structure (Middle Game) = 100
 Pawn Structure (Endgame) = 100
 Passed Pawns (Middle Game) = 100
 Passed Pawns (Endgame) = 100
+Space = 100
 Aggressiveness = 100
 Cowardice = 100
-King Safety Curve = Quadratic
-Quadratic = Linear
-King Safety Coefficient = 40
-King Safety X Intercept = 0
-King Safety Max Slope = 30
-King Safety Max Value = 500
-Queen Contact Check Bonus = 3
-Queen Check Bonus = 2
-Rook Check Bonus = 1
-Bishop Check Bonus = 1
-Knight Check Bonus = 1
-Discovered Check Bonus = 3
-Mate Threat Bonus = 3
 Check Extension (PV nodes) = 2
 Check Extension (non-PV nodes) = 1
 Single Reply Extension (PV nodes) = 2
@@ -53,11 +43,6 @@ Passed Pawn Extension (PV nodes) = 1
 Passed Pawn Extension (non-PV nodes) = 0
 Pawn Endgame Extension (PV nodes) = 2
 Pawn Endgame Extension (non-PV nodes) = 2
-Full Depth Moves (PV nodes) = 14
-Full Depth Moves (non-PV nodes) = 3
-Threat Depth = 5
-Futility Pruning (Main Search) = true
-Futility Pruning (Quiescence Search) = true
 Randomness = 0
 Minimum Split Depth = 4
 Maximum Number of Threads per Split Point = 5

src/Makefile

@@ -1,7 +1,7 @@
 # Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-# Copyright (C) 2004-2007 Tord Romstad
+# Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-# Copyright (C) 2008 Marco Costalba
+# Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
-
+#
 # This file is part of Stockfish.
 #
 # Stockfish is free software: you can redistribute it and/or modify
@@ -18,289 +18,490 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-### Executable name. Do not change
+### ==========================================================================
+### Section 1. General Configuration
+### ==========================================================================
+
+### Executable name
 EXE = stockfish
 
+### Installation dir definitions
+PREFIX = /usr/local
+BINDIR = $(PREFIX)/bin
 
-### ==========================================================================
+### Built-in benchmark for pgo-builds
-### Compiler speed switches for both GCC and ICC. These settings are generally
-### fast on a broad range of systems, but may be changed experimentally
-### ==========================================================================
-GCCFLAGS = -O3 -msse
-ICCFLAGS = -fast -msse
-ICCFLAGS-OSX = -fast -mdynamic-no-pic
-
-
-### ==========================================================================
-### Enable/disable debugging, disabled by default
-### ==========================================================================
-GCCFLAGS += -DNDEBUG
-ICCFLAGS += -DNDEBUG
-ICCFLAGS-OSX += -DNDEBUG
-
-
-### ==========================================================================
-### Remove below comments to compile for a big-endian machine
-### ==========================================================================
-#GCCFLAGS += -DBIGENDIAN
-#ICCFLAGS += -DBIGENDIAN
-#ICCFLAGS-OSX += -DBIGENDIAN
-
-
-### ==========================================================================
-### Run built-in benchmark for pgo-builds with:  32MB hash  1 thread  10 depth
-### These settings are generally fast, but may be changed experimentally
-### ==========================================================================
 PGOBENCH = ./$(EXE) bench 32 1 10 default depth
 
-
+### Object files
-### General compiler settings. Do not change
-GCCFLAGS += -g -Wall -fno-exceptions -fno-rtti
-ICCFLAGS += -g -Wall -fno-exceptions -fno-rtti -wd383,869,981,10187,10188,11505,11503
-ICCFLAGS-OSX += -g -Wall -fno-exceptions -fno-rtti -wd383,869,981,10187,10188,11505,11503
-
-
-### General linker settings. Do not change
-LDFLAGS  = -lpthread
-
-
-### Object files. Do not change
 OBJS = application.o bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
 	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
 	position.o direction.o tt.o value.o uci.o ucioption.o \
 	mersenne.o book.o bitbase.o san.o benchmark.o
 
 
-### General rules. Do not change
+### ==========================================================================
+### Section 2. High-level Configuration
+### ==========================================================================
+#
+# flag                --- Comp switch --- Description
+# ----------------------------------------------------------------------------
+#
+# debug = no/yes      --- -DNDEBUG    --- Enable/Disable debug mode
+# optimize = yes/no   --- (-O3/-fast etc.) --- Enable/Disable optimizations
+# arch = (name)       --- (-arch)     --- Target architecture
+# os = (name)         ---             --- Target operating system
+# bits = 64/32        --- -DIS_64BIT  --- 64-/32-bit operating system
+# bigendian = no/yes  --- -DBIGENDIAN --- big/little-endian byte order
+# prefetch = no/yes   --- -DUSE_PREFETCH  --- Use prefetch x86 asm-instruction
+# bsfq = no/yes       --- -DUSE_BSFQ  --- Use bsfq x86_64 asm-instruction
+#                                     --- (Works only with GCC and ICC 64-bit)
+# popcnt = no/yes     --- -DUSE_POPCNT --- Use popcnt x86_64 asm-instruction
+#
+# Note that Makefile is space sensitive, so when adding new architectures
+# or modifying existing flags, you have to make sure there are no extra spaces
+# at the end of the line for flag values.
+
+### 2.1. General
+debug = no
+optimize = yes
+
+### 2.2 Architecture specific
+
+# General-section
+ifeq ($(ARCH),general-64)
+	arch = any
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),general-32)
+	arch = any
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),bigendian-64)
+	arch = any
+	os = any
+	bits = 64
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),bigendian-32)
+	arch = any
+	os = any
+	bits = 32
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+# x86-section
+ifeq ($(ARCH),x86-64)
+	arch = x86_64
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = no
+endif
+
+ifeq ($(ARCH),x86-64-modern)
+	arch = x86_64
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = yes
+endif
+
+ifeq ($(ARCH),x86-32)
+	arch = i386
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = yes
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),x86-32-old)
+	arch = i386
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+# osx-section
+ifeq ($(ARCH),osx-ppc-64)
+	arch = ppc64
+	os = osx
+	bits = 64
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-ppc-32)
+	arch = ppc
+	os = osx
+	bits = 32
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-x86-64)
+	arch = x86_64
+	os = osx
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-x86-32)
+	arch = i386
+	os = osx
+	bits = 32
+	bigendian = no
+	prefetch = yes
+	bsfq = no
+	popcnt = no
+endif
+
+
+### ==========================================================================
+### Section 3. Low-level configuration
+### ==========================================================================
+
+### 3.1 Selecting compiler (default = gcc)
+ifeq ($(COMP),)
+	COMP=gcc
+endif
+
+ifeq ($(COMP),gcc)
+	comp=gcc
+	CXX=g++
+	profile_prepare = gcc-profile-prepare
+	profile_make = gcc-profile-make
+	profile_use = gcc-profile-use
+	profile_clean = gcc-profile-clean
+endif
+
+ifeq ($(COMP),icc)
+	comp=icc
+	CXX=icpc
+	profile_prepare = icc-profile-prepare
+	profile_make = icc-profile-make
+	profile_use = icc-profile-use
+	profile_clean = icc-profile-clean
+endif
+
+### 3.2 General compiler settings
+CXXFLAGS += -g -Wall -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+
+ifeq ($(comp),icc)
+	CXXFLAGS += -wd383,869,981,10187,10188,11505,11503
+endif
+
+ifeq ($(os),osx)
+	CXXFLAGS += -arch $(arch)
+endif
+
+### 3.3 General linker settings
+LDFLAGS += -lpthread $(EXTRALDFLAGS)
+
+ifeq ($(os),osx)
+	LDFLAGS += -arch $(arch)
+endif
+
+### 3.4 Debugging
+ifeq ($(debug),no)
+	CXXFLAGS += -DNDEBUG
+endif
+
+### 3.5 Optimization
+ifeq ($(optimize),yes)
+
+	ifeq ($(comp),gcc)
+		CXXFLAGS += -O3
+
+		ifeq ($(os),osx)
+			ifeq ($(arch),i386)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+			ifeq ($(arch),x86_64)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+		endif
+	endif
+
+	ifeq ($(comp),icc)
+		CXXFLAGS += -fast
+
+		ifeq ($(os),osx)
+			CXXFLAGS += -mdynamic-no-pic
+		endif
+	endif
+endif
+
+### 3.6. Bits
+ifeq ($(bits),64)
+	CXXFLAGS += -DIS_64BIT
+endif
+
+### 3.7 Endianess
+ifeq ($(bigendian),yes)
+	CXXFLAGS += -DBIGENDIAN
+endif
+
+### 3.8 prefetch
+ifeq ($(prefetch),yes)
+	CXXFLAGS += -msse
+	DEPENDFLAGS += -msse
+else
+	CXXFLAGS += -DNO_PREFETCH
+endif
+
+### 3.9 bsfq
+ifeq ($(bsfq),yes)
+	CXXFLAGS += -DUSE_BSFQ
+endif
+
+### 3.10 popcnt
+ifeq ($(popcnt),yes)
+	CXXFLAGS += -DUSE_POPCNT
+endif
+
+### ==========================================================================
+### Section 4. Public targets
+### ==========================================================================
+
 default:
-	$(MAKE) gcc
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) build
 
 help:
 	@echo ""
-	@echo "Makefile options:"
+	@echo "To compile stockfish, type: "
 	@echo ""
-	@echo "make                >  Default: Compiler = g++"
+	@echo "make target ARCH=arch [COMP=comp]"
-	@echo "make icc            >  Compiler = icpc"
+	@echo ""
-	@echo "make icc-profile    >  Compiler = icpc + automatic pgo-build"
+	@echo "Supported targets:"
-	@echo "make icc-profile-popcnt >  Compiler = icpc + automatic pgo-build + popcnt-support"
+	@echo ""
-	@echo "make osx-ppc32      >  PPC-Mac OS X 32 bit. Compiler = g++"
+	@echo "build                > Build unoptimized version"
-	@echo "make osx-ppc64      >  PPC-Mac OS X 64 bit. Compiler = g++"
+	@echo "profile-build        > Build PGO-optimized version"
-	@echo "make osx-x86        >  x86-Mac OS X 32 bit. Compiler = g++"
+	@echo "popcnt-profile-build > Build PGO-optimized version with optional popcnt-support"
-	@echo "make osx-x86_64     >  x86-Mac OS X 64 bit. Compiler = g++"
+	@echo "strip                > Strip executable"
-	@echo "make osx-icc32      >  x86-Mac OS X 32 bit. Compiler = icpc"
+	@echo "install              > Install executable"
-	@echo "make osx-icc64      >  x86-Mac OS X 64 bit. Compiler = icpc"
+	@echo "clean                > Clean up"
-	@echo "make osx-icc32-profile > OSX 32 bit. Compiler = icpc + automatic pgo-build"
+	@echo "testrun              > Make sample run"
-	@echo "make osx-icc64-profile > OSX 64 bit. Compiler = icpc + automatic pgo-build"
+	@echo ""
-	@echo "make strip          >  Strip executable"
+	@echo "Supported archs:"
-	@echo "make clean          >  Clean up"
+	@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 ""
+	@echo "Supported comps:"
+	@echo ""
+	@echo "gcc                  > Gnu compiler (default)"
+	@echo "icc                  > Intel compiler"
+	@echo ""
+	@echo "Non-standard targets:"
+	@echo ""
+	@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 ""
 
-all: $(EXE) .depend
+build:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
 
-clean:
+profile-build:
-	$(RM) *.o .depend *~ $(EXE)
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
-
+	@echo ""
-
+	@echo "Step 0/4. Preparing for profile build."
-### Possible targets. You may add your own ones here
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
-gcc:
+	@echo ""
-	$(MAKE) \
+	@echo "Step 1/4. Building executable for benchmark ..."
-	CXX='g++' \
-	CXXFLAGS="$(GCCFLAGS)" \
-	all
-
-icc:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS)" \
-	all
-
-icc-profile-make:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS)" \
-	CXXFLAGS+='-prof-gen=srcpos -prof_dir ./profdir' \
-	all
-
-icc-profile-use:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS)" \
-	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
-	all
-
-icc-profile:
-	@rm -rf profdir
-	@mkdir profdir
 	@touch *.cpp *.h
-	$(MAKE) icc-profile-make
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
 	@echo ""
-	@echo "Running benchmark for pgo-build ..."
+	@echo "Step 2/4. Running benchmark for pgo-build ..."
 	@$(PGOBENCH) > /dev/null
-	@echo "Benchmark finished. Build final executable now ..."
 	@echo ""
-	@touch *.cpp *.h
+	@echo "Step 3/4. Building final executable ..."
-	$(MAKE) icc-profile-use
+	@touch *.cpp
-	@rm -rf profdir bench.txt
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
-
-icc-profile-make-with-popcnt:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS) -DUSE_POPCNT" \
-	CXXFLAGS+='-prof-gen=srcpos -prof_dir ./profdir' \
-	all
-
-icc-profile-use-with-popcnt:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS) -DUSE_POPCNT" \
-	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
-	all
-
-icc-profile-popcnt:
-	@rm -rf profdir
-	@mkdir profdir
-	@touch *.cpp *.h
-	$(MAKE) icc-profile-make
 	@echo ""
-	@echo "Running benchmark for pgo-build (popcnt disabled)..."
+	@echo "Step 4/4. Deleting profile data ..."
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
+
+popcnt-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
-	@touch *.cpp *.h
-	$(MAKE) icc-profile-make-with-popcnt
 	@echo ""
-	@echo "Running benchmark for pgo-build (popcnt enabled)..."
+	@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 "Benchmarks finished. Build final executable now ..."
 	@echo ""
+	@echo "Step 5/6. Building final executable ..."
 	@touch *.cpp *.h
-	$(MAKE) icc-profile-use-with-popcnt
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
-	@rm -rf profdir bench.txt
-
-
-osx-ppc32:
-	$(MAKE) \
-	CXX='g++' \
-	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch ppc' \
-	LDFLAGS+='-arch ppc' \
-	all
-
-osx-ppc64:
-	$(MAKE) \
-	CXX='g++' \
-	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch ppc64' \
-	LDFLAGS+='-arch ppc64' \
-	all
-
-osx-x86:
-	$(MAKE) \
-	CXX='g++' \
-	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch i386' \
-	LDFLAGS+='-arch i386' \
-	all
-
-osx-x86_64:
-	$(MAKE) \
-	CXX='g++' \
-	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch x86_64' \
-	LDFLAGS+='-arch x86_64' \
-	all
-	
-osx-icc32:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch i386' \
-	LDFLAGS+='-arch i386' \
-	all
-
-osx-icc64:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch x86_64' \
-	LDFLAGS+='-arch x86_64' \
-	all
-
-osx-icc32-profile-make:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch i386' \
-	CXXFLAGS+='-prof_gen -prof_dir ./profdir' \
-	LDFLAGS+='-arch i386' \
-	all
-
-osx-icc32-profile-use:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch i386' \
-	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
-	LDFLAGS+='-arch i386' \
-	all
-
-osx-icc32-profile:
-	@rm -rf profdir
-	@mkdir profdir
-	@touch *.cpp *.h
-	$(MAKE) osx-icc32-profile-make
 	@echo ""
-	@echo "Running benchmark for pgo-build ..."
+	@echo "Step 6/6. Deleting profile data ..."
-	@$(PGOBENCH) > /dev/null
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
-	@echo "Benchmark finished. Build final executable now ..."
 	@echo ""
-	@touch *.cpp *.h
-	$(MAKE) osx-icc32-profile-use
-	@rm -rf profdir bench.txt
-
-osx-icc64-profile-make:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch x86_64' \
-	CXXFLAGS+='-prof_gen -prof_dir ./profdir' \
-	LDFLAGS+='-arch x86_64' \
-	all
-
-osx-icc64-profile-use:
-	$(MAKE) \
-	CXX='icpc' \
-	CXXFLAGS="$(ICCFLAGS-OSX)" \
-	CXXFLAGS+='-arch x86_64' \
-	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
-	LDFLAGS+='-arch x86_64' \
-	all
-
-osx-icc64-profile:
-	@rm -rf profdir
-	@mkdir profdir
-	@touch *.cpp *.h
-	$(MAKE) osx-icc64-profile-make
-	@echo ""
-	@echo "Running benchmark for pgo-build ..."
-	@$(PGOBENCH) > /dev/null
-	@echo "Benchmark finished. Build final executable now ..."
-	@echo ""
-	@touch *.cpp *.h
-	$(MAKE) osx-icc64-profile-use
-	@rm -rf profdir bench.txt
-
-
 
 strip:
 	strip $(EXE)
 
+install:
+	-mkdir -p -m 755 $(BINDIR)
+	-cp $(EXE) $(BINDIR)
+	-strip $(BINDIR)/$(EXE)
+
+clean:
+	$(RM) $(EXE) *.o .depend *~ core bench.txt
+
+testrun:
+	@$(PGOBENCH)
+
+### ==========================================================================
+### Section 5. Private targets
+### ==========================================================================
+
+all: $(EXE) .depend
+
+config-sanity:
+	@echo ""
+	@echo "Config:"
+	@echo "debug: '$(debug)'"
+	@echo "optimize: '$(optimize)'"
+	@echo "arch: '$(arch)'"
+	@echo "os: '$(os)'"
+	@echo "bits: '$(bits)'"
+	@echo "bigendian: '$(bigendian)'"
+	@echo "prefetch: '$(prefetch)'"
+	@echo "bsfq: '$(bsfq)'"
+	@echo "popcnt: '$(popcnt)'"
+	@echo ""
+	@echo "Flags:"
+	@echo "CXX: $(CXX)"
+	@echo "CXXFLAGS: $(CXXFLAGS)"
+	@echo "LDFLAGS: $(LDFLAGS)"
+	@echo ""
+	@echo "Testing config sanity. If this fails, try 'make help' ..."
+	@echo ""
+	@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 "$(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"
 
-### Compilation. Do not change
 $(EXE): $(OBJS)
-	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
+	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
 
+gcc-profile-prepare:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) gcc-profile-clean
+
+gcc-profile-make:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-generate' \
+	EXTRALDFLAGS='-lgcov' \
+	all
+
+gcc-profile-use:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-use' \
+	all
+
+gcc-profile-clean:
+	@rm -rf *.gcda *.gcno bench.txt
+
+icc-profile-prepare:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) icc-profile-clean
+	@mkdir profdir
+
+icc-profile-make:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
+	all
+
+icc-profile-use:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
+	all
+
+icc-profile-clean:
+	@rm -rf profdir bench.txt
 
-### Dependencies. Do not change
 .depend:
-	$(CXX) -msse -MM $(OBJS:.o=.cpp) > $@
+	-@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null
+
+-include .depend
+
+
+### ==========================================================================
+### Section 6. Non-standard targets
+### ==========================================================================
+
+hpux:
+	$(MAKE) \
+	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG' \
+	CXXFLAGS="" \
+	LDFLAGS="" \
+	all
 
-include .depend

src/application.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -49,6 +49,7 @@ Application::Application() {
     Position::init_piece_square_tables();
     init_eval(1);
     init_bitbases();
+    init_search();
     init_threads();
 
     // Make random number generation less deterministic, for book moves
@@ -56,12 +57,6 @@ Application::Application() {
         genrand_int32();
 }
 
-Application::~Application() {
-
-  stop_threads();
-  quit_eval();
-}
-
 void Application::initialize() {
 
   // A static Application object is allocated
@@ -69,7 +64,15 @@ void Application::initialize() {
   static Application singleton;
 }
 
+void Application::free_resources() {
+
+  // Warning, following functions reference global objects that
+  // must be still alive when free_resources() is called.
+  exit_threads();
+  quit_eval();
+}
+
 void Application::exit_with_failure() {
 
-  exit(EXIT_FAILURE); // d'tor will be called automatically
+  exit(EXIT_FAILURE);
 }

src/application.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -29,10 +29,10 @@ class Application {
 
   Application();
   Application(const Application&);
- ~Application();
 
 public:
   static void initialize();
+  static void free_resources();
   static void exit_with_failure();
 };
 

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -38,8 +38,8 @@ using namespace std;
 
 const string BenchmarkPositions[] = {
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
-  "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
+  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
-  "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
+  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
   "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14",
   "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14",
@@ -84,9 +84,9 @@ void benchmark(const string& commandLine) {
   }
   csStr >> threads;
   csVal >> val;
-  if (val < 1 || val > THREAD_MAX)
+  if (val < 1 || val > MAX_THREADS)
   {
-      cerr << "The number of threads must be between 1 and " << THREAD_MAX << endl;
+      cerr << "The number of threads must be between 1 and " << MAX_THREADS << endl;
       Application::exit_with_failure();
   }
   set_option_value("Hash", ttSize);
@@ -151,14 +151,19 @@ void benchmark(const string& commandLine) {
   {
       Move moves[1] = {MOVE_NONE};
       int dummy[2] = {0, 0};
-      Position pos(*it);
+      Position pos(*it, 0);
       cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
       if (limitType == "perft")
-          totalNodes += perft(pos, maxDepth * OnePly);
+      {
-      else if (!think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+          int64_t perftCnt = perft(pos, maxDepth * OnePly);
+          cerr << "\nPerft " << maxDepth << " result (nodes searched): " << perftCnt << endl << endl;
+          totalNodes += perftCnt;
+      } else {
+          if (!think(pos, false, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
               break;
           totalNodes += nodes_searched();
       }
+  }
 
   cnt = get_system_time() - startTime;
   cerr << "==============================="

src/benchmark.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/bitbase.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -226,8 +226,9 @@ Bitboard StepAttackBB[16][64];
 Bitboard RayBB[64][8];
 Bitboard BetweenBB[64][64];
 
+Bitboard SquaresInFrontMask[2][64];
 Bitboard PassedPawnMask[2][64];
-Bitboard OutpostMask[2][64];
+Bitboard AttackSpanMask[2][64];
 
 Bitboard BishopPseudoAttacks[64];
 Bitboard RookPseudoAttacks[64];
@@ -246,14 +247,12 @@ namespace {
   void init_ray_bitboards();
   void init_attacks();
   void init_between_bitboards();
+  void init_pseudo_attacks();
+  Bitboard index_to_bitboard(int index, Bitboard mask);
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin, int fmax, int rmin, int rmax);
-  Bitboard index_to_bitboard(int index, Bitboard mask);
+  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
-  void init_sliding_attacks(Bitboard attacks[],
+                            const int shift[], const Bitboard mult[], int deltas[][2]);
-                            int attackIndex[], Bitboard mask[],
-                            const int shift[2], const Bitboard mult[],
-                            int deltas[][2]);
-  void init_pseudo_attacks();
 }
 
 
@@ -265,10 +264,13 @@ namespace {
 /// standard output.  This is sometimes useful for debugging.
 
 void print_bitboard(Bitboard b) {
-  for(Rank r = RANK_8; r >= RANK_1; r--) {
+
+  for (Rank r = RANK_8; r >= RANK_1; r--)
+  {
       std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
       for (File f = FILE_A; f <= FILE_H; f++)
           std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
+
       std::cout << "|" << std::endl;
   }
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
@@ -279,8 +281,10 @@ void print_bitboard(Bitboard b) {
 /// program initialization.
 
 void init_bitboards() {
+
   int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
   int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
+
   init_masks();
   init_ray_bitboards();
   init_attacks();
@@ -297,8 +301,8 @@ void init_bitboards() {
 
 #if defined(IS_64BIT) && !defined(USE_BSFQ)
 
-CACHE_LINE_ALIGNMENT
+static CACHE_LINE_ALIGNMENT
-static const int BitTable[64] = {
+const int BitTable[64] = {
   0, 1, 2, 7, 3, 13, 8, 19, 4, 25, 14, 28, 9, 34, 20, 40, 5, 17, 26, 38, 15,
   46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63, 6, 12, 18, 24, 27, 33, 39,
   16, 37, 45, 47, 30, 53, 49, 56, 62, 11, 23, 32, 36, 44, 52, 55, 61, 22, 43,
@@ -326,6 +330,7 @@ const int BitTable[64] = {
 };
 
 Square first_1(Bitboard b) {
+
   b ^= (b - 1);
   uint32_t fold = int(b) ^ int(b >> 32);
   return Square(BitTable[(fold * 0x783a9b23) >> 26]);
@@ -348,46 +353,26 @@ union b_union {
 
 Square pop_1st_bit(Bitboard* bb) {
 
-   b_union* u;
+   b_union u;
    Square ret;
 
-   u = (b_union*)bb;
+   u.b = *bb;
 
-   if (u->dw.l)
+   if (u.dw.l)
    {
-       ret = Square(BitTable[((u->dw.l ^ (u->dw.l - 1)) * 0x783a9b23) >> 26]);
+       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
-       u->dw.l &= (u->dw.l - 1);
+       u.dw.l &= (u.dw.l - 1);
+       *bb = u.b;
        return ret;
    }
-   ret = Square(BitTable[((~(u->dw.h ^ (u->dw.h - 1))) * 0x783a9b23) >> 26]);
+   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
-   u->dw.h &= (u->dw.h - 1);
+   u.dw.h &= (u.dw.h - 1);
+   *bb = u.b;
    return ret;
 }
 
 #endif
 
-int bitScanReverse32(uint32_t b)
-{
-   int result = 0;
-
-   if (b > 0xFFFF) {
-      b >>= 16;
-      result += 16;
-   }
-   if (b > 0xFF) {
-      b >>= 8;
-      result += 8;
-   }
-   if (b > 0xF) {
-      b >>= 4;
-      result += 4;
-   }
-   if (b > 0x3) {
-      b >>= 2;
-      result += 2;
-   }
-   return result + (b > 0) + (b > 1);
-}
 
 namespace {
 
@@ -397,39 +382,46 @@ namespace {
   // be necessary to touch any of them.
 
   void init_masks() {
+
     SetMaskBB[SQ_NONE] = 0ULL;
     ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
-    for(Square s = SQ_A1; s <= SQ_H8; s++) {
+
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    {
         SetMaskBB[s] = (1ULL << s);
         ClearMaskBB[s] = ~SetMaskBB[s];
     }
+
     for (Color c = WHITE; c <= BLACK; c++)
-      for(Square s = SQ_A1; s <= SQ_H8; s++) {
+        for (Square s = SQ_A1; s <= SQ_H8; s++)
-        PassedPawnMask[c][s] =
+        {
-          in_front_bb(c, s) & this_and_neighboring_files_bb(s);
+            SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
-        OutpostMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
+            PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s);
+            AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
         }
 
     for (Bitboard b = 0ULL; b < 256ULL; b++)
         BitCount8Bit[b] = (uint8_t)count_1s(b);
   }
 
+  int remove_bit_8(int i) { return ((i & ~15) >> 1) | (i & 7); }
 
   void init_ray_bitboards() {
-    int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-    for(int i = 0; i < 128; i = (i + 9) & ~8) {
-      for(int j = 0; j < 8; j++) {
-        RayBB[(i&7)|((i>>4)<<3)][j] = EmptyBoardBB;
-        for(int k = i + d[j]; (k & 0x88) == 0; k += d[j])
-          set_bit(&(RayBB[(i&7)|((i>>4)<<3)][j]), Square((k&7)|((k>>4)<<3)));
-      }
-    }
-  }
 
+    int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
+
+    for (int i = 0; i < 128; i = (i + 9) & ~8)
+        for (int j = 0; j < 8; j++)
+        {
+            RayBB[remove_bit_8(i)][j] = EmptyBoardBB;
+            for (int k = i + d[j]; (k & 0x88) == 0; k += d[j])
+                set_bit(&(RayBB[remove_bit_8(i)][j]), Square(remove_bit_8(k)));
+        }
+  }
 
   void init_attacks() {
-    int i, j, k, l;
+
-    int step[16][8] =  {
+    const int step[16][8] =  {
       {0},
       {7,9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
       {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}, {0}, {0},
@@ -437,102 +429,112 @@ namespace {
       {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
     };
 
-    for(i = 0; i < 64; i++) {
+    for (int i = 0; i < 64; i++)
-      for(j = 0; j <= int(BK); j++) {
+        for (int j = 0; j <= int(BK); j++)
+        {
             StepAttackBB[j][i] = EmptyBoardBB;
-        for(k = 0; k < 8 && step[j][k] != 0; k++) {
+            for (int k = 0; k < 8 && step[j][k] != 0; k++)
-          l = i + step[j][k];
+            {
+                int l = i + step[j][k];
                 if (l >= 0 && l < 64 && abs((i & 7) - (l & 7)) < 3)
                     StepAttackBB[j][i] |= (1ULL << l);
            }
         }
   }
-  }
-
 
   Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
                            int fmin=0, int fmax=7, int rmin=0, int rmax=7) {
     Bitboard result = 0ULL;
-    int rk = sq / 8, fl = sq % 8, r, f, i;
+    int rk = sq / 8;
-    for(i = 0; i < dirs; i++) {
+    int fl = sq % 8;
-      int dx = deltas[i][0], dy = deltas[i][1];
+
-      for(f = fl+dx, r = rk+dy;
+    for (int i = 0; i < dirs; i++)
-          (dx==0 || (f>=fmin && f<=fmax)) && (dy==0 || (r>=rmin && r<=rmax));
+    {
-          f += dx, r += dy) {
+        int dx = deltas[i][0];
+        int dy = deltas[i][1];
+        int f = fl + dx;
+        int r = rk + dy;
+
+        while (   (dx == 0 || (f >= fmin && f <= fmax))
+               && (dy == 0 || (r >= rmin && r <= rmax)))
+        {
             result |= (1ULL << (f + r*8));
-        if(block & (1ULL << (f + r*8))) break;
+            if (block & (1ULL << (f + r*8)))
+                break;
+
+            f += dx;
+            r += dy;
         }
     }
     return result;
   }
 
-
   void init_between_bitboards() {
-    SquareDelta step[8] = {
+
-      DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+    const SquareDelta step[8] = { DELTA_E, DELTA_W, DELTA_N, DELTA_S,
-    };
+                                  DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE };
-    SignedDirection d;
+
     for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for(Square s2 = SQ_A1; s2 <= SQ_H8; s2++) {
+        for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+        {
             BetweenBB[s1][s2] = EmptyBoardBB;
-        d = signed_direction_between_squares(s1, s2);
+            SignedDirection d = signed_direction_between_squares(s1, s2);
+
             if (d != SIGNED_DIR_NONE)
+            {
                 for (Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
                     set_bit(&(BetweenBB[s1][s2]), s3);
             }
       }
-
+  }
 
   Bitboard index_to_bitboard(int index, Bitboard mask) {
-    int i, j, bits = count_1s(mask);
+
     Bitboard result = 0ULL;
-    for(i = 0; i < bits; i++) {
+    int bits = count_1s(mask);
-      j = pop_1st_bit(&mask);
+
-      if(index & (1 << i)) result |= (1ULL << j);
+    for (int i = 0; i < bits; i++)
+    {
+        int j = pop_1st_bit(&mask);
+        if (index & (1 << i))
+            result |= (1ULL << j);
     }
     return result;
   }
 
+  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
+                            const int shift[], const Bitboard mult[], int deltas[][2]) {
 
-  void init_sliding_attacks(Bitboard attacks[],
+    for (int i = 0, index = 0; i < 64; i++)
-                            int attackIndex[], Bitboard mask[],
+    {
-                            const int shift[2], const Bitboard mult[],
-                            int deltas[][2]) {
-    int i, j, k, index = 0;
-    Bitboard b;
-    for(i = 0; i < 64; i++) {
         attackIndex[i] = index;
         mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
 
 #if defined(IS_64BIT)
-      j = (1 << (64 - shift[i]));
+        int j = (1 << (64 - shift[i]));
 #else
-      j = (1 << (32 - shift[i]));
+        int j = (1 << (32 - shift[i]));
 #endif
 
-      for(k = 0; k < j; k++) {
+        for (int k = 0; k < j; k++)
-
+        {
 #if defined(IS_64BIT)
-        b = index_to_bitboard(k, mask[i]);
+            Bitboard b = index_to_bitboard(k, mask[i]);
-        attacks[index + ((b * mult[i]) >> shift[i])] =
+            attacks[index + ((b * mult[i]) >> shift[i])] = sliding_attacks(i, b, 4, deltas);
-          sliding_attacks(i, b, 4, deltas);
 #else
-        b = index_to_bitboard(k, mask[i]);
+            Bitboard b = index_to_bitboard(k, mask[i]);
-        attacks[index +
+            unsigned v = int(b) * int(mult[i]) ^ int(b >> 32) * int(mult[i] >> 32);
-                 (unsigned(int(b) * int(mult[i]) ^
+            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, 4, deltas);
-                           int(b >> 32) * int(mult[i] >> 32))
-                  >> shift[i])] =
-          sliding_attacks(i, b, 4, deltas);
 #endif
         }
         index += j;
     }
   }
 
-
   void init_pseudo_attacks() {
-    Square s;
+
-    for(s = SQ_A1; s <= SQ_H8; s++) {
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    {
         BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
         RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
         QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -74,8 +74,9 @@ extern Bitboard StepAttackBB[16][64];
 extern Bitboard RayBB[64][8];
 extern Bitboard BetweenBB[64][64];
 
+extern Bitboard SquaresInFrontMask[2][64];
 extern Bitboard PassedPawnMask[2][64];
-extern Bitboard OutpostMask[2][64];
+extern Bitboard AttackSpanMask[2][64];
 
 extern const uint64_t RMult[64];
 extern const int RShift[64];
@@ -127,9 +128,8 @@ inline void do_move_bb(Bitboard *b, Bitboard move_bb) {
   *b ^= move_bb;
 }
 
-/// rank_bb() and file_bb() gives a bitboard containing all squares on a given
+/// rank_bb() and file_bb() take a file or a square as input, and return
-/// file or rank.  It is also possible to pass a square as input to these
+/// a bitboard representing all squares on the given file or rank.
-/// functions.
 
 inline Bitboard rank_bb(Rank r) {
   return RankBB[r];
@@ -156,7 +156,7 @@ inline Bitboard neighboring_files_bb(File f) {
 }
 
 inline Bitboard neighboring_files_bb(Square s) {
-  return neighboring_files_bb(square_file(s));
+  return NeighboringFilesBB[square_file(s)];
 }
 
 
@@ -169,7 +169,7 @@ inline Bitboard this_and_neighboring_files_bb(File f) {
 }
 
 inline Bitboard this_and_neighboring_files_bb(Square s) {
-  return this_and_neighboring_files_bb(square_file(s));
+  return ThisAndNeighboringFilesBB[square_file(s)];
 }
 
 
@@ -195,7 +195,7 @@ inline Bitboard in_front_bb(Color c, Rank r) {
 }
 
 inline Bitboard in_front_bb(Color c, Square s) {
-  return in_front_bb(c, square_rank(s));
+  return InFrontBB[c][square_rank(s)];
 }
 
 
@@ -208,7 +208,7 @@ inline Bitboard behind_bb(Color c, Rank r) {
 }
 
 inline Bitboard behind_bb(Color c, Square s) {
-  return in_front_bb(opposite_color(c), square_rank(s));
+  return InFrontBB[opposite_color(c)][square_rank(s)];
 }
 
 
@@ -274,12 +274,11 @@ inline Bitboard squares_between(Square s1, Square 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.  For instance,
+/// from the point of view of the given color. Definition of the table is:
-/// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares
+/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
-/// e3, e2 and e1 set.
 
 inline Bitboard squares_in_front_of(Color c, Square s) {
-  return in_front_bb(c, s) & file_bb(s);
+  return SquaresInFrontMask[c][s];
 }
 
 
@@ -287,33 +286,27 @@ inline Bitboard squares_in_front_of(Color c, Square s) {
 /// behind the square instead of in front of the square.
 
 inline Bitboard squares_behind(Color c, Square s) {
-  return in_front_bb(opposite_color(c), s) & file_bb(s);
+  return SquaresInFrontMask[opposite_color(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.
+/// 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)
 
 inline Bitboard passed_pawn_mask(Color c, Square s) {
   return PassedPawnMask[c][s];
 }
 
 
-/// outpost_mask takes a color and a square as input, and returns a bitboard
+/// attack_span_mask takes a color and a square as input, and returns a bitboard
-/// mask which can be used to test whether a piece on the square can possibly
+/// representing all squares that can be attacked by a pawn of the given color
-/// be driven away by an enemy pawn.
+/// when it moves along its file starting from the given square. Definition is:
+/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
 
-inline Bitboard outpost_mask(Color c, Square s) {
+inline Bitboard attack_span_mask(Color c, Square s) {
-  return OutpostMask[c][s];
+  return AttackSpanMask[c][s];
-}
-
-
-/// isolated_pawn_mask takes a square as input, and returns a bitboard mask
-/// which can be used to test whether a pawn on the given square is isolated.
-
-inline Bitboard isolated_pawn_mask(Square s) {
-  return neighboring_files_bb(s);
 }
 
 
@@ -349,7 +342,6 @@ extern Square pop_1st_bit(Bitboard* b);
 
 extern void print_bitboard(Bitboard b);
 extern void init_bitboards();
-extern int bitScanReverse32(uint32_t b);
 
 
 #endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -26,40 +26,18 @@
 
 // Select type of intrinsic bit count instruction to use, see
 // README.txt on how to pgo compile with POPCNT support.
-
+#if !defined(USE_POPCNT)
-#if defined(__INTEL_COMPILER) && defined(USE_POPCNT) // Intel compiler
-
-#include <nmmintrin.h>
-
-inline bool cpu_has_popcnt() {
-
-  int CPUInfo[4] = {-1};
-  __cpuid(CPUInfo, 0x00000001);
-  return (CPUInfo[2] >> 23) & 1;
-}
-
-#define POPCNT_INTRINSIC(x) _mm_popcnt_u64(x)
-
-#elif defined(_MSC_VER) && defined(USE_POPCNT) // Microsoft compiler
-
-#include <intrin.h>
-
-inline bool cpu_has_popcnt() {
-
-  int CPUInfo[4] = {-1};
-  __cpuid(CPUInfo, 0x00000001);
-  return (CPUInfo[2] >> 23) & 1;
-}
-
-#define POPCNT_INTRINSIC(x) __popcnt64(x)
-
-#else // Safe fallback for unsupported compilers or when USE_POPCNT is disabled
-
-inline bool cpu_has_popcnt() { return false; }
-
 #define POPCNT_INTRINSIC(x) 0
+#elif defined(_MSC_VER)
+#define POPCNT_INTRINSIC(x) (int)__popcnt64(x)
+#elif defined(__GNUC__)
 
-#endif // cpu_has_popcnt() and POPCNT_INTRINSIC() definitions
+#define POPCNT_INTRINSIC(x) ({ \
+   unsigned long __ret; \
+   __asm__("popcnt %1, %0" : "=r" (__ret) : "r" (x)); \
+   __ret; })
+
+#endif
 
 
 /// Software implementation of bit count functions
@@ -126,10 +104,23 @@ inline int count_1s_max_15(Bitboard b) {
 }
 
 
+// Detect hardware POPCNT support
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+
 // Global constant initialized at startup that is set to true if
 // CPU on which application runs supports POPCNT intrinsic. Unless
 // USE_POPCNT is not defined.
+#if defined(USE_POPCNT)
 const bool CpuHasPOPCNT = cpu_has_popcnt();
+#else
+const bool CpuHasPOPCNT = false;
+#endif
 
 
 // Global constant used to print info about the use of 64 optimized

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -390,7 +390,7 @@ void Book::close() {
 /// Book::file_name() returns the file name of the currently active book,
 /// or the empty string if no book is open.
 
-const string Book::file_name() const {
+const string Book::file_name() { // Not const to compile on HP-UX 11.X
 
   return is_open() ? fileName : "";
 }
@@ -399,14 +399,15 @@ const string Book::file_name() const {
 /// Book::get_move() gets a book move for a given position. Returns
 /// MOVE_NONE if no book move is found.
 
-Move Book::get_move(const Position& pos) {
+Move Book::get_move(const Position& pos, bool findBestMove) {
 
   if (!is_open() || bookSize == 0)
       return MOVE_NONE;
 
-  int bookMove = 0, scoresSum = 0;
-  uint64_t key = book_key(pos);
   BookEntry entry;
+  int bookMove = MOVE_NONE;
+  int scoresSum = 0, bestScore = 0;
+  uint64_t key = book_key(pos);
 
   // Choose a book move among the possible moves for the given position
   for (int idx = find_key(key); idx < bookSize; idx++)
@@ -419,6 +420,17 @@ Move Book::get_move(const Position& pos) {
 
       assert(score > 0);
 
+      // If findBestMove is true choose highest rated book move
+      if (findBestMove)
+      {
+          if (score > bestScore)
+          {
+              bestScore = score;
+              bookMove = entry.move;
+          }
+          continue;
+      }
+
       // Choose book move according to its score. If a move has a very
       // high score it has more probability to be choosen then a one with
       // lower score. Note that first entry is always chosen.

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -53,12 +53,15 @@ struct BookEntry {
 };
 
 class Book : private std::ifstream {
+  Book(const Book&); // just decleared..
+  Book& operator=(const Book&); // ..to avoid a warning
 public:
+  Book() {}
   ~Book();
   void open(const std::string& fName);
   void close();
-  const std::string file_name() const;
+  const std::string file_name();
-  Move get_move(const Position& pos);
+  Move get_move(const Position& pos, bool findBestMove);
 
 private:
   Book& operator>>(uint64_t& n) { n = read_integer(8); return *this; }

src/color.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/depth.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,7 +27,8 @@
 
 enum Depth {
   DEPTH_ZERO = 0,
-  DEPTH_MAX = 200  // 100 * OnePly;
+  DEPTH_MAX = 200, // 100 * OnePly;
+  DEPTH_ENSURE_SIGNED = -1
 };
 
 
@@ -49,6 +50,7 @@ inline void operator+= (Depth &d1, Depth d2) { d1 += int(d2); }
 inline Depth operator- (Depth d, int i) { return Depth(int(d) - i); }
 inline Depth operator- (Depth d1, Depth d2) { return Depth(int(d1) - int(d2)); }
 inline void operator-= (Depth &d, int i) { d = Depth(int(d) - i); }
+inline void operator-= (Depth &d1, Depth d2) { d1 -= int(d2); }
 inline Depth operator* (Depth d, int i) { return Depth(int(d) * i); }
 inline Depth operator* (int i, Depth d) { return Depth(int(d) * i); }
 inline void operator*= (Depth &d, int i) { d = Depth(int(d) * i); }

src/direction.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/direction.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/endgame.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -104,7 +104,7 @@ namespace {
 /// attacking side a bonus for driving the defending king towards the edge
 /// of the board, and for keeping the distance between the two kings small.
 template<>
-Value EvaluationFunction<KXK>::apply(const Position& pos) {
+Value EvaluationFunction<KXK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(weakerSide) == Value(0));
   assert(pos.piece_count(weakerSide, PAWN) == Value(0));
@@ -130,7 +130,7 @@ Value EvaluationFunction<KXK>::apply(const Position& pos) {
 /// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
 /// defending king towards a corner square of the right color.
 template<>
-Value EvaluationFunction<KBNK>::apply(const Position& pos) {
+Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(weakerSide) == Value(0));
   assert(pos.piece_count(weakerSide, PAWN) == Value(0));
@@ -159,7 +159,7 @@ Value EvaluationFunction<KBNK>::apply(const Position& pos) {
 
 /// KP vs K. This endgame is evaluated with the help of a bitbase.
 template<>
-Value EvaluationFunction<KPK>::apply(const Position& pos) {
+Value EvaluationFunction<KPK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == Value(0));
   assert(pos.non_pawn_material(weakerSide) == Value(0));
@@ -207,7 +207,7 @@ Value EvaluationFunction<KPK>::apply(const Position& pos) {
 /// far advanced with support of the king, while the attacking king is far
 /// away.
 template<>
-Value EvaluationFunction<KRKP>::apply(const Position& pos) {
+Value EvaluationFunction<KRKP>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 0);
@@ -264,7 +264,7 @@ Value EvaluationFunction<KRKP>::apply(const Position& pos) {
 /// KR vs KB. This is very simple, and always returns drawish scores.  The
 /// score is slightly bigger when the defending king is close to the edge.
 template<>
-Value EvaluationFunction<KRKB>::apply(const Position& pos) {
+Value EvaluationFunction<KRKB>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 0);
@@ -280,7 +280,7 @@ Value EvaluationFunction<KRKB>::apply(const Position& pos) {
 /// KR vs KN.  The attacking side has slightly better winning chances than
 /// in KR vs KB, particularly if the king and the knight are far apart.
 template<>
-Value EvaluationFunction<KRKN>::apply(const Position& pos) {
+Value EvaluationFunction<KRKN>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 0);
@@ -304,7 +304,7 @@ Value EvaluationFunction<KRKN>::apply(const Position& pos) {
 /// for the defending side in the search, this is usually sufficient to be
 /// able to win KQ vs KR.
 template<>
-Value EvaluationFunction<KQKR>::apply(const Position& pos) {
+Value EvaluationFunction<KQKR>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 0);
@@ -323,7 +323,7 @@ Value EvaluationFunction<KQKR>::apply(const Position& pos) {
 }
 
 template<>
-Value EvaluationFunction<KBBKN>::apply(const Position& pos) {
+Value EvaluationFunction<KBBKN>::apply(const Position& pos) const {
 
   assert(pos.piece_count(strongerSide, BISHOP) == 2);
   assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame);
@@ -352,12 +352,12 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) {
 /// K and two minors vs K and one or two minors or K and two knights against
 /// king alone are always draw.
 template<>
-Value EvaluationFunction<KmmKm>::apply(const Position&) {
+Value EvaluationFunction<KmmKm>::apply(const Position&) const {
   return Value(0);
 }
 
 template<>
-Value EvaluationFunction<KNNK>::apply(const Position&) {
+Value EvaluationFunction<KNNK>::apply(const Position&) const {
   return Value(0);
 }
 
@@ -367,7 +367,7 @@ Value EvaluationFunction<KNNK>::apply(const Position&) {
 /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
 /// will be used.
 template<>
-ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) {
+ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
@@ -421,7 +421,7 @@ ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) {
 /// It tests for fortress draws with a rook on the third rank defended by
 /// a pawn.
 template<>
-ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) {
+ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
   assert(pos.piece_count(strongerSide, QUEEN) == 1);
@@ -452,7 +452,7 @@ ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) {
 /// It would also be nice to rewrite the actual code for this function,
 /// which is mostly copied from Glaurung 1.x, and not very pretty.
 template<>
-ScaleFactor ScalingFunction<KRPKR>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 1);
@@ -570,7 +570,7 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position &pos) {
 /// single pattern: If the stronger side has no pawns and the defending king
 /// is actively placed, the position is drawish.
 template<>
-ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == RookValueMidgame);
   assert(pos.piece_count(strongerSide, PAWN) == 2);
@@ -609,7 +609,7 @@ ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position &pos) {
 /// against king. There is just a single rule here: If all pawns are on
 /// the same rook file and are blocked by the defending king, it's a draw.
 template<>
-ScaleFactor ScalingFunction<KPsK>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KPsK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == Value(0));
   assert(pos.piece_count(strongerSide, PAWN) >= 2);
@@ -655,7 +655,7 @@ ScaleFactor ScalingFunction<KPsK>::apply(const Position &pos) {
 /// it's a draw. If the two bishops have opposite color, it's almost always
 /// a draw.
 template<>
-ScaleFactor ScalingFunction<KBPKB>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
@@ -708,7 +708,7 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position &pos) {
 /// KBPPKBScalingFunction scales KBPP vs KB endgames. It detects a few basic
 /// draws with opposite-colored bishops.
 template<>
-ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) {
+ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
@@ -784,7 +784,7 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) {
 /// square of the king is not of the same color as the stronger side's bishop,
 /// it's a draw.
 template<>
-ScaleFactor ScalingFunction<KBPKN>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KBPKN>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
@@ -811,7 +811,7 @@ ScaleFactor ScalingFunction<KBPKN>::apply(const Position &pos) {
 /// If the pawn is a rook pawn on the 7th rank and the defending king prevents
 /// the pawn from advancing, the position is drawn.
 template<>
-ScaleFactor ScalingFunction<KNPK>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
   assert(pos.piece_count(strongerSide, KNIGHT) == 1);
@@ -841,7 +841,7 @@ ScaleFactor ScalingFunction<KNPK>::apply(const Position &pos) {
 /// advanced and not on a rook file; in this case it is often possible to win
 /// (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1).
 template<>
-ScaleFactor ScalingFunction<KPKP>::apply(const Position &pos) {
+ScaleFactor ScalingFunction<KPKP>::apply(const Position& pos) const {
 
   assert(pos.non_pawn_material(strongerSide) == Value(0));
   assert(pos.non_pawn_material(weakerSide) == Value(0));

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -68,7 +68,7 @@ class EndgameFunctionBase {
 public:
   EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
   virtual ~EndgameFunctionBase() {}
-  virtual T apply(const Position&) = 0;
+  virtual T apply(const Position&) const = 0;
   Color color() const { return strongerSide; }
 
 protected:
@@ -85,14 +85,14 @@ template<EndgameType>
 struct EvaluationFunction : public EndgameEvaluationFunctionBase {
   typedef EndgameEvaluationFunctionBase Base;
   explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
-  Value apply(const Position&);
+  Value apply(const Position&) const;
 };
 
 template<EndgameType>
 struct ScalingFunction : public EndgameScalingFunctionBase {
   typedef EndgameScalingFunctionBase Base;
   explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
-  ScaleFactor apply(const Position&);
+  ScaleFactor apply(const Position&) const;
 };
 
 

src/evaluate.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -46,9 +46,11 @@ namespace {
   const int GrainSize = 8;
 
   // Evaluation weights, initialized from UCI options
-  Score WeightMobility, WeightPawnStructure;
+  enum { Mobility, PawnStructure, PassedPawns, Space, KingDangerUs, KingDangerThem };
-  Score WeightPassedPawns, WeightSpace;
+  Score Weights[6];
-  Score WeightKingSafety[2];
+
+  typedef Value V;
+  #define S(mg, eg) make_score(mg, eg)
 
   // Internal evaluation weights. These are applied on top of the evaluation
   // weights read from UCI parameters. The purpose is to be able to change
@@ -56,19 +58,9 @@ namespace {
   // parameters at 100, which looks prettier.
   //
   // Values modified by Joona Kiiski
-  const Score WeightMobilityInternal      = make_score(248, 271);
+  const Score WeightsInternal[] = {
-  const Score WeightPawnStructureInternal = make_score(233, 201);
+      S(248, 271), S(233, 201), S(252, 259), S(46, 0), S(247, 0), S(259, 0)
-  const Score WeightPassedPawnsInternal   = make_score(252, 259);
+  };
-  const Score WeightSpaceInternal         = make_score( 46,   0);
-  const Score WeightKingSafetyInternal    = make_score(247,   0);
-  const Score WeightKingOppSafetyInternal = make_score(259,   0);
-
-  // Mobility and outposts bonus modified by Joona Kiiski
-
-  typedef Value V;
-  #define S(mg, eg) make_score(mg, eg)
-
-  CACHE_LINE_ALIGNMENT
 
   // Knight mobility bonus in middle game and endgame, indexed by the number
   // of attacked squares not occupied by friendly piecess.
@@ -138,28 +130,22 @@ namespace {
     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
   };
 
-  // ThreatBonus[][] contains bonus according to which piece type
+  // ThreatBonus[attacking][attacked] contains bonus according to which
-  // attacks which one.
+  // piece type attacks which one.
-  #define Z S(0, 0)
-
   const Score ThreatBonus[8][8] = {
-      { Z, Z, Z, Z, Z, Z, Z, Z }, // not used
+    {}, {},
-      { Z, S(18,37),       Z, S(37,47), S(55,97), S(55,97), Z, Z }, // KNIGHT attacks
+    { S(0, 0), S( 7, 39), S( 0,  0), S(24, 49), S(41,100), S(41,100) }, // KNIGHT
-      { Z, S(18,37), S(37,47),       Z, S(55,97), S(55,97), Z, Z }, // BISHOP attacks
+    { S(0, 0), S( 7, 39), S(24, 49), S( 0,  0), S(41,100), S(41,100) }, // BISHOP
-      { Z, S( 9,27), S(27,47), S(27,47),       Z, S(37,47), Z, Z }, // ROOK attacks
+    { S(0, 0), S(-1, 29), S(15, 49), S(15, 49), S( 0,  0), S(24, 49) }, // ROOK
-      { Z, S(27,37), S(27,37), S(27,37), S(27,37),       Z, Z, Z }, // QUEEN attacks
+    { S(0, 0), S(15, 39), S(15, 39), S(15, 39), S(15, 39), S( 0,  0) }  // QUEEN
-      { Z, Z, Z, Z, Z, Z, Z, Z }, // not used
-      { Z, Z, Z, Z, Z, Z, Z, Z }, // not used
-      { Z, Z, Z, Z, Z, Z, Z, Z }  // not used
   };
 
   // ThreatedByPawnPenalty[] contains a penalty according to which piece
   // type is attacked by an enemy pawn.
   const Score ThreatedByPawnPenalty[8] = {
-    Z, Z, S(56, 70), S(56, 70), S(76, 99), S(86, 118), Z, Z
+    S(0, 0), S(0, 0), S(56, 70), S(56, 70), S(76, 99), S(86, 118)
   };
 
-  #undef Z
   #undef S
 
   // Bonus for unstoppable passed pawns
@@ -211,28 +197,20 @@ namespace {
     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
   };
 
-  /// King safety constants and variables. The king safety scores are taken
+  /// King danger constants and variables. The king danger scores are taken
-  /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
+  /// from the KingDangerTable[]. Various little "meta-bonuses" measuring
-  /// the strength of the attack are added up into an integer, which is used
+  /// the strength of the enemy attack are added up into an integer, which
-  /// as an index to SafetyTable[].
+  /// is used as an index to KingDangerTable[].
 
-  // Attack weights for each piece type and table indexed on piece type
+  // KingAttackWeights[] contains king attack weights by piece type
-  const int QueenAttackWeight  = 5;
+  const int KingAttackWeights[8] = { 0, 0, 2, 2, 3, 5 };
-  const int RookAttackWeight   = 3;
-  const int BishopAttackWeight = 2;
-  const int KnightAttackWeight = 2;
 
-  const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
+  // Bonuses for enemy's safe checks
-
+  const int QueenContactCheckBonus = 3;
-  // Bonuses for safe checks, initialized from UCI options
+  const int QueenCheckBonus        = 2;
-  int QueenContactCheckBonus, DiscoveredCheckBonus;
+  const int RookCheckBonus         = 1;
-  int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
+  const int BishopCheckBonus       = 1;
-
+  const int KnightCheckBonus       = 1;
-  // Scan for queen contact mates?
-  const bool QueenContactMates = true;
-
-  // Bonus for having a mate threat, initialized from UCI options
-  int MateThreatBonus;
 
   // InitKingDanger[] contains bonuses based on the position of the defending
   // king.
@@ -247,13 +225,13 @@ namespace {
     15, 15, 15, 15, 15, 15, 15, 15
   };
 
-  // SafetyTable[] contains the actual king safety scores. It is initialized
+  // KingDangerTable[color][] contains the actual king danger weighted scores
-  // in init_safety().
+  Score KingDangerTable[2][128];
-  Value SafetyTable[100];
 
-  // Pawn and material hash tables, indexed by the current thread id
+  // Pawn and material hash tables, indexed by the current thread id.
-  MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  // Note that they will be initialized at 0 being global variables.
-  PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  MaterialInfoTable* MaterialTable[MAX_THREADS];
+  PawnInfoTable* PawnTable[MAX_THREADS];
 
   // Sizes of pawn and material hash tables
   const int PawnTableSize = 16384;
@@ -261,7 +239,10 @@ namespace {
 
   // Function prototypes
   template<bool HasPopCnt>
-  Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
+  Value do_evaluate(const Position& pos, EvalInfo& ei);
+
+  template<Color Us, bool HasPopCnt>
+  void init_attack_tables(const Position& pos, EvalInfo& ei);
 
   template<Color Us, bool HasPopCnt>
   void evaluate_pieces_of_color(const Position& pos, EvalInfo& ei);
@@ -273,9 +254,12 @@ namespace {
   void evaluate_threats(const Position& pos, EvalInfo& ei);
 
   template<Color Us, bool HasPopCnt>
-  void evaluate_space(const Position& pos, EvalInfo& ei);
+  int evaluate_space(const Position& pos, EvalInfo& ei);
 
+  template<Color Us>
   void evaluate_passed_pawns(const Position& pos, EvalInfo& ei);
+
+  void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei);
   void evaluate_trapped_bishop_a7h7(const Position& pos, Square s, Color us, EvalInfo& ei);
   void evaluate_trapped_bishop_a1h1(const Position& pos, Square s, Color us, EvalInfo& ei);
   inline Score apply_weight(Score v, Score weight);
@@ -292,19 +276,21 @@ namespace {
 /// evaluate() is the main evaluation function. It always computes two
 /// values, an endgame score and a middle game score, and interpolates
 /// between them based on the remaining material.
-Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
+Value evaluate(const Position& pos, EvalInfo& ei) {
 
-    return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
+    return CpuHasPOPCNT ? do_evaluate<true>(pos, ei)
-                        : do_evaluate<false>(pos, ei, threadID);
+                        : do_evaluate<false>(pos, ei);
 }
 
 namespace {
 
 template<bool HasPopCnt>
-Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
+Value do_evaluate(const Position& pos, EvalInfo& ei) {
+
+  ScaleFactor factor[2];
 
   assert(pos.is_ok());
-  assert(threadID >= 0 && threadID < THREAD_MAX);
+  assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);
   assert(!pos.is_check());
 
   memset(&ei, 0, sizeof(EvalInfo));
@@ -314,7 +300,7 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   ei.value = pos.value();
 
   // Probe the material hash table
-  ei.mi = MaterialTable[threadID]->get_material_info(pos);
+  ei.mi = MaterialTable[pos.thread()]->get_material_info(pos);
   ei.value += ei.mi->material_value();
 
   // If we have a specialized evaluation function for the current material
@@ -323,30 +309,16 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
       return ei.mi->evaluate(pos);
 
   // After get_material_info() call that modifies them
-  ScaleFactor factor[2];
   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 
   // Probe the pawn hash table
-  ei.pi = PawnTable[threadID]->get_pawn_info(pos);
+  ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);
-  ei.value += apply_weight(ei.pi->pawns_value(), WeightPawnStructure);
+  ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
 
-  // Initialize king attack bitboards and king attack zones for both sides
+  // Initialize attack bitboards with pawns evaluation
-  ei.attackedBy[WHITE][KING] = pos.attacks_from<KING>(pos.king_square(WHITE));
+  init_attack_tables<WHITE, HasPopCnt>(pos, ei);
-  ei.attackedBy[BLACK][KING] = pos.attacks_from<KING>(pos.king_square(BLACK));
+  init_attack_tables<BLACK, HasPopCnt>(pos, ei);
-  ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
-  ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
-
-  // Initialize pawn attack bitboards for both sides
-  ei.attackedBy[WHITE][PAWN] = ei.pi->pawn_attacks(WHITE);
-  ei.attackedBy[BLACK][PAWN] = ei.pi->pawn_attacks(BLACK);
-  Bitboard b1 = ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING];
-  Bitboard b2 = ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING];
-  if (b1)
-      ei.kingAttackersCount[WHITE] = count_1s_max_15<HasPopCnt>(b1)/2;
-
-  if (b2)
-      ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2;
 
   // Evaluate pieces
   evaluate_pieces_of_color<WHITE, HasPopCnt>(pos, ei);
@@ -358,23 +330,24 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   evaluate_king<WHITE, HasPopCnt>(pos, ei);
   evaluate_king<BLACK, HasPopCnt>(pos, ei);
 
-  // Evaluate tactical threats, we need full attack info
+  // Evaluate tactical threats, we need full attack info including king
   evaluate_threats<WHITE>(pos, ei);
   evaluate_threats<BLACK>(pos, ei);
 
-  // Evaluate passed pawns. We evaluate passed pawns for both sides at once,
+  // Evaluate passed pawns, we need full attack info including king
-  // because we need to know which side promotes first in positions where
+  evaluate_passed_pawns<WHITE>(pos, ei);
-  // both sides have an unstoppable passed pawn. To be called after all attacks
+  evaluate_passed_pawns<BLACK>(pos, ei);
-  // are computed, included king.
+
-  if (ei.pi->passed_pawns())
+  // If one side has only a king, check whether exsists any unstoppable passed pawn
-      evaluate_passed_pawns(pos, ei);
+  if (!pos.non_pawn_material(WHITE) || !pos.non_pawn_material(BLACK))
+      evaluate_unstoppable_pawns(pos, ei);
 
   Phase phase = ei.mi->game_phase();
 
   // Middle-game specific evaluation terms
   if (phase > PHASE_ENDGAME)
   {
-    // Pawn storms in positions with opposite castling.
+      // Pawn storms in positions with opposite castling
       if (   square_file(pos.king_square(WHITE)) >= FILE_E
           && square_file(pos.king_square(BLACK)) <= FILE_D)
 
@@ -388,13 +361,13 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
       // Evaluate space for both sides
       if (ei.mi->space_weight() > 0)
       {
-        evaluate_space<WHITE, HasPopCnt>(pos, ei);
+          int s = evaluate_space<WHITE, HasPopCnt>(pos, ei) - evaluate_space<BLACK, HasPopCnt>(pos, ei);
-        evaluate_space<BLACK, HasPopCnt>(pos, ei);
+          ei.value += apply_weight(make_score(s * ei.mi->space_weight(), 0), Weights[Space]);
       }
   }
 
   // Mobility
-  ei.value += apply_weight(ei.mobility, WeightMobility);
+  ei.value += apply_weight(ei.mobility, Weights[Mobility]);
 
   // If we don't already have an unusual scale factor, check for opposite
   // colored bishop endgames, and use a lower scale for those
@@ -426,37 +399,18 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   }
 
   // Interpolate between the middle game and the endgame score
-  Color stm = pos.side_to_move();
+  return Sign[pos.side_to_move()] * scale_by_game_phase(ei.value, phase, factor);
-
-  Value v = Sign[stm] * scale_by_game_phase(ei.value, phase, factor);
-
-  return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
 }
 
 } // namespace
 
-/// quick_evaluate() does a very approximate evaluation of the current position.
-/// It currently considers only material and piece square table scores. Perhaps
-/// we should add scores from the pawn and material hash tables?
-
-Value quick_evaluate(const Position &pos) {
-
-  assert(pos.is_ok());
-
-  static const ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
-
-  Value v = scale_by_game_phase(pos.value(), MaterialInfoTable::game_phase(pos), sf);
-  return (pos.side_to_move() == WHITE ? v : -v);
-}
-
-
 /// init_eval() initializes various tables used by the evaluation function
 
 void init_eval(int threads) {
 
-  assert(threads <= THREAD_MAX);
+  assert(threads <= MAX_THREADS);
 
-  for (int i = 0; i < THREAD_MAX; i++)
+  for (int i = 0; i < MAX_THREADS; i++)
   {
     if (i >= threads)
     {
@@ -478,7 +432,7 @@ void init_eval(int threads) {
 
 void quit_eval() {
 
-  for (int i = 0; i < THREAD_MAX; i++)
+  for (int i = 0; i < MAX_THREADS; i++)
   {
       delete PawnTable[i];
       delete MaterialTable[i];
@@ -492,28 +446,46 @@ void quit_eval() {
 
 void read_weights(Color us) {
 
-  Color them = opposite_color(us);
+  // King safety is asymmetrical. Our king danger level is weighted by
+  // "Cowardice" UCI parameter, instead the opponent one by "Aggressiveness".
+  const int kingDangerUs   = (us == WHITE ? KingDangerUs   : KingDangerThem);
+  const int kingDangerThem = (us == WHITE ? KingDangerThem : KingDangerUs);
 
-  WeightMobility         = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightMobilityInternal);
+  Weights[Mobility]       = weight_option("Mobility (Middle Game)", "Mobility (Endgame)", WeightsInternal[Mobility]);
-  WeightPawnStructure    = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightPawnStructureInternal);
+  Weights[PawnStructure]  = weight_option("Pawn Structure (Middle Game)", "Pawn Structure (Endgame)", WeightsInternal[PawnStructure]);
-  WeightPassedPawns      = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightPassedPawnsInternal);
+  Weights[PassedPawns]    = weight_option("Passed Pawns (Middle Game)", "Passed Pawns (Endgame)", WeightsInternal[PassedPawns]);
-  WeightSpace            = weight_option("Space", "Space", WeightSpaceInternal);
+  Weights[Space]          = weight_option("Space", "Space", WeightsInternal[Space]);
-  WeightKingSafety[us]   = weight_option("Cowardice", "Cowardice", WeightKingSafetyInternal);
+  Weights[kingDangerUs]   = weight_option("Cowardice", "Cowardice", WeightsInternal[KingDangerUs]);
-  WeightKingSafety[them] = weight_option("Aggressiveness", "Aggressiveness", WeightKingOppSafetyInternal);
+  Weights[kingDangerThem] = weight_option("Aggressiveness", "Aggressiveness", WeightsInternal[KingDangerThem]);
 
   // If running in analysis mode, make sure we use symmetrical king safety. We do this
-  // by replacing both WeightKingSafety[us] and WeightKingSafety[them] by their average.
+  // by replacing both Weights[kingDangerUs] and Weights[kingDangerThem] by their average.
   if (get_option_value_bool("UCI_AnalyseMode"))
-  {
+      Weights[kingDangerUs] = Weights[kingDangerThem] = (Weights[kingDangerUs] + Weights[kingDangerThem]) / 2;
-      WeightKingSafety[us] = (WeightKingSafety[us] + WeightKingSafety[them]) / 2;
+
-      WeightKingSafety[them] = WeightKingSafety[us];
-  }
   init_safety();
 }
 
 
 namespace {
 
+  // init_attack_tables() initializes king bitboards for both sides adding
+  // pawn attacks. To be done before other evaluations.
+
+  template<Color Us, bool HasPopCnt>
+  void init_attack_tables(const Position& pos, EvalInfo& ei) {
+
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+    Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from<KING>(pos.king_square(Them));
+    ei.kingZone[Us] = (b | (Us == WHITE ? b >> 8 : b << 8));
+    ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us);
+    b &= ei.attackedBy[Us][PAWN];
+    if (b)
+        ei.kingAttackersCount[Us] = count_1s_max_15<HasPopCnt>(b) / 2;
+  }
+
+
   // evaluate_outposts() evaluates bishop and knight outposts squares
 
   template<PieceType Piece, Color Us>
@@ -571,7 +543,7 @@ namespace {
         if (b & ei.kingZone[Us])
         {
             ei.kingAttackersCount[Us]++;
-            ei.kingAttackersWeight[Us] += AttackWeight[Piece];
+            ei.kingAttackersWeight[Us] += KingAttackWeights[Piece];
             Bitboard bb = (b & ei.attackedBy[Them][KING]);
             if (bb)
                 ei.kingAdjacentZoneAttacksCount[Us] += count_1s_max_15<HasPopCnt>(bb);
@@ -589,7 +561,7 @@ namespace {
             ei.value -= Sign[Us] * ThreatedByPawnPenalty[Piece];
 
         // Bishop and knight outposts squares
-        if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Them))
+        if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, Us))
             evaluate_outposts<Piece, Us>(pos, ei, s);
 
         // Special patterns: trapped bishops on a7/h7/a2/h2
@@ -717,16 +689,15 @@ namespace {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-    Bitboard undefended, attackedByOthers, escapeSquares, occ, b, b2, safe;
+    Bitboard undefended, b, b1, b2, safe;
-    Square from, to;
     bool sente;
-    int attackUnits, count, shelter = 0;
+    int attackUnits, shelter = 0;
-    const Square s = pos.king_square(Us);
+    const Square ksq = pos.king_square(Us);
 
     // King shelter
-    if (relative_rank(Us, s) <= RANK_4)
+    if (relative_rank(Us, ksq) <= RANK_4)
     {
-        shelter = ei.pi->get_king_shelter(pos, Us, s);
+        shelter = ei.pi->get_king_shelter(pos, Us, ksq);
         ei.value += Sign[Us] * make_score(shelter, 0);
     }
 
@@ -748,248 +719,140 @@ namespace {
                         | ei.attacked_by(Us, QUEEN));
 
         // Initialize the 'attackUnits' variable, which is used later on as an
-      // index to the SafetyTable[] array. The initial value is based on the
+        // index to the KingDangerTable[] array. The initial value is based on
-      // number and types of the attacking pieces, the number of attacked and
+        // the number and types of the enemy's attacking pieces, the number of
-      // undefended squares around the king, the square of the king, and the
+        // attacked and undefended squares around our king, the square of the
-      // quality of the pawn shelter.
+        // king, and the quality of the pawn shelter.
         attackUnits =  Min(25, (ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) / 2)
                      + 3 * (ei.kingAdjacentZoneAttacksCount[Them] + count_1s_max_15<HasPopCnt>(undefended))
-                   + InitKingDanger[relative_square(Us, s)]
+                     + InitKingDanger[relative_square(Us, ksq)]
-                   - (shelter >> 5);
+                     - shelter / 32;
 
-      // Analyse safe queen contact checks
+        // Analyse enemy's safe queen contact checks. First find undefended
+        // squares around the king attacked by enemy queen...
         b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them);
         if (b)
         {
-        attackedByOthers =  ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
+            // ...then remove squares not supported by another enemy piece
-                          | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK);
+            b &= (  ei.attacked_by(Them, PAWN)   | ei.attacked_by(Them, KNIGHT)
-
+                  | ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK));
-        b &= attackedByOthers;
-
-        // Squares attacked by the queen and supported by another enemy piece and
-        // not defended by other pieces but our king.
             if (b)
-        {
+                attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
-            // The bitboard b now contains the squares available for safe queen
-            // contact checks.
-            count = count_1s_max_15<HasPopCnt>(b);
-            attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
-
-            // Is there a mate threat?
-            if (QueenContactMates && !pos.is_check())
-            {
-                escapeSquares = pos.attacks_from<KING>(s) & ~pos.pieces_of_color(Us) & ~attackedByOthers;
-                occ = pos.occupied_squares();
-                while (b)
-                {
-                    to = pop_1st_bit(&b);
-
-                    // Do we have escape squares from queen contact check attack ?
-                    if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
-                    {
-                        // We have a mate, unless the queen is pinned or there
-                        // is an X-ray attack through the queen.
-                        for (int i = 0; i < pos.piece_count(Them, QUEEN); i++)
-                        {
-                            from = pos.piece_list(Them, QUEEN, i);
-                            if (    bit_is_set(pos.attacks_from<QUEEN>(from), to)
-                                && !bit_is_set(pos.pinned_pieces(Them), from)
-                                && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(ROOK, QUEEN, Us))
-                                && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & pos.pieces(BISHOP, QUEEN, Us)))
-
-                                // Set the mate threat move
-                                ei.mateThreat[Them] = make_move(from, to);
-                        }
-                    }
-                }
-            }
-        }
         }
 
-      // Analyse safe distance checks
+        // Analyse enemy's safe distance checks for sliders and knights
         safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us));
 
-      if (QueenCheckBonus > 0 || RookCheckBonus > 0)
+        b1 = pos.attacks_from<ROOK>(ksq) & safe;
-      {
+        b2 = pos.attacks_from<BISHOP>(ksq) & safe;
-          b = pos.attacks_from<ROOK>(s) & safe;
 
-          // Queen checks
+        // Enemy queen safe checks
-          b2 = b & ei.attacked_by(Them, QUEEN);
+        b = (b1 | b2) & ei.attacked_by(Them, QUEEN);
-          if (b2)
-              attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
-
-          // Rook checks
-          b2 = b & ei.attacked_by(Them, ROOK);
-          if (b2)
-              attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
-      }
-      if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
-      {
-          b = pos.attacks_from<BISHOP>(s) & safe;
-
-          // Queen checks
-          b2 = b & ei.attacked_by(Them, QUEEN);
-          if (b2)
-              attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
-
-          // Bishop checks
-          b2 = b & ei.attacked_by(Them, BISHOP);
-          if (b2)
-              attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
-      }
-      if (KnightCheckBonus > 0)
-      {
-          b = pos.attacks_from<KNIGHT>(s) & safe;
-
-          // Knight checks
-          b2 = b & ei.attacked_by(Them, KNIGHT);
-          if (b2)
-              attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
-      }
-
-      // Analyse discovered checks (only for non-pawns right now, consider
-      // adding pawns later).
-      if (DiscoveredCheckBonus)
-      {
-          b = pos.discovered_check_candidates(Them) & ~pos.pieces(PAWN);
         if (b)
-              attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
+            attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
-      }
 
-      // Has a mate threat been found? We don't do anything here if the
+        // Enemy rooks safe checks
-      // side with the mating move is the side to move, because in that
+        b = b1 & ei.attacked_by(Them, ROOK);
-      // case the mating side will get a huge bonus at the end of the main
+        if (b)
-      // evaluation function instead.
+            attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
-      if (ei.mateThreat[Them] != MOVE_NONE)
-          attackUnits += MateThreatBonus;
 
-      // Ensure that attackUnits is between 0 and 99, in order to avoid array
+        // Enemy bishops safe checks
-      // out of bounds errors.
+        b = b2 & ei.attacked_by(Them, BISHOP);
+        if (b)
+            attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+        // Enemy knights safe checks
+        b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe;
+        if (b)
+            attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
+
+        // To index KingDangerTable[] attackUnits must be in [0, 99] range
         attackUnits = Min(99, Max(0, attackUnits));
 
-      // Finally, extract the king safety score from the SafetyTable[] array.
+        // Finally, extract the king danger score from the KingDangerTable[]
-      // Add the score to the evaluation, and also to ei.futilityMargin. The
+        // array and subtract the score from evaluation. Set also ei.kingDanger[]
-      // reason for adding the king safety score to the futility margin is
+        // value that will be used for pruning because this value can sometimes
-      // that the king safety scores can sometimes be very big, and that
+        // be very big, and so capturing a single attacking piece can therefore
-      // capturing a single attacking piece can therefore result in a score
+        // result in a score change far bigger than the value of the captured piece.
-      // change far bigger than the value of the captured piece.
+        ei.value -= Sign[Us] * KingDangerTable[Us][attackUnits];
-      Score v = apply_weight(make_score(SafetyTable[attackUnits], 0), WeightKingSafety[Us]);
+        ei.kingDanger[Us] = mg_value(KingDangerTable[Us][attackUnits]);
-
-      ei.value -= Sign[Us] * v;
-
-      if (Us == pos.side_to_move())
-          ei.futilityMargin += mg_value(v);
     }
   }
 
 
-  // evaluate_passed_pawns() evaluates the passed pawns of the given color
+  // evaluate_passed_pawns<>() evaluates the passed pawns of the given color
 
   template<Color Us>
-  void evaluate_passed_pawns_of_color(const Position& pos, int movesToGo[], Square pawnToGo[], EvalInfo& ei) {
+  void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-    Bitboard b2, b3, b4;
+    Bitboard squaresToQueen, defendedSquares, unsafeSquares, supportingPawns;
-    Square ourKingSq = pos.king_square(Us);
+    Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(Us);
-    Square theirKingSq = pos.king_square(Them);
-    Bitboard b = ei.pi->passed_pawns() & pos.pieces(PAWN, Us);
 
     while (b)
     {
         Square s = pop_1st_bit(&b);
 
-        assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
         assert(pos.pawn_is_passed(Us, s));
 
         int r = int(relative_rank(Us, s) - RANK_2);
-        int tr = Max(0, r * (r - 1));
+        int tr = r * (r - 1);
 
         // Base bonus based on rank
         Value mbonus = Value(20 * tr);
         Value ebonus = Value(10 + r * r * 10);
 
-        // Adjust bonus based on king proximity
         if (tr)
         {
             Square blockSq = s + pawn_push(Us);
 
-            ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
+            // Adjust bonus based on kings proximity
-            ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(Us)) * 1 * tr);
+            ebonus -= Value(square_distance(pos.king_square(Us), blockSq) * 3 * tr);
-            ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
+            ebonus -= Value(square_distance(pos.king_square(Us), blockSq + pawn_push(Us)) * 1 * tr);
+            ebonus += Value(square_distance(pos.king_square(Them), blockSq) * 6 * tr);
 
             // If the pawn is free to advance, increase bonus
             if (pos.square_is_empty(blockSq))
             {
-                // There are no enemy pawns in the pawn's path
+                squaresToQueen = squares_in_front_of(Us, s);
-                b2 = squares_in_front_of(Us, s);
+                defendedSquares = squaresToQueen & ei.attacked_by(Us);
-
-                assert((b2 & pos.pieces(PAWN, Them)) == EmptyBoardBB);
-
-                // Squares attacked by us
-                b4 = b2 & ei.attacked_by(Us);
-
-                // Squares attacked or occupied by enemy pieces
-                b3 = b2 & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
 
                 // If there is an enemy rook or queen attacking the pawn from behind,
-                // add all X-ray attacks by the rook or queen.
+                // add all X-ray attacks by the rook or queen. Otherwise consider only
+                // the squares in the pawn's path attacked or occupied by the enemy.
                 if (   (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them))
                     && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<QUEEN>(s)))
-                    b3 = b2;
+                    unsafeSquares = squaresToQueen;
+                else
+                    unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them));
 
-                // Are any of the squares in the pawn's path attacked or occupied by the enemy?
+                // If there aren't enemy attacks or pieces along the path to queen give
-                if (b3 == EmptyBoardBB)
+                // huge bonus. Even bigger if we protect the pawn's path.
-                    // No enemy attacks or pieces, huge bonus!
+                if (!unsafeSquares)
-                    // Even bigger if we protect the pawn's path
+                    ebonus += Value(tr * (squaresToQueen == defendedSquares ? 17 : 15));
-                    ebonus += Value(tr * (b2 == b4 ? 17 : 15));
                 else
                     // OK, there are enemy attacks or pieces (but not pawns). Are those
                     // squares which are attacked by the enemy also attacked by us ?
                     // If yes, big bonus (but smaller than when there are no enemy attacks),
                     // if no, somewhat smaller bonus.
-                    ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
+                    ebonus += Value(tr * ((unsafeSquares & defendedSquares) == unsafeSquares ? 13 : 8));
 
                 // At last, add a small bonus when there are no *friendly* pieces
                 // in the pawn's path.
-                if ((b2 & pos.pieces_of_color(Us)) == EmptyBoardBB)
+                if (!(squaresToQueen & pos.pieces_of_color(Us)))
                     ebonus += Value(tr);
             }
         } // tr != 0
 
-        // If the pawn is supported by a friendly pawn, increase bonus
+        // Increase the bonus if the passed pawn is supported by a friendly pawn
-        b2 = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
+        // on the same rank and a bit smaller if it's on the previous rank.
-        if (b2 & rank_bb(s))
+        supportingPawns = pos.pieces(PAWN, Us) & neighboring_files_bb(s);
+        if (supportingPawns & rank_bb(s))
             ebonus += Value(r * 20);
-        else if (pos.attacks_from<PAWN>(s, Them) & b2)
+        else if (supportingPawns & rank_bb(s - pawn_push(Us)))
             ebonus += Value(r * 12);
 
-        // If the other side has only a king, check whether the pawn is
-        // unstoppable
-        if (pos.non_pawn_material(Them) == Value(0))
-        {
-            Square qsq;
-            int d;
-
-            qsq = relative_square(Us, make_square(square_file(s), RANK_8));
-            d =  square_distance(s, qsq)
-               - square_distance(theirKingSq, qsq)
-               + (Us != pos.side_to_move());
-
-            if (d < 0)
-            {
-                int mtg = RANK_8 - relative_rank(Us, s);
-                int blockerCount = count_1s_max_15(squares_in_front_of(Us,s) & pos.occupied_squares());
-                mtg += blockerCount;
-                d += blockerCount;
-                if (d < 0 && (!movesToGo[Us] || movesToGo[Us] > mtg))
-                {
-                    movesToGo[Us] = mtg;
-                    pawnToGo[Us] = s;
-                }
-            }
-        }
-
         // Rook pawns are a special case: They are sometimes worse, and
         // sometimes better than other passed pawns. It is difficult to find
         // good rules for determining whether they are good or bad. For now,
@@ -998,30 +861,60 @@ namespace {
         // value if the other side has a rook or queen.
         if (square_file(s) == FILE_A || square_file(s) == FILE_H)
         {
-            if (   pos.non_pawn_material(Them) <= KnightValueMidgame
+            if (pos.non_pawn_material(Them) <= KnightValueMidgame)
-                && pos.piece_count(Them, KNIGHT) <= 1)
                 ebonus += ebonus / 4;
             else if (pos.pieces(ROOK, QUEEN, Them))
                 ebonus -= ebonus / 4;
         }
 
-        // Add the scores for this pawn to the middle game and endgame eval.
+        // Add the scores for this pawn to the middle game and endgame eval
-        ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), WeightPassedPawns);
+        ei.value += Sign[Us] * apply_weight(make_score(mbonus, ebonus), Weights[PassedPawns]);
 
     } // while
   }
 
 
-  // evaluate_passed_pawns() evaluates the passed pawns for both sides
+  // evaluate_unstoppable_pawns() evaluates the unstoppable passed pawns for both sides
 
-  void evaluate_passed_pawns(const Position& pos, EvalInfo& ei) {
+  void evaluate_unstoppable_pawns(const Position& pos, EvalInfo& ei) {
 
     int movesToGo[2] = {0, 0};
     Square pawnToGo[2] = {SQ_NONE, SQ_NONE};
 
-    // Evaluate pawns for each color
+    for (Color c = WHITE; c <= BLACK; c++)
-    evaluate_passed_pawns_of_color<WHITE>(pos, movesToGo, pawnToGo, ei);
+    {
-    evaluate_passed_pawns_of_color<BLACK>(pos, movesToGo, pawnToGo, ei);
+        // Skip evaluation if other side has non-pawn pieces
+        if (pos.non_pawn_material(opposite_color(c)))
+            continue;
+
+        Bitboard b = ei.pi->passed_pawns() & pos.pieces_of_color(c);
+
+        while (b)
+        {
+            Square s = pop_1st_bit(&b);
+            Square queeningSquare = relative_square(c, make_square(square_file(s), RANK_8));
+            int d =  square_distance(s, queeningSquare)
+                   - (relative_rank(c, s) == RANK_2) // Double pawn push
+                   - square_distance(pos.king_square(opposite_color(c)), queeningSquare)
+                   + int(c != pos.side_to_move());
+
+            // Do we protect the path to queening ?
+            bool pathDefended = (ei.attacked_by(c) & squares_in_front_of(c, s)) == squares_in_front_of(c, s);
+
+            if (d < 0 || pathDefended)
+            {
+                int mtg = RANK_8 - relative_rank(c, s);
+                int blockerCount = count_1s_max_15(squares_in_front_of(c, s) & pos.occupied_squares());
+                mtg += blockerCount;
+                d += blockerCount;
+                if ((d < 0 || pathDefended) && (!movesToGo[c] || movesToGo[c] > mtg))
+                {
+                    movesToGo[c] = mtg;
+                    pawnToGo[c] = s;
+                }
+            }
+        }
+    }
 
     // Neither side has an unstoppable passed pawn?
     if (!(movesToGo[WHITE] | movesToGo[BLACK]))
@@ -1144,29 +1037,24 @@ namespace {
   // twice. Finally, the space bonus is scaled by a weight taken from the
   // material hash table.
   template<Color Us, bool HasPopCnt>
-  void evaluate_space(const Position& pos, EvalInfo& ei) {
+  int evaluate_space(const Position& pos, EvalInfo& ei) {
 
     const Color Them = (Us == WHITE ? BLACK : WHITE);
 
     // Find the safe squares for our pieces inside the area defined by
     // SpaceMask[us]. A square is unsafe if it is attacked by an enemy
     // pawn, or if it is undefended and attacked by an enemy piece.
-
+    Bitboard safe =   SpaceMask[Us]
-    Bitboard safeSquares =   SpaceMask[Us]
                    & ~pos.pieces(PAWN, Us)
                    & ~ei.attacked_by(Them, PAWN)
-                          & ~(~ei.attacked_by(Us) & ei.attacked_by(Them));
+                   & (ei.attacked_by(Us) | ~ei.attacked_by(Them));
 
-    // Find all squares which are at most three squares behind some friendly
+    // Find all squares which are at most three squares behind some friendly pawn
-    // pawn.
+    Bitboard behind = pos.pieces(PAWN, Us);
-    Bitboard behindFriendlyPawns = pos.pieces(PAWN, Us);
+    behind |= (Us == WHITE ? behind >>  8 : behind <<  8);
-    behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >>  8 : behindFriendlyPawns <<  8);
+    behind |= (Us == WHITE ? behind >> 16 : behind << 16);
-    behindFriendlyPawns |= (Us == WHITE ? behindFriendlyPawns >> 16 : behindFriendlyPawns << 16);
 
-    int space =  count_1s_max_15<HasPopCnt>(safeSquares)
+    return count_1s_max_15<HasPopCnt>(safe) + count_1s_max_15<HasPopCnt>(behind & safe);
-               + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
-
-    ei.value += Sign[Us] * apply_weight(make_score(space * ei.mi->space_weight(), 0), WeightSpace);
   }
 
 
@@ -1199,17 +1087,11 @@ namespace {
 
   Score weight_option(const std::string& mgOpt, const std::string& egOpt, Score internalWeight) {
 
-    Score uciWeight = make_score(get_option_value_int(mgOpt), get_option_value_int(egOpt));
+    // Scale option value from 100 to 256
+    int mg = get_option_value_int(mgOpt) * 256 / 100;
+    int eg = get_option_value_int(egOpt) * 256 / 100;
 
-    // Convert to integer to prevent overflow
+    return apply_weight(make_score(mg, eg), internalWeight);
-    int mg = mg_value(uciWeight);
-    int eg = eg_value(uciWeight);
-
-    mg = (mg * 0x100) / 100;
-    eg = (eg * 0x100) / 100;
-    mg = (mg * mg_value(internalWeight)) / 0x100;
-    eg = (eg * eg_value(internalWeight)) / 0x100;
-    return make_score(mg, eg);
   }
 
   // init_safety() initizes the king safety evaluation, based on UCI
@@ -1217,39 +1099,24 @@ namespace {
 
   void init_safety() {
 
-    QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
+    const Value MaxSlope = Value(30);
-    QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
+    const Value Peak = Value(1280);
-    RookCheckBonus         = get_option_value_int("Rook Check Bonus");
+    Value t[100];
-    BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
-    KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
-    DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
-    MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
-
-    int maxSlope = get_option_value_int("King Safety Max Slope");
-    int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
-    double a     = get_option_value_int("King Safety Coefficient") / 100.0;
-    double b     = get_option_value_int("King Safety X Intercept");
-    bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
-    bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
 
+    // First setup the base table
     for (int i = 0; i < 100; i++)
     {
-        if (i < b)
+        t[i] = Value(int(0.4 * i * i));
-            SafetyTable[i] = Value(0);
+
-        else if (quad)
+        if (i > 0)
-            SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
+            t[i] = Min(t[i], t[i - 1] + MaxSlope);
-        else if (linear)
+
-            SafetyTable[i] = Value((int)(100 * a * (i - b)));
+        t[i] = Min(t[i], Peak);
     }
 
+    // Then apply the weights and get the final KingDangerTable[] array
+    for (Color c = WHITE; c <= BLACK; c++)
         for (int i = 0; i < 100; i++)
-    {
+            KingDangerTable[c][i] = apply_weight(make_score(t[i], 0), Weights[KingDangerUs + c]);
-        if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
-            for (int j = i + 1; j < 100; j++)
-                SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
-
-        if (SafetyTable[i]  > Value(peak))
-            SafetyTable[i] = Value(peak);
-    }
   }
 }

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -47,6 +47,8 @@ class Position;
 
 struct EvalInfo {
 
+  EvalInfo() { kingDanger[0] = kingDanger[1] = Value(0); }
+
   // Middle game and endgame evaluations
   Score value;
 
@@ -87,15 +89,11 @@ struct EvalInfo {
   // 2 to kingAdjacentZoneAttacksCount[BLACK].
   int kingAdjacentZoneAttacksCount[2];
 
-  // mateThreat[color] is a move for the given side which gives a direct mate.
+  // Middle game and endgame mobility scores
-  Move mateThreat[2];
-
-  // Middle game and endgame mobility scores.
   Score mobility;
 
-  // Extra futility margin. This is added to the standard futility margin
+  // Value of the danger for the king of the given color
-  // in the quiescence search.
+  Value kingDanger[2];
-  Value futilityMargin;
 };
 
 
@@ -103,8 +101,7 @@ struct EvalInfo {
 //// Prototypes
 ////
 
-extern Value evaluate(const Position& pos, EvalInfo& ei, int threadID);
+extern Value evaluate(const Position& pos, EvalInfo& ei);
-extern Value quick_evaluate(const Position& pos);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);

src/history.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -42,6 +42,7 @@ History::History() { clear(); }
 
 void History::clear() {
   memset(history, 0, 2 * 8 * 64 * sizeof(int));
+  memset(maxStaticValueDelta, 0, 2 * 8 * 64 * sizeof(int));
 }
 
 
@@ -61,7 +62,7 @@ void History::success(Piece p, Square to, Depth d) {
   if (history[p][to] >= HistoryMax)
       for (int i = 0; i < 16; i++)
           for (int j = 0; j < 64; j++)
-              history[i][j] /= 4;
+              history[i][j] /= 2;
 }
 
 
@@ -75,8 +76,12 @@ void History::failure(Piece p, Square to, Depth d) {
   assert(square_is_ok(to));
 
   history[p][to] -= int(d) * int(d);
-  if (history[p][to] < 0)
+
-      history[p][to] = 0;
+  // Prevent history underflow
+  if (history[p][to] <= -HistoryMax)
+      for (int i = 0; i < 16; i++)
+          for (int j = 0; j < 64; j++)
+              history[i][j] /= 2;
 }
 
 
@@ -90,3 +95,21 @@ int History::move_ordering_score(Piece p, Square to) const {
 
   return history[p][to];
 }
+
+
+/// History::set_gain() and History::gain() store and retrieve the
+/// gain of a move given the delta of the static position evaluations
+/// before and after the move.
+
+void History::set_gain(Piece p, Square to, Value delta)
+{
+  if (delta >= maxStaticValueDelta[p][to])
+      maxStaticValueDelta[p][to] = delta;
+  else
+      maxStaticValueDelta[p][to]--;
+}
+
+Value History::gain(Piece p, Square to) const
+{
+  return Value(maxStaticValueDelta[p][to]);
+}

src/history.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -28,6 +28,7 @@
 #include "depth.h"
 #include "move.h"
 #include "piece.h"
+#include "value.h"
 
 
 ////
@@ -49,9 +50,12 @@ public:
   void success(Piece p, Square to, Depth d);
   void failure(Piece p, Square to, Depth d);
   int move_ordering_score(Piece p, Square to) const;
+  void set_gain(Piece p, Square to, Value delta);
+  Value gain(Piece p, Square to) const;
 
 private:
   int history[16][64];  // [piece][square]
+  int maxStaticValueDelta[16][64];  // [piece][from_square][to_square]
 };
 
 
@@ -61,13 +65,13 @@ private:
 
 /// HistoryMax controls how often the history counters will be scaled down:
 /// When the history score for a move gets bigger than HistoryMax, all
-/// entries in the table are divided by 4. It is difficult to guess what
+/// entries in the table are divided by 2. It is difficult to guess what
 /// the ideal value of this constant is. Scaling down the scores often has
 /// the effect that parts of the search tree which have been searched
 /// recently have a bigger importance for move ordering than the moves which
 /// have been searched a long time ago.
 
-const int HistoryMax = 25000 * OnePly;
+const int HistoryMax = 50000 * OnePly;
 
 
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -99,5 +99,4 @@ typedef CRITICAL_SECTION Lock;
 
 #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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -57,8 +57,19 @@ int main(int argc, char *argv[]) {
   CALLGRIND_START_INSTRUMENTATION;
 #endif
 
-  // Process command line arguments if any
+  if (argc <= 1)
-  if (argc > 1)
+  {
+      // Print copyright notice
+      cout << engine_name()
+           << " by Tord Romstad, Marco Costalba, Joona Kiiski" << endl;
+
+      if (CpuHasPOPCNT)
+          cout << "Good! CPU has hardware POPCNT." << endl;
+
+      // Enter UCI mode
+      uci_main_loop();
+  }
+  else // Process command line arguments
   {
       if (string(argv[1]) != "bench" || argc < 4 || argc > 8)
           cout << "Usage: stockfish bench <hash size> <threads> "
@@ -73,17 +84,8 @@ int main(int argc, char *argv[]) {
           string tim  = argc > 7 ? argv[7] : "";
           benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim + " " + tim);
       }
-      return 0;
   }
 
-  // Print copyright notice
+  Application::free_resources();
-  cout << engine_name()
-       << ". By Tord Romstad, Marco Costalba, Joona Kiiski." << endl;
-
-  if (CpuHasPOPCNT)
-      cout << "Good! CPU has hardware POPCNT. We will use it." << endl;
-
-  // Enter UCI mode
-  uci_main_loop();
   return 0;
 }

src/material.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -55,17 +55,40 @@ namespace {
   { 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 } };
 
-  // Named endgame evaluation and scaling functions, these
-  // are accessed direcly and not through the function maps.
-  EvaluationFunction<KmmKm> EvaluateKmmKm(WHITE);
-  EvaluationFunction<KXK>   EvaluateKXK(WHITE), EvaluateKKX(BLACK);
-  ScalingFunction<KBPsK>    ScaleKBPsK(WHITE),  ScaleKKBPs(BLACK);
-  ScalingFunction<KQKRPs>   ScaleKQKRPs(WHITE), ScaleKRPsKQ(BLACK);
-  ScalingFunction<KPsK>     ScaleKPsK(WHITE),   ScaleKKPs(BLACK);
-  ScalingFunction<KPKP>     ScaleKPKPw(WHITE),  ScaleKPKPb(BLACK);
-
   typedef EndgameEvaluationFunctionBase EF;
   typedef EndgameScalingFunctionBase SF;
+
+  // Endgame evaluation and scaling functions accessed direcly and not through
+  // the function maps because correspond to more then one material hash key.
+  EvaluationFunction<KmmKm> EvaluateKmmKm[] = { EvaluationFunction<KmmKm>(WHITE), EvaluationFunction<KmmKm>(BLACK) };
+  EvaluationFunction<KXK>   EvaluateKXK[]   = { EvaluationFunction<KXK>(WHITE),   EvaluationFunction<KXK>(BLACK) };
+  ScalingFunction<KBPsK>    ScaleKBPsK[]    = { ScalingFunction<KBPsK>(WHITE),    ScalingFunction<KBPsK>(BLACK) };
+  ScalingFunction<KQKRPs>   ScaleKQKRPs[]   = { ScalingFunction<KQKRPs>(WHITE),   ScalingFunction<KQKRPs>(BLACK) };
+  ScalingFunction<KPsK>     ScaleKPsK[]     = { ScalingFunction<KPsK>(WHITE),     ScalingFunction<KPsK>(BLACK) };
+  ScalingFunction<KPKP>     ScaleKPKP[]     = { ScalingFunction<KPKP>(WHITE),     ScalingFunction<KPKP>(BLACK) };
+
+  // Helper templates used to detect a given material distribution
+  template<Color Us> bool is_KXK(const Position& pos) {
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return   pos.non_pawn_material(Them) == Value(0)
+          && pos.piece_count(Them, PAWN) == 0
+          && pos.non_pawn_material(Us)   >= RookValueMidgame;
+  }
+
+  template<Color Us> bool is_KBPsK(const Position& pos) {
+    return   pos.non_pawn_material(Us)   == BishopValueMidgame
+          && pos.piece_count(Us, BISHOP) == 1
+          && pos.piece_count(Us, PAWN)   >= 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;
+  }
 }
 
 
@@ -181,18 +204,9 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
       return mi;
 
-  else if (   pos.non_pawn_material(BLACK) == Value(0)
+  else if (is_KXK<WHITE>(pos) || is_KXK<BLACK>(pos))
-           && pos.piece_count(BLACK, PAWN) == 0
-           && pos.non_pawn_material(WHITE) >= RookValueMidgame)
   {
-      mi->evaluationFunction = &EvaluateKXK;
+      mi->evaluationFunction = is_KXK<WHITE>(pos) ? &EvaluateKXK[WHITE] : &EvaluateKXK[BLACK];
-      return mi;
-  }
-  else if (   pos.non_pawn_material(WHITE) == Value(0)
-           && pos.piece_count(WHITE, PAWN) == 0
-           && pos.non_pawn_material(BLACK) >= RookValueMidgame)
-  {
-      mi->evaluationFunction = &EvaluateKKX;
       return mi;
   }
   else if (   pos.pieces(PAWN)  == EmptyBoardBB
@@ -207,7 +221,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
       if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
           && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
       {
-          mi->evaluationFunction = &EvaluateKmmKm;
+          mi->evaluationFunction = &EvaluateKmmKm[WHITE];
           return mi;
       }
   }
@@ -215,10 +229,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   // OK, we didn't find any special evaluation function for the current
   // material configuration. Is there a suitable scaling function?
   //
-  // The code below is rather messy, and it could easily get worse later,
+  // We face problems when there are several conflicting applicable
-  // if we decide to add more special cases. We face problems when there
+  // scaling functions and we need to decide which one to use.
-  // are several conflicting applicable scaling functions and we need to
-  // decide which one to use.
   SF* sf;
 
   if ((sf = funcs->get<SF>(key)) != NULL)
@@ -230,48 +242,36 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   // 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 (   pos.non_pawn_material(WHITE) == BishopValueMidgame
+  if (is_KBPsK<WHITE>(pos))
-      && pos.piece_count(WHITE, BISHOP) == 1
+      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
-      && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKBPsK;
 
-  if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
+  if (is_KBPsK<BLACK>(pos))
-      && pos.piece_count(BLACK, BISHOP) == 1
+      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
-      && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKKBPs;
 
-  if (   pos.piece_count(WHITE, PAWN) == 0
+  if (is_KQKRPs<WHITE>(pos))
-      && pos.non_pawn_material(WHITE) == QueenValueMidgame
+      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
-      && pos.piece_count(WHITE, QUEEN) == 1
-      && pos.piece_count(BLACK, ROOK) == 1
-      && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKQKRPs;
 
-  else if (   pos.piece_count(BLACK, PAWN) == 0
+  else if (is_KQKRPs<BLACK>(pos))
-           && pos.non_pawn_material(BLACK) == QueenValueMidgame
+      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
-           && pos.piece_count(BLACK, QUEEN) == 1
-           && pos.piece_count(WHITE, ROOK) == 1
-           && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKRPsKQ;
 
   if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
   {
       if (pos.piece_count(BLACK, PAWN) == 0)
       {
           assert(pos.piece_count(WHITE, PAWN) >= 2);
-          mi->scalingFunction[WHITE] = &ScaleKPsK;
+          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
       }
       else if (pos.piece_count(WHITE, PAWN) == 0)
       {
           assert(pos.piece_count(BLACK, PAWN) >= 2);
-          mi->scalingFunction[BLACK] = &ScaleKKPs;
+          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
       }
       else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
       {
           // This is a special case because we set scaling functions
           // for both colors instead of only one.
-          mi->scalingFunction[WHITE] = &ScaleKPKPw;
+          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
-          mi->scalingFunction[BLACK] = &ScaleKPKPb;
+          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
   }
 
@@ -374,7 +374,6 @@ EndgameFunctions::EndgameFunctions() {
   add<ScalingFunction<KBPPKB>  >("KBPPKB");
   add<ScalingFunction<KBPKN>   >("KBPKN");
   add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
 }
 
 EndgameFunctions::~EndgameFunctions() {
@@ -404,7 +403,7 @@ Key EndgameFunctions::buildKey(const string& keyCode) {
         s << char(upcase? toupper(keyCode[i]) : tolower(keyCode[i]));
     }
     s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w -";
-    return Position(s.str()).get_material_key();
+    return Position(s.str(), 0).get_material_key();
 }
 
 const string EndgameFunctions::swapColors(const string& keyCode) {

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/mersenne.cpp

@@ -41,93 +41,110 @@
    email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
 */
 
-#include "types.h"
 #include "mersenne.h"
 
-/* Period parameters */
+namespace {
-#define N 624
-#define M 397
-#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
-#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
-#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
 
-static unsigned long mt[N]; /* the array for the state vector  */
+  // Period parameters
-static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
+  const int N = 624;
+  const int M = 397;
+  const unsigned long MATRIX_A   = 0x9908b0dfUL; // Constant vector a
+  const unsigned long UPPER_MASK = 0x80000000UL; // Most significant w-r bits
+  const unsigned long LOWER_MASK = 0x7fffffffUL; // Least significant r bits
+
+  unsigned long mt[N]; // The array for the state vector
+  int mti = N + 1;     // mti == N+1 means mt[N] is not initialized
+
+  // Initializes mt[N] with a seed
+  void init_genrand(unsigned long s) {
 
-/* initializes mt[N] with a seed */
-static void init_genrand(unsigned long s)
-{
       mt[0]= s & 0xffffffffUL;
-    for (mti=1; mti<N; mti++) {
+      for (mti = 1; mti < N; mti++)
-        mt[mti] =
-            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
-        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
-        /* In the previous versions, MSBs of the seed affect   */
-        /* only MSBs of the array mt[].                        */
-        /* 2002/01/09 modified by Makoto Matsumoto             */
-        mt[mti] &= 0xffffffffUL;
-        /* for >32 bit machines */
-    }
-}
-
-/* initialize by an array with array-length */
-/* init_key is the array for initializing keys */
-/* key_length is its length */
-/* slight change for C++, 2004/2/26 */
-static void init_by_array(unsigned long init_key[], int key_length)
       {
-    int i, j, k;
+          // See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
+          // In the previous versions, MSBs of the seed affect
+          // only MSBs of the array mt[].
+          // 2002/01/09 modified by Makoto Matsumoto
+          mt[mti] = 1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti;
+          mt[mti] &= 0xffffffffUL; // For > 32 bit machines
+      }
+  }
+
+  // Initialize by an array with array-length
+  // init_key is the array for initializing keys
+  // key_length is its length
+  // slight change for C++, 2004/2/26
+  void init_by_array(unsigned long init_key[], int key_length) {
+
+      int i = 1;
+      int j = 0;
+      int k = (N > key_length ? N : key_length);
+
       init_genrand(19650218UL);
-    i=1; j=0;
+
-    k = (N>key_length ? N : key_length);
+      for ( ; k; k--)
-    for (; k; k--) {
+      {
-        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
+          mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL)) + init_key[j] + j; // Non linear
-          + init_key[j] + j; /* non linear */
+          mt[i] &= 0xffffffffUL; // For WORDSIZE > 32 machines
-        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
           i++; j++;
-        if (i>=N) { mt[0] = mt[N-1]; i=1; }
+          if (i >= N)
-        if (j>=key_length) j=0;
+          {
+              mt[0] = mt[N-1];
+              i = 1;
           }
-    for (k=N-1; k; k--) {
+          if (j >= key_length)
-        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
+              j = 0;
-          - i; /* non linear */
+      }
-        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+      for (k = N-1; k; k--)
+      {
+          mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL)) - i; // Non linear
+          mt[i] &= 0xffffffffUL; // For WORDSIZE > 32 machines
           i++;
-        if (i>=N) { mt[0] = mt[N-1]; i=1; }
+          if (i >= N)
+          {
+              mt[0] = mt[N-1];
+              i = 1;
+          }
+      }
+      mt[0] = 0x80000000UL; // MSB is 1; assuring non-zero initial array
   }
 
-    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
+} // namespace
-}
+
+
+// Generates a random number on [0,0xffffffff]-interval
+uint32_t genrand_int32() {
 
-/* generates a random number on [0,0xffffffff]-interval */
-uint32_t genrand_int32(void) {
   unsigned long y;
   static unsigned long mag01[2] = {0x0UL, MATRIX_A};
   /* mag01[x] = x * MATRIX_A  for x=0,1 */
 
-  if (mti >= N) { /* generate N words at one time */
+  // Generate N words at one time
+  if (mti >= N)
+  {
       int kk;
 
-    if (mti == N+1)   /* if init_genrand() has not been called, */
+      if (mti == N+1)           // If init_genrand() has not been called,
-      init_genrand(5489UL); /* a default initial seed is used */
+          init_genrand(5489UL); // a default initial seed is used.
 
-    for (kk=0;kk<N-M;kk++) {
+      for (kk = 0; kk < N-M; kk++)
+      {
           y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
           mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
       }
-    for (;kk<N-1;kk++) {
+      for ( ; kk < N-1; kk++)
+      {
           y = (mt[kk] & UPPER_MASK) | (mt[kk+1] & LOWER_MASK);
           mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
       }
       y = (mt[N-1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
       mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
-
       mti = 0;
   }
 
   y = mt[mti++];
 
-  /* Tempering */
+  // Tempering
   y ^= (y >> 11);
   y ^= (y <<  7) & 0x9d2c5680UL;
   y ^= (y << 15) & 0xefc60000UL;
@@ -136,14 +153,19 @@ uint32_t genrand_int32(void) {
   return y;
 }
 
-uint64_t genrand_int64(void) {
+uint64_t genrand_int64() {
+
   uint64_t x, y;
 
-  x = genrand_int32(); y = genrand_int32();
+  x = genrand_int32();
+  y = genrand_int32();
   return (x << 32) | y;
 }
 
-void init_mersenne(void) {
+void init_mersenne() {
-  unsigned long init[4]={0x123, 0x234, 0x345, 0x456}, length=4;
+
+  unsigned long init[4] = {0x123, 0x234, 0x345, 0x456};
+  unsigned long length = 4;
+
   init_by_array(init, length);
 }

src/mersenne.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -32,9 +32,9 @@
 //// Prototypes
 ////
 
-extern uint32_t genrand_int32(void);
+extern uint32_t genrand_int32();
-extern uint64_t genrand_int64(void);
+extern uint64_t genrand_int64();
-extern void init_mersenne(void);
+extern void init_mersenne();
 
 
 #endif // !defined(MERSENNE_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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,6 +27,9 @@
 #  include <sys/time.h>
 #  include <sys/types.h>
 #  include <unistd.h>
+#  if defined(__hpux)
+#     include <sys/pstat.h>
+#  endif
 
 #else
 
@@ -36,6 +39,10 @@
 
 #endif
 
+#if !defined(NO_PREFETCH)
+#  include <xmmintrin.h>
+#endif
+
 #include <cassert>
 #include <cstdio>
 #include <iomanip>
@@ -44,13 +51,14 @@
 
 #include "bitcount.h"
 #include "misc.h"
+#include "thread.h"
 
 using namespace std;
 
 /// Version number. If this is left empty, the current date (in the format
 /// YYMMDD) is used as a version number.
 
-static const string EngineVersion = "1.6";
+static const string EngineVersion = "1.8";
 static const string AppName = "Stockfish";
 static const string AppTag  = "";
 
@@ -185,7 +193,15 @@ int get_system_time() {
 
 #  if defined(_SC_NPROCESSORS_ONLN)
 int cpu_count() {
-  return Min(sysconf(_SC_NPROCESSORS_ONLN), 8);
+  return Min(sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
+}
+#  elif defined(__hpux)
+int cpu_count() {
+  struct pst_dynamic psd;
+  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
+      return 1;
+
+  return Min(psd.psd_proc_cnt, MAX_THREADS);
 }
 #  else
 int cpu_count() {
@@ -198,7 +214,7 @@ int cpu_count() {
 int cpu_count() {
   SYSTEM_INFO s;
   GetSystemInfo(&s);
-  return Min(s.dwNumberOfProcessors, 8);
+  return Min(s.dwNumberOfProcessors, MAX_THREADS);
 }
 
 #endif
@@ -275,4 +291,27 @@ int Bioskey()
         return 0;
     }
 }
+
 #endif
+
+/// 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 RAM, that can be very slow.
+#if defined(NO_PREFETCH)
+void prefetch(char*) {}
+#else
+
+void prefetch(char* addr) {
+
+#if defined(__INTEL_COMPILER) || defined(__ICL)
+   // 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
+}
+
+#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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -55,6 +55,7 @@ extern const std::string engine_name();
 extern int get_system_time();
 extern int cpu_count();
 extern int Bioskey();
+extern void prefetch(char* addr);
 
 
 ////

src/move.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/move.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -86,10 +86,10 @@ inline void insertion_sort(T* firstMove, T* lastMove)
         }
 }
 
-// Our dedicated sort in range [firstMove, lastMove), it is well
+// Our dedicated sort in range [firstMove, lastMove), first splits
-// tuned for non-captures where we have a lot of zero scored moves.
+// positive scores from ramining then order seaprately the two sets.
 template<typename T>
-inline void sort_moves(T* firstMove, T* lastMove)
+inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
 {
     T tmp;
     T *p, *d;
@@ -101,11 +101,11 @@ inline void sort_moves(T* firstMove, T* lastMove)
 
     // Split positives vs non-positives
     do {
-        while ((++p)->score > 0);
+        while ((++p)->score > 0) {}
 
         if (p != d)
         {
-            while (--d != p && d->score <= 0);
+            while (--d != p && d->score <= 0) {}
 
             tmp = *p;
             *p = *d;
@@ -114,29 +114,9 @@ inline void sort_moves(T* firstMove, T* lastMove)
 
     } while (p != d);
 
-    // Sort positives
+    // Sort just positive scored moves, remaining only when we get there
     insertion_sort<T>(firstMove, p);
-
+    *lastPositive = p;
-    d = lastMove;
-    p--;
-
-    // Split zero vs negatives
-    do {
-        while ((++p)->score == 0);
-
-        if (p != d)
-        {
-            while (--d != p && d->score < 0);
-
-            tmp = *p;
-            *p = *d;
-            *d = tmp;
-        }
-
-    } while (p != d);
-
-    // Sort negatives
-    insertion_sort<T>(p, lastMove);
 }
 
 // Picks up the best move in range [curMove, lastMove), one per cycle.

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -338,6 +338,10 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
            ||(square_rank(to) == RANK_1 && us != WHITE)) != bool(move_is_promotion(m)))
           return false;
 
+      // The promotion piece, if any, must be valid
+      if (move_promotion_piece(m) > QUEEN || move_promotion_piece(m) == PAWN)
+          return false;
+
       // Proceed according to the square delta between the origin and
       // destination squares.
       switch (direction)

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -70,11 +70,11 @@ namespace {
 /// 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,
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
-                       const History& h, SearchStack* ss) : pos(p), H(h) {
+                       SearchStack* ss, Value beta) : pos(p), H(h) {
   int searchTT = ttm;
   ttMoves[0].move = ttm;
-  finished = false;
+  badCaptureThreshold = 0;
   lastBadCapture = badCaptures;
 
   pinned = p.pinned_pieces(pos.side_to_move());
@@ -91,13 +91,28 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
   if (p.is_check())
       phasePtr = EvasionsPhaseTable;
   else if (d > Depth(0))
+  {
+      // Consider sligtly negative captures as good if at low
+      // depth and far from beta.
+      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * OnePly)
+          badCaptureThreshold = -PawnValueMidgame;
+
       phasePtr = MainSearchPhaseTable;
+  }
   else if (d == Depth(0))
       phasePtr = QsearchWithChecksPhaseTable;
   else
+  {
       phasePtr = QsearchWithoutChecksPhaseTable;
 
-  phasePtr += !searchTT - 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 != MOVE_NONE && !pos.move_is_capture_or_promotion(ttm))
+          searchTT = ttMoves[0].move = MOVE_NONE;
+  }
+
+  phasePtr += int(!searchTT) - 1;
   go_next_phase();
 }
 
@@ -129,7 +144,7 @@ void MovePicker::go_next_phase() {
   case PH_NONCAPTURES:
       lastMove = generate_noncaptures(pos, moves);
       score_noncaptures();
-      sort_moves(moves, lastMove);
+      sort_moves(moves, lastMove, &lastGoodNonCapture);
       return;
 
   case PH_BAD_CAPTURES:
@@ -142,7 +157,7 @@ void MovePicker::go_next_phase() {
   case PH_EVASIONS:
       assert(pos.is_check());
       lastMove = generate_evasions(pos, moves);
-      score_evasions();
+      score_evasions_or_checks();
       return;
 
   case PH_QCAPTURES:
@@ -151,12 +166,12 @@ void MovePicker::go_next_phase() {
       return;
 
   case PH_QCHECKS:
-      // Perhaps we should order moves move here?  FIXME
       lastMove = generate_non_capture_checks(pos, moves);
+      score_evasions_or_checks();
       return;
 
   case PH_STOP:
-      lastMove = curMove + 1; // hack to be friendly for get_next_move()
+      lastMove = curMove + 1; // Avoids another go_next_phase() call
       return;
 
   default:
@@ -216,16 +231,16 @@ void MovePicker::score_noncaptures() {
       piece = pos.piece_on(from);
       hs = H.move_ordering_score(piece, to);
 
-      // Ensure history is always preferred to pst
+      // Ensure history has always highest priority
       if (hs > 0)
-          hs += 1000;
+          hs += 10000;
 
-      // pst based scoring
+      // Gain table based scoring
-      cur->score = hs + mg_value(pos.pst_delta(piece, from, to));
+      cur->score = hs + 16 * H.gain(piece, to);
   }
 }
 
-void MovePicker::score_evasions() {
+void MovePicker::score_evasions_or_checks() {
   // 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
@@ -233,11 +248,15 @@ void MovePicker::score_evasions() {
   Move m;
   int seeScore;
 
+  // Skip if we don't have at least two moves to order
+  if (lastMove < moves + 2)
+      return;
+
   for (MoveStack* cur = moves; cur != lastMove; cur++)
   {
       m = cur->move;
       if ((seeScore = pos.see_sign(m)) < 0)
-          cur->score = seeScore;
+          cur->score = seeScore - HistoryMax; // Be sure are at the bottom
       else if (pos.move_is_capture(m))
           cur->score =  pos.midgame_value_of_piece_on(move_to(m))
                       - pos.type_of_piece_on(move_from(m)) + HistoryMax;
@@ -251,6 +270,8 @@ void MovePicker::score_evasions() {
 /// are no more moves left.
 /// It picks the move with the biggest score from a list of generated moves taking
 /// care not to return the tt move if has already been searched previously.
+/// Note that this function is not thread safe so should be lock protected by
+/// caller when accessed through a shared MovePicker object.
 
 Move MovePicker::get_next_move() {
 
@@ -277,7 +298,7 @@ Move MovePicker::get_next_move() {
               {
                   // Check for a non negative SEE now
                   int seeValue = pos.see_sign(move);
-                  if (seeValue >= 0)
+                  if (seeValue >= badCaptureThreshold)
                       return move;
 
                   // Losing capture, move it to the badCaptures[] array, note
@@ -292,14 +313,19 @@ Move MovePicker::get_next_move() {
           case PH_KILLERS:
               move = (curMove++)->move;
               if (   move != MOVE_NONE
+                  && move_is_legal(pos, move, pinned)
                   && move != ttMoves[0].move
                   && move != ttMoves[1].move
-                  && move_is_legal(pos, move, pinned)
                   && !pos.move_is_capture(move))
                   return move;
               break;
 
           case PH_NONCAPTURES:
+
+              // Sort negative scored moves only when we get there
+              if (curMove == lastGoodNonCapture)
+                  insertion_sort(lastGoodNonCapture, lastMove);
+
               move = (curMove++)->move;
               if (   move != ttMoves[0].move
                   && move != ttMoves[1].move
@@ -340,21 +366,3 @@ Move MovePicker::get_next_move() {
   }
 }
 
-/// A variant of get_next_move() which takes a lock as a parameter, used to
-/// prevent multiple threads from picking the same move at a split point.
-
-Move MovePicker::get_next_move(Lock &lock) {
-
-   lock_grab(&lock);
-   if (finished)
-   {
-       lock_release(&lock);
-       return MOVE_NONE;
-   }
-   Move m = get_next_move();
-   if (m == MOVE_NONE)
-       finished = true;
-
-   lock_release(&lock);
-   return m;
-}

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,7 +27,6 @@
 
 #include "depth.h"
 #include "history.h"
-#include "lock.h"
 #include "position.h"
 
 
@@ -50,25 +49,23 @@ class MovePicker {
   MovePicker& operator=(const MovePicker&); // silence a warning under MSVC
 
 public:
-  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
+  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL, Value beta = -VALUE_INFINITE);
   Move get_next_move();
-  Move get_next_move(Lock& lock);
   int number_of_evasions() const;
 
 private:
   void score_captures();
   void score_noncaptures();
-  void score_evasions();
+  void score_evasions_or_checks();
   void go_next_phase();
 
   const Position& pos;
   const History& H;
-  MoveStack ttMoves[2], killers[2];
-  bool finished;
-  int phase;
-  const uint8_t* phasePtr;
-  MoveStack *curMove, *lastMove, *lastBadCapture;
   Bitboard pinned;
+  MoveStack ttMoves[2], killers[2];
+  int badCaptureThreshold, phase;
+  const uint8_t* phasePtr;
+  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *lastBadCapture;
   MoveStack moves[256], badCaptures[64];
 };
 

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -94,12 +94,13 @@ namespace {
   };
 
   // Pawn storm open file bonuses by file
-  const int16_t KStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
+  const int16_t QStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
-  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
+  const int16_t KStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
 
   // Pawn storm lever bonuses by file
   const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
 
+  #undef S
 }
 
 
@@ -107,11 +108,10 @@ namespace {
 //// Functions
 ////
 
-/// Constructor
+/// PawnInfoTable c'tor and d'tor instantiated one each thread
 
-PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
+PawnInfoTable::PawnInfoTable(unsigned numOfEntries) : size(numOfEntries) {
 
-  size = numOfEntries;
   entries = new PawnInfo[size];
   if (!entries)
   {
@@ -122,9 +122,8 @@ PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
 }
 
 
-/// Destructor
-
 PawnInfoTable::~PawnInfoTable() {
+
   delete [] entries;
 }
 
@@ -140,11 +139,11 @@ void PawnInfo::clear() {
 
 
 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it.  The result is also
+/// a PawnInfo object, and returns a pointer to it. The result is also stored
-/// stored in a hash table, so we don't have to recompute everything when
+/// in a hash table, so we don't have to recompute everything when the same
-/// the same pawn structure occurs again.
+/// pawn structure occurs again.
 
-PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
+PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
 
   assert(pos.is_ok());
 
@@ -179,12 +178,13 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
 
 template<Color Us>
 Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                                    Bitboard theirPawns, PawnInfo* pi) {
+                                    Bitboard theirPawns, PawnInfo* pi) const {
+  Bitboard b;
   Square s;
   File f;
   Rank r;
-  bool passed, isolated, doubled, chain, backward, candidate;
   int bonus;
+  bool passed, isolated, doubled, opposed, chain, backward, candidate;
   Score value = make_score(0, 0);
   const Square* ptr = pos.piece_list_begin(Us, PAWN);
 
@@ -205,79 +205,24 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
 
       assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
 
-      // Passed, isolated or doubled pawn?
+      // Calculate kingside and queenside pawn storm scores for both colors to be
-      passed   = Position::pawn_is_passed(theirPawns, Us, s);
+      // used when evaluating middle game positions with opposite side castling.
-      isolated = Position::pawn_is_isolated(ourPawns, s);
+      bonus = (f >= FILE_F ? evaluate_pawn_storm<Us, KingSide>(s, r, f, theirPawns) : 0);
-      doubled  = Position::pawn_is_doubled(ourPawns, Us, s);
+      pi->ksStormValue[Us] += KStormTable[relative_square(Us, s)] + bonus;
 
-      // We calculate kingside and queenside pawn storm
+      bonus = (f <= FILE_C ? evaluate_pawn_storm<Us, QueenSide>(s, r, f, theirPawns) : 0);
-      // scores for both colors. These are used when evaluating
+      pi->qsStormValue[Us] += QStormTable[relative_square(Us, s)] + bonus;
-      // middle game positions with opposite side castling.
-      //
-      // Each pawn is given a base score given by a piece square table
-      // (KStormTable[] or QStormTable[]). Pawns which seem to have good
-      // chances of creating an open file by exchanging itself against an
-      // enemy pawn on an adjacent file gets an additional bonus.
 
-      // Kingside pawn storms
+      // Our rank plus previous one. Used for chain detection.
-      bonus = KStormTable[relative_square(Us, s)];
+      b = rank_bb(r) | rank_bb(r + (Us == WHITE ? -1 : 1));
-      if (f >= FILE_F)
-      {
-          Bitboard b = outpost_mask(Us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
-          while (b)
-          {
-              Square s2 = pop_1st_bit(&b);
-              if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-              {
-                  // The enemy pawn has no pawn beside itself, which makes it
-                  // particularly vulnerable. Big bonus, especially against a
-                  // weakness on the rook file.
-                  if (square_file(s2) == FILE_H)
-                      bonus += 4*StormLeverBonus[f] - 8*square_distance(s, s2);
-                  else
-                      bonus += 2*StormLeverBonus[f] - 4*square_distance(s, s2);
-              } else
-                  // There is at least one enemy pawn beside the enemy pawn we look
-                  // at, which means that the pawn has somewhat better chances of
-                  // defending itself by advancing. Smaller bonus.
-                  bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
-          }
-      }
-      pi->ksStormValue[Us] += bonus;
 
-      // Queenside pawn storms
+      // Passed, isolated, doubled or member of a pawn
-      bonus = QStormTable[relative_square(Us, s)];
+      // chain (but not the backward one) ?
-      if (f <= FILE_C)
+      passed   = !(theirPawns & passed_pawn_mask(Us, s));
-      {
+      doubled  =   ourPawns   & squares_behind(Us, s);
-          Bitboard b = outpost_mask(Us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
+      opposed  =   theirPawns & squares_in_front_of(Us, s);
-          while (b)
+      isolated = !(ourPawns   & neighboring_files_bb(f));
-          {
+      chain    =   ourPawns   & neighboring_files_bb(f) & b;
-              Square s2 = pop_1st_bit(&b);
-              if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-              {
-                  // The enemy pawn has no pawn beside itself, which makes it
-                  // particularly vulnerable. Big bonus, especially against a
-                  // weakness on the rook file.
-                  if (square_file(s2) == FILE_A)
-                      bonus += 4*StormLeverBonus[f] - 16*square_distance(s, s2);
-                  else
-                      bonus += 2*StormLeverBonus[f] - 8*square_distance(s, s2);
-              } else
-                  // There is at least one enemy pawn beside the enemy pawn we look
-                  // at, which means that the pawn has somewhat better chances of
-                  // defending itself by advancing. Smaller bonus.
-                  bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
-          }
-      }
-      pi->qsStormValue[Us] += bonus;
-
-      // Member of a pawn chain (but not the backward one)? We could speed up
-      // the test a little by introducing an array of masks indexed by color
-      // and square for doing the test, but because everything is hashed,
-      // it probably won't make any noticable difference.
-      chain =  ourPawns
-             & neighboring_files_bb(f)
-             & (rank_bb(r) | rank_bb(r - (Us == WHITE ? 1 : -1)));
 
       // Test for backward pawn
       //
@@ -286,7 +231,7 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
       // there are friendly pawns behind on neighboring files it cannot
       // be backward either.
       if (   (passed | isolated | chain)
-          || (ourPawns & behind_bb(Us, r) & neighboring_files_bb(f))
+          || (ourPawns & attack_span_mask(opposite_color(Us), s))
           || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
           backward = false;
       else
@@ -295,7 +240,7 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
           // 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.
-          Bitboard b = pos.attacks_from<PAWN>(s, Us);
+          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.
@@ -307,12 +252,12 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
           backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
       }
 
+      assert(passed | opposed | (attack_span_mask(Us, s) & theirPawns));
+
       // Test for candidate passed pawn
-      candidate =   !passed
+      candidate =   !(opposed | passed)
-                 && !(theirPawns & file_bb(f))
+                 && (b = attack_span_mask(opposite_color(Us), s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
-                 && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(Us, r) | rank_bb(r)) & ourPawns)
+                 &&  count_1s_max_15(b) >= count_1s_max_15(attack_span_mask(Us, s) & theirPawns);
-                     - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(Us, r)              & theirPawns)
-                     >= 0);
 
       // In order to prevent doubled passed pawns from receiving a too big
       // bonus, only the frontmost passed pawn on each file is considered as
@@ -320,10 +265,12 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
       if (passed && (ourPawns & squares_in_front_of(Us, s)))
           passed = false;
 
-      // Score this pawn
+      // Mark the pawn as passed. Pawn will be properly scored in evaluation
+      // because we need full attack info to evaluate passed pawns.
       if (passed)
           set_bit(&(pi->passedPawns), s);
 
+      // Score this pawn
       if (isolated)
       {
           value -= IsolatedPawnPenalty[f];
@@ -350,13 +297,47 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
 }
 
 
+/// PawnInfoTable::evaluate_pawn_storm() evaluates each pawn which seems
+/// to have good chances of creating an open file by exchanging itself
+/// against an enemy pawn on an adjacent file.
+
+template<Color Us, PawnInfoTable::SideType Side>
+int PawnInfoTable::evaluate_pawn_storm(Square s, Rank r, File f, Bitboard theirPawns) const {
+
+  const Bitboard StormFilesBB = (Side == KingSide ? FileFBB | FileGBB | FileHBB
+                                                  : FileABB | FileBBB | FileCBB);
+  const int K = (Side == KingSide ? 2 : 4);
+  const File RookFile = (Side == KingSide ? FILE_H : FILE_A);
+
+  Bitboard b = attack_span_mask(Us, s) & theirPawns & StormFilesBB;
+  int bonus = 0;
+
+  while (b)
+  {
+      // Give a bonus according to the distance of the nearest enemy pawn
+      Square s2 = pop_1st_bit(&b);
+      Rank r2 = square_rank(s2);
+      int v = StormLeverBonus[f] - K * rank_distance(r, r2);
+
+      // If enemy pawn has no pawn beside itself is particularly vulnerable.
+      // Big bonus, especially against a weakness on the rook file
+      if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
+          v *= (square_file(s2) == RookFile ? 4 : 2);
+
+      bonus += v;
+  }
+  return bonus;
+}
+
+
 /// PawnInfo::updateShelter calculates and caches king shelter. It is called
 /// only when king square changes, about 20% of total get_king_shelter() calls.
 int PawnInfo::updateShelter(const Position& pos, Color c, Square ksq) {
 
-  unsigned shelter = 0;
   Bitboard pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
+  unsigned shelter = 0;
   unsigned r = ksq & (7 << 3);
+
   for (int i = 1, k = (c ? -8 : 8); i < 4; i++)
   {
       r += k;

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -64,10 +64,10 @@ private:
   Key key;
   Bitboard passedPawns;
   Bitboard pawnAttacks[2];
+  Square kingSquares[2];
   Score value;
   int16_t ksStormValue[2], qsStormValue[2];
   uint8_t halfOpenFiles[2];
-  Square kingSquares[2];
   uint8_t kingShelters[2];
 };
 
@@ -78,14 +78,19 @@ private:
 
 class PawnInfoTable {
 
+  enum SideType { KingSide, QueenSide };
+
 public:
   PawnInfoTable(unsigned numOfEntries);
   ~PawnInfoTable();
-  PawnInfo* get_pawn_info(const Position& pos);
+  PawnInfo* get_pawn_info(const Position& pos) const;
 
 private:
   template<Color Us>
-  Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
+  Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi) const;
+
+  template<Color Us, SideType Side>
+  int evaluate_pawn_storm(Square s, Rank r, File f, Bitboard theirPawns) const;
 
   unsigned size;
   PawnInfo* entries;

src/piece.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -38,7 +38,7 @@ static const string PieceChars(" pnbrqk PNBRQK");
 
 char piece_type_to_char(PieceType pt, bool upcase) {
 
-  return PieceChars[pt + upcase * 7];
+  return PieceChars[pt + int(upcase) * 7];
 }
 
 PieceType piece_type_from_char(char c) {

src/piece.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/position.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -44,12 +44,9 @@ using std::string;
 //// Variables
 ////
 
-int Position::castleRightsMask[64];
-
 Key Position::zobrist[2][8][64];
 Key Position::zobEp[64];
 Key Position::zobCastle[16];
-Key Position::zobMaterial[2][8][16];
 Key Position::zobSideToMove;
 Key Position::zobExclusion;
 
@@ -76,12 +73,36 @@ CheckInfo::CheckInfo(const Position& pos) {
   checkSq[KING] = EmptyBoardBB;
 }
 
-Position::Position(const Position& pos) {
+
-  copy(pos);
+/// Position c'tors. Here we always create a copy of the original position
+/// or the FEN string, we want the new born Position object do not depend
+/// on any external data so we detach state pointer from the source one.
+
+Position::Position(int th) : threadID(th) {}
+
+Position::Position(const Position& pos, int th) {
+
+  memcpy(this, &pos, sizeof(Position));
+  detach(); // Always detach() in copy c'tor to avoid surprises
+  threadID = th;
 }
 
-Position::Position(const string& fen) {
+Position::Position(const string& fen, int th) {
+
   from_fen(fen);
+  threadID = th;
+}
+
+
+/// Position::detach() copies the content of the current state and castling
+/// masks inside the position itself. This is needed when the st pointee could
+/// become stale, as example because the caller is about to going out of scope.
+
+void Position::detach() {
+
+  startState = *st;
+  st = &startState;
+  st->previous = NULL; // as a safe guard
 }
 
 
@@ -204,11 +225,16 @@ void Position::from_fen(const string& fen) {
   while (fen[i] == ' ')
       i++;
 
-  // En passant square
+  // En passant square -- ignore if no capture is possible
   if (    i <= fen.length() - 2
       && (fen[i] >= 'a' && fen[i] <= 'h')
       && (fen[i+1] == '3' || fen[i+1] == '6'))
+  {
+      Square fenEpSquare = square_from_string(fen.substr(i, 2));
+      Color them = opposite_color(sideToMove);
+      if (attacks_from<PAWN>(fenEpSquare, them) & this->pieces(PAWN, sideToMove))
           st->epSquare = square_from_string(fen.substr(i, 2));
+  }
 
   // Various initialisation
   for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
@@ -265,11 +291,25 @@ const string Position::to_fen() const {
   }
   fen += (sideToMove == WHITE ? "w " : "b ");
   if (st->castleRights != NO_CASTLES)
+  {
+     if (initialKFile == FILE_E && initialQRFile == FILE_A && initialKRFile == FILE_H)
      {
         if (can_castle_kingside(WHITE))  fen += 'K';
         if (can_castle_queenside(WHITE)) fen += 'Q';
         if (can_castle_kingside(BLACK))  fen += 'k';
         if (can_castle_queenside(BLACK)) fen += 'q';
+     }
+     else
+     {
+        if (can_castle_kingside(WHITE))
+           fen += char(toupper(file_to_char(initialKRFile)));
+        if (can_castle_queenside(WHITE))
+           fen += char(toupper(file_to_char(initialQRFile)));
+        if (can_castle_kingside(BLACK))
+           fen += file_to_char(initialKRFile);
+        if (can_castle_queenside(BLACK))
+           fen += file_to_char(initialQRFile);
+     }
   } else
       fen += '-';
 
@@ -300,8 +340,9 @@ void Position::print(Move m) const {
   std::cout << std::endl;
   if (m != MOVE_NONE)
   {
+      Position p(*this, thread());
       string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
-      std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
+      std::cout << "Move is: " << col << move_to_san(p, m) << std::endl;
   }
   for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {
@@ -326,20 +367,11 @@ void Position::print(Move m) const {
 }
 
 
-/// Position::copy() creates a copy of the input position.
-
-void Position::copy(const Position& pos) {
-
-  memcpy(this, &pos, sizeof(Position));
-  saveState(); // detach and copy state info
-}
-
-
 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
 /// king) pieces for the given color and for the given pinner type. Or, when
 /// template parameter FindPinned is false, the pieces of the given color
 /// candidate for a discovery check against the enemy king.
-/// Note that checkersBB bitboard must be already updated.
+/// Bitboard checkersBB must be already updated when looking for pinners.
 
 template<bool FindPinned>
 Bitboard Position::hidden_checkers(Color c) const {
@@ -373,7 +405,8 @@ Bitboard Position::hidden_checkers(Color c) const {
 
 
 /// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the given color.
+/// king) pieces for the given color. Note that checkersBB bitboard must
+/// be already updated.
 
 Bitboard Position::pinned_pieces(Color c) const {
 
@@ -383,7 +416,8 @@ Bitboard Position::pinned_pieces(Color c) const {
 
 /// Position:discovered_check_candidates() returns a bitboard containing all
 /// pieces for the given side which are candidates for giving a discovered
-/// check.
+/// check. Contrary to pinned_pieces() here there is no need of checkersBB
+/// to be already updated.
 
 Bitboard Position::discovered_check_candidates(Color c) const {
 
@@ -609,8 +643,8 @@ bool Position::move_is_check(Move m, const CheckInfo& ci) const {
 
   // En passant capture with check ? We have already handled the case
   // of direct checks and ordinary discovered check, the only case we
-  // need to handle is the unusual case of a discovered check through the
+  // need to handle is the unusual case of a discovered check through
-  // captured pawn.
+  // the captured pawn.
   if (move_is_ep(m))
   {
       Square capsq = make_square(square_file(to), square_rank(from));
@@ -662,16 +696,16 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   assert(is_ok());
   assert(move_is_ok(m));
 
-  Bitboard key = st->key;
+  Key key = st->key;
 
   // Copy some fields of old state to our new StateInfo object except the
   // ones which are recalculated from scratch anyway, then switch our state
   // pointer to point to the new, ready to be updated, state.
   struct ReducedStateInfo {
     Key pawnKey, materialKey;
-    int castleRights, rule50, pliesFromNull;
+    int castleRights, rule50, gamePly, pliesFromNull;
     Square epSquare;
-    Value value;
+    Score value;
     Value npMaterial[2];
   };
 
@@ -681,8 +715,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
 
   // Save the current key to the history[] array, in order to be able to
   // detect repetition draws.
-  history[gamePly] = key;
+  history[st->gamePly++] = key;
-  gamePly++;
 
   // Update side to move
   key ^= zobSideToMove;
@@ -739,7 +772,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   }
 
   // Prefetch TT access as soon as we know key is updated
-  TT.prefetch(key);
+  prefetch((char*)TT.first_entry(key));
 
   // Move the piece
   Bitboard move_bb = make_move_bb(from, to);
@@ -774,13 +807,6 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
               key ^= zobEp[st->epSquare];
           }
       }
-  }
-
-  // Update incremental scores
-  st->value += pst_delta(piece, from, to);
-
-  // Set capture piece
-  st->capture = capture;
 
       if (pm) // promotion ?
       {
@@ -793,13 +819,13 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
           set_bit(&(byTypeBB[promotion]), to);
           board[to] = piece_of_color_and_type(us, promotion);
 
-      // Update material key
-      st->materialKey ^= zobMaterial[us][PAWN][pieceCount[us][PAWN]];
-      st->materialKey ^= zobMaterial[us][promotion][pieceCount[us][promotion]+1];
-
           // Update piece counts
-      pieceCount[us][PAWN]--;
           pieceCount[us][promotion]++;
+          pieceCount[us][PAWN]--;
+
+          // Update material key
+          st->materialKey ^= zobrist[us][PAWN][pieceCount[us][PAWN]];
+          st->materialKey ^= zobrist[us][promotion][pieceCount[us][promotion]-1];
 
           // Update piece lists, move the last pawn at index[to] position
           // and shrink the list. Add a new promotion piece to the list.
@@ -821,6 +847,13 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
           // Update material
           st->npMaterial[us] += piece_value_midgame(promotion);
       }
+  }
+
+  // Update incremental scores
+  st->value += pst_delta(piece, from, to);
+
+  // Set capture piece
+  st->capture = capture;
 
   // Update the key with the final value
   st->key = key;
@@ -861,12 +894,16 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
 /// Position::do_capture_move() is a private method used to update captured
 /// piece info. It is called from the main Position::do_move function.
 
-void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Square to, bool ep) {
+void Position::do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep) {
 
     assert(capture != KING);
 
     Square capsq = to;
 
+    // If the captured piece was a pawn, update pawn hash key,
+    // otherwise update non-pawn material.
+    if (capture == PAWN)
+    {
         if (ep) // en passant ?
         {
             capsq = (them == BLACK)? (to - DELTA_N) : (to - DELTA_S);
@@ -878,6 +915,10 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
 
             board[capsq] = EMPTY;
         }
+        st->pawnKey ^= zobrist[them][PAWN][capsq];
+    }
+    else
+        st->npMaterial[them] -= piece_value_midgame(capture);
 
     // Remove captured piece
     clear_bit(&(byColorBB[them]), capsq);
@@ -890,19 +931,12 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
     // Update incremental scores
     st->value -= pst(them, capture, capsq);
 
-    // If the captured piece was a pawn, update pawn hash key,
-    // otherwise update non-pawn material.
-    if (capture == PAWN)
-        st->pawnKey ^= zobrist[them][PAWN][capsq];
-    else
-        st->npMaterial[them] -= piece_value_midgame(capture);
-
-    // Update material hash key
-    st->materialKey ^= zobMaterial[them][capture][pieceCount[them][capture]];
-
     // Update piece count
     pieceCount[them][capture]--;
 
+    // Update material hash key
+    st->materialKey ^= zobrist[them][capture][pieceCount[them][capture]];
+
     // Update piece list, move the last piece at index[capsq] position
     //
     // WARNING: This is a not perfectly revresible operation. When we
@@ -1026,7 +1060,6 @@ void Position::undo_move(Move m) {
   assert(is_ok());
   assert(move_is_ok(m));
 
-  gamePly--;
   sideToMove = opposite_color(sideToMove);
 
   if (move_is_castle(m))
@@ -1076,7 +1109,6 @@ void Position::undo_move(Move m) {
       pieceList[us][PAWN][index[to]] = to;
   }
 
-
   // Put the piece back at the source square
   Bitboard move_bb = make_move_bb(to, from);
   do_move_bb(&(byColorBB[us]), move_bb);
@@ -1211,21 +1243,20 @@ void Position::do_null_move(StateInfo& backupSt) {
 
   // Save the current key to the history[] array, in order to be able to
   // detect repetition draws.
-  history[gamePly] = st->key;
+  history[st->gamePly++] = st->key;
 
   // Update the necessary information
   if (st->epSquare != SQ_NONE)
       st->key ^= zobEp[st->epSquare];
 
   st->key ^= zobSideToMove;
-  TT.prefetch(st->key);
+  prefetch((char*)TT.first_entry(st->key));
 
   sideToMove = opposite_color(sideToMove);
   st->epSquare = SQ_NONE;
   st->rule50++;
   st->pliesFromNull = 0;
   st->value += (sideToMove == WHITE) ?  TempoValue : -TempoValue;
-  gamePly++;
 }
 
 
@@ -1247,7 +1278,7 @@ void Position::undo_null_move() {
   // Update the necessary information
   sideToMove = opposite_color(sideToMove);
   st->rule50--;
-  gamePly--;
+  st->gamePly--;
 }
 
 
@@ -1276,10 +1307,10 @@ int Position::see_sign(Move m) const {
   Square from = move_from(m);
   Square to = move_to(m);
 
-  // Early return if SEE cannot be negative because capturing piece value
+  // Early return if SEE cannot be negative because captured piece value
-  // is not bigger then captured one.
+  // is not less then capturing one. Note that king moves always return
-  if (   midgame_value_of_piece_on(from) <= midgame_value_of_piece_on(to)
+  // here because king midgame value is set to 0.
-      && type_of_piece_on(from) != KING)
+  if (midgame_value_of_piece_on(to) >= midgame_value_of_piece_on(from))
       return 1;
 
   return see(from, to);
@@ -1422,19 +1453,6 @@ int Position::see(Square from, Square to) const {
 }
 
 
-/// Position::saveState() copies the content of the current state
-/// inside startState and makes st point to it. This is needed
-/// when the st pointee could become stale, as example because
-/// the caller is about to going out of scope.
-
-void Position::saveState() {
-
-  startState = *st;
-  st = &startState;
-  st->previous = NULL; // as a safe guard
-}
-
-
 /// Position::clear() erases the position object to a pristine state, with an
 /// empty board, white to move, and no castling rights.
 
@@ -1457,7 +1475,6 @@ void Position::clear() {
           pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
 
   sideToMove = WHITE;
-  gamePly = 0;
   initialKFile = FILE_E;
   initialKRFile = FILE_H;
   initialQRFile = FILE_A;
@@ -1472,7 +1489,7 @@ void Position::clear() {
 
 void Position::reset_game_ply() {
 
-  gamePly = 0;
+  st->gamePly = 0;
 }
 
 
@@ -1576,8 +1593,8 @@ Key Position::compute_material_key() const {
       for (PieceType pt = PAWN; pt <= QUEEN; pt++)
       {
           int count = piece_count(c, pt);
-          for (int i = 0; i <= count; i++)
+          for (int i = 0; i < count; i++)
-              result ^= zobMaterial[c][pt][i];
+              result ^= zobrist[c][pt][i];
       }
   return result;
 }
@@ -1636,6 +1653,7 @@ Value Position::compute_non_pawn_material(Color c) const {
 /// Position::is_draw() tests whether the position is drawn by material,
 /// repetition, or the 50 moves rule. It does not detect stalemates, this
 /// must be done by the search.
+// FIXME: Currently we are not handling 50 move rule correctly when in check
 
 bool Position::is_draw() const {
 
@@ -1649,8 +1667,8 @@ bool Position::is_draw() const {
       return true;
 
   // Draw by repetition?
-  for (int i = 2; i < Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
+  for (int i = 4, e = Min(Min(st->gamePly, st->rule50), st->pliesFromNull); i <= e; i += 2)
-      if (history[gamePly - i] == st->key)
+      if (history[st->gamePly - i] == st->key)
           return true;
 
   return false;
@@ -1729,15 +1747,6 @@ void Position::init_zobrist() {
       zobCastle[i] = genrand_int64();
 
   zobSideToMove = genrand_int64();
-
-  for (int i = 0; i < 2; i++)
-      for (int j = 0; j < 8; j++)
-          for (int k = 0; k < 16; k++)
-              zobMaterial[i][j][k] = (k > 0)? Key(genrand_int64()) : Key(0LL);
-
-  for (int i = 0; i < 16; i++)
-      zobMaterial[0][KING][i] = zobMaterial[1][KING][i] = Key(0ULL);
-
   zobExclusion = genrand_int64();
 }
 
@@ -1774,6 +1783,7 @@ void Position::flipped_copy(const Position& pos) {
   assert(pos.is_ok());
 
   clear();
+  threadID = pos.thread();
 
   // Board
   for (Square s = SQ_A1; s <= SQ_H8; s++)
@@ -1843,6 +1853,7 @@ bool Position::is_ok(int* failedStep) const {
   static const bool debugNonPawnMaterial = false;
   static const bool debugPieceCounts = false;
   static const bool debugPieceList = false;
+  static const bool debugCastleSquares = false;
 
   if (failedStep) *failedStep = 1;
 
@@ -1979,6 +1990,25 @@ bool Position::is_ok(int* failedStep) const {
                       return false;
               }
   }
+
+  if (failedStep) (*failedStep)++;
+  if (debugCastleSquares) {
+      for (Color c = WHITE; c <= BLACK; c++) {
+          if (can_castle_kingside(c) && piece_on(initial_kr_square(c)) != piece_of_color_and_type(c, ROOK))
+              return false;
+          if (can_castle_queenside(c) && piece_on(initial_qr_square(c)) != piece_of_color_and_type(c, ROOK))
+              return false;
+      }
+      if (castleRightsMask[initial_kr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OO))
+          return false;
+      if (castleRightsMask[initial_qr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OOO))
+          return false;
+      if (castleRightsMask[initial_kr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OO))
+          return false;
+      if (castleRightsMask[initial_qr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OOO))
+          return false;
+  }
+
   if (failedStep) *failedStep = 0;
   return true;
 }

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -68,11 +68,11 @@ const int MaxGameLength = 220;
 
 struct CheckInfo {
 
-    CheckInfo(const Position&);
+    explicit CheckInfo(const Position&);
 
-    Square ksq;
     Bitboard dcCandidates;
     Bitboard checkSq[8];
+    Square ksq;
 };
 
 /// Castle rights, encoded as bit fields
@@ -100,13 +100,13 @@ enum Phase {
 
 struct StateInfo {
   Key pawnKey, materialKey;
-  int castleRights, rule50, pliesFromNull;
+  int castleRights, rule50, gamePly, pliesFromNull;
   Square epSquare;
   Score value;
   Value npMaterial[2];
 
-  Key key;
   PieceType capture;
+  Key key;
   Bitboard checkersBB;
   StateInfo* previous;
 };
@@ -139,6 +139,9 @@ class Position {
   friend class MaterialInfo;
   friend class EndgameFunctions;
 
+  Position(); // No default or copy c'tor allowed
+  Position(const Position& pos);
+
 public:
   enum GamePhase {
       MidGame,
@@ -146,9 +149,9 @@ public:
   };
 
   // Constructors
-  Position() {}
+  explicit Position(int threadID);
-  Position(const Position& pos);
+  Position(const Position& pos, int threadID);
-  Position(const std::string& fen);
+  Position(const std::string& fen, int threadID);
 
   // Text input/output
   void from_fen(const std::string& fen);
@@ -156,7 +159,6 @@ public:
   void print(Move m = MOVE_NONE) const;
 
   // Copying
-  void copy(const Position& pos);
   void flipped_copy(const Position& pos);
 
   // The piece on a given square
@@ -224,17 +226,17 @@ public:
   bool move_is_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) const;
 
+  // Piece captured with previous moves
+  PieceType captured_piece() const;
+
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
-  static bool pawn_is_passed(Bitboard theirPawns, Color c, Square s);
-  static bool pawn_is_isolated(Bitboard ourPawns, Square s);
-  static bool pawn_is_doubled(Bitboard ourPawns, Color c, Square s);
 
   // Weak squares
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void saveState();
+  void detach();
   void do_move(Move m, StateInfo& st);
   void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
   void undo_move(Move m);
@@ -272,6 +274,9 @@ public:
   bool opposite_colored_bishops() const;
   bool has_pawn_on_7th(Color c) const;
 
+  // Current thread ID searching on the position
+  int thread() const;
+
   // Reset the gamePly variable to 0
   void reset_game_ply();
 
@@ -291,7 +296,7 @@ private:
   void allow_ooo(Color c);
 
   // Helper functions for doing and undoing moves
-  void do_capture_move(Bitboard& key, PieceType capture, Color them, Square to, bool ep);
+  void do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep);
   void do_castle_move(Move m);
   void undo_castle_move(Move m);
   void find_checkers();
@@ -324,18 +329,17 @@ private:
 
   // Other info
   Color sideToMove;
-  int gamePly;
   Key history[MaxGameLength];
-  File initialKFile, initialKRFile, initialQRFile;
+  int castleRightsMask[64];
   StateInfo startState;
+  File initialKFile, initialKRFile, initialQRFile;
+  int threadID;
   StateInfo* st;
 
   // Static variables
-  static int castleRightsMask[64];
   static Key zobrist[2][8][64];
   static Key zobEp[64];
   static Key zobCastle[16];
-  static Key zobMaterial[2][8][16];
   static Key zobSideToMove;
   static Score PieceSquareTable[16][64];
   static Key zobExclusion;
@@ -410,8 +414,8 @@ inline int Position::piece_count(Color c, PieceType pt) const {
   return pieceCount[c][pt];
 }
 
-inline Square Position::piece_list(Color c, PieceType pt, int index) const {
+inline Square Position::piece_list(Color c, PieceType pt, int idx) const {
-  return pieceList[c][pt][index];
+  return pieceList[c][pt][idx];
 }
 
 inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
@@ -483,20 +487,8 @@ inline bool Position::pawn_is_passed(Color c, Square s) const {
   return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
 }
 
-inline bool Position::pawn_is_passed(Bitboard theirPawns, Color c, Square s) {
-  return !(theirPawns & passed_pawn_mask(c, s));
-}
-
-inline bool Position::pawn_is_isolated(Bitboard ourPawns, Square s) {
-  return !(ourPawns & neighboring_files_bb(s));
-}
-
-inline bool Position::pawn_is_doubled(Bitboard ourPawns, Color c, Square s) {
-  return ourPawns & squares_behind(c, s);
-}
-
 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(pieces(PAWN, c) & outpost_mask(opposite_color(c), s));
+  return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
 }
 
 inline Key Position::get_key() const {
@@ -567,4 +559,12 @@ inline bool Position::move_is_capture_or_promotion(Move m) const {
   return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
 }
 
+inline PieceType Position::captured_piece() const {
+  return st->capture;
+}
+
+inline int Position::thread() const {
+  return threadID;
+}
+
 #endif // !defined(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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/san.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -47,7 +47,7 @@ namespace {
     AMBIGUITY_BOTH
   };
 
-  const History H; // used as dummy argument for MovePicker c'tor
+  const History H; // Used as dummy argument for MovePicker c'tor
 
   Ambiguity move_ambiguity(const Position& pos, Move m);
   const string time_string(int milliseconds);
@@ -63,19 +63,15 @@ namespace {
 /// that the move is a legal move from the position. The return value is
 /// a string containing the move in short algebraic notation.
 
-const string move_to_san(const Position& pos, Move m) {
+const string move_to_san(Position& pos, Move m) {
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
 
-  Square from, to;
+  string san;
-  PieceType pt;
+  Square from = move_from(m);
-
+  Square to = move_to(m);
-  from = move_from(m);
+  PieceType pt = type_of_piece(pos.piece_on(move_from(m)));
-  to = move_to(m);
-  pt = type_of_piece(pos.piece_on(move_from(m)));
-
-  string san = "";
 
   if (m == MOVE_NONE)
       return "(none)";
@@ -90,6 +86,7 @@ const string move_to_san(const Position& pos, Move m) {
       if (pt != PAWN)
       {
           san += piece_type_to_char(pt, true);
+
           switch (move_ambiguity(pos, m)) {
           case AMBIGUITY_NONE:
             break;
@@ -115,18 +112,18 @@ const string move_to_san(const Position& pos, Move m) {
       san += square_to_string(move_to(m));
       if (move_is_promotion(m))
       {
-          san += '=';
+          san += "=";
           san += piece_type_to_char(move_promotion_piece(m), true);
       }
   }
-  // Is the move check?  We don't use pos.move_is_check(m) here, because
+
-  // Position::move_is_check doesn't detect all checks (not castling moves,
+  // The move gives check ? We don't use pos.move_is_check() here
-  // promotions and en passant captures).
+  // because we need to test for mate after the move is done.
   StateInfo st;
-  Position p(pos);
+  pos.do_move(m, st);
-  p.do_move(m, st);
+  if (pos.is_check())
-  if (p.is_check())
+      san += pos.is_mate() ? "#" : "+";
-      san += p.is_mate()? "#" : "+";
+  pos.undo_move(m);
 
   return san;
 }
@@ -299,23 +296,23 @@ const string line_to_san(const Position& pos, Move line[], int startColumn, bool
   string moveStr;
   size_t length = 0;
   size_t maxLength = 80 - startColumn;
-  Position p(pos);
+  Position p(pos, pos.thread());
 
-  for (int i = 0; line[i] != MOVE_NONE; i++)
+  for (Move* m = line; *m != MOVE_NONE; m++)
   {
-      moveStr = move_to_san(p, line[i]);
+      moveStr = move_to_san(p, *m);
       length += moveStr.length() + 1;
       if (breakLines && length > maxLength)
       {
-          s << '\n' << std::setw(startColumn) << ' ';
+          s << "\n" << std::setw(startColumn) << " ";
           length = moveStr.length() + 1;
       }
       s << moveStr << ' ';
 
-      if (line[i] == MOVE_NULL)
+      if (*m == MOVE_NULL)
           p.do_null_move(st);
       else
-          p.do_move(line[i], st);
+          p.do_move(*m, st);
   }
   return s.str();
 }
@@ -325,27 +322,31 @@ const string line_to_san(const Position& pos, Move line[], int startColumn, bool
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").
 
-const string pretty_pv(const Position& pos, int time, int depth,
+const string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes,
-                       uint64_t nodes, Value score, ValueType type, Move pv[]) {
+                       Value score, ValueType type, Move pv[]) {
+
+  const uint64_t K = 1000;
+  const uint64_t M = 1000000;
+
   std::stringstream s;
 
   // Depth
   s << std::setw(2) << depth << "  ";
 
   // Score
-  s << ((type == VALUE_TYPE_LOWER)? ">" : ((type == VALUE_TYPE_UPPER)? "<" : " "));
+  s << (type == VALUE_TYPE_LOWER ? ">" : type == VALUE_TYPE_UPPER ? "<" : " ")
-  s << std::setw(7) << score_string(score);
+    << std::setw(7) << score_string(score);
 
   // Time
   s << std::setw(8) << time_string(time) << " ";
 
   // Nodes
-  if (nodes < 1000000ULL)
+  if (nodes < M)
-    s << std::setw(8) << nodes << " ";
+      s << std::setw(8) << nodes / 1 << " ";
-  else if (nodes < 1000000000ULL)
+  else if (nodes < K * M)
-    s << std::setw(7) << nodes/1000ULL << 'k' << " ";
+      s << std::setw(7) << nodes / K << "K ";
   else
-    s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
+      s << std::setw(7) << nodes / M << "M ";
 
   // PV
   s << line_to_san(pos, pv, 30, true);
@@ -398,14 +399,17 @@ namespace {
   }
 
 
-  const string time_string(int milliseconds) {
+  const string time_string(int millisecs) {
+
+    const int MSecMinute = 1000 * 60;
+    const int MSecHour   = 1000 * 60 * 60;
 
     std::stringstream s;
     s << std::setfill('0');
 
-    int hours = milliseconds / (1000*60*60);
+    int hours = millisecs / MSecHour;
-    int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
+    int minutes = (millisecs - hours * MSecHour) / MSecMinute;
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
+    int seconds = (millisecs - hours * MSecHour - minutes * MSecMinute) / 1000;
 
     if (hours)
         s << hours << ':';

src/san.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -36,7 +36,7 @@
 //// Prototypes
 ////
 
-extern const std::string move_to_san(const Position& pos, Move m);
+extern const std::string move_to_san(Position& pos, Move m);
 extern Move move_from_san(const Position& pos, const std::string& str);
 extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
 extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, ValueType type, Move pv[]);

src/scale.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,6 +27,7 @@
 
 #include "depth.h"
 #include "move.h"
+#include "value.h"
 
 
 ////
@@ -46,16 +47,20 @@ const int KILLER_MAX = 2;
 /// from nodes shallower and deeper in the tree during the search.  Each
 /// search thread has its own array of SearchStack objects, indexed by the
 /// current ply.
+struct EvalInfo;
 
 struct SearchStack {
-  Move pv[PLY_MAX_PLUS_2];
   Move currentMove;
   Move mateKiller;
   Move threatMove;
+  Move excludedMove;
+  Move bestMove;
   Move killers[KILLER_MAX];
   Depth reduction;
+  Value eval;
+  bool skipNullMove;
 
-  void init(int ply);
+  void init();
   void initKillers();
 };
 
@@ -64,8 +69,9 @@ struct SearchStack {
 //// Prototypes
 ////
 
+extern void init_search();
 extern void init_threads();
-extern void stop_threads();
+extern void exit_threads();
 extern bool think(const Position &pos, bool infinite, bool ponder, int side_to_move,
                   int time[], int increment[], int movesToGo, int maxDepth,
                   int maxNodes, int maxTime, Move searchMoves[]);

src/square.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -26,6 +26,8 @@
 //// Includes
 ////
 
+#include <cstring>
+
 #include "lock.h"
 #include "movepick.h"
 #include "position.h"
@@ -36,7 +38,8 @@
 //// Constants and variables
 ////
 
-const int THREAD_MAX = 8;
+const int MAX_THREADS = 8;
+const int ACTIVE_SPLIT_POINTS_MAX = 8;
 
 
 ////
@@ -44,35 +47,47 @@ const int THREAD_MAX = 8;
 ////
 
 struct SplitPoint {
+
+  // Const data after splitPoint has been setup
   SplitPoint* parent;
-  Position pos;
+  const Position* pos;
-  SearchStack sstack[THREAD_MAX][PLY_MAX_PLUS_2];
-  SearchStack *parentSstack;
-  int ply;
   Depth depth;
-  volatile Value alpha, beta, bestValue, futilityValue;
+  bool pvNode, mateThreat;
-  Value approximateEval;
+  Value beta;
-  bool pvNode;
+  int ply;
-  int master, slaves[THREAD_MAX];
+  SearchStack sstack[MAX_THREADS][PLY_MAX_PLUS_2];
-  Lock lock;
+
+  // Const pointers to shared data
   MovePicker* mp;
-  volatile int moves;
+  SearchStack* parentSstack;
-  volatile int cpus;
+
-  bool finished;
+  // Shared data
+  Lock lock;
+  volatile Value alpha;
+  volatile Value bestValue;
+  volatile int moveCount;
+  volatile bool stopRequest;
+  volatile int slaves[MAX_THREADS];
 };
 
+// ThreadState type is used to represent thread's current state
+
+enum ThreadState
+{
+  THREAD_SEARCHING,     // thread is performing work
+  THREAD_AVAILABLE,     // thread is polling for work
+  THREAD_SLEEPING,      // we are not thinking, so thread is sleeping
+  THREAD_BOOKED,        // other thread (master) has booked us as a slave
+  THREAD_WORKISWAITING, // master has ordered us to start
+  THREAD_TERMINATED     // we are quitting and thread is terminated
+};
 
 struct Thread {
-  SplitPoint *splitPoint;
+  SplitPoint* volatile splitPoint;
-  int activeSplitPoints;
+  volatile int activeSplitPoints;
   uint64_t nodes;
   uint64_t betaCutOffs[2];
-  bool failHighPly1;
+  volatile ThreadState state;
-  volatile bool stop;
-  volatile bool running;
-  volatile bool idle;
-  volatile bool workIsWaiting;
-  volatile bool printCurrentLine;
   unsigned char pad[64]; // set some distance among local data for each thread
 };
 

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -25,7 +25,6 @@
 #include <cassert>
 #include <cmath>
 #include <cstring>
-#include <xmmintrin.h>
 
 #include "movegen.h"
 #include "tt.h"
@@ -39,7 +38,7 @@ TranspositionTable TT;
 
 TranspositionTable::TranspositionTable() {
 
-  size = writes = 0;
+  size = overwrites = 0;
   entries = 0;
   generation = 0;
 }
@@ -53,11 +52,9 @@ TranspositionTable::~TranspositionTable() {
 /// TranspositionTable::set_size sets the size of the transposition table,
 /// measured in megabytes.
 
-void TranspositionTable::set_size(unsigned mbSize) {
+void TranspositionTable::set_size(size_t mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 4096);
+  size_t newSize = 1024;
-
-  unsigned newSize = 1024;
 
   // We store a cluster of ClusterSize number of TTEntry for each position
   // and newSize is the maximum number of storable positions.
@@ -91,16 +88,6 @@ void TranspositionTable::clear() {
 }
 
 
-/// TranspositionTable::first_entry returns a pointer to the first
-/// entry of a cluster given a position. The low 32 bits of the key
-/// are used to get the index in the table.
-
-inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
-
-  return entries[uint32_t(posKey) & (size - 1)].data;
-}
-
-
 /// TranspositionTable::store writes a new entry containing a position,
 /// a value, a value type, a search depth, and a best move to the
 /// transposition table. Transposition table is organized in clusters of
@@ -111,8 +98,9 @@ inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
 /// is bigger than the depth of t2. A TTEntry of type VALUE_TYPE_EVAL
 /// never replaces another entry for the same position.
 
-void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m) {
+void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
 
+  int c1, c2, c3;
   TTEntry *tte, *replace;
   uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key
 
@@ -121,28 +109,26 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
   {
       if (!tte->key() || tte->key() == posKey32) // empty or overwrite old
       {
-          // Do not overwrite when new type is VALUE_TYPE_EV_LO
+          // Preserve any exsisting ttMove
-          if (tte->key() && t == VALUE_TYPE_EV_LO)
-              return;
-
           if (m == MOVE_NONE)
               m = tte->move();
 
-          *tte = TTEntry(posKey32, v, t, d, m, generation);
+          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
           return;
       }
-      else if (i == 0)  // replace would be a no-op in this common case
+
+      if (i == 0)  // replace would be a no-op in this common case
           continue;
 
-      int c1 = (replace->generation() == generation ?  2 : 0);
+      c1 = (replace->generation() == generation ?  2 : 0);
-      int c2 = (tte->generation() == generation ? -2 : 0);
+      c2 = (tte->generation() == generation ? -2 : 0);
-      int c3 = (tte->depth() < replace->depth() ?  1 : 0);
+      c3 = (tte->depth() < replace->depth() ?  1 : 0);
 
       if (c1 + c2 + c3 > 0)
           replace = tte;
   }
-  *replace = TTEntry(posKey32, v, t, d, m, generation);
+  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
-  writes++;
+  overwrites++;
 }
 
 
@@ -163,27 +149,6 @@ TTEntry* TranspositionTable::retrieve(const Key posKey) const {
 }
 
 
-/// TranspositionTable::prefetch looks up the current position in the
-/// transposition table and load it in L1/L2 cache. This is a non
-/// blocking function and do not stalls the CPU waiting for data
-/// to be loaded from RAM, that can be very slow. When we will
-/// subsequently call retrieve() the TT data will be already
-/// quickly accessible in L1/L2 CPU cache.
-
-void TranspositionTable::prefetch(const Key posKey) const {
-
-#if defined(__INTEL_COMPILER) || defined(__ICL)
-   // This hack prevents prefetches to be optimized away by the
-   // Intel compiler. Both MSVC and gcc seems not affected.
-   __asm__ ("");
-#endif
-
-   char const* addr = (char*)first_entry(posKey);
-  _mm_prefetch(addr, _MM_HINT_T2);
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
-}
-
-
 /// 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
@@ -192,7 +157,7 @@ void TranspositionTable::prefetch(const Key posKey) const {
 void TranspositionTable::new_search() {
 
   generation++;
-  writes = 0;
+  overwrites = 0;
 }
 
 
@@ -204,13 +169,13 @@ void TranspositionTable::new_search() {
 void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 
   StateInfo st;
-  Position p(pos);
+  Position p(pos, pos.thread());
 
   for (int i = 0; pv[i] != MOVE_NONE; i++)
   {
       TTEntry *tte = retrieve(p.get_key());
       if (!tte || tte->move() != pv[i])
-          store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]);
+          store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i], VALUE_NONE, VALUE_NONE);
       p.do_move(pv[i], st);
   }
 }
@@ -222,20 +187,23 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 /// will often get single-move PVs when the search stops while failing high,
 /// and a single-move PV means that we don't have a ponder move.
 
-void TranspositionTable::extract_pv(const Position& pos, Move pv[], const int PLY_MAX) {
+void TranspositionTable::extract_pv(const Position& pos, Move bestMove, Move pv[], const int PLY_MAX) {
 
   const TTEntry* tte;
   StateInfo st;
-  Position p(pos);
+  Position p(pos, pos.thread());
   int ply = 0;
 
-  // Update position to the end of current PV
+  assert(bestMove != MOVE_NONE);
-  while (pv[ply] != MOVE_NONE)
+
+  pv[ply] = bestMove;
   p.do_move(pv[ply++], st);
 
-  // Try to add moves from TT while possible
+  // Extract moves from TT when possible. We try hard to always
+  // get a ponder move, that's the reason of ply < 2 conditions.
   while (   (tte = retrieve(p.get_key())) != NULL
          && tte->move() != MOVE_NONE
+         && (tte->type() == VALUE_TYPE_EXACT || ply < 2)
          && move_is_legal(p, tte->move())
          && (!p.is_draw() || ply < 2)
          && ply < PLY_MAX)
@@ -248,11 +216,11 @@ void TranspositionTable::extract_pv(const Position& pos, Move pv[], const int PL
 
 
 /// TranspositionTable::full() returns the permill of all transposition table
-/// entries which have received at least one write during the current search.
+/// entries which have received at least one overwrite during the current search.
 /// It is used to display the "info hashfull ..." information in UCI.
 
 int TranspositionTable::full() const {
 
   double N = double(size) * ClusterSize;
-  return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
+  return int(1000 * (1 - exp(overwrites * log(1.0 - 1.0/N))));
 }

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -53,36 +53,45 @@
 class TTEntry {
 
 public:
-  TTEntry() {}
+  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value kd) {
-  TTEntry(uint32_t k, Value v, ValueType t, Depth d, Move m, int generation)
-        : key_ (k), data((m & 0x1FFFF) | (t << 20) | (generation << 23)),
-          value_(int16_t(v)), depth_(int16_t(d)) {}
 
-  uint32_t key() const { return key_; }
+      key32 = k;
-  Depth depth() const { return Depth(depth_); }
+      data = (m & 0x1FFFF) | (t << 20) | (g << 23);
+      value16     = int16_t(v);
+      depth16     = int16_t(d);
+      staticValue = int16_t(statV);
+      kingDanger  = int16_t(kd);
+  }
+
+  uint32_t key() const { return key32; }
+  Depth depth() const { return Depth(depth16); }
   Move move() const { return Move(data & 0x1FFFF); }
-  Value value() const { return Value(value_); }
+  Value value() const { return Value(value16); }
   ValueType type() const { return ValueType((data >> 20) & 7); }
-  int generation() const { return (data >> 23); }
+  int generation() const { return data >> 23; }
+  Value static_value() const { return Value(staticValue); }
+  Value king_danger() const { return Value(kingDanger); }
 
 private:
-  uint32_t key_;
+  uint32_t key32;
   uint32_t data;
-  int16_t value_;
+  int16_t value16;
-  int16_t depth_;
+  int16_t depth16;
+  int16_t staticValue;
+  int16_t kingDanger;
 };
 
 
 /// This is the number of TTEntry slots for each position
-const int ClusterSize = 5;
+const int ClusterSize = 4;
 
 /// Each group of ClusterSize number of TTEntry form a TTCluster
-/// that is indexed by a single position key. Cluster is padded
+/// that is indexed by a single position key. TTCluster size must
-/// to a cache line size so to guarantee always aligned accesses.
+///  be not bigger then a cache line size, in case it is less then
+/// it should be padded to guarantee always aligned accesses.
 
 struct TTCluster {
   TTEntry data[ClusterSize];
-  char cache_line_padding[64 - sizeof(TTEntry[ClusterSize])];
 };
 
 
@@ -95,30 +104,38 @@ class TranspositionTable {
 public:
   TranspositionTable();
   ~TranspositionTable();
-  void set_size(unsigned mbSize);
+  void set_size(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m);
+  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
   TTEntry* retrieve(const Key posKey) const;
-  void prefetch(const Key posKey) const;
   void new_search();
   void insert_pv(const Position& pos, Move pv[]);
-  void extract_pv(const Position& pos, Move pv[], const int PLY_MAX);
+  void extract_pv(const Position& pos, Move bestMove, Move pv[], const int PLY_MAX);
   int full() const;
+  TTEntry* first_entry(const Key posKey) const;
 
 private:
-  inline TTEntry* first_entry(const Key posKey) const;
+  // Be sure 'overwrites' is at least one cache line away
-
-  // Be sure 'writes' is at least one cache line away
   // from read only variables.
   unsigned char pad_before[64 - sizeof(unsigned)];
-  unsigned writes; // heavy SMP read/write access here
+  unsigned overwrites; // heavy SMP read/write access here
   unsigned char pad_after[64];
 
-  unsigned size;
+  size_t size;
   TTCluster* entries;
   uint8_t generation;
 };
 
 extern TranspositionTable TT;
 
+
+/// TranspositionTable::first_entry returns a pointer to the first
+/// entry of a cluster given a position. The low 32 bits of the key
+/// are used to get the index in the table.
+
+inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
+
+  return entries[uint32_t(posKey) & (size - 1)].data;
+}
+
 #endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -49,20 +49,32 @@ typedef uint64_t Bitboard;
 
 
 ////
-//// Compiler specific defines
+//// Configuration
 ////
 
-// Quiet a warning on Intel compiler
+//// For Linux and OSX configuration is done automatically using Makefile.
-#if !defined(__SIZEOF_INT__ )
+//// To get started type "make help".
-#define __SIZEOF_INT__ 0
+////
-#endif
+//// For windows part of the configuration is detected automatically, but
+//// some switches need to be set manually:
+////
+//// -DNDEBUG       | Disable debugging mode. Use always.
+////
+//// -DNO_PREFETCH  | Disable use of prefetch asm-instruction. A must if you want the
+////                | executable to run on some very old machines.
+////
+//// -DUSE_POPCNT   | Add runtime support for use of popcnt asm-instruction.
+////                | Works only in 64-bit mode. For compiling requires hardware
+////                | with popcnt support. Around 4% speed-up.
 
-// Check for 64 bits for different compilers: Intel, MSVC and gcc
+// Automatic detection for 64-bit under Windows
-#if defined(__x86_64) || defined(_M_X64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
+#if defined(_WIN64)
 #define IS_64BIT
 #endif
 
-#if defined(IS_64BIT) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
+// Automatic detection for use of bsfq asm-instruction under Windows.
+// Works only in 64-bit mode. Does not work with MSVC.
+#if defined(_WIN64) && defined(__INTEL_COMPILER)
 #define USE_BSFQ
 #endif
 
@@ -73,4 +85,28 @@ typedef uint64_t Bitboard;
 #define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
 #endif
 
+// Define a __cpuid() function for gcc compilers, for Intel and MSVC
+// is already available as an intrinsic.
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+inline void __cpuid(int CPUInfo[4], int InfoType)
+{
+  int* eax = CPUInfo + 0;
+  int* ebx = CPUInfo + 1;
+  int* ecx = CPUInfo + 2;
+  int* edx = CPUInfo + 3;
+
+  *eax = InfoType;
+  *ecx = 0;
+  __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+                  : "0" (*eax), "2" (*ecx));
+}
+#else
+inline void __cpuid(int CPUInfo[4], int)
+{
+   CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0;
+}
+#endif
+
 #endif // !defined(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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -54,7 +54,7 @@ namespace {
   // The root position. This is set up when the user (or in practice, the GUI)
   // sends the "position" UCI command. The root position is sent to the think()
   // function when the program receives the "go" command.
-  Position RootPosition;
+  Position RootPosition(0);
 
   // Local functions
   bool handle_command(const string& command);
@@ -107,7 +107,8 @@ namespace {
     UCIInputParser uip(command);
     string token;
 
-    uip >> token; // operator>>() skips any whitespace
+    if (!(uip >> token)) // operator>>() skips any whitespace
+        return true;
 
     if (token == "quit")
         return false;
@@ -142,7 +143,7 @@ namespace {
         RootPosition.print();
     else if (token == "flip")
     {
-        Position p(RootPosition);
+        Position p(RootPosition, RootPosition.thread());
         RootPosition.flipped_copy(p);
     }
     else if (token == "eval")
@@ -150,7 +151,7 @@ namespace {
         EvalInfo ei;
         cout << "Incremental mg: " << mg_value(RootPosition.value())
              << "\nIncremental eg: " << eg_value(RootPosition.value())
-             << "\nFull eval: " << evaluate(RootPosition, ei, 0) << endl;
+             << "\nFull eval: " << evaluate(RootPosition, ei) << endl;
     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()
@@ -159,14 +160,8 @@ namespace {
     else if (token == "perft")
         perft(uip);
     else
-    {
         cout << "Unknown command: " << command << endl;
-        while (!uip.eof())
+
-        {
-            uip >> token;
-            cout << token << endl;
-        }
-    }
     return true;
   }
 
@@ -181,33 +176,33 @@ namespace {
 
     string token;
 
-    uip >> token; // operator>>() skips any whitespace
+    if (!(uip >> token)) // operator>>() skips any whitespace
+        return;
 
     if (token == "startpos")
         RootPosition.from_fen(StartPosition);
     else if (token == "fen")
     {
         string fen;
-        while (token != "moves" && !uip.eof())
+        while (uip >> token && token != "moves")
         {
-            uip >> token;
             fen += token;
             fen += ' ';
         }
         RootPosition.from_fen(fen);
     }
 
-    if (!uip.eof())
+    if (uip.good())
     {
         if (token != "moves")
           uip >> token;
+
         if (token == "moves")
         {
             Move move;
             StateInfo st;
-            while (!uip.eof())
+            while (uip >> token)
             {
-                uip >> token;
                 move = move_from_string(RootPosition, token);
                 RootPosition.do_move(move, st);
                 if (RootPosition.rule_50_counter() == 0)
@@ -215,7 +210,7 @@ namespace {
             }
             // Our StateInfo st is about going out of scope so copy
             // its content inside RootPosition before they disappear.
-            RootPosition.saveState();
+            RootPosition.detach();
         }
     }
   }
@@ -229,27 +224,22 @@ namespace {
 
   void set_option(UCIInputParser& uip) {
 
-    string token, name;
+    string token, name, value;
 
-    uip >> token;
+    if (!(uip >> token)) // operator>>() skips any whitespace
-    if (token == "name")
+        return;
-    {
-        uip >> name;
-        while (!uip.eof())
-        {
-            uip >> token;
-            if (token == "value")
-                break;
 
+    if (token == "name" && uip >> name)
+    {
+        while (uip >> token && token != "value")
             name += (" " + token);
-        }
-        if (token == "value")
-        {
-            // Reads until end of line and left trim white space
-            getline(uip, token);
-            token.erase(0, token.find_first_not_of(" \n\r\t"));
 
-            set_option_value(name, token);
+        if (token == "value" && uip >> value)
+        {
+            while (uip >> token)
+                value += (" " + token);
+
+            set_option_value(name, value);
         } else
             push_button(name);
     }
@@ -276,10 +266,8 @@ namespace {
 
     searchMoves[0] = MOVE_NONE;
 
-    while (!uip.eof())
+    while (uip >> token)
     {
-        uip >> token;
-
         if (token == "infinite")
             infinite = true;
         else if (token == "ponder")
@@ -303,18 +291,13 @@ namespace {
         else if (token == "searchmoves")
         {
             int numOfMoves = 0;
-            while (!uip.eof())
+            while (uip >> token)
-            {
-                uip >> token;
                 searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
-            }
+
             searchMoves[numOfMoves] = MOVE_NONE;
         }
     }
 
-    if (moveTime)
-        infinite = true;  // HACK
-
     assert(RootPosition.is_ok());
 
     return think(RootPosition, infinite, ponder, RootPosition.side_to_move(),
@@ -325,12 +308,11 @@ namespace {
 
     string token;
     int depth, tm, n;
-    Position pos = RootPosition;
+    Position pos(RootPosition, RootPosition.thread());
 
-    if (uip.eof())
+    if (!(uip >> depth))
         return;
 
-    uip >> depth;
     tm = get_system_time();
 
     n = perft(pos, depth * OnePly);

src/uci.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -79,6 +79,7 @@ namespace {
     o["Use Search Log"] = Option(false);
     o["Search Log Filename"] = Option("SearchLog.txt");
     o["Book File"] = Option("book.bin");
+    o["Best Book Move"] = Option(false);
     o["Mobility (Middle Game)"] = Option(100, 0, 200);
     o["Mobility (Endgame)"] = Option(100, 0, 200);
     o["Pawn Structure (Middle Game)"] = Option(100, 0, 200);
@@ -88,48 +89,28 @@ namespace {
     o["Space"] = Option(100, 0, 200);
     o["Aggressiveness"] = Option(100, 0, 200);
     o["Cowardice"] = Option(100, 0, 200);
-    o["King Safety Curve"] = Option("Quadratic", COMBO);
-
-       o["King Safety Curve"].comboValues.push_back("Quadratic");
-       o["King Safety Curve"].comboValues.push_back("Linear");  /*, "From File"*/
-
-    o["King Safety Coefficient"] = Option(40, 1, 100);
-    o["King Safety X Intercept"] = Option(0, 0, 20);
-    o["King Safety Max Slope"] = Option(30, 10, 100);
-    o["King Safety Max Value"] = Option(500, 100, 1000);
-    o["Queen Contact Check Bonus"] = Option(3, 0, 8);
-    o["Queen Check Bonus"] = Option(2, 0, 4);
-    o["Rook Check Bonus"] = Option(1, 0, 4);
-    o["Bishop Check Bonus"] = Option(1, 0, 4);
-    o["Knight Check Bonus"] = Option(1, 0, 4);
-    o["Discovered Check Bonus"] = Option(3, 0, 8);
-    o["Mate Threat Bonus"] = Option(3, 0, 8);
     o["Check Extension (PV nodes)"] = Option(2, 0, 2);
     o["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
-    o["Single Reply Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Single Evasion Extension (PV nodes)"] = Option(2, 0, 2);
-    o["Single Reply Extension (non-PV nodes)"] = Option(2, 0, 2);
+    o["Single Evasion Extension (non-PV nodes)"] = Option(2, 0, 2);
-    o["Mate Threat Extension (PV nodes)"] = Option(0, 0, 2);
+    o["Mate Threat Extension (PV nodes)"] = Option(2, 0, 2);
-    o["Mate Threat Extension (non-PV nodes)"] = Option(0, 0, 2);
+    o["Mate Threat Extension (non-PV nodes)"] = Option(2, 0, 2);
     o["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
     o["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2);
     o["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2);
     o["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2);
     o["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2);
     o["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2);
-    o["Full Depth Moves (PV nodes)"] = Option(10, 1, 100);
-    o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
-    o["Threat Depth"] = Option(5, 0, 100);
     o["Randomness"] = Option(0, 0, 10);
     o["Minimum Split Depth"] = Option(4, 4, 7);
     o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
-    o["Threads"] = Option(1, 1, 8);
+    o["Threads"] = Option(1, 1, MAX_THREADS);
-    o["Hash"] = Option(32, 4, 4096);
+    o["Hash"] = Option(32, 4, 8192);
     o["Clear Hash"] = Option(false, BUTTON);
     o["New Game"] = Option(false, BUTTON);
     o["Ponder"] = Option(true);
     o["OwnBook"] = Option(true);
     o["MultiPV"] = Option(1, 1, 500);
-    o["UCI_ShowCurrLine"] = Option(false);
     o["UCI_Chess960"] = Option(false);
     o["UCI_AnalyseMode"] = Option(false);
 
@@ -196,15 +177,18 @@ void init_uci_options() {
 
   load_defaults(options);
 
-  // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
+  // Set optimal value for parameter "Minimum Split Depth"
-  // According to Ken Dail's tests, Glaurung plays much better with 7 than
+  // according to number of available cores.
-  // with 8 threads.  This is weird, but it is probably difficult to find out
-  // why before I have a 8-core computer to experiment with myself.
   assert(options.find("Threads") != options.end());
   assert(options.find("Minimum Split Depth") != options.end());
 
-  options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
+  Option& thr = options["Threads"];
-  options["Threads"].currentValue = stringify(Min(cpu_count(), 7));
+  Option& msd = options["Minimum Split Depth"];
+
+  thr.defaultValue = thr.currentValue = stringify(cpu_count());
+
+  if (cpu_count() >= 8)
+      msd.defaultValue = msd.currentValue = stringify(7);
 }
 
 
@@ -292,10 +276,28 @@ void set_option_value(const string& name, const string& value) {
   else if (v == "false")
       v = "0";
 
-  if (options.find(name) != options.end())
+  if (options.find(name) == options.end())
-      options[name].currentValue = v;
+  {
-  else
       std::cout << "No such option: " << name << std::endl;
+      return;
+  }
+
+  // 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& opt = options[name];
+
+  if (opt.type == CHECK && v != "0" && v != "1")
+      return;
+
+  else if (opt.type == SPIN)
+  {
+      int val = atoi(v.c_str());
+      if (val < opt.minValue || val > opt.maxValue)
+          return;
+  }
+
+  opt.currentValue = v;
 }
 
 

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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/value.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/value.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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -36,10 +36,7 @@ enum ValueType {
   VALUE_TYPE_NONE  = 0,
   VALUE_TYPE_UPPER = 1,  // Upper bound
   VALUE_TYPE_LOWER = 2,  // Lower bound
-  VALUE_TYPE_EXACT = 3,  // Exact score
+  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
-  VALUE_TYPE_EVAL  = 4,  // Evaluation cache
-  VALUE_TYPE_EV_UP = 5,  // Evaluation cache for upper bound
-  VALUE_TYPE_EV_LO = 6   // Evaluation cache for lower bound
 };
 
 
@@ -48,17 +45,31 @@ enum Value {
   VALUE_KNOWN_WIN = 15000,
   VALUE_MATE = 30000,
   VALUE_INFINITE = 30001,
-  VALUE_NONE = 30002
+  VALUE_NONE = 30002,
+  VALUE_ENSURE_SIGNED = -1
 };
 
 
-/// Score struct keeps a midgame and an endgame value in a single
+/// Score enum keeps a midgame and an endgame value in a single
-/// ScoreValue 64 bit union.
+/// integer (enum), first LSB 16 bits are used to store endgame
+/// value, while upper bits are used for midgame value.
 
-enum Score {};
+// 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 { ENSURE_32_BITS_SIZE_P = (1 << 16), ENSURE_32_BITS_SIZE_N = -(1 << 16)};
 
+// 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(((int(s) + 32768) & ~0xffff) / 0x10000); }
+
+// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in
+// this case, although not 100% standard compliant it seems to work for Intel and MSVC.
+#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
 inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
-inline Value mg_value(Score s) { return Value((int(s) + 32768) >> 16); }
+#else
+inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); }
+#endif
 
 inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }