Stockfish 1.6.2

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

Readme.txt

@@ -14,7 +14,9 @@ number of CPUs on your computer and set the number of search threads
 accordingly, but please be aware that the detection is not always
 correct.  It is therefore recommended to inspect the value of the
 "Threads" UCI parameter, and to make sure it equals the number of CPU
-cores on your computer.
+cores on your computer. If you are using more than four threads, it
+is recommended to raise the value of "Minimum Split Depth" UCI parameter
+to 6.
 
 
 2. Files
@@ -45,36 +47,25 @@ PolyGlot documentation.  The book file can be selected by setting the
 UCI parameter "Book File".
 
 
-
 4. Compiling it yourself
 ------------------------
 
 On Unix-like systems, it should usually be possible to compile
 Stockfish directly from the source code with the included Makefile.
-The exception is computer with big-endian CPUs, like PowerPC
-Macintoshes. Some of the bitboard routines in the current version of
-Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
-Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
-of bitboard.h is commented out should solve this problem.
-Commenting out the line with "#define USE_32BIT_ATTACKS" near the
 
-There is also a problem with compiling Stockfish on certain 64-bit
+For big-endian machines like Power PC you need to enable the proper
-systems, regardless of the endianness.  If Stockfish segfaults
+flag changing from -DNBIGENDIAN to -DBIGENDIAN in the Makefile.
-immediately after startup, try to comment out the line with
-"#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
-recompile.
 
-Finally, even if Stockfish does work without any changes on your
+Stockfish has POPCNT instruction runtime detection and support. This can
-computer, it might be possible to improve the performance by changing
+give an extra speed on Core i7 or similar systems. To enable this feature
-some of the #define directives in bitboard.h.  The default settings
+compile with 'make icc-profile-popcnt'
-are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
+
-to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
+On 64 bit Unix-like systems the 'bsfq' assembly instruction will be used
-BITCOUNT_SWAR_64.  For computers with very little memory (like
+for bit counting. Detection is automatic at compile time, but in case you
-handheld devices), it is possible to conserve memory by defining
+experience compile problems you can comment out #define USE_BSFQ line in types.h
-USE_COMPACT_ROOK_ATTACKS.
 
 
-6. Terms of use
+5. Terms of use
 ---------------
 
 Stockfish is free, and distributed under the GNU General Public License
@@ -93,7 +84,7 @@ For full details, read the copy of the GPL found in the file named
 Copying.txt.
 
 
-7. Feedback
+6. Feedback
 -----------
 
 The author's e-mail address is mcostalba@gmail.com

src/Makefile

@@ -18,133 +18,289 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-###
+### Executable name. Do not change
-### Files
-###
-
 EXE = stockfish
 
-OBJS = bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
+
+### ==========================================================================
+### 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
+
+
+### 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
-### Rules
+default:
-###
+	$(MAKE) gcc
+
+help:
+	@echo ""
+	@echo "Makefile options:"
+	@echo ""
+	@echo "make                >  Default: Compiler = g++"
+	@echo "make icc            >  Compiler = icpc"
+	@echo "make icc-profile    >  Compiler = icpc + automatic pgo-build"
+	@echo "make icc-profile-popcnt >  Compiler = icpc + automatic pgo-build + popcnt-support"
+	@echo "make osx-ppc32      >  PPC-Mac OS X 32 bit. Compiler = g++"
+	@echo "make osx-ppc64      >  PPC-Mac OS X 64 bit. Compiler = g++"
+	@echo "make osx-x86        >  x86-Mac OS X 32 bit. Compiler = g++"
+	@echo "make osx-x86_64     >  x86-Mac OS X 64 bit. Compiler = g++"
+	@echo "make osx-icc32      >  x86-Mac OS X 32 bit. Compiler = icpc"
+	@echo "make osx-icc64      >  x86-Mac OS X 64 bit. Compiler = icpc"
+	@echo "make osx-icc32-profile > OSX 32 bit. Compiler = icpc + automatic pgo-build"
+	@echo "make osx-icc64-profile > OSX 64 bit. Compiler = icpc + automatic pgo-build"
+	@echo "make strip          >  Strip executable"
+	@echo "make clean          >  Clean up"
+	@echo ""
 
 all: $(EXE) .depend
 
 clean:
-	$(RM) *.o .depend stockfish
+	$(RM) *.o .depend *~ $(EXE)
 
 
-###
+### Possible targets. You may add your own ones here
-### Compiler:
+gcc:
-###
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	all
 
-# CXX = g++
+icc:
-# CXX = g++-4.2
+	$(MAKE) \
-CXX = icpc
+	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
+	@echo ""
+	@echo "Running benchmark for pgo-build ..."
+	@$(PGOBENCH) > /dev/null
+	@echo "Benchmark finished. Build final executable now ..."
+	@echo ""
+	@touch *.cpp *.h
+	$(MAKE) icc-profile-use
+	@rm -rf profdir bench.txt
+
+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)..."
+	@$(PGOBENCH) > /dev/null
+	@touch *.cpp *.h
+	$(MAKE) icc-profile-make-with-popcnt
+	@echo ""
+	@echo "Running benchmark for pgo-build (popcnt enabled)..."
+	@$(PGOBENCH) > /dev/null
+	@echo "Benchmarks finished. Build final executable now ..."
+	@echo ""
+	@touch *.cpp *.h
+	$(MAKE) icc-profile-use-with-popcnt
+	@rm -rf profdir bench.txt
 
 
-###
+osx-ppc32:
-### Dependencies
+	$(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 ..."
+	@$(PGOBENCH) > /dev/null
+	@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)
+
+
+### Compilation. Do not change
 $(EXE): $(OBJS)
 	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
 
+
+### Dependencies. Do not change
 .depend:
-	$(CXX) -MM $(OBJS:.o=.cpp) > $@
+	$(CXX) -msse -MM $(OBJS:.o=.cpp) > $@
 
 include .depend
-
-
-###
-### Compiler and linker switches
-###
-
-# Enable/disable debugging:
-
-CXXFLAGS += -DNDEBUG
-
-
-# Compile with full warnings, and symbol names
-
-CXXFLAGS += -Wall -g
-
-
-# General optimization flags.  Note that -O2 might be faster than -O3 on some
-# systems; this requires testing.
-
-CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fno-strict-aliasing
-
-# Disable most annoying warnings for the Intel C++ compiler
-
-CXXFLAGS += -wd383,869,981
-
-
-# Compiler optimization flags for the Intel C++ compiler in Mac OS X:
-
-# CXXFLAGS += -mdynamic-no-pic -no-prec-div -ipo -static -xP
-
-
-# Profiler guided optimization with the Intel C++ compiler.  To use it, first
-# create the directory ./profdata if it does not already exist, and delete its
-# contents if it does exist.  Then compile with -prof_gen, and run the
-# resulting binary for a while (for instance, do ./stockfish bench 128 1, and
-# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and
-# recompile with -prof_use.
-
-# CXXFLAGS += -prof_gen -prof_dir profdata
-# CXXFLAGS += -prof_use -prof_dir ./profdata
-
-
-# Profiler guided optimization with GCC.  I've never been able to make this
-# work.
-
-# CXXFLAGS += -fprofile-generate
-# LDFLAGS += -fprofile-generate
-# CXXFLAGS += -fprofile-use
-# CXXFLAGS += -fprofile-use
-
-
-# General linker flags
-
-LDFLAGS += -lm -lpthread
-
-
-# Compiler switches for generating binaries for various CPUs in Mac OS X.
-# Note that 'arch ppc' and 'arch ppc64' only works with g++, and not with
-# the intel compiler.
-
-# CXXFLAGS += -arch ppc
-# CXXFLAGS += -arch ppc64
-# CXXFLAGS += -arch i386
-# CXXFLAGS += -arch x86_64
-# LDFLAGS += -arch ppc
-# LDFLAGS += -arch ppc64
-# LDFLAGS += -arch i386
-# LDFLAGS += -arch x86_64
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with
-# GCC 4.0.  I haven't found a way to make it work with GCC 4.2.
-
-# CXXFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# CXXFLAGS += -mmacosx-version-min=10.4
-# LDFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -Wl,-syslibroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -mmacosx-version-min=10.4
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling with ICC.  Doesn't
-# work yet. :-(
-
-# CXXFLAGS += -DMAC_OS_X_VERSION_MIN_REQUIRED=1040
-# CXXFLAGS += -DMAC_OS_X_VERSION_MAX_ALLOWED=1040
-# CXXFLAGS += -D__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__=1040
-# CXXFLAGS += -F/Developer/SDKs/MacOSX10.4u.sdk/
-# LDFLAGS += -Wl,-syslibroot -Wl,/Developer/SDKs/MacOSX10.4u.sdk

src/application.cpp

@@ -0,0 +1,75 @@
+/*
+  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
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+////
+//// Includes
+////
+
+#include "bitboard.h"
+#include "direction.h"
+#include "endgame.h"
+#include "evaluate.h"
+#include "material.h"
+#include "mersenne.h"
+#include "misc.h"
+#include "movepick.h"
+#include "position.h"
+#include "search.h"
+#include "thread.h"
+#include "ucioption.h"
+
+
+/// Application class is in charge of initializing global resources
+/// at startup and cleanly releases them when program terminates.
+
+Application::Application() {
+
+    init_mersenne();
+    init_direction_table();
+    init_bitboards();
+    init_uci_options();
+    Position::init_zobrist();
+    Position::init_piece_square_tables();
+    init_eval(1);
+    init_bitbases();
+    init_threads();
+
+    // Make random number generation less deterministic, for book moves
+    for (int i = abs(get_system_time() % 10000); i > 0; i--)
+        genrand_int32();
+}
+
+Application::~Application() {
+
+  stop_threads();
+  quit_eval();
+}
+
+void Application::initialize() {
+
+  // A static Application object is allocated
+  // once only when this function is called.
+  static Application singleton;
+}
+
+void Application::exit_with_failure() {
+
+  exit(EXIT_FAILURE); // d'tor will be called automatically
+}

src/application.h

@@ -0,0 +1,39 @@
+/*
+  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
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#if !defined(APPLICATION_H_INCLUDED)
+#define APPLICATION_H_INCLUDED
+
+
+/// Singleton class used to housekeep memory and global resources
+/// so to be sure we always leave in a clean state.
+
+class Application {
+
+  Application();
+  Application(const Application&);
+ ~Application();
+
+public:
+  static void initialize();
+  static void exit_with_failure();
+};
+
+#endif // !defined(APPLICATION_H_INCLUDED)

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -30,12 +30,13 @@
 #include "thread.h"
 #include "ucioption.h"
 
+using namespace std;
 
 ////
 //// Variables
 ////
 
-const std::string BenchmarkPositions[] = {
+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",
   "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
@@ -67,27 +68,26 @@ const std::string BenchmarkPositions[] = {
 /// format (default are the BenchmarkPositions defined above).
 /// The analysis is written to a file named bench.txt.
 
-void benchmark(const std::string& commandLine) {
+void benchmark(const string& commandLine) {
 
-  std::istringstream csVal(commandLine);
+  istringstream csVal(commandLine);
-  std::istringstream csStr(commandLine);
+  istringstream csStr(commandLine);
-  std::string ttSize, threads, fileName, limitType;
+  string ttSize, threads, fileName, limitType, timFile;
   int val, secsPerPos, maxDepth, maxNodes;
 
   csStr >> ttSize;
   csVal >> val;
   if (val < 4 || val > 1024)
   {
-      std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
+      cerr << "The hash table size must be between 4 and 1024" << endl;
-      exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
   csStr >> threads;
   csVal >> val;
   if (val < 1 || val > THREAD_MAX)
   {
-      std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
+      cerr << "The number of threads must be between 1 and " << THREAD_MAX << endl;
-                << std::endl;
+      Application::exit_with_failure();
-      exit(EXIT_FAILURE);
   }
   set_option_value("Hash", ttSize);
   set_option_value("Threads", threads);
@@ -98,54 +98,84 @@ void benchmark(const std::string& commandLine) {
   csVal >> val;
   csVal >> fileName;
   csVal >> limitType;
+  csVal >> timFile;
 
   secsPerPos = maxDepth = maxNodes = 0;
 
   if (limitType == "time")
       secsPerPos = val * 1000;
-  else if (limitType == "depth")
+  else if (limitType == "depth" || limitType == "perft")
       maxDepth = val;
   else
       maxNodes = val;
 
-  std::vector<std::string> positions;
+  vector<string> positions;
 
   if (fileName != "default")
   {
-      std::ifstream fenFile(fileName.c_str());
+      ifstream fenFile(fileName.c_str());
       if (!fenFile.is_open())
       {
-          std::cerr << "Unable to open positions file " << fileName
+          cerr << "Unable to open positions file " << fileName << endl;
-                    << std::endl;
+          Application::exit_with_failure();
-          exit(EXIT_FAILURE);
       }
-      std::string pos;
+      string pos;
       while (fenFile.good())
       {
-          std::getline(fenFile, pos);
+          getline(fenFile, pos);
           if (!pos.empty())
               positions.push_back(pos);
       }
       fenFile.close();
   } else
       for (int i = 0; i < 16; i++)
-          positions.push_back(std::string(BenchmarkPositions[i]));
+          positions.push_back(string(BenchmarkPositions[i]));
 
-  int startTime = get_system_time();
+  ofstream timingFile;
-  std::vector<std::string>::iterator it;
+  if (!timFile.empty())
+  {
+      timingFile.open(timFile.c_str(), ios::out | ios::app);
+      if (!timingFile.is_open())
+      {
+          cerr << "Unable to open timing file " << timFile << endl;
+          Application::exit_with_failure();
+      }
+  }
+
+  vector<string>::iterator it;
   int cnt = 1;
   int64_t totalNodes = 0;
+  int startTime = get_system_time();
+
   for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
   {
       Move moves[1] = {MOVE_NONE};
       int dummy[2] = {0, 0};
       Position pos(*it);
-      std::cout << "\nProcessing position " << cnt << '/' << positions.size() << std::endl << std::endl;
+      cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
-      think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves);
+      if (limitType == "perft")
+          totalNodes += perft(pos, maxDepth * OnePly);
+      else if (!think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+          break;
       totalNodes += nodes_searched();
   }
-  std::cout << "\nProcessing time (ms) " << get_system_time() - startTime << std::endl
+
-            << "Nodes searched " << totalNodes << std::endl
+  cnt = get_system_time() - startTime;
-            << "Press any key to exit" << std::endl;
+  cerr << "==============================="
-  std::cin >> fileName;
+       << "\nTotal time (ms) : " << cnt
+       << "\nNodes searched  : " << totalNodes
+       << "\nNodes/second    : " << (int)(totalNodes/(cnt/1000.0)) << endl << endl;
+
+  if (!timFile.empty())
+  {
+      timingFile << cnt << endl << endl;
+      timingFile.close();
+  }
+
+  // Under MS Visual C++ debug window always unconditionally closes
+  // when program exits, this is bad because we want to read results before.
+  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
+  cerr << "Press any key to exit" << endl;
+  cin >> fileName;
+  #endif
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -22,137 +22,14 @@
 //// Includes
 ////
 
-#ifdef _MSC_VER
-    #include <intrin.h>
-    #ifdef _WIN64
-        #pragma intrinsic(_BitScanForward64)
-    #else
-        #pragma intrinsic(_BitScanForward)
-    #endif
-    #define USING_INTRINSICS
-#endif
-
 #include <iostream>
 
 #include "bitboard.h"
+#include "bitcount.h"
 #include "direction.h"
 
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+#if defined(IS_64BIT)
-
-Bitboard RankAttacks[8][64], FileAttacks[8][64];
-
-#elif defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
-  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
-  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
-  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
-  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
-  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
-  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
-  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
-  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
-  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
-  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
-  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
-  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
-  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
-  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
-  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
-  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
-  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
-  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
-  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
-  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
-  0x5ac08a4735370479ULL,
-};
-
-const int RShift[64] = {
-  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
-  0x410201ce5c030092ULL
-};
-
-const int RShift[64] = {
-  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
-};
-
-#endif // defined(USE_32BIT_ATTACKS)
-
-#if !defined(USE_COMPACT_ROOK_ATTACKS)
-Bitboard RMask[64];
-int RAttackIndex[64];
-Bitboard RAttacks[0x19000];
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
-
-const uint64_t BMult[64] = {
-  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
-  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
-  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
-  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
-  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
-  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
-  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
-  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
-  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
-  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
-  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
-  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
-  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
-  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
-  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
-  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
-  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
-  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
-  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
-  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
-  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
-  0xdc01f6dca4bebbdcULL,
-};
-
-const int BShift[64] = {
-  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
-  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
-  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
 
 const uint64_t BMult[64] = {
   0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL,
@@ -179,6 +56,31 @@ const uint64_t BMult[64] = {
   0xa08520292120600ULL
 };
 
+const uint64_t RMult[64] = {
+  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
+  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
+  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
+  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
+  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
+  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
+  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
+  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
+  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
+  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
+  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
+  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
+  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
+  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
+  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
+  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
+  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
+  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
+  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
+  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
+  0x410201ce5c030092ULL
+};
+
 const int BShift[64] = {
   58, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 59, 59,
   59, 59, 57, 57, 57, 57, 59, 59, 59, 59, 57, 55, 55, 57, 59, 59,
@@ -186,7 +88,132 @@ const int BShift[64] = {
   59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
 };
 
-#endif // defined(USE_32BIT_ATTACKS)
+const int RShift[64] = {
+  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
+};
+
+#else // if !defined(IS_64BIT)
+
+const uint64_t BMult[64] = {
+  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
+  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
+  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
+  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
+  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
+  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
+  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
+  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
+  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
+  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
+  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
+  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
+  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
+  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
+  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
+  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
+  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
+  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
+  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
+  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
+  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
+  0xdc01f6dca4bebbdcULL,
+};
+
+const uint64_t RMult[64] = {
+  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
+  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
+  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
+  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
+  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
+  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
+  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
+  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
+  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
+  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
+  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
+  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
+  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
+  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
+  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
+  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
+  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
+  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
+  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
+  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
+  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
+  0x5ac08a4735370479ULL,
+};
+
+const int BShift[64] = {
+  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
+  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
+  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
+};
+
+const int RShift[64] = {
+  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
+};
+
+#endif // defined(IS_64BIT)
+
+const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
+
+const Bitboard FileBB[8] = {
+  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
+};
+
+const Bitboard NeighboringFilesBB[8] = {
+  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
+  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
+};
+
+const Bitboard ThisAndNeighboringFilesBB[8] = {
+  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
+  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
+  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
+  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
+};
+
+const Bitboard RankBB[8] = {
+  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
+};
+
+const Bitboard RelativeRankBB[2][8] = {
+  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
+  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
+};
+
+const Bitboard InFrontBB[2][8] = {
+  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank6BB | Rank7BB | Rank8BB,
+    Rank7BB | Rank8BB,
+    Rank8BB,
+    EmptyBoardBB
+  },
+  { EmptyBoardBB,
+    Rank1BB,
+    Rank2BB | Rank1BB,
+    Rank3BB | Rank2BB | Rank1BB,
+    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
+  }
+};
+
+Bitboard RMask[64];
+int RAttackIndex[64];
+Bitboard RAttacks[0x19000];
 
 Bitboard BMask[64];
 int BAttackIndex[64];
@@ -206,6 +233,8 @@ Bitboard BishopPseudoAttacks[64];
 Bitboard RookPseudoAttacks[64];
 Bitboard QueenPseudoAttacks[64];
 
+uint8_t BitCount8Bit[256];
+
 
 ////
 //// Local definitions
@@ -225,9 +254,6 @@ namespace {
                             const int shift[2], const Bitboard mult[],
                             int deltas[][2]);
   void init_pseudo_attacks();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  void init_file_and_rank_attacks();
-#endif
 }
 
 
@@ -259,88 +285,19 @@ void init_bitboards() {
   init_ray_bitboards();
   init_attacks();
   init_between_bitboards();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
-  init_file_and_rank_attacks();
+  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
-#else
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift,
-                       RMult, rookDeltas);
-#endif
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift,
-                       BMult, bishopDeltas);
   init_pseudo_attacks();
 }
 
 
-#if defined(USE_FOLDED_BITSCAN)
-
-static const int BitTable[64] = {
-  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2,
-  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52,
-  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28,
-  58, 20, 37, 17, 36, 8
-};
-
-
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = int(b) ^ int(b >> 32);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
 
-#if defined(USE_32BIT_ATTACKS)
+#if defined(IS_64BIT) && !defined(USE_BSFQ)
-
-// Use type-punning
-union b_union {
-
-    Bitboard b;
-    struct {
-        uint32_t l;
-        uint32_t h;
-    };
-};
-
-// WARNING: Needs -fno-strict-aliasing compiler option
-Square pop_1st_bit(Bitboard *bb) {
-
-  b_union u;
-  uint32_t b;
-
-  u.b = *bb;
-
-  if (u.l)
-  {
-      b = u.l;
-      *((uint32_t*)bb) = b & (b - 1);
-      b ^= (b - 1);
-  }
-  else
-  {
-      b = u.h;
-      *((uint32_t*)bb+1) = b & (b - 1); // Little endian only?
-      b = ~(b ^ (b - 1));
-  }
-  return Square(BitTable[(b * 0x783a9b23) >> 26]);
-}
-
-#else
-
-Square pop_1st_bit(Bitboard *b) {
-  Bitboard bb = *b ^ (*b - 1);
-  uint32_t fold = int(bb) ^ int(bb >> 32);
-  *b &= (*b - 1);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-#endif
-
-#else
 
+CACHE_LINE_ALIGNMENT
 static 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,
@@ -348,25 +305,91 @@ static const int BitTable[64] = {
   51, 60, 42, 59, 58
 };
 
-
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
 Square first_1(Bitboard b) {
   return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
 Square pop_1st_bit(Bitboard* b) {
   Bitboard bb = *b;
   *b &= (*b - 1);
   return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-#endif // defined(USE_FOLDED_BITSCAN)
+#elif !defined(USE_BSFQ)
 
+static CACHE_LINE_ALIGNMENT
+const int BitTable[64] = {
+  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2,
+  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52,
+  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28,
+  58, 20, 37, 17, 36, 8
+};
+
+Square first_1(Bitboard b) {
+  b ^= (b - 1);
+  uint32_t fold = int(b) ^ int(b >> 32);
+  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
+}
+
+// Use type-punning
+union b_union {
+
+    Bitboard b;
+    struct {
+#if defined (BIGENDIAN)
+        uint32_t h;
+        uint32_t l;
+#else
+        uint32_t l;
+        uint32_t h;
+#endif
+    } dw;
+};
+
+Square pop_1st_bit(Bitboard* bb) {
+
+   b_union u;
+   Square ret;
+
+   u.b = *bb;
+
+   if (u.dw.l)
+   {
+       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
+       u.dw.l &= (u.dw.l - 1);
+       *bb = u.b;
+       return ret;
+   }
+   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
+   u.dw.h &= (u.dw.h - 1);
+   *bb = u.b;
+   return ret;
+}
+
+#endif
+
+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 {
 
@@ -388,6 +411,9 @@ namespace {
           in_front_bb(c, s) & this_and_neighboring_files_bb(s);
         OutpostMask[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);
   }
 
 
@@ -480,25 +506,25 @@ namespace {
       attackIndex[i] = index;
       mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
 
-#if defined(USE_32BIT_ATTACKS)
+#if defined(IS_64BIT)
-      j = (1 << (32 - shift[i]));
-#else
       j = (1 << (64 - shift[i]));
+#else
+      j = (1 << (32 - shift[i]));
 #endif
 
       for(k = 0; k < j; k++) {
 
-#if defined(USE_32BIT_ATTACKS)
+#if defined(IS_64BIT)
+        b = index_to_bitboard(k, mask[i]);
+        attacks[index + ((b * mult[i]) >> shift[i])] =
+          sliding_attacks(i, b, 4, deltas);
+#else
         b = index_to_bitboard(k, mask[i]);
         attacks[index +
                  (unsigned(int(b) * int(mult[i]) ^
                            int(b >> 32) * int(mult[i] >> 32))
                   >> shift[i])] =
           sliding_attacks(i, b, 4, deltas);
-#else
-        b = index_to_bitboard(k, mask[i]);
-        attacks[index + ((b * mult[i]) >> shift[i])] =
-          sliding_attacks(i, b, 4, deltas);
 #endif
       }
       index += j;
@@ -515,29 +541,4 @@ namespace {
     }
   }
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  void init_file_and_rank_attacks() {
-    int i, j, k, l, m, s;
-    Bitboard b1, b2;
-    for(i = 0; i < 64; i++) {
-
-      for(m = 0; m <= 1; m++) {
-        b1 = 0ULL;
-        for(j = 0; j < 6; j++) if(i & (1<<j)) b1 |= (1ULL << ((j+1)*(1+m*7)));
-        for(j = 0; j < 8; j++) {
-          b2 = 0ULL;
-          for(k = 0, s = 1; k < 2; k++, s *= -1) {
-            for(l = j+s; l >= 0 && l <= 7; l += s) {
-              b2 |= (m? RankBB[l] : FileBB[l]);
-              if(b1 & (1ULL << (l*(1+m*7)))) break;
-            }
-          }
-          if(m) FileAttacks[j][(b1*0xd6e8802041d0c441ULL) >> 58] = b2;
-          else RankAttacks[j][i] = b2;
-        }
-      }
-    }
-  }
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
-
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -22,43 +22,6 @@
 #if !defined(BITBOARD_H_INCLUDED)
 #define BITBOARD_H_INCLUDED
 
-
-////
-//// Defines
-////
-
-// Comment following define if you prefer manually adjust
-// platform macros defined below
-#define AUTO_CONFIGURATION
-
-// Quiet a warning on Intel compiler
-#if !defined(__SIZEOF_INT__ )
-#define __SIZEOF_INT__ 0
-#endif
-
-// Check for 64 bits for different compilers: Intel, MSVC and gcc
-#if defined(__x86_64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
-#define IS_64BIT
-#endif
-
-#if !defined(AUTO_CONFIGURATION) || defined(IS_64BIT)
-
-//#define USE_COMPACT_ROOK_ATTACKS
-//#define USE_32BIT_ATTACKS
-#define USE_FOLDED_BITSCAN
-
-#define BITCOUNT_SWAR_64
-//#define BITCOUNT_SWAR_32
-//#define BITCOUNT_LOOP
-
-#else
-
-#define USE_32BIT_ATTACKS
-#define USE_FOLDED_BITSCAN
-#define BITCOUNT_SWAR_32
-
-#endif
-
 ////
 //// Includes
 ////
@@ -69,13 +32,6 @@
 #include "types.h"
 
 
-////
-//// Types
-////
-
-typedef uint64_t Bitboard;
-
-
 ////
 //// Constants and variables
 ////
@@ -84,7 +40,6 @@ const Bitboard EmptyBoardBB = 0ULL;
 
 const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
 const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
-const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
 
 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = 0x0202020202020202ULL;
@@ -95,22 +50,6 @@ const Bitboard FileFBB = 0x2020202020202020ULL;
 const Bitboard FileGBB = 0x4040404040404040ULL;
 const Bitboard FileHBB = 0x8080808080808080ULL;
 
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};
-
 const Bitboard Rank1BB = 0xFFULL;
 const Bitboard Rank2BB = 0xFF00ULL;
 const Bitboard Rank3BB = 0xFF0000ULL;
@@ -120,35 +59,13 @@ const Bitboard Rank6BB = 0xFF0000000000ULL;
 const Bitboard Rank7BB = 0xFF000000000000ULL;
 const Bitboard Rank8BB = 0xFF00000000000000ULL;
 
-const Bitboard RankBB[8] = {
+extern const Bitboard SquaresByColorBB[2];
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
+extern const Bitboard FileBB[8];
-};
+extern const Bitboard NeighboringFilesBB[8];
-
+extern const Bitboard ThisAndNeighboringFilesBB[8];
-const Bitboard RelativeRankBB[2][8] = {
+extern const Bitboard RankBB[8];
-  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
+extern const Bitboard RelativeRankBB[2][8];
-  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
+extern const Bitboard InFrontBB[2][8];
-};
-
-const Bitboard InFrontBB[2][8] = {
-  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  { EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
 
 extern Bitboard SetMaskBB[65];
 extern Bitboard ClearMaskBB[65];
@@ -160,20 +77,12 @@ extern Bitboard BetweenBB[64][64];
 extern Bitboard PassedPawnMask[2][64];
 extern Bitboard OutpostMask[2][64];
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-
-extern Bitboard RankAttacks[8][64], FileAttacks[8][64];
-
-#else
-
 extern const uint64_t RMult[64];
 extern const int RShift[64];
 extern Bitboard RMask[64];
 extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
 
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
-
 extern const uint64_t BMult[64];
 extern const int BShift[64];
 extern Bitboard BMask[64];
@@ -184,6 +93,8 @@ extern Bitboard BishopPseudoAttacks[64];
 extern Bitboard RookPseudoAttacks[64];
 extern Bitboard QueenPseudoAttacks[64];
 
+extern uint8_t BitCount8Bit[256];
+
 
 ////
 //// Inline functions
@@ -205,6 +116,17 @@ inline void clear_bit(Bitboard *b, Square s) {
 }
 
 
+/// Functions used to update a bitboard after a move. This is faster
+/// then calling a sequence of clear_bit() + set_bit()
+
+inline Bitboard make_move_bb(Square from, Square to) {
+  return SetMaskBB[from] | SetMaskBB[to];
+}
+
+inline void do_move_bb(Bitboard *b, Bitboard move_bb) {
+  *b ^= move_bb;
+}
+
 /// rank_bb() and file_bb() gives a bitboard containing all squares on a given
 /// file or rank.  It is also possible to pass a square as input to these
 /// functions.
@@ -303,24 +225,19 @@ inline Bitboard ray_bb(Square s, SignedDirection d) {
 /// bitboard of occupied squares as input, and return a bitboard representing
 /// all squares attacked by a rook, bishop or queen on the given square.
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+#if defined(IS_64BIT)
-
-inline Bitboard file_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> square_file(s)) & 0x01010101010100ULL;
-  return
-    FileAttacks[square_rank(s)][(b*0xd6e8802041d0c441ULL)>>58] & file_bb(s);
-}
-
-inline Bitboard rank_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> ((s & 56) + 1)) & 63;
-  return RankAttacks[square_file(s)][b] & rank_bb(s);
-}
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  return file_attacks_bb(s, blockers) | rank_attacks_bb(s, blockers);
+  Bitboard b = blockers & RMask[s];
+  return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
 }
 
-#elif defined(USE_32BIT_ATTACKS)
+inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
+  Bitboard b = blockers & BMask[s];
+  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
+}
+
+#else // if !defined(IS_64BIT)
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & RMask[s];
@@ -330,17 +247,6 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
                    >> RShift[s])];
 }
 
-#else
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
-}
-
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
-
 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & BMask[s];
   return BAttacks[BAttackIndex[s] +
@@ -349,14 +255,7 @@ inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
                    >> BShift[s])];
 }
 
-#else // defined(USE_32BIT_ATTACKS)
+#endif
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
-}
-
-#endif // defined(USE_32BIT_ATTACKS)
 
 inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
   return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
@@ -418,63 +317,30 @@ inline Bitboard isolated_pawn_mask(Square s) {
 }
 
 
-/// count_1s() counts the number of nonzero bits in a bitboard.
+/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// pop_1st_bit() finds and clears the least significant nonzero bit in a
+/// nonzero bitboard.
 
-#if defined(BITCOUNT_LOOP)
+#if defined(USE_BSFQ) // Assembly code by Heinz van Saanen
 
-inline int count_1s(Bitboard b) {
+inline Square first_1(Bitboard b) {
-  int r;
+  Bitboard dummy;
-  for(r = 0; b; r++, b &= b - 1);
+  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
-  return r;
+  return (Square)(dummy);
 }
 
-inline int count_1s_max_15(Bitboard b) {
+inline Square pop_1st_bit(Bitboard* b) {
-  return count_1s(b);
+  const Square s = first_1(*b);
+  *b &= ~(1ULL<<s);
+  return s;
 }
 
-#elif defined(BITCOUNT_SWAR_32)
+#else // if !defined(USE_BSFQ)
 
-inline int count_1s(Bitboard b) {
+extern Square first_1(Bitboard b);
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
+extern Square pop_1st_bit(Bitboard* b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
-  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
-  v *= 0x01010101; // mul is fast on amd procs
-  return int(v >> 24);
-}
 
-inline int count_1s_max_15(Bitboard b) {
+#endif
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
-  w -= (w >> 1) & 0x55555555;
-  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
-  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
-  v += w; // 0-8 in 4 bits
-  v *= 0x11111111;
-  return int(v >> 28);
-}
-
-#elif defined(BITCOUNT_SWAR_64)
-
-inline int count_1s(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
-}
-
-inline int count_1s_max_15(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
-}
-
-#endif // BITCOUNT
 
 
 ////
@@ -483,8 +349,7 @@ inline int count_1s_max_15(Bitboard b) {
 
 extern void print_bitboard(Bitboard b);
 extern void init_bitboards();
-extern Square first_1(Bitboard b);
+extern int bitScanReverse32(uint32_t b);
-extern Square pop_1st_bit(Bitboard *b);
 
 
 #endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -0,0 +1,143 @@
+/*
+  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
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#if !defined(BITCOUNT_H_INCLUDED)
+#define BITCOUNT_H_INCLUDED
+
+#include "types.h"
+
+// Select type of intrinsic bit count instruction to use, see
+// README.txt on how to pgo compile with POPCNT support.
+
+#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
+
+#endif // cpu_has_popcnt() and POPCNT_INTRINSIC() definitions
+
+
+/// Software implementation of bit count functions
+
+#if defined(IS_64BIT)
+
+inline int count_1s(Bitboard b) {
+  b -= ((b>>1) & 0x5555555555555555ULL);
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  b *= 0x0101010101010101ULL;
+  return int(b >> 56);
+}
+
+inline int count_1s_max_15(Bitboard b) {
+  b -= (b>>1) & 0x5555555555555555ULL;
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b *= 0x1111111111111111ULL;
+  return int(b >> 60);
+}
+
+#else // if !defined(IS_64BIT)
+
+inline int count_1s(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
+  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  v *= 0x01010101; // mul is fast on amd procs
+  return int(v >> 24);
+}
+
+inline int count_1s_max_15(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v += w; // 0-8 in 4 bits
+  v *= 0x11111111;
+  return int(v >> 28);
+}
+
+#endif // BITCOUNT
+
+
+/// count_1s() counts the number of nonzero bits in a bitboard.
+/// If template parameter is true an intrinsic is called, otherwise
+/// we fallback on a software implementation.
+
+template<bool UseIntrinsic>
+inline int count_1s(Bitboard b) {
+
+  return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s(b);
+}
+
+template<bool UseIntrinsic>
+inline int count_1s_max_15(Bitboard b) {
+
+  return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s_max_15(b);
+}
+
+
+// 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.
+const bool CpuHasPOPCNT = cpu_has_popcnt();
+
+
+// Global constant used to print info about the use of 64 optimized
+// functions to verify that a 64 bit compile has been correctly built.
+#if defined(IS_64BIT)
+const bool CpuHas64BitPath = true;
+#else
+const bool CpuHas64BitPath = false;
+#endif
+
+#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -35,6 +35,7 @@
 #include "mersenne.h"
 #include "movegen.h"
 
+using namespace std;
 
 ////
 //// Global variables
@@ -49,7 +50,11 @@ Book OpeningBook;
 
 namespace {
 
-  /// Random numbers from PolyGlot, used to compute book hash keys.
+  /// Book entry size in bytes
+  const int EntrySize = 16;
+
+
+  /// Random numbers from PolyGlot, used to compute book hash keys
 
   const uint64_t Random64[781] = {
     0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
@@ -324,13 +329,6 @@ namespace {
   const int RandomTurn      = 780;
 
 
-  /// Convert pieces to the range 0..1
-
-  const int PieceTo12[] = {
-    0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11
-  };
-
-
   /// Prototypes
 
   uint64_t book_key(const Position& pos);
@@ -338,10 +336,6 @@ namespace {
   uint64_t book_castle_key(const Position& pos);
   uint64_t book_ep_key(const Position& pos);
   uint64_t book_color_key(const Position& pos);
-
-  uint16_t read_integer16(std::ifstream& file);
-  uint64_t read_integer64(std::ifstream& file);
-  uint64_t read_integer(std::ifstream& file, int size);
 }
 
 
@@ -350,89 +344,97 @@ namespace {
 ////
 
 
-/// Constructor
+/// Destructor. Be sure file is closed before we leave.
 
-Book::Book() : bookSize(0) {}
+Book::~Book() {
+
+  close();
+}
 
 
-/// Book::open() opens a book file with a given file name.
+/// Book::open() opens a book file with a given file name
 
-void Book::open(const std::string &fName) {
+void Book::open(const string& fName) {
+
+  // Close old file before opening the new
+  close();
 
   fileName = fName;
-  bookFile.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);
+  ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary);
-  if (!bookFile.is_open())
+  if (!is_open())
       return;
 
-  bookFile.seekg(0, std::ios::end);
+  // Get the book size in number of entries
-  bookSize = bookFile.tellg() / 16;
+  seekg(0, ios::end);
-  bookFile.seekg(0, std::ios::beg);
+  bookSize = tellg() / EntrySize;
+  seekg(0, ios::beg);
 
-  if (!bookFile.good())
+  if (!good())
   {
-      std::cerr << "Failed to open book file " << fileName << std::endl;
+      cerr << "Failed to open book file " << fileName << endl;
-      exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
 }
 
 
-/// Book::close() closes the currently open book file.
+/// Book::close() closes the file only if it is open, otherwise
+/// we can end up in a little mess due to how std::ifstream works.
 
 void Book::close() {
 
-  if (bookFile.is_open())
+  if (is_open())
-      bookFile.close();
+      ifstream::close();
-}
-
-
-/// Book::is_open() tests whether a book file has been opened.
-
-bool Book::is_open() const {
-
-  return bookFile.is_open() && bookSize != 0;
 }
 
 
 /// Book::file_name() returns the file name of the currently active book,
 /// or the empty string if no book is open.
 
-const std::string Book::file_name() const {
+const string Book::file_name() const {
 
-  return bookFile.is_open() ? fileName : "";
+  return is_open() ? fileName : "";
 }
 
 
 /// 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) const {
+Move Book::get_move(const Position& pos) {
-  if(this->is_open()) {
+
-    int bestMove = 0, bestScore = 0, move, score;
+  if (!is_open() || bookSize == 0)
+      return MOVE_NONE;
+
+  int bookMove = 0, scoresSum = 0;
   uint64_t key = book_key(pos);
   BookEntry entry;
 
-    for(int i = this->find_key(key); i < bookSize; i++) {
+  // Choose a book move among the possible moves for the given position
-      this->read_entry(entry, i);
+  for (int idx = find_key(key); idx < bookSize; idx++)
+  {
+      read_entry(entry, idx);
       if (entry.key != key)
           break;
-      move = entry.move;
+
-      score = entry.count;
+      int score = entry.count;
+
       assert(score > 0);
 
-      bestScore += score;
+      // Choose book move according to its score. If a move has a very
-      if(int(genrand_int32() % bestScore) < score)
+      // high score it has more probability to be choosen then a one with
-        bestMove = move;
+      // lower score. Note that first entry is always chosen.
+      scoresSum += score;
+      if (int(genrand_int32() % scoresSum) < score)
+          bookMove = entry.move;
   }
+  if (!bookMove)
+      return MOVE_NONE;
+
+  MoveStack mlist[256];
+  MoveStack* last = generate_moves(pos, mlist);
+  for (MoveStack* cur = mlist; cur != last; cur++)
+      if ((int(cur->move) & 07777) == bookMove)
+          return cur->move;
 
-    if(bestMove != 0) {
-      MoveStack moves[256];
-      int n, j;
-      n = generate_legal_moves(pos, moves);
-      for(j = 0; j < n; j++)
-        if((int(moves[j].move) & 07777) == bestMove)
-          return moves[j].move;
-    }
-  }
   return MOVE_NONE;
 }
 
@@ -442,7 +444,8 @@ Move Book::get_move(const Position &pos) const {
 /// entry with the same key as the input is returned. When the key is not
 /// found in the book file, bookSize is returned.
 
-int Book::find_key(uint64_t key) const {
+int Book::find_key(uint64_t key) {
+
   int left, right, mid;
   BookEntry entry;
 
@@ -452,12 +455,13 @@ int Book::find_key(uint64_t key) const {
 
   assert(left <= right);
 
-  while(left < right) {
+  while (left < right)
+  {
       mid = (left + right) / 2;
+
       assert(mid >= left && mid < right);
 
-    this->read_entry(entry, mid);
+      read_entry(entry, mid);
-
       if (key <= entry.key)
           right = mid;
       else
@@ -466,8 +470,7 @@ int Book::find_key(uint64_t key) const {
 
   assert(left == right);
 
-  this->read_entry(entry, left);
+  read_entry(entry, left);
-
   return (entry.key == key)? left : bookSize;
 }
 
@@ -476,22 +479,35 @@ int Book::find_key(uint64_t key) const {
 /// input, and looks up the opening book entry at the given index in the book
 /// file. The book entry is copied to the first input parameter.
 
-void Book::read_entry(BookEntry& entry, int n) const {
+void Book::read_entry(BookEntry& entry, int idx) {
 
-  assert(n >= 0 && n < bookSize);
+  assert(idx >= 0 && idx < bookSize);
-  assert(bookFile.is_open());
+  assert(is_open());
 
-  bookFile.seekg(n*16, std::ios_base::beg);
+  seekg(idx * EntrySize, ios_base::beg);
-  if (!bookFile.good())
+  *this >> entry;
+  if (!good())
   {
-    std::cerr << "Failed to read book entry at index " << n << std::endl;
+      cerr << "Failed to read book entry at index " << idx << endl;
-    exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
-  entry.key = read_integer64(bookFile);
+}
-  entry.move = read_integer16(bookFile);
+
-  entry.count = read_integer16(bookFile);
+
-  entry.n = read_integer16(bookFile);
+/// Book::read_integer() reads size chars from the file stream
-  entry.sum = read_integer16(bookFile);
+/// and converts them in an integer number.
+
+uint64_t Book::read_integer(int size) {
+
+  char buf[8];
+  read(buf, size);
+
+  // Numbers are stored on disk as a binary byte stream
+  uint64_t n = 0ULL;
+  for (int i = 0; i < size; i++)
+      n = (n << 8) + (unsigned char)buf[i];
+
+  return n;
 }
 
 
@@ -502,91 +518,66 @@ void Book::read_entry(BookEntry& entry, int n) const {
 namespace {
 
   uint64_t book_key(const Position& pos) {
+
     uint64_t result = 0ULL;
 
-    for(Color c = WHITE; c <= BLACK; c++) {
+    for (Color c = WHITE; c <= BLACK; c++)
+    {
         Bitboard b = pos.pieces_of_color(c);
-      Square s;
+
-      Piece p;
+        while (b)
-      while(b != EmptyBoardBB) {
+        {
-        s = pop_1st_bit(&b);
+            Square s = pop_1st_bit(&b);
-        p = pos.piece_on(s);
+            Piece p = pos.piece_on(s);
+
             assert(piece_is_ok(p));
             assert(color_of_piece(p) == c);
 
             result ^= book_piece_key(p, s);
         }
     }
-
     result ^= book_castle_key(pos);
     result ^= book_ep_key(pos);
     result ^= book_color_key(pos);
-
     return result;
   }
 
 
   uint64_t book_piece_key(Piece p, Square s) {
+
+    /// Convert pieces to the range 0..11
+    static const int PieceTo12[] = { 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 };
+
     return Random64[RandomPiece + (PieceTo12[int(p)]^1) * 64 + int(s)];
   }
 
 
   uint64_t book_castle_key(const Position& pos) {
+
     uint64_t result = 0ULL;
 
     if (pos.can_castle_kingside(WHITE))
         result ^= Random64[RandomCastle+0];
+
     if (pos.can_castle_queenside(WHITE))
         result ^= Random64[RandomCastle+1];
+
     if (pos.can_castle_kingside(BLACK))
         result ^= Random64[RandomCastle+2];
+
     if (pos.can_castle_queenside(BLACK))
         result ^= Random64[RandomCastle+3];
+
     return result;
   }
 
 
   uint64_t book_ep_key(const Position& pos) {
-    return (pos.ep_square() == SQ_NONE)?
+    return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]);
-      0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
   }
 
 
   uint64_t book_color_key(const Position& pos) {
-    return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL;
+    return (pos.side_to_move() == WHITE ? Random64[RandomTurn] : 0ULL);
-  }
-
-
-  uint16_t read_integer16(std::ifstream& file) {
-
-    uint64_t n = read_integer(file, 2);
-    assert(n == (uint16_t)n);
-    return (uint16_t)n;
-  }
-
-
-  uint64_t read_integer64(std::ifstream& file) {
-
-    return read_integer(file, 8);
-  }
-
-
-  uint64_t read_integer(std::ifstream& file, int size) {
-
-    char buf[8];
-    file.read(buf, size);
-
-    if (!file.good())
-    {
-        std::cerr << "Failed to read " << size << " bytes from book file"
-                  << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    // Numbers are stored in little endian format
-    uint64_t n = 0ULL;
-    for (int i = 0; i < size; i++)
-        n = (n << 8) + (unsigned char)buf[i];
-
-    return n;
   }
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -52,31 +52,24 @@ struct BookEntry {
   uint16_t sum;
 };
 
-class Book {
+class Book : private std::ifstream {
-
 public:
-  // Constructors
+  ~Book();
-  Book();
-
-  // Open and close book files
   void open(const std::string& fName);
   void close();
-
-  // Testing if a book is opened
-  bool is_open() const;
-
-  // The file name of the currently active book
   const std::string file_name() const;
-
+  Move get_move(const Position& pos);
-  // Get a book move for a given position
-  Move get_move(const Position &pos) const;
 
 private:
-  int find_key(uint64_t key) const;
+  Book& operator>>(uint64_t& n) { n = read_integer(8); return *this; }
-  void read_entry(BookEntry &entry, int n) const;
+  Book& operator>>(uint16_t& n) { n = (uint16_t)read_integer(2); return *this; }
+  void operator>>(BookEntry& e) { *this >> e.key >> e.move >> e.count >> e.n >> e.sum; }
+
+  uint64_t read_integer(int size);
+  void read_entry(BookEntry& e, int n);
+  int find_key(uint64_t key);
 
   std::string fileName;
-  mutable std::ifstream bookFile;
   int bookSize;
 };
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -37,7 +37,6 @@ enum Color {
 //// Inline functions
 ////
 
-inline Color operator+ (Color c, int i) { return Color(int(c) + i); }
 inline void operator++ (Color &c, int) { c = Color(int(c) + 1); }
 
 inline Color opposite_color(Color c) {

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -35,9 +35,6 @@ enum Depth {
 //// Constants
 ////
 
-/// Note: If OnePly is changed, the constant HistoryMax in history.h should
-/// probably also be changed.
-
 const Depth OnePly = Depth(2);
 
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,32 @@
 #include "square.h"
 
 
+////
+//// Local definitions
+////
+
+namespace {
+
+  const SquareDelta directionToDelta[] = {
+      DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+  };
+
+  bool reachable(Square orig, Square dest, SignedDirection dir) {
+
+    SquareDelta delta = directionToDelta[dir];
+    Square from = orig;
+    Square to = from + delta;
+    while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
+    {
+        from = to;
+        to += delta;
+    }
+    return (to == dest && square_distance(from, to) == 1);
+  }
+
+}
+
+
 ////
 //// Variables
 ////
@@ -39,21 +65,19 @@ uint8_t SignedDirectionTable[64][64];
 ////
 
 void init_direction_table() {
-  SquareDelta deltas[8] = {
+
-    DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
-  };
   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++)
+      {
           DirectionTable[s1][s2] = uint8_t(DIR_NONE);
           SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
-      if(s1 == s2) continue;
+          if (s1 == s2)
-      for(SignedDirection d = SIGNED_DIR_E; d <= SIGNED_DIR_SE; d++) {
+              continue;
-        SquareDelta delta = deltas[d];
+
-        Square s3, s4;
+          for (SignedDirection d = SIGNED_DIR_E; d != SIGNED_DIR_NONE; d++)
-        for(s4 = s1 + delta, s3 = s1;
+          {
-            square_distance(s4, s3) == 1 && s4 != s2 && square_is_ok(s4);
+              if (reachable(s1, s2, d))
-            s3 = s4, s4 += delta);
+              {
-        if(s4 == s2 && square_distance(s4, s3) == 1) {
                   SignedDirectionTable[s1][s2] = uint8_t(d);
                   DirectionTable[s1][s2] = uint8_t(d / 2);
                   break;

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,44 +25,10 @@
 #include <cassert>
 
 #include "bitbase.h"
+#include "bitcount.h"
 #include "endgame.h"
 
 
-////
-//// Constants and variables
-////
-
-/// Evaluation functions
-
-// Generic "mate lone king" eval
-EvaluationFunction<KXK> EvaluateKXK(WHITE), EvaluateKKX(BLACK);
-
-// K and two minors vs K and one or two minors
-EvaluationFunction<KmmKm> EvaluateKmmKm(WHITE);
-
-EvaluationFunction<KBNK> EvaluateKBNK(WHITE), EvaluateKKBN(BLACK); // KBN vs K
-EvaluationFunction<KPK> EvaluateKPK(WHITE), EvaluateKKP(BLACK);    // KP vs K
-EvaluationFunction<KRKP> EvaluateKRKP(WHITE), EvaluateKPKR(BLACK); // KR vs KP
-EvaluationFunction<KRKB> EvaluateKRKB(WHITE), EvaluateKBKR(BLACK); // KR vs KB
-EvaluationFunction<KRKN> EvaluateKRKN(WHITE), EvaluateKNKR(BLACK); // KR vs KN
-EvaluationFunction<KQKR> EvaluateKQKR(WHITE), EvaluateKRKQ(BLACK); // KQ vs KR
-EvaluationFunction<KBBKN> EvaluateKBBKN(WHITE), EvaluateKNKBB(BLACK); // KBB vs KN
-
-
-/// Scaling functions
-
-ScalingFunction<KBPK> ScaleKBPK(WHITE), ScaleKKBP(BLACK);    // KBP vs K
-ScalingFunction<KQKRP> ScaleKQKRP(WHITE), ScaleKRPKQ(BLACK); // KQ vs KRP
-ScalingFunction<KRPKR> ScaleKRPKR(WHITE), ScaleKRKRP(BLACK); // KRP vs KR
-ScalingFunction<KRPPKRP> ScaleKRPPKRP(WHITE), ScaleKRPKRPP(BLACK); // KRPP vs KRP
-ScalingFunction<KPsK> ScaleKPsK(WHITE), ScaleKKPs(BLACK);    // King and pawns vs king
-ScalingFunction<KBPKB> ScaleKBPKB(WHITE), ScaleKBKBP(BLACK); // KBP vs KB
-ScalingFunction<KBPPKB> ScaleKBPPKB(WHITE), ScaleKBKBPP(BLACK); // KBPP vs KB
-ScalingFunction<KBPKN> ScaleKBPKN(WHITE), ScaleKNKBP(BLACK); // KBP vs KN
-ScalingFunction<KNPK> ScaleKNPK(WHITE), ScaleKKNP(BLACK);    // KNP vs K
-ScalingFunction<KPKP> ScaleKPKPw(WHITE), ScaleKPKPb(BLACK);  // KPKP
-
-
 ////
 //// Local definitions
 ////
@@ -363,7 +329,7 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) {
   assert(pos.non_pawn_material(strongerSide) == 2*BishopValueMidgame);
   assert(pos.piece_count(weakerSide, KNIGHT) == 1);
   assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame);
-  assert(pos.pawns() == EmptyBoardBB);
+  assert(pos.pieces(PAWN) == EmptyBoardBB);
 
   Value result = BishopValueEndgame;
   Square wksq = pos.king_square(strongerSide);
@@ -377,16 +343,23 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) {
   result += Value(square_distance(bksq, nsq) * 32);
 
   // Bonus for restricting the knight's mobility
-  result += Value((8 - count_1s_max_15(pos.piece_attacks<KNIGHT>(nsq))) * 8);
+  result += Value((8 - count_1s_max_15(pos.attacks_from<KNIGHT>(nsq))) * 8);
 
   return (strongerSide == pos.side_to_move() ? result : -result);
 }
 
+
+/// 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&) {
   return Value(0);
 }
 
+template<>
+Value EvaluationFunction<KNNK>::apply(const Position&) {
+  return Value(0);
+}
 
 /// KBPKScalingFunction scales endgames where the stronger side has king,
 /// bishop and one or more pawns. It checks for draws with rook pawns and a
@@ -394,7 +367,7 @@ Value EvaluationFunction<KmmKm>::apply(const Position&) {
 /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
 /// will be used.
 template<>
-ScaleFactor ScalingFunction<KBPK>::apply(const Position& pos) {
+ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) {
 
   assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
@@ -403,7 +376,7 @@ ScaleFactor ScalingFunction<KBPK>::apply(const Position& pos) {
   // No assertions about the material of weakerSide, because we want draws to
   // be detected even when the weaker side has some pawns.
 
-  Bitboard pawns = pos.pawns(strongerSide);
+  Bitboard pawns = pos.pieces(PAWN, strongerSide);
   File pawnFile = square_file(pos.piece_list(strongerSide, PAWN, 0));
 
   // All pawns are on a single rook file ?
@@ -420,7 +393,6 @@ ScaleFactor ScalingFunction<KBPK>::apply(const Position& pos) {
           // The bishop has the wrong color, and the defending king is on the
           // file of the pawn(s) or the neighboring file. Find the rank of the
           // frontmost pawn.
-
           Rank rank;
           if (strongerSide == WHITE)
           {
@@ -449,7 +421,7 @@ ScaleFactor ScalingFunction<KBPK>::apply(const Position& pos) {
 /// It tests for fortress draws with a rook on the third rank defended by
 /// a pawn.
 template<>
-ScaleFactor ScalingFunction<KQKRP>::apply(const Position& pos) {
+ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) {
 
   assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame);
   assert(pos.piece_count(strongerSide, QUEEN) == 1);
@@ -460,12 +432,12 @@ ScaleFactor ScalingFunction<KQKRP>::apply(const Position& pos) {
   Square kingSq = pos.king_square(weakerSide);
   if (   relative_rank(weakerSide, kingSq) <= RANK_2
       && relative_rank(weakerSide, pos.king_square(strongerSide)) >= RANK_4
-      && (pos.rooks(weakerSide) & relative_rank_bb(weakerSide, RANK_3))
+      && (pos.pieces(ROOK, weakerSide) & relative_rank_bb(weakerSide, RANK_3))
-      && (pos.pawns(weakerSide) & relative_rank_bb(weakerSide, RANK_2))
+      && (pos.pieces(PAWN, weakerSide) & relative_rank_bb(weakerSide, RANK_2))
-      && (pos.piece_attacks<KING>(kingSq) & pos.pawns(weakerSide)))
+      && (pos.attacks_from<KING>(kingSq) & pos.pieces(PAWN, weakerSide)))
   {
       Square rsq = pos.piece_list(weakerSide, ROOK, 0);
-      if (pos.pawn_attacks(strongerSide, rsq) & pos.pawns(weakerSide))
+      if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
           return ScaleFactor(0);
   }
   return SCALE_FACTOR_NONE;
@@ -644,7 +616,7 @@ ScaleFactor ScalingFunction<KPsK>::apply(const Position &pos) {
   assert(pos.non_pawn_material(weakerSide) == Value(0));
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
-  Bitboard pawns = pos.pawns(strongerSide);
+  Bitboard pawns = pos.pieces(PAWN, strongerSide);
 
   // Are all pawns on the 'a' file?
   if ((pawns & ~FileABB) == EmptyBoardBB)
@@ -722,9 +694,9 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position &pos) {
       else
       {
           Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
-          if (ray & pos.kings(weakerSide))
+          if (ray & pos.pieces(KING, weakerSide))
               return ScaleFactor(0);
-          if(  (pos.piece_attacks<BISHOP>(weakerBishopSq) & ray)
+          if(  (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
              && square_distance(weakerBishopSq, pawnSq) >= 3)
               return ScaleFactor(0);
       }
@@ -789,13 +761,13 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) {
     if (   ksq == blockSq1
         && square_color(ksq) != square_color(wbsq)
         && (   bbsq == blockSq2
-            || (pos.piece_attacks<BISHOP>(blockSq2) & pos.bishops(weakerSide))
+            || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
             || rank_distance(r1, r2) >= 2))
         return ScaleFactor(0);
     else if (   ksq == blockSq2
              && square_color(ksq) != square_color(wbsq)
              && (   bbsq == blockSq1
-                 || (pos.piece_attacks<BISHOP>(blockSq1) & pos.bishops(weakerSide))))
+                 || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
         return ScaleFactor(0);
     else
         return SCALE_FACTOR_NONE;

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -45,11 +45,12 @@ enum EndgameType {
     KRKN,  // KR vs KN
     KQKR,  // KQ vs KR
     KBBKN, // KBB vs KN
+    KNNK,  // KNN vs K
     KmmKm, // K and two minors vs K and one or two minors
 
     // Scaling functions
-    KBPK,    // KBP vs K
+    KBPsK,   // KB+pawns vs K
-    KQKRP,   // KQ vs KRP
+    KQKRPs,  // KQ vs KR+pawns
     KRPKR,   // KRP vs KR
     KRPPKRP, // KRPP vs KRP
     KPsK,    // King and pawns vs king
@@ -65,9 +66,10 @@ enum EndgameType {
 template<typename T>
 class EndgameFunctionBase {
 public:
-  EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); }
+  EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
   virtual ~EndgameFunctionBase() {}
   virtual T apply(const Position&) = 0;
+  Color color() const { return strongerSide; }
 
 protected:
   Color strongerSide, weakerSide;
@@ -81,42 +83,19 @@ typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
 
 template<EndgameType>
 struct EvaluationFunction : public EndgameEvaluationFunctionBase {
+  typedef EndgameEvaluationFunctionBase Base;
   explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
   Value apply(const Position&);
 };
 
 template<EndgameType>
 struct ScalingFunction : public EndgameScalingFunctionBase {
+  typedef EndgameScalingFunctionBase Base;
   explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
   ScaleFactor apply(const Position&);
 };
 
 
-////
-//// Constants and variables
-////
-
-extern EvaluationFunction<KXK> EvaluateKXK, EvaluateKKX;       // Generic "mate lone king" eval
-extern EvaluationFunction<KBNK> EvaluateKBNK, EvaluateKKBN;    // KBN vs K
-extern EvaluationFunction<KPK> EvaluateKPK, EvaluateKKP;       // KP vs K
-extern EvaluationFunction<KRKP> EvaluateKRKP, EvaluateKPKR;    // KR vs KP
-extern EvaluationFunction<KRKB> EvaluateKRKB, EvaluateKBKR;    // KR vs KB
-extern EvaluationFunction<KRKN> EvaluateKRKN, EvaluateKNKR;    // KR vs KN
-extern EvaluationFunction<KQKR> EvaluateKQKR, EvaluateKRKQ;    // KQ vs KR
-extern EvaluationFunction<KBBKN> EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN
-extern EvaluationFunction<KmmKm> EvaluateKmmKm; // K and two minors vs K and one or two minors:
-
-extern ScalingFunction<KBPK> ScaleKBPK, ScaleKKBP;    // KBP vs K
-extern ScalingFunction<KQKRP> ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP
-extern ScalingFunction<KRPKR> ScaleKRPKR, ScaleKRKRP; // KRP vs KR
-extern ScalingFunction<KRPPKRP> ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP
-extern ScalingFunction<KPsK> ScaleKPsK, ScaleKKPs;    // King and pawns vs king
-extern ScalingFunction<KBPKB> ScaleKBPKB, ScaleKBKBP; // KBP vs KB
-extern ScalingFunction<KBPPKB> ScaleKBPPKB, ScaleKBKBPP; // KBPP vs KB
-extern ScalingFunction<KBPKN> ScaleKBPKN, ScaleKNKBP; // KBP vs KN
-extern ScalingFunction<KNPK> ScaleKNPK, ScaleKKNP;    // KNP vs K
-extern ScalingFunction<KPKP> ScaleKPKPw, ScaleKPKPb;  // KP vs KP
-
 ////
 //// Prototypes
 ////

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,6 +25,8 @@
 //// Includes
 ////
 
+#include <iostream>
+
 #include "material.h"
 #include "pawns.h"
 
@@ -46,14 +48,14 @@ class Position;
 struct EvalInfo {
 
   // Middle game and endgame evaluations
-  Value mgValue, egValue;
+  Score value;
 
   // Pointers to material and pawn hash table entries
   MaterialInfo* mi;
   PawnInfo* pi;
 
   // attackedBy[color][piece type] is a bitboard representing all squares
-  // attacked by a given color and piece type.  attackedBy[color][0] contains
+  // attacked by a given color and piece type, attackedBy[color][0] contains
   // all squares attacked by the given color.
   Bitboard attackedBy[2][8];
   Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
@@ -89,7 +91,7 @@ struct EvalInfo {
   Move mateThreat[2];
 
   // Middle game and endgame mobility scores.
-  Value mgMobility, egMobility;
+  Score mobility;
 
   // Extra futility margin. This is added to the standard futility margin
   // in the quiescence search.

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,39 +32,36 @@
 //// Functions
 ////
 
+
 /// Constructor
 
-History::History() {
+History::History() { clear(); }
-  this->clear();
-}
 
 
-/// History::clear() clears the history tables.
+/// History::clear() clears the history tables
 
 void History::clear() {
   memset(history, 0, 2 * 8 * 64 * sizeof(int));
-  memset(successCount, 0, 2 * 8 * 64 * sizeof(int));
-  memset(failureCount, 0, 2 * 8 * 64 * sizeof(int));
 }
 
 
 /// History::success() registers a move as being successful. This is done
 /// whenever a non-capturing move causes a beta cutoff in the main search.
-/// The three parameters are the moving piece, the move itself, and the
+/// The three parameters are the moving piece, the destination square, and
-/// search depth.
+/// the search depth.
+
+void History::success(Piece p, Square to, Depth d) {
 
-void History::success(Piece p, Move m, Depth d) {
   assert(piece_is_ok(p));
-  assert(move_is_ok(m));
+  assert(square_is_ok(to));
 
-  history[p][move_to(m)] += int(d) * int(d);
+  history[p][to] += int(d) * int(d);
-  successCount[p][move_to(m)]++;
 
-  // Prevent history overflow:
+  // Prevent history overflow
-  if(history[p][move_to(m)] >= HistoryMax)
+  if (history[p][to] >= HistoryMax)
       for (int i = 0; i < 16; i++)
           for (int j = 0; j < 64; j++)
-        history[i][j] /= 2;
+              history[i][j] /= 4;
 }
 
 
@@ -72,31 +69,24 @@ void History::success(Piece p, Move m, Depth d) {
 /// called for each non-capturing move which failed to produce a beta cutoff
 /// at a node where a beta cutoff was finally found.
 
-void History::failure(Piece p, Move m) {
+void History::failure(Piece p, Square to, Depth d) {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
 
-  failureCount[p][move_to(m)]++;
+  assert(piece_is_ok(p));
+  assert(square_is_ok(to));
+
+  history[p][to] -= int(d) * int(d);
+  if (history[p][to] < 0)
+      history[p][to] = 0;
 }
 
 
 /// History::move_ordering_score() returns an integer value used to order the
 /// non-capturing moves in the MovePicker class.
 
-int History::move_ordering_score(Piece p, Move m) const {
+int History::move_ordering_score(Piece p, Square to) const {
+
   assert(piece_is_ok(p));
-  assert(move_is_ok(m));
+  assert(square_is_ok(to));
 
-  return history[p][move_to(m)];
+  return history[p][to];
-}
-
-
-/// History::ok_to_prune() decides whether a move has been sufficiently
-/// unsuccessful that it makes sense to prune it entirely.
-
-bool History::ok_to_prune(Piece p, Move m, Depth d) const {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
-
-  return (int(d) * successCount[p][move_to(m)] < failureCount[p][move_to(m)]);
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -34,24 +34,24 @@
 //// Types
 ////
 
-/// The History class stores statistics about how often different moves have
+/// The History class stores statistics about how often different moves
-/// been successful or unsuccessful during the current search.  These
+/// have been successful or unsuccessful during the current search. These
-/// statistics are used for reduction and move ordering decisions.
+/// statistics are used for reduction and move ordering decisions. History
+/// entries are stored according only to moving piece and destination square,
+/// in particular two moves with different origin but same destination and
+/// same piece will be considered identical.
 
 class History {
 
 public:
   History();
   void clear();
-  void success(Piece p, Move m, Depth d);
+  void success(Piece p, Square to, Depth d);
-  void failure(Piece p, Move m);
+  void failure(Piece p, Square to, Depth d);
-  int move_ordering_score(Piece p, Move m) const;
+  int move_ordering_score(Piece p, Square to) const;
-  bool ok_to_prune(Piece p, Move m, Depth d) const;
 
 private:
   int history[16][64];  // [piece][square]
-  int successCount[16][64];
-  int failureCount[16][64];
 };
 
 
@@ -61,17 +61,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 2.  It is difficult to guess what
+/// entries in the table are divided by 4. 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.
-///
-/// Note that HistoryMax should probably be changed whenever the constant
-/// OnePly in depth.h is changed.  This is somewhat annoying.  Perhaps it
-/// would be better to scale down the history table at regular intervals?
 
-const int HistoryMax = 50000;
+const int HistoryMax = 25000 * 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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,8 +86,9 @@ typedef pthread_mutex_t Lock;
 
 #else
 
-
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
 
 typedef CRITICAL_SECTION Lock;
 #  define lock_init(x, y) InitializeCriticalSection(x)

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -17,29 +17,28 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+// To profile with callgrind uncomment following line
+//#define USE_CALLGRIND
+
 
 ////
 //// Includes
 ////
 
 #include <iostream>
+#include <string>
 
 #include "benchmark.h"
-#include "bitboard.h"
+#include "bitcount.h"
-#include "direction.h"
-#include "endgame.h"
-#include "evaluate.h"
-#include "material.h"
-#include "mersenne.h"
 #include "misc.h"
-#include "movepick.h"
-#include "position.h"
-#include "search.h"
-#include "thread.h"
 #include "uci.h"
-#include "ucioption.h"
 
-using std::string;
+#ifdef USE_CALLGRIND
+#include <valgrind/callgrind.h>
+#endif
+
+using namespace std;
+
 
 ////
 //// Functions
@@ -48,50 +47,43 @@ using std::string;
 int main(int argc, char *argv[]) {
 
   // Disable IO buffering
-  std::cout.rdbuf()->pubsetbuf(NULL, 0);
+  cout.rdbuf()->pubsetbuf(NULL, 0);
-  std::cin.rdbuf()->pubsetbuf(NULL, 0);
+  cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  // Initialization
+  // Initialization through global resources manager
-  init_mersenne();
+  Application::initialize();
-  init_direction_table();
-  init_bitboards();
-  init_uci_options();
-  Position::init_zobrist();
-  Position::init_piece_square_tables();
-  MovePicker::init_phase_table();
-  init_eval(1);
-  init_bitbases();
-  init_threads();
 
-  // Make random number generation less deterministic, for book moves
+#ifdef USE_CALLGRIND
-  for (int i = abs(get_system_time() % 10000); i > 0; i--)
+  CALLGRIND_START_INSTRUMENTATION;
-      genrand_int32();
+#endif
 
-  // Process command line arguments
+  // Process command line arguments if any
-  if (argc >= 2 && string(argv[1]) == "bench")
+  if (argc > 1)
   {
-      if (argc < 4 || argc > 7)
+      if (string(argv[1]) != "bench" || argc < 4 || argc > 8)
-      {
+          cout << "Usage: stockfish bench <hash size> <threads> "
-        std::cout << "Usage: stockfish bench <hash size> <threads> "
                << "[time = 60s] [fen positions file = default] "
-                  << "[time, depth or node limited = time]"
+               << "[time, depth, perft or node limited = time] "
-                  << std::endl;
+               << "[timing file name = none]" << endl;
-        exit(0);
+      else
-      }
+      {
           string time = argc > 4 ? argv[4] : "60";
           string fen = argc > 5 ? argv[5] : "default";
           string lim = argc > 6 ? argv[6] : "time";
-      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim);
+          string tim = argc > 7 ? argv[7] : "";
+          benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim + " " + tim);
+      }
       return 0;
   }
 
   // Print copyright notice
-  std::cout << engine_name() << ".  Copyright (C) "
+  cout << engine_name()
-            << "2004-2008 Tord Romstad, Marco Costalba. "
+       << ". By Tord Romstad, Marco Costalba, Joona Kiiski." << endl;
-            << std::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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -23,12 +23,13 @@
 ////
 
 #include <cassert>
-#include <cstring>
 #include <sstream>
 #include <map>
 
 #include "material.h"
 
+using namespace std;
+
 
 ////
 //// Local definitions
@@ -36,84 +37,119 @@
 
 namespace {
 
-  const Value BishopPairMidgameBonus = Value(109);
+  // Values modified by Joona Kiiski
-  const Value BishopPairEndgameBonus = Value(97);
+  const Value MidgameLimit = Value(15581);
+  const Value EndgameLimit = Value(3998);
 
-  Key KNNKMaterialKey, KKNNMaterialKey;
+  // Polynomial material balance parameters
+  const Value RedundantQueenPenalty = Value(320);
+  const Value RedundantRookPenalty  = Value(554);
 
+  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+
+  const int QuadraticCoefficientsSameColor[][6] = {
+  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
+  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
+
+  const int QuadraticCoefficientsOppositeColor[][6] = {
+  { 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;
 }
 
+
 ////
 //// Classes
 ////
 
-
+/// EndgameFunctions class stores endgame evaluation and scaling functions
-/// See header for a class description. It is declared here to avoid
+/// in two std::map. Because STL library is not guaranteed to be thread
-/// to include <map> in the header file.
+/// safe even for read access, the maps, although with identical content,
+/// are replicated for each thread. This is faster then using locks.
 
 class EndgameFunctions {
-
 public:
   EndgameFunctions();
-  EndgameEvaluationFunctionBase* getEEF(Key key) const;
+  ~EndgameFunctions();
-  EndgameScalingFunctionBase* getESF(Key key, Color* c) const;
+  template<class T> T* get(Key key) const;
 
 private:
-  void add(const std::string& keyCode, EndgameEvaluationFunctionBase* f);
+  template<class T> void add(const string& keyCode);
-  void add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f);
-  Key buildKey(const std::string& keyCode);
 
-  struct ScalingInfo
+  static Key buildKey(const string& keyCode);
-  {
+  static const string swapColors(const string& keyCode);
-      Color col;
+
-      EndgameScalingFunctionBase* fun;
+  // Here we store two maps, for evaluate and scaling functions
+  pair<map<Key, EF*>, map<Key, SF*> > maps;
+
+  // Maps accessing functions returning const and non-const references
+  template<typename T> const map<Key, T*>& get() const { return maps.first; }
+  template<typename T> map<Key, T*>& get() { return maps.first; }
 };
 
-  std::map<Key, EndgameEvaluationFunctionBase*> EEFmap;
+// Explicit specializations of a member function shall be declared in
-  std::map<Key, ScalingInfo> ESFmap;
+// the namespace of which the class template is a member.
-};
+template<> const map<Key, SF*>&
+EndgameFunctions::get<SF>() const { return maps.second; }
+
+template<> map<Key, SF*>&
+EndgameFunctions::get<SF>() { return maps.second; }
 
 
 ////
 //// Functions
 ////
 
-
+/// MaterialInfoTable c'tor and d'tor, called once by each thread
-/// Constructor for the MaterialInfoTable class
 
 MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {
 
   size = numOfEntries;
   entries = new MaterialInfo[size];
   funcs = new EndgameFunctions();
+
   if (!entries || !funcs)
   {
-      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
+      cerr << "Failed to allocate " << numOfEntries * sizeof(MaterialInfo)
-                << " bytes for material hash table." << std::endl;
+           << " bytes for material hash table." << endl;
-      exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
-  clear();
 }
 
-
-/// Destructor for the MaterialInfoTable class
-
 MaterialInfoTable::~MaterialInfoTable() {
 
-  delete [] entries;
   delete funcs;
+  delete [] entries;
 }
 
 
-/// MaterialInfoTable::clear() clears a material hash table by setting
+/// MaterialInfoTable::game_phase() calculates the phase given the current
-/// all entries to 0.
+/// position. Because the phase is strictly a function of the material, it
+/// is stored in MaterialInfo.
 
-void MaterialInfoTable::clear() {
+Phase MaterialInfoTable::game_phase(const Position& pos) {
 
-  memset(entries, 0, size * sizeof(MaterialInfo));
+  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
+
+  if (npm >= MidgameLimit)
+      return PHASE_MIDGAME;
+  else if (npm <= EndgameLimit)
+      return PHASE_ENDGAME;
+
+  return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
 }
 
-
 /// MaterialInfoTable::get_material_info() takes a position object as input,
 /// computes or looks up a MaterialInfo object, and returns a pointer to it.
 /// If the material configuration is not already present in the table, it
@@ -136,42 +172,37 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   mi->clear();
   mi->key = key;
 
-  // A special case before looking for a specialized evaluation function
+  // Store game phase
-  // KNN vs K is a draw.
+  mi->gamePhase = MaterialInfoTable::game_phase(pos);
-  if (key == KNNKMaterialKey || key == KKNNMaterialKey)
-  {
-      mi->factor[WHITE] = mi->factor[BLACK] = 0;
-      return mi;
-  }
 
   // Let's look if we have a specialized evaluation function for this
   // particular material configuration. First we look for a fixed
   // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->getEEF(key)) != NULL)
+  if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
       return mi;
 
   else if (   pos.non_pawn_material(BLACK) == Value(0)
            && pos.piece_count(BLACK, PAWN) == 0
-           && pos.non_pawn_material(WHITE) >= RookValueEndgame)
+           && pos.non_pawn_material(WHITE) >= RookValueMidgame)
   {
       mi->evaluationFunction = &EvaluateKXK;
       return mi;
   }
   else if (   pos.non_pawn_material(WHITE) == Value(0)
            && pos.piece_count(WHITE, PAWN) == 0
-           && pos.non_pawn_material(BLACK) >= RookValueEndgame)
+           && pos.non_pawn_material(BLACK) >= RookValueMidgame)
   {
       mi->evaluationFunction = &EvaluateKKX;
       return mi;
   }
-  else if (   pos.pawns() == EmptyBoardBB
+  else if (   pos.pieces(PAWN) == EmptyBoardBB
-           && pos.rooks() == EmptyBoardBB
+           && pos.pieces(ROOK) == EmptyBoardBB
-           && pos.queens() == EmptyBoardBB)
+           && pos.pieces(QUEEN) == EmptyBoardBB)
   {
-      // Minor piece endgame with at least one minor piece per side,
+      // Minor piece endgame with at least one minor piece per side and
-      // and no pawns.
+      // no pawns. Note that the case KmmK is already handled by KXK.
-      assert(pos.knights(WHITE) | pos.bishops(WHITE));
+      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
-      assert(pos.knights(BLACK) | pos.bishops(BLACK));
+      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
 
       if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
           && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
@@ -188,38 +219,40 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   // if we decide to add more special cases. We face problems when there
   // are several conflicting applicable scaling functions and we need to
   // decide which one to use.
-  Color c;
+  SF* sf;
-  EndgameScalingFunctionBase* sf;
 
-  if ((sf = funcs->getESF(key, &c)) != NULL)
+  if ((sf = funcs->get<SF>(key)) != NULL)
   {
-      mi->scalingFunction[c] = sf;
+      mi->scalingFunction[sf->color()] = sf;
       return mi;
   }
 
+  // Generic scaling functions that refer to more then one material
+  // distribution. Should be probed after the specialized ones.
+  // Note that these ones don't return after setting the function.
   if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
       && pos.piece_count(WHITE, BISHOP) == 1
       && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKBPK;
+      mi->scalingFunction[WHITE] = &ScaleKBPsK;
 
   if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
       && pos.piece_count(BLACK, BISHOP) == 1
       && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKKBP;
+      mi->scalingFunction[BLACK] = &ScaleKKBPs;
 
   if (   pos.piece_count(WHITE, PAWN) == 0
       && pos.non_pawn_material(WHITE) == QueenValueMidgame
       && pos.piece_count(WHITE, QUEEN) == 1
       && pos.piece_count(BLACK, ROOK) == 1
       && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKQKRP;
+      mi->scalingFunction[WHITE] = &ScaleKQKRPs;
 
   else if (   pos.piece_count(BLACK, PAWN) == 0
            && pos.non_pawn_material(BLACK) == QueenValueMidgame
            && pos.piece_count(BLACK, QUEEN) == 1
            && pos.piece_count(WHITE, ROOK) == 1
            && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKRPKQ;
+      mi->scalingFunction[BLACK] = &ScaleKRPsKQ;
 
   if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
   {
@@ -235,6 +268,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
       }
       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[BLACK] = &ScaleKPKPb;
       }
@@ -253,10 +288,13 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   }
 
   // Evaluate the material balance
-
+  const int pieceCount[2][6] = { { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
-  int sign;
+                                   pos.piece_count(WHITE, BISHOP), pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
-  Value egValue = Value(0);
+                                 { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
-  Value mgValue = Value(0);
+                                   pos.piece_count(BLACK, BISHOP), pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+  Color c, them;
+  int sign, pt1, pt2, pc;
+  int v, vv, matValue = 0;
 
   for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
   {
@@ -283,85 +321,81 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
         }
     }
 
-    // Bishop pair
+    // Redundancy of major pieces, formula based on Kaufman's paper
-    if (pos.piece_count(c, BISHOP) >= 2)
+    // "The Evaluation of Material Imbalances in Chess"
-    {
-        mgValue += sign * BishopPairMidgameBonus;
-        egValue += sign * BishopPairEndgameBonus;
-    }
-
-    // Knights are stronger when there are many pawns on the board.  The
-    // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess":
     // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
+    if (pieceCount[c][ROOK] >= 1)
-    egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
+        matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty);
 
-    // Redundancy of major pieces, again based on Kaufman's paper:
+    them = opposite_color(c);
-    if (pos.piece_count(c, ROOK) >= 1)
+    v = 0;
+
+    // Second-degree polynomial material imbalance by Tord Romstad
+    //
+    // We use NO_PIECE_TYPE as a place holder for the bishop pair "extended piece",
+    // this allow us to be more flexible in defining bishop pair bonuses.
+    for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
     {
-        Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
+        pc = pieceCount[c][pt1];
-        mgValue -= sign * v;
+        if (!pc)
-        egValue -= sign * v;
+            continue;
+
+        vv = LinearCoefficients[pt1];
+
+        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+            vv +=  pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2]
+                 + pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
+
+        v += pc * vv;
     }
+    matValue += sign * v;
   }
-  mi->mgValue = int16_t(mgValue);
+  mi->value = int16_t(matValue / 16);
-  mi->egValue = int16_t(egValue);
   return mi;
 }
 
 
-/// EndgameFunctions member definitions. This class is used to store the maps
+/// EndgameFunctions member definitions.
-/// of end game and scaling functions that MaterialInfoTable will query for
-/// each key. The maps are constant and are populated only at construction,
-/// but are per-thread instead of globals to avoid expensive locks.
 
 EndgameFunctions::EndgameFunctions() {
 
-  KNNKMaterialKey = buildKey("KNNK");
+  add<EvaluationFunction<KNNK>  >("KNNK");
-  KKNNMaterialKey = buildKey("KKNN");
+  add<EvaluationFunction<KPK>   >("KPK");
+  add<EvaluationFunction<KBNK>  >("KBNK");
+  add<EvaluationFunction<KRKP>  >("KRKP");
+  add<EvaluationFunction<KRKB>  >("KRKB");
+  add<EvaluationFunction<KRKN>  >("KRKN");
+  add<EvaluationFunction<KQKR>  >("KQKR");
+  add<EvaluationFunction<KBBKN> >("KBBKN");
 
-  add("KPK",   &EvaluateKPK);
+  add<ScalingFunction<KNPK>    >("KNPK");
-  add("KKP",   &EvaluateKKP);
+  add<ScalingFunction<KRPKR>   >("KRPKR");
-  add("KBNK",  &EvaluateKBNK);
+  add<ScalingFunction<KBPKB>   >("KBPKB");
-  add("KKBN",  &EvaluateKKBN);
+  add<ScalingFunction<KBPPKB>  >("KBPPKB");
-  add("KRKP",  &EvaluateKRKP);
+  add<ScalingFunction<KBPKN>   >("KBPKN");
-  add("KPKR",  &EvaluateKPKR);
+  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-  add("KRKB",  &EvaluateKRKB);
+  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-  add("KBKR",  &EvaluateKBKR);
-  add("KRKN",  &EvaluateKRKN);
-  add("KNKR",  &EvaluateKNKR);
-  add("KQKR",  &EvaluateKQKR);
-  add("KRKQ",  &EvaluateKRKQ);
-  add("KBBKN", &EvaluateKBBKN);
-  add("KNKBB", &EvaluateKNKBB);
-
-  add("KNPK",    WHITE, &ScaleKNPK);
-  add("KKNP",    BLACK, &ScaleKKNP);
-  add("KRPKR",   WHITE, &ScaleKRPKR);
-  add("KRKRP",   BLACK, &ScaleKRKRP);
-  add("KBPKB",   WHITE, &ScaleKBPKB);
-  add("KBKBP",   BLACK, &ScaleKBKBP);
-  add("KBPPKB",  WHITE, &ScaleKBPPKB);
-  add("KBKBPP",  BLACK, &ScaleKBKBPP);
-  add("KBPKN",   WHITE, &ScaleKBPKN);
-  add("KNKBP",   BLACK, &ScaleKNKBP);
-  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
-  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
-  add("KRPPKRP", WHITE, &ScaleKRPPKRP);
-  add("KRPKRPP", BLACK, &ScaleKRPKRPP);
 }
 
-Key EndgameFunctions::buildKey(const std::string& keyCode) {
+EndgameFunctions::~EndgameFunctions() {
+
+    for (map<Key, EF*>::iterator it = maps.first.begin(); it != maps.first.end(); ++it)
+        delete (*it).second;
+
+    for (map<Key, SF*>::iterator it = maps.second.begin(); it != maps.second.end(); ++it)
+        delete (*it).second;
+}
+
+Key EndgameFunctions::buildKey(const string& keyCode) {
 
     assert(keyCode.length() > 0 && keyCode[0] == 'K');
     assert(keyCode.length() < 8);
 
-    std::stringstream s;
+    stringstream s;
     bool upcase = false;
 
-    // Build up a fen substring with the given pieces, note
+    // Build up a fen string with the given pieces, note that
-    // that the fen string could be of an illegal position.
+    // the fen string could be of an illegal position.
     for (size_t i = 0; i < keyCode.length(); i++)
     {
         if (keyCode[i] == 'K')
@@ -373,29 +407,25 @@ Key EndgameFunctions::buildKey(const std::string& keyCode) {
     return Position(s.str()).get_material_key();
 }
 
-void EndgameFunctions::add(const std::string& keyCode, EndgameEvaluationFunctionBase* f) {
+const string EndgameFunctions::swapColors(const string& keyCode) {
 
-  EEFmap.insert(std::pair<Key, EndgameEvaluationFunctionBase*>(buildKey(keyCode), f));
+    // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
+    size_t idx = keyCode.find("K", 1);
+    return keyCode.substr(idx) + keyCode.substr(0, idx);
 }
 
-void EndgameFunctions::add(const std::string& keyCode, Color c, EndgameScalingFunctionBase* f) {
+template<class T>
+void EndgameFunctions::add(const string& keyCode) {
 
-  ScalingInfo s = {c, f};
+  typedef typename T::Base F;
-  ESFmap.insert(std::pair<Key, ScalingInfo>(buildKey(keyCode), s));
+
+  get<F>().insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
+  get<F>().insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
 }
 
-EndgameEvaluationFunctionBase* EndgameFunctions::getEEF(Key key) const {
+template<class T>
+T* EndgameFunctions::get(Key key) const {
 
-  std::map<Key, EndgameEvaluationFunctionBase*>::const_iterator it(EEFmap.find(key));
+  typename map<Key, T*>::const_iterator it(get<T>().find(key));
-  return (it != EEFmap.end() ? it->second : NULL);
+  return (it != get<T>().end() ? it->second : NULL);
-}
-
-EndgameScalingFunctionBase* EndgameFunctions::getESF(Key key, Color* c) const {
-
-  std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
-  if (it == ESFmap.end())
-      return NULL;
-
-  *c = it->second.col;
-  return it->second.fun;
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,47 +49,42 @@ class MaterialInfo {
   friend class MaterialInfoTable;
 
 public:
-  Value mg_value() const;
+  MaterialInfo() : key(0) { clear(); }
-  Value eg_value() const;
+
+  Score material_value() const;
   ScaleFactor scale_factor(const Position& pos, Color c) const;
   int space_weight() const;
+  Phase game_phase() const;
   bool specialized_eval_exists() const;
   Value evaluate(const Position& pos) const;
 
 private:
-  void clear();
+  inline void clear();
 
   Key key;
-  int16_t mgValue;
+  int16_t value;
-  int16_t egValue;
   uint8_t factor[2];
   EndgameEvaluationFunctionBase* evaluationFunction;
   EndgameScalingFunctionBase* scalingFunction[2];
   int spaceWeight;
+  Phase gamePhase;
 };
 
-
-/// EndgameFunctions class stores the endgame evaluation functions std::map.
-/// Because STL library is not thread safe even for read access, the maps,
-/// although with identical content, are replicated for each thread. This
-/// is faster then using locks with an unique set of global maps.
-
-class EndgameFunctions;
-
-
 /// The MaterialInfoTable class represents a pawn hash table. It is basically
 /// just an array of MaterialInfo objects and a few methods for accessing these
 /// objects. The most important method is get_material_info, which looks up a
 /// position in the table and returns a pointer to a MaterialInfo object.
+class EndgameFunctions;
 
 class MaterialInfoTable {
 
 public:
   MaterialInfoTable(unsigned numOfEntries);
   ~MaterialInfoTable();
-  void clear();
   MaterialInfo* get_material_info(const Position& pos);
 
+  static Phase game_phase(const Position& pos);
+
 private:
   unsigned size;
   MaterialInfo* entries;
@@ -101,30 +96,26 @@ private:
 //// Inline functions
 ////
 
-/// MaterialInfo::mg_value and MaterialInfo::eg_value simply returns the
-/// material balance evaluation for the middle game and the endgame.
 
-inline Value MaterialInfo::mg_value() const {
+/// MaterialInfo::material_value simply returns the material balance
+/// evaluation that is independent from game phase.
 
-  return Value(mgValue);
+inline Score MaterialInfo::material_value() const {
-}
 
-inline Value MaterialInfo::eg_value() const {
+  return make_score(value, value);
-
-  return Value(egValue);
 }
 
 
 /// MaterialInfo::clear() resets a MaterialInfo object to an empty state,
-/// with all slots at their default values.
+/// with all slots at their default values but the key.
 
 inline void MaterialInfo::clear() {
 
-  mgValue = egValue = 0;
+  value = 0;
   factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
-  spaceWeight = 0;
   evaluationFunction = NULL;
   scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
+  spaceWeight = 0;
 }
 
 
@@ -155,6 +146,14 @@ inline int MaterialInfo::space_weight() const {
   return spaceWeight;
 }
 
+/// MaterialInfo::game_phase() returns the game phase according
+/// to this material configuration.
+
+inline Phase MaterialInfo::game_phase() const {
+
+  return gamePhase;
+}
+
 
 /// MaterialInfo::specialized_eval_exists decides whether there is a
 /// specialized evaluation function for the current material configuration,

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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/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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,32 +29,10 @@
 #  include <unistd.h>
 
 #else
-/*
-   (c) Copyright 1992 Eric Backus
 
-   This software may be used freely so long as this copyright notice is
+#define _CRT_SECURE_NO_DEPRECATE
-   left intact. There is no warrantee on this software.
-*/
 #include <windows.h>
-#  include <time.h>
+#include <sys/timeb.h>
-#  include "dos.h"
-static int gettimeofday(struct timeval* tp, struct timezone*)
-{
-    SYSTEMTIME systime;
-
-    if (tp)
-    {
-        struct tm tmrec;
-        time_t theTime = time(NULL);
-
-        tmrec = *localtime(&theTime);
-        tp->tv_sec = mktime(&tmrec);
-        GetLocalTime(&systime); /* system time */
-
-        tp->tv_usec = systime.wMilliseconds * 1000;
-    }
-    return 0;
-}
 
 #endif
 
@@ -64,6 +42,7 @@ static int gettimeofday(struct timeval* tp, struct timezone*)
 #include <iostream>
 #include <sstream>
 
+#include "bitcount.h"
 #include "misc.h"
 
 using namespace std;
@@ -71,7 +50,7 @@ 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.3.1";
+static const string EngineVersion = "1.6.2";
 static const string AppName = "Stockfish";
 static const string AppTag  = "";
 
@@ -80,8 +59,10 @@ static const string AppTag  = "";
 //// Variables
 ////
 
-long dbg_cnt0 = 0;
+bool Chess960;
-long dbg_cnt1 = 0;
+
+uint64_t dbg_cnt0 = 0;
+uint64_t dbg_cnt1 = 0;
 
 bool dbg_show_mean = false;
 bool dbg_show_hit_rate = false;
@@ -159,8 +140,10 @@ void dbg_print_mean(ofstream& logFile) {
 
 const string engine_name() {
 
+  const string cpu64(CpuHas64BitPath ? " 64bit" : "");
+
   if (!EngineVersion.empty())
-      return "Stockfish " + EngineVersion;
+      return AppName+ " " + EngineVersion + cpu64;
 
   string date(__DATE__); // From compiler, format is "Sep 21 2008"
   string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
@@ -173,7 +156,7 @@ const string engine_name() {
   string name = AppName + " " + AppTag + " ";
 
   s << name << date.substr(date.length() - 2) << setfill('0')
-    << setw(2) << mon << setw(2) << day;
+    << setw(2) << mon << setw(2) << day << cpu64;
 
   return s.str();
 }
@@ -183,9 +166,16 @@ const string engine_name() {
 /// milliseconds.
 
 int get_system_time() {
+
+#if defined(_MSC_VER)
+    struct _timeb t;
+    _ftime(&t);
+    return int(t.time*1000 + t.millitm);
+#else
     struct timeval t;
     gettimeofday(&t, NULL);
     return t.tv_sec*1000 + t.tv_usec/1000;
+#endif
 }
 
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,6 +29,8 @@
 #include <fstream>
 #include <string>
 
+#include "application.h"
+#include "types.h"
 
 ////
 //// Macros
@@ -38,6 +40,13 @@
 #define Max(x, y) (((x) < (y))? (y) : (x))
 
 
+////
+//// Variables
+////
+
+extern bool Chess960;
+
+
 ////
 //// Prototypes
 ////
@@ -47,6 +56,7 @@ extern int get_system_time();
 extern int cpu_count();
 extern int Bioskey();
 
+
 ////
 //// Debug
 ////
@@ -54,8 +64,8 @@ extern int Bioskey();
 extern bool dbg_show_mean;
 extern bool dbg_show_hit_rate;
 
-extern long dbg_cnt0;
+extern uint64_t dbg_cnt0;
-extern long dbg_cnt1;
+extern uint64_t dbg_cnt1;
 
 extern void dbg_hit_on(bool b);
 extern void dbg_hit_on_c(bool c, bool b);

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 "move.h"
 #include "piece.h"
 #include "position.h"
-#include "ucioption.h"
 
 
 ////
@@ -130,8 +129,8 @@ const std::string move_to_string(Move move) {
               return (from == SQ_E1 ? "e1c1" : "e8c8");
       }
       str = square_to_string(from) + square_to_string(to);
-      if (move_promotion(move))
+      if (move_is_promotion(move))
-          str += piece_type_to_char(move_promotion(move), false);
+          str += piece_type_to_char(move_promotion_piece(move), false);
   }
   return str;
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -62,9 +62,103 @@ struct MoveStack {
   int score;
 };
 
-// Note that operator< is set up such that std::sort() will sort in descending order
+// Note that operator< is set up such that sorting will be in descending order
 inline bool operator<(const MoveStack& f, const MoveStack& s) { return s.score < f.score; }
 
+// An helper insertion sort implementation
+template<typename T>
+inline void insertion_sort(T* firstMove, T* lastMove)
+{
+    T value;
+    T *cur, *p, *d;
+
+    if (firstMove != lastMove)
+        for (cur = firstMove + 1; cur != lastMove; cur++)
+        {
+            p = d = cur;
+            value = *p--;
+            if (value < *p)
+            {
+                do *d = *p;
+                while (--d != firstMove && value < *--p);
+                *d = value;
+            }
+        }
+}
+
+// Our dedicated sort in range [firstMove, lastMove), it is well
+// tuned for non-captures where we have a lot of zero scored moves.
+template<typename T>
+inline void sort_moves(T* firstMove, T* lastMove)
+{
+    T tmp;
+    T *p, *d;
+
+    d = lastMove;
+    p = firstMove - 1;
+
+    d->score = -1; // right guard
+
+    // Split positives vs non-positives
+    do {
+        while ((++p)->score > 0);
+
+        if (p != d)
+        {
+            while (--d != p && d->score <= 0);
+
+            tmp = *p;
+            *p = *d;
+            *d = tmp;
+        }
+
+    } while (p != d);
+
+    // Sort positives
+    insertion_sort<T>(firstMove, 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.
+// It is faster then sorting all the moves in advance when moves are few,
+// as normally are the possible captures. Note that is not a stable alghoritm.
+template<typename T>
+inline T pick_best(T* curMove, T* lastMove)
+{
+    T bestMove, tmp;
+
+    bestMove = *curMove;
+    while (++curMove != lastMove)
+    {
+        if (*curMove < bestMove)
+        {
+            tmp = *curMove;
+            *curMove = bestMove;
+            bestMove = tmp;
+        }
+    }
+    return bestMove;
+}
 
 ////
 //// Inline functions
@@ -78,16 +172,24 @@ inline Square move_to(Move m) {
   return Square(m & 0x3F);
 }
 
-inline PieceType move_promotion(Move m) {
+inline PieceType move_promotion_piece(Move m) {
   return PieceType((int(m) >> 12) & 7);
 }
 
-inline bool move_is_ep(Move m) {
+inline int move_is_special(Move m) {
-  return bool((int(m) >> 15) & 1);
+  return m & (0x1F << 12);
 }
 
-inline bool move_is_castle(Move m) {
+inline int move_is_promotion(Move m) {
-  return bool((int(m) >> 16) & 1);
+  return m & (7 << 12);
+}
+
+inline int move_is_ep(Move m) {
+  return m & (1 << 15);
+}
+
+inline int move_is_castle(Move m) {
+  return m & (1 << 16);
 }
 
 inline bool move_is_short_castle(Move m) {

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,12 +32,13 @@
 //// Prototypes
 ////
 
-extern int generate_captures(const Position& pos, MoveStack* mlist);
+extern MoveStack* generate_captures(const Position& pos, MoveStack* mlist);
-extern int generate_noncaptures(const Position& pos, MoveStack* mlist);
+extern MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist);
-extern int generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc);
+extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist);
-extern int generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned);
+extern MoveStack* generate_evasions(const Position& pos, MoveStack* mlist);
-extern int generate_legal_moves(const Position& pos, MoveStack* mlist);
+extern MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLegal = false);
 extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
+extern bool move_is_legal(const Position& pos, const Move m);
 
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -23,11 +23,9 @@
 //// Includes
 ////
 
-#include <algorithm>
 #include <cassert>
 
 #include "history.h"
-#include "evaluate.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
@@ -40,14 +38,23 @@
 
 namespace {
 
-  /// Variables
+  enum MovegenPhase {
-
+    PH_TT_MOVES,       // Transposition table move and mate killer
-  MovePicker::MovegenPhase PhaseTable[32];
+    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-  int MainSearchPhaseIndex;
+    PH_KILLERS,        // Killer moves from the current ply
-  int EvasionsPhaseIndex;
+    PH_NONCAPTURES,    // Non-captures and underpromotions
-  int QsearchWithChecksPhaseIndex;
+    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
-  int QsearchWithoutChecksPhaseIndex;
+    PH_EVASIONS,       // Check evasions
+    PH_QCAPTURES,      // Captures in quiescence search
+    PH_QCHECKS,        // Non-capture checks in quiescence search
+    PH_STOP
+  };
 
+  CACHE_LINE_ALIGNMENT
+  const uint8_t MainSearchPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP};
+  const uint8_t EvasionsPhaseTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP};
+  const uint8_t QsearchWithChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP};
+  const uint8_t QsearchWithoutChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP};
 }
 
 
@@ -63,39 +70,187 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(const Position& p, bool pv, Move ttm,
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
-                       const SearchStack& ss, Depth d) : pos(p) {
+                       const History& h, SearchStack* ss) : pos(p), H(h) {
-  pvNode = pv;
+  int searchTT = ttm;
-  ttMove = ttm;
+  ttMoves[0].move = ttm;
-  mateKiller = (ss.mateKiller == ttm)? MOVE_NONE : ss.mateKiller;
+  finished = false;
-  killer1 = ss.killers[0];
+  lastBadCapture = badCaptures;
-  killer2 = ss.killers[1];
+
-  depth = d;
+  pinned = p.pinned_pieces(pos.side_to_move());
-  movesPicked = 0;
+
-  numOfMoves = 0;
+  if (ss && !p.is_check())
-  numOfBadCaptures = 0;
+  {
+      ttMoves[1].move = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
+      searchTT |= ttMoves[1].move;
+      killers[0].move = ss->killers[0];
+      killers[1].move = ss->killers[1];
+  } else
+      ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
 
   if (p.is_check())
-      phaseIndex = EvasionsPhaseIndex;
+      phasePtr = EvasionsPhaseTable;
-  else if (depth > Depth(0))
+  else if (d > Depth(0))
-      phaseIndex = MainSearchPhaseIndex;
+      phasePtr = MainSearchPhaseTable;
-  else if (depth == Depth(0))
+  else if (d == Depth(0))
-      phaseIndex = QsearchWithChecksPhaseIndex;
+      phasePtr = QsearchWithChecksPhaseTable;
   else
-      phaseIndex = QsearchWithoutChecksPhaseIndex;
+      phasePtr = QsearchWithoutChecksPhaseTable;
 
-  Color us = pos.side_to_move();
+  phasePtr += !searchTT - 1;
-
+  go_next_phase();
-  dc = p.discovered_check_candidates(us);
-  pinned = p.pinned_pieces(us);
-
-  finished = false;
 }
 
 
+/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
+/// of moves when there are no more moves to try for the current phase.
+
+void MovePicker::go_next_phase() {
+
+  curMove = moves;
+  phase = *(++phasePtr);
+  switch (phase) {
+
+  case PH_TT_MOVES:
+      curMove = ttMoves;
+      lastMove = curMove + 2;
+      return;
+
+  case PH_GOOD_CAPTURES:
+      lastMove = generate_captures(pos, moves);
+      score_captures();
+      return;
+
+  case PH_KILLERS:
+      curMove = killers;
+      lastMove = curMove + 2;
+      return;
+
+  case PH_NONCAPTURES:
+      lastMove = generate_noncaptures(pos, moves);
+      score_noncaptures();
+      sort_moves(moves, lastMove);
+      return;
+
+  case PH_BAD_CAPTURES:
+      // Bad captures SEE value is already calculated so just sort them
+      // to get SEE move ordering.
+      curMove = badCaptures;
+      lastMove = lastBadCapture;
+      return;
+
+  case PH_EVASIONS:
+      assert(pos.is_check());
+      lastMove = generate_evasions(pos, moves);
+      score_evasions();
+      return;
+
+  case PH_QCAPTURES:
+      lastMove = generate_captures(pos, moves);
+      score_captures();
+      return;
+
+  case PH_QCHECKS:
+      // Perhaps we should order moves move here?  FIXME
+      lastMove = generate_non_capture_checks(pos, moves);
+      return;
+
+  case PH_STOP:
+      lastMove = curMove + 1; // hack to be friendly for get_next_move()
+      return;
+
+  default:
+      assert(false);
+      return;
+  }
+}
+
+
+/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
+/// MovePicker::score_evasions() assign a numerical move ordering score
+/// to each move in a move list.  The moves with highest scores will be
+/// picked first by get_next_move().
+
+void MovePicker::score_captures() {
+  // Winning and equal captures in the main search are ordered by MVV/LVA.
+  // Suprisingly, this appears to perform slightly better than SEE based
+  // move ordering. The reason is probably that in a position with a winning
+  // capture, capturing a more valuable (but sufficiently defended) piece
+  // first usually doesn't hurt. The opponent will have to recapture, and
+  // the hanging piece will still be hanging (except in the unusual cases
+  // where it is possible to recapture with the hanging piece). Exchanging
+  // big pieces before capturing a hanging piece probably helps to reduce
+  // the subtree size.
+  // In main search we want to push captures with negative SEE values to
+  // badCaptures[] array, but instead of doing it now we delay till when
+  // the move has been picked up in pick_move_from_list(), this way we save
+  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
+  Move m;
+
+  // Use MVV/LVA ordering
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      if (move_is_promotion(m))
+          cur->score = QueenValueMidgame;
+      else
+          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
+                      - pos.type_of_piece_on(move_from(m));
+  }
+}
+
+void MovePicker::score_noncaptures() {
+  // First score by history, when no history is available then use
+  // piece/square tables values. This seems to be better then a
+  // random choice when we don't have an history for any move.
+  Move m;
+  Piece piece;
+  Square from, to;
+  int hs;
+
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      from = move_from(m);
+      to = move_to(m);
+      piece = pos.piece_on(from);
+      hs = H.move_ordering_score(piece, to);
+
+      // Ensure history is always preferred to pst
+      if (hs > 0)
+          hs += 1000;
+
+      // pst based scoring
+      cur->score = hs + mg_value(pos.pst_delta(piece, from, to));
+  }
+}
+
+void MovePicker::score_evasions() {
+  // Try good captures ordered by MVV/LVA, then non-captures if
+  // destination square is not under attack, ordered by history
+  // value, and at the end bad-captures and non-captures with a
+  // negative SEE. This last group is ordered by the SEE score.
+  Move m;
+  int seeScore;
+
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      if ((seeScore = pos.see_sign(m)) < 0)
+          cur->score = seeScore;
+      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;
+      else
+          cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
+  }
+}
+
 /// MovePicker::get_next_move() is the most important method of the MovePicker
 /// class. It returns a new legal move every time it is called, until there
-/// are no more moves left of the types we are interested in.
+/// 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.
 
 Move MovePicker::get_next_move() {
 
@@ -103,75 +258,74 @@ Move MovePicker::get_next_move() {
 
   while (true)
   {
-    // If we already have a list of generated moves, pick the best move from
+      while (curMove != lastMove)
-    // the list, and return it.
-    move = pick_move_from_list();
-    if (move != MOVE_NONE)
       {
-        assert(move_is_ok(move));
+          switch (phase) {
+
+          case PH_TT_MOVES:
+              move = (curMove++)->move;
+              if (   move != MOVE_NONE
+                  && move_is_legal(pos, move, pinned))
                   return move;
-    }
-
-    // Next phase
-    phaseIndex++;
-    switch (PhaseTable[phaseIndex]) {
-
-    case PH_TT_MOVE:
-        if (ttMove != MOVE_NONE)
-        {
-            assert(move_is_ok(ttMove));
-            if (move_is_legal(pos, ttMove, pinned))
-                return ttMove;
-        }
-        break;
-
-    case PH_MATE_KILLER:
-        if (mateKiller != MOVE_NONE)
-        {
-            assert(move_is_ok(mateKiller));
-            if (move_is_legal(pos, mateKiller, pinned))
-                return mateKiller;
-        }
               break;
 
           case PH_GOOD_CAPTURES:
-        numOfMoves = generate_captures(pos, moves);
+              move = pick_best(curMove++, lastMove).move;
-        score_captures();
+              if (   move != ttMoves[0].move
-        std::sort(moves, moves + numOfMoves);
+                  && move != ttMoves[1].move
-        movesPicked = 0;
+                  && pos.pl_move_is_legal(move, pinned))
+              {
+                  // Check for a non negative SEE now
+                  int seeValue = pos.see_sign(move);
+                  if (seeValue >= 0)
+                      return move;
+
+                  // Losing capture, move it to the badCaptures[] array, note
+                  // that move has now been already checked for legality.
+                  assert(int(lastBadCapture - badCaptures) < 63);
+                  lastBadCapture->move = move;
+                  lastBadCapture->score = seeValue;
+                  lastBadCapture++;
+              }
               break;
 
-    case PH_BAD_CAPTURES:
+          case PH_KILLERS:
-        // It's probably a good idea to use SEE move ordering here. FIXME
+              move = (curMove++)->move;
-        movesPicked = 0;
+              if (   move != MOVE_NONE
+                  && 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:
-        numOfMoves = generate_noncaptures(pos, moves);
+              move = (curMove++)->move;
-        score_noncaptures();
+              if (   move != ttMoves[0].move
-        std::sort(moves, moves + numOfMoves);
+                  && move != ttMoves[1].move
-        movesPicked = 0;
+                  && move != killers[0].move
+                  && move != killers[1].move
+                  && pos.pl_move_is_legal(move, pinned))
+                  return move;
               break;
 
+          case PH_BAD_CAPTURES:
+              move = pick_best(curMove++, lastMove).move;
+              return move;
+
           case PH_EVASIONS:
-        assert(pos.is_check());
-        numOfMoves = generate_evasions(pos, moves, pinned);
-        score_evasions();
-        std::sort(moves, moves + numOfMoves);
-        movesPicked = 0;
-        break;
-
           case PH_QCAPTURES:
-        numOfMoves = generate_captures(pos, moves);
+              move = pick_best(curMove++, lastMove).move;
-        score_qcaptures();
+              if (   move != ttMoves[0].move
-        std::sort(moves, moves + numOfMoves);
+                  && pos.pl_move_is_legal(move, pinned))
-        movesPicked = 0;
+                  return move;
               break;
 
           case PH_QCHECKS:
-        // Perhaps we should order moves move here?  FIXME
+              move = (curMove++)->move;
-        numOfMoves = generate_non_capture_checks(pos, moves, dc);
+              if (   move != ttMoves[0].move
-        movesPicked = 0;
+                  && pos.pl_move_is_legal(move, pinned))
+                  return move;
               break;
 
           case PH_STOP:
@@ -179,11 +333,12 @@ Move MovePicker::get_next_move() {
 
           default:
               assert(false);
-        return MOVE_NONE;
+              break;
           }
       }
+      go_next_phase();
+  }
 }
-
 
 /// 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.
@@ -203,206 +358,3 @@ Move MovePicker::get_next_move(Lock &lock) {
    lock_release(&lock);
    return m;
 }
-
-
-/// MovePicker::score_captures(), MovePicker::score_noncaptures(),
-/// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
-/// numerical move ordering score to each move in a move list.  The moves
-/// with highest scores will be picked first by pick_move_from_list().
-
-void MovePicker::score_captures() {
-  // Winning and equal captures in the main search are ordered by MVV/LVA.
-  // Suprisingly, this appears to perform slightly better than SEE based
-  // move ordering.  The reason is probably that in a position with a winning
-  // capture, capturing a more valuable (but sufficiently defended) piece
-  // first usually doesn't hurt.  The opponent will have to recapture, and
-  // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece). Exchanging
-  // big pieces before capturing a hanging piece probably helps to reduce
-  // the subtree size.
-  // While scoring captures it moves all captures with negative SEE values
-  // to the badCaptures[] array.
-  Move m;
-  int seeValue;
-
-  for (int i = 0; i < numOfMoves; i++)
-  {
-      m = moves[i].move;
-      seeValue = pos.see(m);
-      if (seeValue >= 0)
-      {
-          if (move_promotion(m))
-              moves[i].score = QueenValueMidgame;
-          else
-              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                              -int(pos.type_of_piece_on(move_from(m)));
-      }
-      else
-      {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          moves[i].score = seeValue;
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-      }
-  }
-}
-
-void MovePicker::score_noncaptures() {
-  // First score by history, when no history is available then use
-  // piece/square tables values. This seems to be better then a
-  // random choice when we don't have an history for any move.
-  Move m;
-  int hs;
-
-  for (int i = 0; i < numOfMoves; i++)
-  {
-      m = moves[i].move;
-
-      if (m == killer1)
-          hs = HistoryMax + 2;
-      else if (m == killer2)
-          hs = HistoryMax + 1;
-      else
-          hs = H.move_ordering_score(pos.piece_on(move_from(m)), m);
-
-      // Ensure history is always preferred to pst
-      if (hs > 0)
-          hs += 1000;
-
-      // pst based scoring
-      moves[i].score = hs + pos.mg_pst_delta(m);
-  }
-}
-
-void MovePicker::score_evasions() {
-
-  for (int i = 0; i < numOfMoves; i++)
-  {
-      Move m = moves[i].move;
-      if (m == ttMove)
-          moves[i].score = 2*HistoryMax;
-      else if (!pos.square_is_empty(move_to(m)))
-      {
-          int seeScore = pos.see(m);
-          moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
-      } else
-          moves[i].score = H.move_ordering_score(pos.piece_on(move_from(m)), m);
-  }
-}
-
-void MovePicker::score_qcaptures() {
-
-  // Use MVV/LVA ordering
-  for (int i = 0; i < numOfMoves; i++)
-  {
-      Move m = moves[i].move;
-      if (move_promotion(m))
-          moves[i].score = QueenValueMidgame;
-      else
-          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                          -int(pos.type_of_piece_on(move_from(m)));
-  }
-}
-
-
-/// MovePicker::pick_move_from_list() picks the move with the biggest score
-/// from a list of generated moves (moves[] or badCaptures[], depending on
-/// the current move generation phase).  It takes care not to return the
-/// transposition table move if that has already been serched previously.
-
-Move MovePicker::pick_move_from_list() {
-
-  assert(movesPicked >= 0);
-  assert(!pos.is_check() || PhaseTable[phaseIndex] == PH_EVASIONS || PhaseTable[phaseIndex] == PH_STOP);
-  assert( pos.is_check() || PhaseTable[phaseIndex] != PH_EVASIONS);
-
-  switch (PhaseTable[phaseIndex]) {
-
-  case PH_GOOD_CAPTURES:
-  case PH_NONCAPTURES:
-      while (movesPicked < numOfMoves)
-      {
-          Move move = moves[movesPicked++].move;
-          if (   move != ttMove
-              && move != mateKiller
-              && pos.pl_move_is_legal(move, pinned))
-              return move;
-      }
-      break;
-
-  case PH_EVASIONS:
-      if (movesPicked < numOfMoves)
-          return moves[movesPicked++].move;
-
-      break;
-
-  case PH_BAD_CAPTURES:
-      while (movesPicked < numOfBadCaptures)
-      {
-          Move move = badCaptures[movesPicked++].move;
-          if (   move != ttMove
-              && move != mateKiller
-              && pos.pl_move_is_legal(move, pinned))
-              return move;
-      }
-      break;
-
-  case PH_QCAPTURES:
-  case PH_QCHECKS:
-      while (movesPicked < numOfMoves)
-      {
-          Move move = moves[movesPicked++].move;
-          // Maybe postpone the legality check until after futility pruning?
-          if (   move != ttMove
-              && pos.pl_move_is_legal(move, pinned))
-              return move;
-      }
-      break;
-
-  default:
-      break;
-  }
-  return MOVE_NONE;
-}
-
-
-/// MovePicker::init_phase_table() initializes the PhaseTable[],
-/// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex. It is only called once during
-/// program startup, and never again while the program is running.
-
-void MovePicker::init_phase_table() {
-
-  int i = 0;
-
-  // Main search
-  MainSearchPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_TT_MOVE;
-  PhaseTable[i++] = PH_MATE_KILLER;
-  PhaseTable[i++] = PH_GOOD_CAPTURES;
-  // PH_KILLER_1 and PH_KILLER_2 are not yet used.
-  // PhaseTable[i++] = PH_KILLER_1;
-  // PhaseTable[i++] = PH_KILLER_2;
-  PhaseTable[i++] = PH_NONCAPTURES;
-  PhaseTable[i++] = PH_BAD_CAPTURES;
-  PhaseTable[i++] = PH_STOP;
-
-  // Check evasions
-  EvasionsPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_EVASIONS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search with checks
-  QsearchWithChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_TT_MOVE;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_QCHECKS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search without checks
-  QsearchWithoutChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_TT_MOVE;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_STOP;
-}

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,7 @@
 ////
 
 #include "depth.h"
+#include "history.h"
 #include "lock.h"
 #include "position.h"
 
@@ -34,7 +35,6 @@
 //// Types
 ////
 
-struct EvalInfo;
 struct SearchStack;
 
 /// MovePicker is a class which is used to pick one legal move at a time from
@@ -47,50 +47,29 @@ struct SearchStack;
 
 class MovePicker {
 
-  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
+  MovePicker& operator=(const MovePicker&); // silence a warning under MSVC
 
 public:
-
+  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
-  enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
-    PH_MATE_KILLER,    // Mate killer from the current ply
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
-    PH_NONCAPTURES,    // Non-captures and underpromotions
-    PH_EVASIONS,       // Check evasions
-    PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
-    PH_STOP
-  };
-
-  MovePicker(const Position& p, bool pvnode, Move ttm, const SearchStack& ss, Depth d);
   Move get_next_move();
   Move get_next_move(Lock& lock);
-  int number_of_moves() const;
+  int number_of_evasions() const;
-  int current_move_score() const;
-  Bitboard discovered_check_candidates() const;
-
-  static void init_phase_table();
 
 private:
   void score_captures();
   void score_noncaptures();
   void score_evasions();
-  void score_qcaptures();
+  void go_next_phase();
-  Move pick_move_from_list();
 
   const Position& pos;
-  Move ttMove, mateKiller, killer1, killer2;
+  const History& H;
-  Bitboard pinned, dc;
+  MoveStack ttMoves[2], killers[2];
-  MoveStack moves[256], badCaptures[64];
-  bool pvNode;
-  Depth depth;
-  int phaseIndex;
-  int numOfMoves, numOfBadCaptures;
-  int movesPicked;
   bool finished;
+  int phase;
+  const uint8_t* phasePtr;
+  MoveStack *curMove, *lastMove, *lastBadCapture;
+  Bitboard pinned;
+  MoveStack moves[256], badCaptures[64];
 };
 
 
@@ -98,21 +77,14 @@ private:
 //// Inline functions
 ////
 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
+/// MovePicker::number_of_evasions() simply returns the number of moves in
-/// variable. It is intended to be used in positions where the side to move
+/// evasions phase. It is intended to be used in positions where the side to
-/// is in check, for detecting checkmates or situations where there is only
+/// move is in check, for detecting checkmates or situations where there is
-/// a single reply to check.
+/// only a single reply to check.
+/// WARNING: It works as long as PH_EVASIONS is the _only_ phase for evasions.
 
-inline int MovePicker::number_of_moves() const {
+inline int MovePicker::number_of_evasions() const {
-  return numOfMoves;
+  return int(lastMove - moves);
-}
-
-/// MovePicker::discovered_check_candidates() returns a bitboard containing
-/// all pieces which can possibly give discovered check.  This bitboard is
-/// computed by the constructor function.
-
-inline Bitboard MovePicker::discovered_check_candidates() const {
-  return dc;
 }
 
 #endif // !defined(MOVEPICK_H_INCLUDED)

src/pawns.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,6 +25,7 @@
 #include <cassert>
 #include <cstring>
 
+#include "bitcount.h"
 #include "pawns.h"
 #include "position.h"
 
@@ -37,95 +38,67 @@ namespace {
 
   /// Constants and variables
 
-  // Doubled pawn penalty by file, middle game.
+  #define S(mg, eg) make_score(mg, eg)
-  const Value DoubledPawnMidgamePenalty[8] = {
+
-    Value(20), Value(30), Value(34), Value(34),
+  // Doubled pawn penalty by file
-    Value(34), Value(34), Value(30), Value(20)
+  const Score DoubledPawnPenalty[8] = {
+    S(13, 43), S(20, 48), S(23, 48), S(23, 48),
+    S(23, 48), S(23, 48), S(20, 48), S(13, 43)
   };
 
-  // Doubled pawn penalty by file, endgame.
+  // Isolated pawn penalty by file
-  const Value DoubledPawnEndgamePenalty[8] = {
+  const Score IsolatedPawnPenalty[8] = {
-    Value(35), Value(40), Value(40), Value(40),
+    S(25, 30), S(36, 35), S(40, 35), S(40, 35),
-    Value(40), Value(40), Value(40), Value(35)
+    S(40, 35), S(40, 35), S(36, 35), S(25, 30)
   };
 
-  // Isolated pawn penalty by file, middle game.
+  // Backward pawn penalty by file
-  const Value IsolatedPawnMidgamePenalty[8] = {
+  const Score BackwardPawnPenalty[8] = {
-    Value(20), Value(30), Value(34), Value(34),
+    S(20, 28), S(29, 31), S(33, 31), S(33, 31),
-    Value(34), Value(34), Value(30), Value(20)
+    S(33, 31), S(33, 31), S(29, 31), S(20, 28)
   };
 
-  // Isolated pawn penalty by file, endgame.
+  // Pawn chain membership bonus by file
-  const Value IsolatedPawnEndgamePenalty[8] = {
+  const Score ChainBonus[8] = {
-    Value(35), Value(40), Value(40), Value(40),
+    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
-    Value(40), Value(40), Value(40), Value(35)
+    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
   };
 
-  // Backward pawn penalty by file, middle game.
+  // Candidate passed pawn bonus by rank
-  const Value BackwardPawnMidgamePenalty[8] = {
+  const Score CandidateBonus[8] = {
-    Value(16), Value(24), Value(27), Value(27),
+    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
-    Value(27), Value(27), Value(24), Value(16)
+    S(34,68), S(83,166), S(0, 0), S( 0, 0)
   };
 
-  // Backward pawn penalty by file, endgame.
+  // Pawn storm tables for positions with opposite castling
-  const Value BackwardPawnEndgamePenalty[8] = {
-    Value(28), Value(32), Value(32), Value(32),
-    Value(32), Value(32), Value(32), Value(28)
-  };
-
-  // Pawn chain membership bonus by file, middle game.
-  const Value ChainMidgameBonus[8] = {
-    Value(14), Value(16), Value(17), Value(18),
-    Value(18), Value(17), Value(16), Value(14)
-  };
-
-  // Pawn chain membership bonus by file, endgame.
-  const Value ChainEndgameBonus[8] = {
-    Value(16), Value(16), Value(16), Value(16),
-    Value(16), Value(16), Value(16), Value(16)
-  };
-
-  // Candidate passed pawn bonus by rank, middle game.
-  const Value CandidateMidgameBonus[8] = {
-    Value( 0), Value(12), Value(12), Value(20),
-    Value(40), Value(90), Value( 0), Value( 0)
-  };
-
-  // Candidate passed pawn bonus by rank, endgame.
-  const Value CandidateEndgameBonus[8] = {
-    Value( 0), Value(24), Value(24), Value(40),
-    Value(80), Value(180), Value(0), Value( 0)
-  };
-
-  // Pawn storm tables for positions with opposite castling:
   const int QStormTable[64] = {
     0,  0,  0,  0, 0, 0, 0, 0,
-  -22,-22,-22,-13,-4, 0, 0, 0,
+  -22,-22,-22,-14,-6, 0, 0, 0,
-   -4, -9, -9, -9,-4, 0, 0, 0,
+   -6,-10,-10,-10,-6, 0, 0, 0,
-    9, 18, 22, 18, 9, 0, 0, 0,
+    4, 12, 16, 12, 4, 0, 0, 0,
-   22, 31, 31, 22, 0, 0, 0, 0,
+   16, 23, 23, 16, 0, 0, 0, 0,
-   31, 40, 40, 31, 0, 0, 0, 0,
+   23, 31, 31, 23, 0, 0, 0, 0,
-   31, 40, 40, 31, 0, 0, 0, 0,
+   23, 31, 31, 23, 0, 0, 0, 0,
     0,  0,  0,  0, 0, 0, 0, 0
   };
 
   const int KStormTable[64] = {
     0, 0, 0,  0,  0,  0,  0,  0,
-    0, 0, 0,-4,-13,-22,-27,-27,
+    0, 0, 0,-10,-19,-28,-33,-33,
-    0, 0, 0,-4, -9,-13,-18,-18,
+    0, 0, 0,-10,-15,-19,-24,-24,
-    0, 0, 0, 0,  9,  9,  9,  9,
+    0, 0, 0,  0,  1,  1,  1,  1,
-    0, 0, 0, 0,  9, 18, 27, 27,
+    0, 0, 0,  0,  1, 10, 19, 19,
-    0, 0, 0, 0,  9, 27, 40, 36,
+    0, 0, 0,  0,  1, 19, 31, 27,
-    0, 0, 0, 0,  0, 31, 40, 31,
+    0, 0, 0,  0,  0, 22, 31, 22,
     0, 0, 0,  0,  0,  0,  0,  0
   };
 
   // Pawn storm open file bonuses by file
-  const int16_t KStormOpenFileBonus[8] = { 45, 45, 30, 0, 0, 0, 0, 0 };
+  const int16_t KStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
-  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 30, 45, 30 };
+  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
 
   // Pawn storm lever bonuses by file
-  const int StormLeverBonus[8] = { 20, 20, 10, 0, 0, 10, 20, 20 };
+  const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
 
 }
 
@@ -140,13 +113,12 @@ PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
 
   size = numOfEntries;
   entries = new PawnInfo[size];
-  if (entries == NULL)
+  if (!entries)
   {
       std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
                 << " bytes for pawn hash table." << std::endl;
-      exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
-  clear();
 }
 
 
@@ -157,11 +129,13 @@ PawnInfoTable::~PawnInfoTable() {
 }
 
 
-/// PawnInfoTable::clear() clears the pawn hash table by setting all
+/// PawnInfo::clear() resets to zero the PawnInfo entry. Note that
-/// entries to 0.
+/// kingSquares[] is initialized to SQ_NONE instead.
 
-void PawnInfoTable::clear() {
+void PawnInfo::clear() {
-  memset(entries, 0, size * sizeof(PawnInfo));
+
+  memset(this, 0, sizeof(PawnInfo));
+  kingSquares[WHITE] = kingSquares[BLACK] = SQ_NONE;
 }
 
 
@@ -179,8 +153,8 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
   PawnInfo* pi = entries + index;
 
   // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return the
+  // have analysed this pawn structure before, and we can simply return
-  // information we found the last time instead of recomputing it
+  // the information we found the last time instead of recomputing it.
   if (pi->key == key)
       return pi;
 
@@ -188,43 +162,53 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
   pi->clear();
   pi->key = key;
 
-  Value mgValue[2] = {Value(0), Value(0)};
+  // Calculate pawn attacks
-  Value egValue[2] = {Value(0), Value(0)};
+  Bitboard whitePawns = pos.pieces(PAWN, WHITE);
+  Bitboard blackPawns = pos.pieces(PAWN, BLACK);
+  pi->pawnAttacks[WHITE] = ((whitePawns << 9) & ~FileABB) | ((whitePawns << 7) & ~FileHBB);
+  pi->pawnAttacks[BLACK] = ((blackPawns >> 7) & ~FileABB) | ((blackPawns >> 9) & ~FileHBB);
 
-  // Loop through the pawns for both colors
+  // Evaluate pawns for both colors
-  for (Color us = WHITE; us <= BLACK; us++)
+  pi->value =  evaluate_pawns<WHITE>(pos, whitePawns, blackPawns, pi)
-  {
+             - evaluate_pawns<BLACK>(pos, blackPawns, whitePawns, pi);
-    Color them = opposite_color(us);
+  return pi;
-    Bitboard ourPawns = pos.pawns(us);
+}
-    Bitboard theirPawns = pos.pawns(them);
+
-    Bitboard pawns = ourPawns;
+
+/// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
+
+template<Color Us>
+Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
+                                    Bitboard theirPawns, PawnInfo* pi) {
+  Square s;
+  File f;
+  Rank r;
+  bool passed, isolated, doubled, chain, backward, candidate;
   int bonus;
+  Score value = make_score(0, 0);
+  const Square* ptr = pos.piece_list_begin(Us, PAWN);
 
   // Initialize pawn storm scores by giving bonuses for open files
-    for (File f = FILE_A; f <= FILE_H; f++)
+  for (f = FILE_A; f <= FILE_H; f++)
-        if (pos.file_is_half_open(us, f))
+      if (!(ourPawns & file_bb(f)))
       {
-            pi->ksStormValue[us] += KStormOpenFileBonus[f];
+          pi->ksStormValue[Us] += KStormOpenFileBonus[f];
-            pi->qsStormValue[us] += QStormOpenFileBonus[f];
+          pi->qsStormValue[Us] += QStormOpenFileBonus[f];
+          pi->halfOpenFiles[Us] |= (1 << f);
       }
 
   // Loop through all pawns of the current color and score each pawn
-    while (pawns)
+  while ((s = *ptr++) != SQ_NONE)
   {
-        bool passed, doubled, isolated, backward, chain, candidate;
+      f = square_file(s);
-        Square s = pop_1st_bit(&pawns);
+      r = square_rank(s);
-        File f = square_file(s);
-        Rank r = square_rank(s);
 
-        assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
+      assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
-
-        // The file containing the pawn is not half open
-        pi->halfOpenFiles[us] &= ~(1 << f);
 
       // Passed, isolated or doubled pawn?
-        passed = pos.pawn_is_passed(us, s);
+      passed   = Position::pawn_is_passed(theirPawns, Us, s);
-        isolated = pos.pawn_is_isolated(us, s);
+      isolated = Position::pawn_is_isolated(ourPawns, s);
-        doubled = pos.pawn_is_doubled(us, s);
+      doubled  = Position::pawn_is_doubled(ourPawns, Us, s);
 
       // We calculate kingside and queenside pawn storm
       // scores for both colors. These are used when evaluating
@@ -236,10 +220,10 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
       // enemy pawn on an adjacent file gets an additional bonus.
 
       // Kingside pawn storms
-        bonus = KStormTable[relative_square(us, s)];
+      bonus = KStormTable[relative_square(Us, s)];
       if (f >= FILE_F)
       {
-            Bitboard b = outpost_mask(us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
+          Bitboard b = outpost_mask(Us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
           while (b)
           {
               Square s2 = pop_1st_bit(&b);
@@ -259,13 +243,13 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
                   bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
           }
       }
-        pi->ksStormValue[us] += bonus;
+      pi->ksStormValue[Us] += bonus;
 
       // Queenside pawn storms
-        bonus = QStormTable[relative_square(us, s)];
+      bonus = QStormTable[relative_square(Us, s)];
       if (f <= FILE_C)
       {
-            Bitboard b = outpost_mask(us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
+          Bitboard b = outpost_mask(Us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
           while (b)
           {
               Square s2 = pop_1st_bit(&b);
@@ -285,7 +269,7 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
                   bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
           }
       }
-        pi->qsStormValue[us] += bonus;
+      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
@@ -293,7 +277,7 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
       // it probably won't make any noticable difference.
       chain =  ourPawns
              & neighboring_files_bb(f)
-               & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
+             & (rank_bb(r) | rank_bb(r - (Us == WHITE ? 1 : -1)));
 
       // Test for backward pawn
       //
@@ -301,11 +285,9 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
       // it cannot be backward. If can capture an enemy pawn or if
       // there are friendly pawns behind on neighboring files it cannot
       // be backward either.
-        if (   passed
+      if (   (passed | isolated | chain)
-            || isolated
+          || (ourPawns & behind_bb(Us, r) & neighboring_files_bb(f))
-            || chain
+          || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
-            || (pos.pawn_attacks(us, s) & theirPawns)
-            || (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
           backward = false;
       else
       {
@@ -313,84 +295,74 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
           // 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;
+          Bitboard b = pos.attacks_from<PAWN>(s, Us);
-            if (us == WHITE)
+
-            {
+          // Note that we are sure to find something because pawn is not passed
-                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b <<= 8);
+          // nor isolated, so loop is potentially infinite, but it isn't.
-                backward = (b | (b << 8)) & theirPawns;
+          while (!(b & (ourPawns | theirPawns)))
-            }
+              Us == WHITE ? b <<= 8 : b >>= 8;
-            else
+
-            {
+          // The friendly pawn needs to be at least two ranks closer than the enemy
-                for (b = pos.pawn_attacks(us, s); !(b & (ourPawns | theirPawns)); b >>= 8);
+          // pawn in order to help the potentially backward pawn advance.
-                backward = (b | (b >> 8)) & theirPawns;
+          backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
-            }
       }
 
       // Test for candidate passed pawn
       candidate =   !passed
-                     && pos.file_is_half_open(them, f)
+                 && !(theirPawns & file_bb(f))
-                     && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(us, r) | rank_bb(r)) & ourPawns)
+                 && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(Us, r) | rank_bb(r)) & ourPawns)
-                         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)              & 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
       // a true passed pawn.
-        if (passed && (ourPawns & squares_in_front_of(us, s)))
+      if (passed && (ourPawns & squares_in_front_of(Us, s)))
-        {
-            // candidate = true;
           passed = false;
-        }
 
       // Score this pawn
-        Value mv = Value(0), ev = Value(0);
-        if (isolated)
-        {
-            mv -= IsolatedPawnMidgamePenalty[f];
-            ev -= IsolatedPawnEndgamePenalty[f];
-            if (pos.file_is_half_open(them, f))
-            {
-                mv -= IsolatedPawnMidgamePenalty[f] / 2;
-                ev -= IsolatedPawnEndgamePenalty[f] / 2;
-            }
-        }
-        if (doubled)
-        {
-            mv -= DoubledPawnMidgamePenalty[f];
-            ev -= DoubledPawnEndgamePenalty[f];
-        }
-        if (backward)
-        {
-            mv -= BackwardPawnMidgamePenalty[f];
-            ev -= BackwardPawnEndgamePenalty[f];
-            if (pos.file_is_half_open(them, f))
-            {
-                mv -= BackwardPawnMidgamePenalty[f] / 2;
-                ev -= BackwardPawnEndgamePenalty[f] / 2;
-            }
-        }
-        if (chain)
-        {
-            mv += ChainMidgameBonus[f];
-            ev += ChainEndgameBonus[f];
-        }
-        if (candidate)
-        {
-            mv += CandidateMidgameBonus[relative_rank(us, s)];
-            ev += CandidateEndgameBonus[relative_rank(us, s)];
-        }
-
-        mgValue[us] += mv;
-        egValue[us] += ev;
-
-        // If the pawn is passed, set the square of the pawn in the passedPawns
-        // bitboard
       if (passed)
           set_bit(&(pi->passedPawns), s);
-    } // while(pawns)
-  } // for(colors)
 
-  pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
+      if (isolated)
-  pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
+      {
-  return pi;
+          value -= IsolatedPawnPenalty[f];
+          if (!(theirPawns & file_bb(f)))
+              value -= IsolatedPawnPenalty[f] / 2;
+      }
+      if (doubled)
+          value -= DoubledPawnPenalty[f];
+
+      if (backward)
+      {
+          value -= BackwardPawnPenalty[f];
+          if (!(theirPawns & file_bb(f)))
+              value -= BackwardPawnPenalty[f] / 2;
+      }
+      if (chain)
+          value += ChainBonus[f];
+
+      if (candidate)
+          value += CandidateBonus[relative_rank(Us, s)];
+  }
+
+  return value;
+}
+
+
+/// 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 r = ksq & (7 << 3);
+  for (int i = 1, k = (c ? -8 : 8); i < 4; i++)
+  {
+      r += k;
+      shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
+  }
+  kingSquares[c] = ksq;
+  kingShelters[c] = shelter;
+  return shelter;
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -45,26 +45,32 @@ class PawnInfo {
   friend class PawnInfoTable;
 
 public:
-  Value mg_value() const;
+  PawnInfo() { clear(); }
-  Value eg_value() const;
+
+  Score pawns_value() const;
   Value kingside_storm_value(Color c) const;
   Value queenside_storm_value(Color c) const;
+  Bitboard pawn_attacks(Color c) const;
   Bitboard passed_pawns() const;
   int file_is_half_open(Color c, File f) const;
   int has_open_file_to_left(Color c, File f) const;
   int has_open_file_to_right(Color c, File f) const;
+  int get_king_shelter(const Position& pos, Color c, Square ksq);
 
 private:
   void clear();
+  int updateShelter(const Position& pos, Color c, Square ksq);
 
   Key key;
   Bitboard passedPawns;
-  int16_t mgValue, egValue;
+  Bitboard pawnAttacks[2];
+  Score value;
   int16_t ksStormValue[2], qsStormValue[2];
   uint8_t halfOpenFiles[2];
+  Square kingSquares[2];
+  uint8_t kingShelters[2];
 };
 
-
 /// The PawnInfoTable class represents a pawn hash table.  It is basically
 /// just an array of PawnInfo objects and a few methods for accessing these
 /// objects.  The most important method is get_pawn_info, which looks up a
@@ -75,10 +81,12 @@ class PawnInfoTable {
 public:
   PawnInfoTable(unsigned numOfEntries);
   ~PawnInfoTable();
-  void clear();
   PawnInfo* get_pawn_info(const Position& pos);
 
 private:
+  template<Color Us>
+  Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
+
   unsigned size;
   PawnInfo* entries;
 };
@@ -88,18 +96,18 @@ private:
 //// Inline functions
 ////
 
-inline Value PawnInfo::mg_value() const {
+inline Score PawnInfo::pawns_value() const {
-  return Value(mgValue);
+  return value;
-}
-
-inline Value PawnInfo::eg_value() const {
-  return Value(egValue);
 }
 
 inline Bitboard PawnInfo::passed_pawns() const {
   return passedPawns;
 }
 
+inline Bitboard PawnInfo::pawn_attacks(Color c) const {
+  return pawnAttacks[c];
+}
+
 inline Value PawnInfo::kingside_storm_value(Color c) const {
   return Value(ksStormValue[c]);
 }
@@ -120,14 +128,8 @@ inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
-inline void PawnInfo::clear() {
+inline int PawnInfo::get_king_shelter(const Position& pos, Color c, Square ksq) {
-
+  return (kingSquares[c] == ksq ? kingShelters[c] : updateShelter(pos, c, ksq));
-  passedPawns = EmptyBoardBB;
-  mgValue = egValue = 0;
-  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
-  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
-  halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
 }
 
-
 #endif // !defined(PAWNS_H_INCLUDED)

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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/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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -83,10 +83,6 @@ inline int piece_is_slider(Piece p) {
   return SlidingArray[int(p)];
 }
 
-inline int piece_is_slider(PieceType pt) {
-  return SlidingArray[int(pt)];
-}
-
 inline SquareDelta pawn_push(Color c) {
     return (c == WHITE ? DELTA_N : DELTA_S);
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@
 #if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED
 
-// Disable a silly and noisy warning from MSVC compiler
+// Disable some silly and noisy warning from MSVC compiler
 #if defined(_MSC_VER)
 
 // Forcing value to bool 'true' or 'false' (performance warning)
@@ -50,13 +50,12 @@
 //// Constants
 ////
 
-/// FEN string for the initial position:
+/// FEN string for the initial position
-const std::string StartPosition =
+const std::string StartPosition = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
 /// Maximum number of plies per game (220 should be enough, because the
 /// maximum search depth is 100, and during position setup we reset the
-/// move counter for every non-reversible move):
+/// move counter for every non-reversible move).
 const int MaxGameLength = 220;
 
 
@@ -64,6 +63,18 @@ const int MaxGameLength = 220;
 //// Types
 ////
 
+/// struct checkInfo is initialized at c'tor time and keeps
+/// info used to detect if a move gives check.
+
+struct CheckInfo {
+
+    CheckInfo(const Position&);
+
+    Square ksq;
+    Bitboard dcCandidates;
+    Bitboard checkSq[8];
+};
+
 /// Castle rights, encoded as bit fields
 
 enum CastleRights {
@@ -88,14 +99,15 @@ enum Phase {
 /// must be passed as a parameter.
 
 struct StateInfo {
-  Key key, pawnKey, materialKey;
+  Key pawnKey, materialKey;
-  int castleRights, rule50;
+  int castleRights, rule50, pliesFromNull;
   Square epSquare;
-  Value mgValue, egValue;
+  Score value;
+  Value npMaterial[2];
 
+  Key key;
   PieceType capture;
   Bitboard checkersBB;
-  Move lastMove;
   StateInfo* previous;
 };
 
@@ -104,7 +116,7 @@ struct StateInfo {
 ///
 ///    * For each piece type, a bitboard representing the squares occupied
 ///      by pieces of that type.
-///    * For each color, a bitboard representing the squares occupiecd by
+///    * For each color, a bitboard representing the squares occupied by
 ///      pieces of that color.
 ///    * A bitboard of all occupied squares.
 ///    * A bitboard of all checking pieces.
@@ -116,10 +128,9 @@ struct StateInfo {
 ///    * The en passant square (which is SQ_NONE if no en passant capture is
 ///      possible).
 ///    * The squares of the kings for both sides.
-///    * The last move played.
 ///    * Hash keys for the position itself, the current pawn structure, and
 ///      the current material situation.
-///    * Hash keys for all previous positions in the game (for detecting
+///    * Hash keys for all previous positions in the game for detecting
 ///      repetition draws.
 ///    * A counter for detecting 50 move rule draws.
 
@@ -129,8 +140,13 @@ class Position {
   friend class EndgameFunctions;
 
 public:
+  enum GamePhase {
+      MidGame,
+      EndGame
+  };
+
   // Constructors
-  Position() {};
+  Position() {}
   Position(const Position& pos);
   Position(const std::string& fen);
 
@@ -159,26 +175,10 @@ public:
   Bitboard empty_squares() const;
   Bitboard occupied_squares() const;
   Bitboard pieces_of_color(Color c) const;
-  Bitboard pieces_of_type(PieceType pt) const;
+  Bitboard pieces(PieceType pt) const;
-  Bitboard pieces_of_color_and_type(Color c, PieceType pt) const;
+  Bitboard pieces(PieceType pt, Color c) const;
-  Bitboard pawns() const;
+  Bitboard pieces(PieceType pt1, PieceType pt2) const;
-  Bitboard knights() const;
+  Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
-  Bitboard bishops() const;
-  Bitboard rooks() const;
-  Bitboard queens() const;
-  Bitboard kings() const;
-  Bitboard rooks_and_queens() const;
-  Bitboard bishops_and_queens() const;
-  Bitboard sliders() const;
-  Bitboard pawns(Color c) const;
-  Bitboard knights(Color c) const;
-  Bitboard bishops(Color c) const;
-  Bitboard rooks(Color c) const;
-  Bitboard queens(Color c) const;
-  Bitboard kings(Color c) const;
-  Bitboard rooks_and_queens(Color c) const;
-  Bitboard bishops_and_queens(Color c) const;
-  Bitboard sliders_of_color(Color c) const;
 
   // Number of pieces of each color and type
   int piece_count(Color c, PieceType pt) const;
@@ -196,65 +196,47 @@ public:
   Square initial_kr_square(Color c) const;
   Square initial_qr_square(Color c) const;
 
-  // Attack bitboards
-  Bitboard sliding_attacks(Square s, Direction d) const;
-  Bitboard ray_attacks(Square s, SignedDirection d) const;
-  Bitboard pawn_attacks(Color c, Square s) const;
-
-  template<PieceType>
-  Bitboard piece_attacks(Square s) const;
-
   // Bitboards for pinned pieces and discovered check candidates
   Bitboard discovered_check_candidates(Color c) const;
-  Bitboard pinned_pieces(Color c, Bitboard& p) const;
   Bitboard pinned_pieces(Color c) const;
 
-  // Checking pieces
+  // Checking pieces and under check information
   Bitboard checkers() const;
+  bool is_check() const;
 
   // Piece lists
   Square piece_list(Color c, PieceType pt, int index) const;
+  const Square* piece_list_begin(Color c, PieceType pt) const;
 
-  // Attack information for a given square
+  // Information about attacks to or from a given square
-  bool square_is_attacked(Square s, Color c) const;
+  Bitboard attackers_to(Square s) const;
-  Bitboard attacks_to(Square s) const;
+  Bitboard attacks_from(Piece p, Square s) const;
-  Bitboard attacks_to(Square s, Color c) const;
+  template<PieceType> Bitboard attacks_from(Square s) const;
-  bool is_check() const;
+  template<PieceType> Bitboard attacks_from(Square s, Color c) const;
-  bool pawn_attacks_square(Color c, Square f, Square t) const;
-
-  template<PieceType>
-  Bitboard piece_attacks_square(Square f, Square t) const; // Dispatch at compile-time
-
-  bool piece_attacks_square(Piece p, Square f, Square t) const; // Dispatch at run-time
 
   // Properties of moves
-  bool pl_move_is_legal(Move m) const;
   bool pl_move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_evasion(Move m, Bitboard pinned) const;
   bool move_is_check(Move m) const;
-  bool move_is_check(Move m, Bitboard dcCandidates) const;
+  bool move_is_check(Move m, const CheckInfo& ci) const;
   bool move_is_capture(Move m) const;
-  bool move_is_deep_pawn_push(Move m) const;
+  bool move_is_capture_or_promotion(Move m) const;
-  bool move_is_pawn_push_to_7th(Move m) const;
   bool move_is_passed_pawn_push(Move m) const;
-  bool move_was_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) const;
 
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
-  bool pawn_is_isolated(Color c, Square s) const;
+  static bool pawn_is_passed(Bitboard theirPawns, Color c, Square s);
-  bool pawn_is_doubled(Color c, Square s) const;
+  static bool pawn_is_isolated(Bitboard ourPawns, Square s);
-
+  static bool pawn_is_doubled(Bitboard ourPawns, Color c, Square s);
-  // Open and half-open files
-  bool file_is_open(File f) const;
-  bool file_is_half_open(Color c, File f) const;
 
   // Weak squares
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void setStartState(const StateInfo& st);
+  void saveState();
   void do_move(Move m, StateInfo& st);
-  void do_move(Move m, StateInfo& st, Bitboard dcCandidates);
+  void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
   void undo_move(Move m);
   void do_null_move(StateInfo& st);
   void undo_null_move();
@@ -263,18 +245,18 @@ public:
   int see(Square from, Square to) const;
   int see(Move m) const;
   int see(Square to) const;
+  int see_sign(Move m) const;
 
   // Accessing hash keys
   Key get_key() const;
+  Key get_exclusion_key() const;
   Key get_pawn_key() const;
   Key get_material_key() const;
 
   // Incremental evaluation
-  Value mg_value() const;
+  Score value() const;
-  Value eg_value() const;
   Value non_pawn_material(Color c) const;
-  Phase game_phase() const;
+  Score pst_delta(Piece piece, Square from, Square to) const;
-  Value mg_pst_delta(Move m) const;
 
   // Game termination checks
   bool is_mate() const;
@@ -296,7 +278,7 @@ public:
   // Position consistency check, for debugging
   bool is_ok(int* failedStep = NULL) const;
 
-  // Static member functions:
+  // Static member functions
   static void init_zobrist();
   static void init_piece_square_tables();
 
@@ -309,18 +291,11 @@ private:
   void allow_ooo(Color c);
 
   // Helper functions for doing and undoing moves
-  void do_capture_move(PieceType capture, Color them, Square to);
+  void do_capture_move(Bitboard& key, PieceType capture, Color them, Square to, bool ep);
   void do_castle_move(Move m);
-  void do_promotion_move(Move m);
-  void do_ep_move(Move m);
   void undo_castle_move(Move m);
-  void undo_promotion_move(Move m);
-  void undo_ep_move(Move m);
   void find_checkers();
 
-  template<PieceType Piece>
-  void update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates);
-
   template<bool FindPinned>
   Bitboard hidden_checkers(Color c) const;
 
@@ -330,33 +305,27 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  enum GamePhase {
+  Score pst(Color c, PieceType pt, Square s) const;
-      MidGame,
+  Score compute_value() const;
-      EndGame
-  };
-  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
-  template<GamePhase> Value compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
-  // Bitboards
-  Bitboard byColorBB[2], byTypeBB[8];
-
   // Board
   Piece board[64];
 
+  // Bitboards
+  Bitboard byTypeBB[8], byColorBB[2];
+
   // Piece counts
   int pieceCount[2][8]; // [color][pieceType]
 
   // Piece lists
   Square pieceList[2][8][16]; // [color][pieceType][index]
-  int index[64];
+  int index[64]; // [square]
 
   // Other info
-  Square kingSquare[2];
   Color sideToMove;
   int gamePly;
   Key history[MaxGameLength];
-  Value npMaterial[2];
   File initialKFile, initialKRFile, initialQRFile;
   StateInfo startState;
   StateInfo* st;
@@ -368,8 +337,8 @@ private:
   static Key zobCastle[16];
   static Key zobMaterial[2][8][16];
   static Key zobSideToMove;
-  static Value MgPieceSquareTable[16][64];
+  static Score PieceSquareTable[16][64];
-  static Value EgPieceSquareTable[16][64];
+  static Key zobExclusion;
 };
 
 
@@ -421,84 +390,20 @@ inline Bitboard Position::pieces_of_color(Color c) const {
   return byColorBB[c];
 }
 
-inline Bitboard Position::pieces_of_type(PieceType pt) const {
+inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt) const {
+inline Bitboard Position::pieces(PieceType pt, Color c) const {
-  return pieces_of_color(c) & pieces_of_type(pt);
+  return byTypeBB[pt] & byColorBB[c];
 }
 
-inline Bitboard Position::pawns() const {
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
-  return pieces_of_type(PAWN);
+  return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::knights() const {
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
-  return pieces_of_type(KNIGHT);
+  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
-}
-
-inline Bitboard Position::bishops() const {
-  return pieces_of_type(BISHOP);
-}
-
-inline Bitboard Position::rooks() const {
-  return pieces_of_type(ROOK);
-}
-
-inline Bitboard Position::queens() const {
-  return pieces_of_type(QUEEN);
-}
-
-inline Bitboard Position::kings() const {
-  return pieces_of_type(KING);
-}
-
-inline Bitboard Position::rooks_and_queens() const {
-  return rooks() | queens();
-}
-
-inline Bitboard Position::bishops_and_queens() const {
-  return bishops() | queens();
-}
-
-inline Bitboard Position::sliders() const {
-  return bishops() | queens() | rooks();
-}
-
-inline Bitboard Position::pawns(Color c) const {
-  return pieces_of_color_and_type(c, PAWN);
-}
-
-inline Bitboard Position::knights(Color c) const {
-  return pieces_of_color_and_type(c, KNIGHT);
-}
-
-inline Bitboard Position::bishops(Color c) const {
-  return pieces_of_color_and_type(c, BISHOP);
-}
-
-inline Bitboard Position::rooks(Color c) const {
-  return pieces_of_color_and_type(c, ROOK);
-}
-
-inline Bitboard Position::queens(Color c) const {
-  return pieces_of_color_and_type(c, QUEEN);
-}
-
-inline Bitboard Position::kings(Color c) const {
-  return pieces_of_color_and_type(c, KING);
-}
-
-inline Bitboard Position::rooks_and_queens(Color c) const {
-  return rooks_and_queens() & pieces_of_color(c);
-}
-
-inline Bitboard Position::bishops_and_queens(Color c) const {
-  return bishops_and_queens() & pieces_of_color(c);
-}
-
-inline Bitboard Position::sliders_of_color(Color c) const {
-  return sliders() & pieces_of_color(c);
 }
 
 inline int Position::piece_count(Color c, PieceType pt) const {
@@ -509,12 +414,16 @@ inline Square Position::piece_list(Color c, PieceType pt, int index) const {
   return pieceList[c][pt][index];
 }
 
+inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
+  return pieceList[c][pt];
+}
+
 inline Square Position::ep_square() const {
   return st->epSquare;
 }
 
 inline Square Position::king_square(Color c) const {
-  return kingSquare[c];
+  return pieceList[c][KING][0];
 }
 
 inline bool Position::can_castle_kingside(Color side) const {
@@ -537,38 +446,29 @@ inline Square Position::initial_qr_square(Color c) const {
   return relative_square(c, make_square(initialQRFile, RANK_1));
 }
 
-inline Bitboard Position::pawn_attacks(Color c, Square s) const {
+template<>
+inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
   return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
 }
 
-template<>
+template<PieceType Piece> // Knight and King and white pawns
-inline Bitboard Position::piece_attacks<PAWN>(Square s) const {
+inline Bitboard Position::attacks_from(Square s) const {
-  return StepAttackBB[piece_of_color_and_type(opposite_color(sideToMove), PAWN)][s];
+  return StepAttackBB[Piece][s];
 }
 
 template<>
-inline Bitboard Position::piece_attacks<KNIGHT>(Square s) const {
+inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
-  return StepAttackBB[KNIGHT][s];
-}
-
-template<>
-inline Bitboard Position::piece_attacks<BISHOP>(Square s) const {
   return bishop_attacks_bb(s, occupied_squares());
 }
 
 template<>
-inline Bitboard Position::piece_attacks<ROOK>(Square s) const {
+inline Bitboard Position::attacks_from<ROOK>(Square s) const {
   return rook_attacks_bb(s, occupied_squares());
 }
 
 template<>
-inline Bitboard Position::piece_attacks<QUEEN>(Square s) const {
+inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-  return piece_attacks<ROOK>(s) | piece_attacks<BISHOP>(s);
+  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
-}
-
-template<>
-inline Bitboard Position::piece_attacks<KING>(Square s) const {
-  return StepAttackBB[KING][s];
 }
 
 inline Bitboard Position::checkers() const {
@@ -579,53 +479,34 @@ inline bool Position::is_check() const {
   return st->checkersBB != EmptyBoardBB;
 }
 
-inline bool Position::pawn_attacks_square(Color c, Square f, Square t) const {
-  return bit_is_set(pawn_attacks(c, f), t);
-}
-
-template<PieceType Piece>
-Bitboard Position::piece_attacks_square(Square f, Square t) const {
-  return bit_is_set(piece_attacks<Piece>(f), t);
-}
-
-inline Bitboard Position::attacks_to(Square s, Color c) const {
-
-  return attacks_to(s) & pieces_of_color(c);
-}
-
-inline bool Position::square_is_attacked(Square s, Color c) const {
-
-  return attacks_to(s, c) != EmptyBoardBB;
-}
-
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(pawns(opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
 }
 
-inline bool Position::pawn_is_isolated(Color c, Square s) const {
+inline bool Position::pawn_is_passed(Bitboard theirPawns, Color c, Square s) {
-  return !(pawns(c) & neighboring_files_bb(s));
+  return !(theirPawns & passed_pawn_mask(c, s));
 }
 
-inline bool Position::pawn_is_doubled(Color c, Square s) const {
+inline bool Position::pawn_is_isolated(Bitboard ourPawns, Square s) {
-  return pawns(c) & squares_behind(c, s);
+  return !(ourPawns & neighboring_files_bb(s));
 }
 
-inline bool Position::file_is_open(File f) const {
+inline bool Position::pawn_is_doubled(Bitboard ourPawns, Color c, Square s) {
-  return !(pawns() & file_bb(f));
+  return ourPawns & squares_behind(c, s);
-}
-
-inline bool Position::file_is_half_open(Color c, File f) const {
-  return !(pawns(c) & file_bb(f));
 }
 
 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(pawns(c) & outpost_mask(opposite_color(c), s));
+  return !(pieces(PAWN, c) & outpost_mask(opposite_color(c), s));
 }
 
 inline Key Position::get_key() const {
   return st->key;
 }
 
+inline Key Position::get_exclusion_key() const {
+  return st->key ^ zobExclusion;
+}
+
 inline Key Position::get_pawn_key() const {
   return st->pawnKey;
 }
@@ -634,57 +515,20 @@ inline Key Position::get_material_key() const {
   return st->materialKey;
 }
 
-template<Position::GamePhase Phase>
+inline Score Position::pst(Color c, PieceType pt, Square s) const {
-inline Value Position::pst(Color c, PieceType pt, Square s) const {
+  return PieceSquareTable[piece_of_color_and_type(c, pt)][s];
-  return (Phase == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
-                           : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
 }
 
-inline Value Position::mg_pst_delta(Move m) const {
+inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
-  return MgPieceSquareTable[piece_on(move_from(m))][move_to(m)]
+  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
-        -MgPieceSquareTable[piece_on(move_from(m))][move_from(m)];
 }
 
-inline Value Position::mg_value() const {
+inline Score Position::value() const {
-  return st->mgValue;
+  return st->value;
-}
-
-inline Value Position::eg_value() const {
-  return st->egValue;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
-  return npMaterial[c];
+  return st->npMaterial[c];
-}
-
-inline Phase Position::game_phase() const {
-
-  // Values modified by Joona Kiiski
-  static const Value MidgameLimit = Value(15713);
-  static const Value EndgameLimit = Value(4428);
-
-  Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
-
-  if (npm >= MidgameLimit)
-      return PHASE_MIDGAME;
-  else if(npm <= EndgameLimit)
-      return PHASE_ENDGAME;
-  else
-      return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
-}
-
-inline bool Position::move_is_deep_pawn_push(Move m) const {
-
-  Color c = side_to_move();
-  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
-        && relative_rank(c, move_to(m)) > RANK_4;
-}
-
-inline bool Position::move_is_pawn_push_to_7th(Move m) const {
-
-  Color c = side_to_move();
-  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
-        && relative_rank(c, move_to(m)) == RANK_7;
 }
 
 inline bool Position::move_is_passed_pawn_push(Move m) const {
@@ -694,13 +538,6 @@ inline bool Position::move_is_passed_pawn_push(Move m) const {
         && pawn_is_passed(c, move_to(m));
 }
 
-inline bool Position::move_was_passed_pawn_push(Move m) const {
-
-  Color c = opposite_color(side_to_move());
-  return   piece_on(move_to(m)) == piece_of_color_and_type(c, PAWN)
-        && pawn_is_passed(c, move_to(m));
-}
-
 inline int Position::rule_50_counter() const {
 
   return st->rule50;
@@ -715,17 +552,19 @@ inline bool Position::opposite_colored_bishops() const {
 
 inline bool Position::has_pawn_on_7th(Color c) const {
 
-  return pawns(c) & relative_rank_bb(c, RANK_7);
+  return pieces(PAWN, c) & relative_rank_bb(c, RANK_7);
 }
 
 inline bool Position::move_is_capture(Move m) const {
 
   // Move must not be MOVE_NONE !
+  return (m & (3 << 15)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+}
 
-  return (   !square_is_empty(move_to(m))
+inline bool Position::move_is_capture_or_promotion(Move m) const {
-          && (color_of_piece_on(move_to(m)) != color_of_piece_on(move_from(m)))
+
-         )
+  // Move must not be MOVE_NONE !
-         || move_is_ep(m);
+  return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
 }
 
 #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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,7 +29,7 @@
 
 
 ////
-//// Variables
+//// Constants modified by Joona Kiiski
 ////
 
 static const Value MP = PawnValueMidgame;
@@ -43,68 +43,68 @@ static const int MgPST[][64] = {
   {// Pawn
    // A      B      C     D      E      F      G     H
         0,    0,     0,     0,     0,     0,    0,     0,
-    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
-    MP-38, MP-12, MP+ 6, MP+38, MP+38, MP+ 6, MP-12, MP-38,
+    MP-28, MP-6, MP+ 9, MP+36, MP+36, MP+ 9, MP-6, MP-28,
-    MP-38, MP-12, MP+16, MP+64, MP+64, MP+16, MP-12, MP-38,
+    MP-28, MP-6, MP+17, MP+58, MP+58, MP+17, MP-6, MP-28,
-    MP-38, MP-12, MP+16, MP+38, MP+38, MP+16, MP-12, MP-38,
+    MP-28, MP-6, MP+17, MP+36, MP+36, MP+17, MP-6, MP-28,
-    MP-38, MP-12, MP+ 6, MP+12, MP+12, MP+ 6, MP-12, MP-38,
+    MP-28, MP-6, MP+ 9, MP+14, MP+14, MP+ 9, MP-6, MP-28,
-    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
         0,    0,     0,     0,     0,     0,    0,     0
   },
   {// Knight
    //  A      B       C      D      E      F      G       H
-    MK-128, MK-102, MK-76, MK-64, MK-64, MK-76, MK-102, MK-128,
+    MK-135, MK-107, MK-80, MK-67, MK-67, MK-80, MK-107, MK-135,
-    MK- 89, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK- 89,
+    MK- 93, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK- 93,
-    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
-    MK- 25, MK-  0, MK+25, MK+38, MK+38, MK+25, MK-  0, MK- 25,
+    MK- 25, MK+  1, MK+27, MK+41, MK+41, MK+27, MK+  1, MK- 25,
-    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
-    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
-    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
-    MK-182, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK-182
+    MK-193, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK-193
   },
   {// Bishop
    // A      B      C      D      E      F      G      H
-    MB-46, MB-46, MB-40, MB-35, MB-35, MB-40, MB-46, MB-46,
+    MB-40, MB-40, MB-35, MB-30, MB-30, MB-35, MB-40, MB-40,
-    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
-    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
-    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
-    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
-    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
-    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
-    MB-20, MB-20, MB-15, MB-10, MB-10, MB-15, MB-20, MB-20
+    MB-17, MB-17, MB-13, MB- 8, MB- 8, MB-13, MB-17, MB-17
   },
   {// Rook
    // A      B     C     D     E     F     G     H
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12
   },
   {// Queen
    // A     B     C     D     E     F     G     H
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8
   },
   {// King
    //A    B    C    D    E    F    G    H
-    302, 328, 276, 225, 225, 276, 328, 302,
+    287, 311, 262, 214, 214, 262, 311, 287,
-    276, 302, 251, 200, 200, 251, 302, 276,
+    262, 287, 238, 190, 190, 238, 287, 262,
-    225, 251, 200, 149, 149, 200, 251, 225,
+    214, 238, 190, 142, 142, 190, 238, 214,
-    200, 225, 175, 124, 124, 175, 225, 200,
+    190, 214, 167, 119, 119, 167, 214, 190,
-    175, 200, 149,  98,  98, 149, 200, 175,
+    167, 190, 142,  94,  94, 142, 190, 167,
-    149, 175, 124,  72,  72, 124, 175, 149,
+    142, 167, 119,  69,  69, 119, 167, 142,
-    124, 149,  98,  47,  47,  98, 149, 124,
+    119, 142,  94,  46,  46,  94, 142, 119,
-     98, 124,  72,  21,  21,  72, 124,  98
+     94, 119,  69,  21,  21,  69, 119,  94
   }
 };
 
@@ -119,68 +119,68 @@ static const int EgPST[][64] = {
   {// Pawn
    // A     B     C     D     E     F     G     H
        0,    0,    0,    0,    0,    0,    0,    0,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    EP, EP, EP, EP, EP, EP, EP, EP,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
        0,    0,    0,    0,    0,    0,    0,    0
   },
   {// Knight
    // A       B      C      D      E      F      G      H
-    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102,
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104,
-    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
-    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
-    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104
   },
   {// Bishop
    // A      B      C      D      E      F      G      H
-    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46,
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59,
-    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
-    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
-    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59
   },
   {// Rook
    // A     B     C     D     E     F     G     H
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3, ER-3
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3
   },
   {// Queen
    // A      B      C      D      E      F      G      H
-    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61,
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80,
-    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
-    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
-    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80
   },
   {// King
    //A    B    C    D    E    F    G    H
-     16,  78, 108, 139, 139, 108,  78,  16,
+     18,  77, 105, 135, 135, 105,  77,  18,
-     78, 139, 170, 200, 200, 170, 139,  78,
+     77, 135, 165, 193, 193, 165, 135,  77,
-    108, 170, 200, 230, 230, 200, 170, 108,
+    105, 165, 193, 222, 222, 193, 165, 105,
-    139, 200, 230, 261, 261, 230, 200, 139,
+    135, 193, 222, 251, 251, 222, 193, 135,
-    139, 200, 230, 261, 261, 230, 200, 139,
+    135, 193, 222, 251, 251, 222, 193, 135,
-    108, 170, 200, 230, 230, 200, 170, 108,
+    105, 165, 193, 222, 222, 193, 165, 105,
-     78, 139, 170, 200, 200, 170, 139,  78,
+     77, 135, 165, 193, 193, 165, 135,  77,
-     16,  78, 108, 139, 139, 108,  78,  16
+     18,  77, 105, 135, 135, 105,  77,  18
   }
 };
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,10 +28,11 @@
 #include <string>
 #include <sstream>
 
+#include "history.h"
 #include "movepick.h"
 #include "san.h"
 
-extern SearchStack EmptySearchStack;
+using std::string;
 
 ////
 //// Local definitions
@@ -39,8 +40,6 @@ extern SearchStack EmptySearchStack;
 
 namespace {
 
-  /// Types
-
   enum Ambiguity {
     AMBIGUITY_NONE,
     AMBIGUITY_FILE,
@@ -48,12 +47,11 @@ namespace {
     AMBIGUITY_BOTH
   };
 
-
+  const History H; // used as dummy argument for MovePicker c'tor
-  /// Functions
 
   Ambiguity move_ambiguity(const Position& pos, Move m);
-  const std::string time_string(int milliseconds);
+  const string time_string(int milliseconds);
-  const std::string score_string(Value v);
+  const string score_string(Value v);
 }
 
 
@@ -65,7 +63,7 @@ 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 std::string move_to_san(const Position& pos, Move m) {
+const string move_to_san(const Position& pos, Move m) {
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
@@ -77,7 +75,7 @@ const std::string move_to_san(const Position& pos, Move m) {
   to = move_to(m);
   pt = type_of_piece(pos.piece_on(move_from(m)));
 
-  std::string san = "";
+  string san = "";
 
   if (m == MOVE_NONE)
       return "(none)";
@@ -115,10 +113,10 @@ const std::string move_to_san(const Position& pos, Move m) {
           san += "x";
       }
       san += square_to_string(move_to(m));
-      if (move_promotion(m))
+      if (move_is_promotion(m))
       {
           san += '=';
-          san += piece_type_to_char(move_promotion(m), true);
+          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
@@ -139,18 +137,19 @@ const std::string move_to_san(const Position& pos, Move m) {
 /// the move is returned.  On failure (i.e. if the string is unparsable, or
 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
 
-Move move_from_san(const Position& pos, const std::string& movestr) {
+Move move_from_san(const Position& pos, const string& movestr) {
 
   assert(pos.is_ok());
 
-  MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
+  MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
+  Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
   // Castling moves
   if (movestr == "O-O-O" || movestr == "O-O-O+")
   {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
-          if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
+          if (move_is_long_castle(m) && pos.pl_move_is_legal(m, pinned))
               return m;
 
       return MOVE_NONE;
@@ -159,7 +158,7 @@ Move move_from_san(const Position& pos, const std::string& movestr) {
   {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
-          if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
+          if (move_is_short_castle(m) && pos.pl_move_is_legal(m, pinned))
               return m;
 
     return MOVE_NONE;
@@ -167,7 +166,7 @@ Move move_from_san(const Position& pos, const std::string& movestr) {
 
   // Normal moves. We use a simple FSM to parse the san string.
   enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
-  static const std::string pieceLetters = "KQRBN";
+  static const string pieceLetters = "KQRBN";
   PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
   File fromFile = FILE_NONE, toFile = FILE_NONE;
   Rank fromRank = RANK_NONE, toRank = RANK_NONE;
@@ -177,7 +176,7 @@ Move move_from_san(const Position& pos, const std::string& movestr) {
   for (size_t i = 0; i < movestr.length(); i++)
   {
       char type, c = movestr[i];
-      if (pieceLetters.find(c) != std::string::npos)
+      if (pieceLetters.find(c) != string::npos)
           type = 'P';
       else if (c >= 'a' && c <= 'h')
           type = 'F';
@@ -275,7 +274,7 @@ Move move_from_san(const Position& pos, const std::string& movestr) {
   while ((m = mp.get_next_move()) != MOVE_NONE)
       if (   pos.type_of_piece_on(move_from(m)) == pt
           && move_to(m) == to
-          && move_promotion(m) == promotion
+          && move_promotion_piece(m) == promotion
           && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
           && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
       {
@@ -293,11 +292,11 @@ Move move_from_san(const Position& pos, const std::string& movestr) {
 /// length of 80 characters.  After a line break, 'startColumn' spaces are
 /// inserted at the beginning of the new line.
 
-const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
+const string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
 
   StateInfo st;
   std::stringstream s;
-  std::string moveStr;
+  string moveStr;
   size_t length = 0;
   size_t maxLength = 80 - startColumn;
   Position p(pos);
@@ -326,15 +325,16 @@ const std::string line_to_san(const Position& pos, Move line[], int startColumn,
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").
 
-const std::string pretty_pv(const Position& pos, int time, int depth,
+const string pretty_pv(const Position& pos, int time, int depth,
-                            uint64_t nodes, Value score, Move pv[]) {
+                       uint64_t nodes, Value score, ValueType type, Move pv[]) {
   std::stringstream s;
 
   // Depth
   s << std::setw(2) << depth << "  ";
 
   // Score
-  s << std::setw(8) << score_string(score);
+  s << ((type == VALUE_TYPE_LOWER)? ">" : ((type == VALUE_TYPE_UPPER)? "<" : " "));
+  s << std::setw(7) << score_string(score);
 
   // Time
   s << std::setw(8) << time_string(time) << " ";
@@ -367,12 +367,13 @@ namespace {
     if (type_of_piece(pc) == KING)
         return AMBIGUITY_NONE;
 
-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
+    MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
+    Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
     Move mv, moveList[8];
 
     int n = 0;
     while ((mv = mp.get_next_move()) != MOVE_NONE)
-        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
+        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv, pinned))
             moveList[n++] = mv;
 
     if (n == 1)
@@ -397,7 +398,7 @@ namespace {
   }
 
 
-  const std::string time_string(int milliseconds) {
+  const string time_string(int milliseconds) {
 
     std::stringstream s;
     s << std::setfill('0');
@@ -414,7 +415,7 @@ namespace {
   }
 
 
-  const std::string score_string(Value v) {
+  const string score_string(Value v) {
 
     std::stringstream s;
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -39,6 +39,6 @@
 extern const std::string move_to_san(const 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, Move pv[]);
+extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, ValueType type, Move pv[]);
 
 #endif // !defined(SAN_H_INCLUDED)

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,12 +26,7 @@
 ////
 
 #include "depth.h"
-#include "history.h"
+#include "move.h"
-#include "lock.h"
-#include "movegen.h"
-#include "position.h"
-#include "tt.h"
-#include "value.h"
 
 
 ////
@@ -53,7 +48,7 @@ const int KILLER_MAX = 2;
 /// current ply.
 
 struct SearchStack {
-  Move pv[PLY_MAX];
+  Move pv[PLY_MAX_PLUS_2];
   Move currentMove;
   Move mateKiller;
   Move threatMove;
@@ -65,28 +60,16 @@ struct SearchStack {
 };
 
 
-////
-//// Global variables
-////
-
-extern SearchStack EmptySearchStack;
-extern TranspositionTable TT;
-extern int ActiveThreads;
-extern Lock SMPLock;
-
-// Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;
-
-
 ////
 //// Prototypes
 ////
 
 extern void init_threads();
 extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
+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[]);
+extern int perft(Position &pos, Depth depth);
 extern int64_t nodes_searched();
 
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,13 +46,13 @@ const int THREAD_MAX = 8;
 struct SplitPoint {
   SplitPoint *parent;
   Position pos;
-  SearchStack sstack[THREAD_MAX][PLY_MAX];
+  SearchStack sstack[THREAD_MAX][PLY_MAX_PLUS_2];
   SearchStack *parentSstack;
   int ply;
   Depth depth;
-  volatile Value alpha, beta, bestValue;
+  volatile Value alpha, beta, bestValue, futilityValue;
+  Value approximateEval;
   bool pvNode;
-  Bitboard dcCandidates;
   int master, slaves[THREAD_MAX];
   Lock lock;
   MovePicker *mp;
@@ -66,13 +66,14 @@ struct Thread {
   SplitPoint *splitPoint;
   int activeSplitPoints;
   uint64_t nodes;
+  uint64_t betaCutOffs[2];
   bool failHighPly1;
   volatile bool stop;
   volatile bool running;
   volatile bool idle;
   volatile bool workIsWaiting;
   volatile bool printCurrentLine;
-  unsigned char pad[64];
+  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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,9 +25,13 @@
 #include <cassert>
 #include <cmath>
 #include <cstring>
+#include <xmmintrin.h>
 
+#include "movegen.h"
 #include "tt.h"
 
+// The main transposition table
+TranspositionTable TT;
 
 ////
 //// Functions
@@ -51,25 +55,25 @@ TranspositionTable::~TranspositionTable() {
 
 void TranspositionTable::set_size(unsigned mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 4096);
+  assert(mbSize >= 4 && mbSize <= 2048);
 
   unsigned newSize = 1024;
 
-  // We store a cluster of 4 TTEntry for each position and newSize is
+  // We store a cluster of ClusterSize number of TTEntry for each position
-  // the maximum number of storable positions
+  // and newSize is the maximum number of storable positions.
-  while ((2 * newSize) * 4 * (sizeof(TTEntry)) <= (mbSize << 20))
+  while ((2 * newSize) * sizeof(TTCluster) <= (mbSize << 20))
       newSize *= 2;
 
   if (newSize != size)
   {
       size = newSize;
       delete [] entries;
-      entries = new TTEntry[size * 4];
+      entries = new TTCluster[size];
       if (!entries)
       {
           std::cerr << "Failed to allocate " << mbSize
                     << " MB for transposition table." << std::endl;
-          exit(EXIT_FAILURE);
+          Application::exit_with_failure();
       }
       clear();
   }
@@ -83,7 +87,17 @@ void TranspositionTable::set_size(unsigned mbSize) {
 
 void TranspositionTable::clear() {
 
-  memset(entries, 0, size * 4 * sizeof(TTEntry));
+  memset(entries, 0, size * sizeof(TTCluster));
+}
+
+
+/// 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;
 }
 
 
@@ -97,23 +111,24 @@ void TranspositionTable::clear() {
 /// 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 Position& p, Value v, ValueType t, Depth d, Move m) {
+void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m) {
 
   TTEntry *tte, *replace;
+  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key
 
-  tte = replace = first_entry(p);
+  tte = replace = first_entry(posKey);
-  for (int i = 0; i < 4; i++, tte++)
+  for (int i = 0; i < ClusterSize; i++, tte++)
   {
-      if (!tte->key() || tte->key() == p.get_key()) // empty or overwrite old
+      if (!tte->key() || tte->key() == posKey32) // empty or overwrite old
       {
-          // Do not overwrite when new type is VALUE_TYPE_EVAL
+          // Do not overwrite when new type is VALUE_TYPE_EV_LO
-          if (tte->key() && t == VALUE_TYPE_EVAL)
+          if (tte->key() && t == VALUE_TYPE_EV_LO)
               return;
 
           if (m == MOVE_NONE)
               m = tte->move();
 
-          *tte = TTEntry(p.get_key(), v, t, d, m, generation);
+          *tte = TTEntry(posKey32, v, t, d, m, generation);
           return;
       }
       else if (i == 0)  // replace would be a no-op in this common case
@@ -126,7 +141,7 @@ void TranspositionTable::store(const Position& p, Value v, ValueType t, Depth d,
       if (c1 + c2 + c3 > 0)
           replace = tte;
   }
-  *replace = TTEntry(p.get_key(), v, t, d, m, generation);
+  *replace = TTEntry(posKey32, v, t, d, m, generation);
   writes++;
 }
 
@@ -135,26 +150,40 @@ void TranspositionTable::store(const Position& p, Value v, ValueType t, Depth d,
 /// transposition table. Returns a pointer to the TTEntry or NULL
 /// if position is not found.
 
-TTEntry* TranspositionTable::retrieve(const Position& pos) const {
+TTEntry* TranspositionTable::retrieve(const Key posKey) const {
 
-  TTEntry *tte = first_entry(pos);
+  uint32_t posKey32 = posKey >> 32;
+  TTEntry* tte = first_entry(posKey);
 
-  for (int i = 0; i < 4; i++, tte++)
+  for (int i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == pos.get_key())
+      if (tte->key() == posKey32)
           return tte;
 
   return NULL;
 }
 
 
-/// TranspositionTable::first_entry returns a pointer to the first
+/// TranspositionTable::prefetch looks up the current position in the
-/// entry of a cluster given a position.
+/// 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.
 
-inline TTEntry* TranspositionTable::first_entry(const Position& pos) const {
+void TranspositionTable::prefetch(const Key posKey) const {
 
-  return entries + (int(pos.get_key() & (size - 1)) << 2);
+#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
@@ -179,18 +208,51 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 
   for (int i = 0; pv[i] != MOVE_NONE; i++)
   {
-      store(p, VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[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]);
       p.do_move(pv[i], st);
   }
 }
 
 
+/// TranspositionTable::extract_pv() extends a PV by adding moves from the
+/// transposition table at the end. This should ensure that the PV is almost
+/// always at least two plies long, which is important, because otherwise we
+/// 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) {
+
+  const TTEntry* tte;
+  StateInfo st;
+  Position p(pos);
+  int ply = 0;
+
+  // Update position to the end of current PV
+  while (pv[ply] != MOVE_NONE)
+      p.do_move(pv[ply++], st);
+
+  // Try to add moves from TT while possible
+  while (   (tte = retrieve(p.get_key())) != NULL
+         && tte->move() != MOVE_NONE
+         && move_is_legal(p, tte->move())
+         && (!p.is_draw() || ply < 2)
+         && ply < PLY_MAX)
+  {
+      pv[ply] = tte->move();
+      p.do_move(pv[ply++], st);
+  }
+  pv[ply] = MOVE_NONE;
+}
+
+
 /// TranspositionTable::full() returns the permill of all transposition table
 /// entries which have received at least one write during the current search.
 /// It is used to display the "info hashfull ..." information in UCI.
 
 int TranspositionTable::full() const {
 
-  double N = double(size) * 4.0;
+  double N = double(size) * ClusterSize;
   return int(1000 * (1 - exp(writes * 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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,12 +36,12 @@
 
 /// The TTEntry class is the class of transposition table entries
 ///
-/// A TTEntry needs 128 bits to be stored
+/// A TTEntry needs 96 bits to be stored
 ///
-/// bit    0-63: key
+/// bit  0-31: key
-/// bit   64-95: data
+/// bit 32-63: data
-/// bit  96-111: value
+/// bit 64-79: value
-/// bit 112-127: depth
+/// bit 80-95: depth
 ///
 /// the 32 bits of the data field are so defined
 ///
@@ -54,11 +54,11 @@ class TTEntry {
 
 public:
   TTEntry() {}
-  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation)
+  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)) {}
 
-  Key key() const { return key_; }
+  uint32_t key() const { return key_; }
   Depth depth() const { return Depth(depth_); }
   Move move() const { return Move(data & 0x1FFFF); }
   Value value() const { return Value(value_); }
@@ -66,12 +66,26 @@ public:
   int generation() const { return (data >> 23); }
 
 private:
-  Key key_;
+  uint32_t key_;
   uint32_t data;
   int16_t value_;
   int16_t depth_;
 };
 
+
+/// This is the number of TTEntry slots for each position
+const int ClusterSize = 5;
+
+/// Each group of ClusterSize number of TTEntry form a TTCluster
+/// that is indexed by a single position key. Cluster is padded
+/// to a cache line size so to guarantee always aligned accesses.
+
+struct TTCluster {
+  TTEntry data[ClusterSize];
+  char cache_line_padding[64 - sizeof(TTEntry[ClusterSize])];
+};
+
+
 /// The transposition table class. This is basically just a huge array
 /// containing TTEntry objects, and a few methods for writing new entries
 /// and reading new ones.
@@ -83,18 +97,28 @@ public:
   ~TranspositionTable();
   void set_size(unsigned mbSize);
   void clear();
-  void store(const Position& pos, Value v, ValueType type, Depth d, Move m);
+  void store(const Key posKey, Value v, ValueType type, Depth d, Move m);
-  TTEntry* retrieve(const Position& pos) const;
+  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);
   int full() const;
 
 private:
-  inline TTEntry* first_entry(const Position& pos) const;
+  inline TTEntry* first_entry(const Key posKey) const;
 
-  unsigned size, writes;
+  // Be sure 'writes' is at least one cache line away
-  TTEntry* entries;
+  // from read only variables.
+  unsigned char pad_before[64 - sizeof(unsigned)];
+  unsigned writes; // heavy SMP read/write access here
+  unsigned char pad_after[64];
+
+  unsigned size;
+  TTCluster* entries;
   uint8_t generation;
 };
 
+extern TranspositionTable TT;
+
 #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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -31,9 +31,9 @@ typedef __int8 int8_t;
 typedef unsigned __int8 uint8_t;
 typedef __int16 int16;
 typedef unsigned __int16 uint16_t;
-typedef __int32 int32;
+typedef __int32 int32_t;
 typedef unsigned __int32 uint32_t;
-typedef __int64 int64;
+typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
 
 typedef __int16 int16_t;
@@ -41,7 +41,36 @@ typedef __int64 int64_t;
 
 #endif // !defined(_MSC_VER)
 
-// Hash keys:
+// Hash keys
 typedef uint64_t Key;
 
+// Bitboard type
+typedef uint64_t Bitboard;
+
+
+////
+//// Compiler specific defines
+////
+
+// Quiet a warning on Intel compiler
+#if !defined(__SIZEOF_INT__ )
+#define __SIZEOF_INT__ 0
+#endif
+
+// Check for 64 bits for different compilers: Intel, MSVC and gcc
+#if defined(__x86_64) || defined(_M_X64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
+#define IS_64BIT
+#endif
+
+#if defined(IS_64BIT) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
+#define USE_BSFQ
+#endif
+
+// Cache line alignment specification
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#else
+#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,6 +38,7 @@
 #include "uci.h"
 #include "ucioption.h"
 
+using namespace std;
 
 ////
 //// Local definitions:
@@ -48,7 +49,7 @@ namespace {
   // UCIInputParser is a class for parsing UCI input. The class
   // is actually a string stream built on a given input string.
 
-  typedef std::istringstream UCIInputParser;
+  typedef istringstream UCIInputParser;
 
   // 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()
@@ -56,11 +57,11 @@ namespace {
   Position RootPosition;
 
   // Local functions
-  void get_command();
+  bool handle_command(const string& command);
-  void handle_command(const std::string &command);
   void set_option(UCIInputParser& uip);
   void set_position(UCIInputParser& uip);
-  void go(UCIInputParser &uip);
+  bool go(UCIInputParser& uip);
+  void perft(UCIInputParser& uip);
 }
 
 
@@ -71,14 +72,22 @@ namespace {
 /// uci_main_loop() is the only global function in this file. It is
 /// called immediately after the program has finished initializing.
 /// The program remains in this loop until it receives the "quit" UCI
-/// command.
+/// command. It waits for a command from the user, and passes this
+/// command to handle_command and also intercepts EOF from stdin,
+/// by translating EOF to the "quit" command. This ensures that Stockfish
+/// exits gracefully if the GUI dies unexpectedly.
 
 void uci_main_loop() {
 
   RootPosition.from_fen(StartPosition);
+  string command;
 
-  while (1)
+  do {
-      get_command();
+      // Wait for a command from stdin
+      if (!getline(cin, command))
+          command = "quit";
+
+  } while (handle_command(command));
 }
 
 
@@ -88,64 +97,43 @@ void uci_main_loop() {
 
 namespace {
 
-  // get_command() waits for a command from the user, and passes
-  // this command to handle_command.  get_command also intercepts
-  // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Stockfish exits gracefully if the GUI dies
-  // unexpectedly.
-
-  void get_command() {
-
-    std::string command;
-
-    if (!std::getline(std::cin, command))
-        command = "quit";
-
-    handle_command(command);
-  }
-
-
   // handle_command() takes a text string as input, uses a
   // UCIInputParser object to parse this text string as a UCI command,
   // and calls the appropriate functions. In addition to the UCI
   // commands, the function also supports a few debug commands.
 
-  void handle_command(const std::string &command) {
+  bool handle_command(const string& command) {
 
     UCIInputParser uip(command);
-    std::string token;
+    string token;
 
-    uip >> token; // operator >> skips any whitespace
+    uip >> token; // operator>>() skips any whitespace
 
     if (token == "quit")
+        return false;
+
+    if (token == "go")
+        return go(uip);
+
+    if (token == "uci")
     {
-        OpeningBook.close();
+        cout << "id name " << engine_name()
-        stop_threads();
+             << "\nid author Tord Romstad, Marco Costalba, Joona Kiiski\n";
-        quit_eval();
-        exit(0);
-    }
-    else if (token == "uci")
-    {
-        std::cout << "id name " << engine_name() << std::endl
-                  << "id author Tord Romstad, Marco Costalba"
-                  << std::endl;
         print_uci_options();
-        std::cout << "uciok" << std::endl;
+        cout << "uciok" << endl;
     }
     else if (token == "ucinewgame")
     {
-        TT.clear();
+        push_button("New Game");
         Position::init_piece_square_tables();
         RootPosition.from_fen(StartPosition);
     }
     else if (token == "isready")
-        std::cout << "readyok" << std::endl;
+        cout << "readyok" << endl;
     else if (token == "position")
         set_position(uip);
     else if (token == "setoption")
         set_option(uip);
-    else if (token == "go")
-        go(uip);
 
     // The remaining commands are for debugging purposes only.
     // Perhaps they should be removed later in order to reduce the
@@ -160,30 +148,26 @@ namespace {
     else if (token == "eval")
     {
         EvalInfo ei;
-        std::cout << "Incremental mg: " << RootPosition.mg_value()
+        cout << "Incremental mg: " << mg_value(RootPosition.value())
-                  << std::endl;
+             << "\nIncremental eg: " << eg_value(RootPosition.value())
-        std::cout << "Incremental eg: " << RootPosition.eg_value()
+             << "\nFull eval: " << evaluate(RootPosition, ei, 0) << endl;
-                  << std::endl;
-        std::cout << "Full eval: "
-                  << evaluate(RootPosition, ei, 0)
-                  << std::endl;
     }
     else if (token == "key")
-    {
+        cout << "key: " << hex << RootPosition.get_key()
-        std::cout << "key: " << std::hex << RootPosition.get_key()
+             << "\nmaterial key: " << RootPosition.get_material_key()
-                  << " material key: " << RootPosition.get_material_key()
+             << "\npawn key: " << RootPosition.get_pawn_key() << endl;
-                  << " pawn key: " << RootPosition.get_pawn_key()
+    else if (token == "perft")
-                  << std::endl;
+        perft(uip);
-    }
     else
     {
-        std::cout << "Unknown command: " << command << std::endl;
+        cout << "Unknown command: " << command << endl;
         while (!uip.eof())
         {
             uip >> token;
-            std::cout << token << std::endl;
+            cout << token << endl;
         }
     }
+    return true;
   }
 
 
@@ -195,15 +179,15 @@ namespace {
 
   void set_position(UCIInputParser& uip) {
 
-    std::string token;
+    string token;
 
-    uip >> token; // operator >> skips any whitespace
+    uip >> token; // operator>>() skips any whitespace
 
     if (token == "startpos")
         RootPosition.from_fen(StartPosition);
     else if (token == "fen")
     {
-        std::string fen;
+        string fen;
         while (token != "moves" && !uip.eof())
         {
             uip >> token;
@@ -229,9 +213,9 @@ namespace {
                 if (RootPosition.rule_50_counter() == 0)
                     RootPosition.reset_game_ply();
             }
-            // Our StateInfo st is about going out of scope,
+            // Our StateInfo st is about going out of scope so copy
-            // so save its content before they disappear.
+            // its content inside RootPosition before they disappear.
-            RootPosition.setStartState(st);
+            RootPosition.saveState();
         }
     }
   }
@@ -245,7 +229,7 @@ namespace {
 
   void set_option(UCIInputParser& uip) {
 
-    std::string token, name;
+    string token, name;
 
     uip >> token;
     if (token == "name")
@@ -261,7 +245,10 @@ namespace {
         }
         if (token == "value")
         {
-            std::getline(uip, token); // reads until end of line
+            // 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);
         } else
             push_button(name);
@@ -275,11 +262,12 @@ namespace {
   // and is ready to read the second token. The function sets the
   // thinking time and other parameters from the input string, and
   // calls think() (defined in search.cpp) with the appropriate
-  // parameters.
+  // parameters. Returns false if a quit command is received while
+  // thinking, returns true otherwise.
 
-  void go(UCIInputParser &uip) {
+  bool go(UCIInputParser& uip) {
 
-    std::string token;
+    string token;
 
     int time[2] = {0, 0}, inc[2] = {0, 0};
     int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
@@ -329,7 +317,27 @@ namespace {
 
     assert(RootPosition.is_ok());
 
-    think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
+    return think(RootPosition, infinite, ponder, RootPosition.side_to_move(),
-          inc, movesToGo, depth, nodes, moveTime, searchMoves);
+                 time, inc, movesToGo, depth, nodes, moveTime, searchMoves);
+  }
+
+  void perft(UCIInputParser& uip) {
+
+    string token;
+    int depth, tm, n;
+    Position pos = RootPosition;
+
+    if (uip.eof())
+        return;
+
+    uip >> depth;
+    tm = get_system_time();
+
+    n = perft(pos, depth * OnePly);
+
+    tm = get_system_time() - tm;
+    std::cout << "\nNodes " << n
+              << "\nTime (ms) " << tm
+              << "\nNodes/second " << (int)(n/(tm/1000.0)) << std::endl;
   }
 }

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -33,13 +33,7 @@
 #include "thread.h"
 #include "ucioption.h"
 
-
+using std::string;
-////
-//// Variables
-////
-
-bool Chess960;
-
 
 ////
 //// Local definitions
@@ -53,11 +47,11 @@ namespace {
 
   enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
 
-  typedef std::vector<std::string> ComboValues;
+  typedef std::vector<string> ComboValues;
 
   struct Option {
 
-    std::string name, defaultValue, currentValue;
+    string name, defaultValue, currentValue;
     OptionType type;
     size_t idx;
     int minValue, maxValue;
@@ -71,7 +65,7 @@ namespace {
     bool operator<(const Option& o) const { return this->idx < o.idx; }
   };
 
-  typedef std::map<std::string, Option> Options;
+  typedef std::map<string, Option> Options;
 
   ///
   /// Constants
@@ -122,25 +116,22 @@ namespace {
     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(14, 1, 100);
+    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["Futility Pruning (Main Search)"] = Option(true);
-    o["Futility Pruning (Quiescence Search)"] = Option(true);
-    o["LSN filtering"] = Option(false);
-    o["LSN Time Margin (sec)"] = Option(4, 1, 10);
-    o["LSN Value Margin"] = Option(200, 100, 600);
     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, THREAD_MAX);
-    o["Hash"] = Option(32, 4, 4096);
+    o["Hash"] = Option(32, 4, 2048);
     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);
 
     // Any option should know its name so to be easily printed
     for (Options::iterator it = o.begin(); it != o.end(); ++it)
@@ -155,7 +146,7 @@ namespace {
 
   // stringify converts a value of type T to a std::string
   template<typename T>
-  std::string stringify(const T& v) {
+  string stringify(const T& v) {
 
      std::ostringstream ss;
      ss << v;
@@ -168,7 +159,7 @@ namespace {
   // type changes a template seems a proper solution.
 
   template<typename T>
-  T get_option_value(const std::string& optionName) {
+  T get_option_value(const string& optionName) {
 
       T ret = T();
       if (options.find(optionName) == options.end())
@@ -179,6 +170,18 @@ namespace {
       return ret;
   }
 
+  // Specialization for std::string where instruction 'ss >> ret;'
+  // would erroneusly tokenize a string with spaces.
+
+  template<>
+  string get_option_value<string>(const string& optionName) {
+
+      if (options.find(optionName) == options.end())
+          return string();
+
+      return options[optionName].currentValue;
+  }
+
 }
 
 ////
@@ -202,15 +205,6 @@ void init_uci_options() {
 
   options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
   options["Threads"].currentValue = stringify(Min(cpu_count(), 7));
-
-  // Increase the minimum split depth when the number of CPUs is big.
-  // It would probably be better to let this depend on the number of threads
-  // instead.
-  if (cpu_count() > 4)
-  {
-      options["Minimum Split Depth"].defaultValue = "6";
-      options["Minimum Split Depth"].currentValue = "6";
-  }
 }
 
 
@@ -245,9 +239,7 @@ void print_uci_options() {
           std::cout << " default " << it->defaultValue;
 
       if (it->type == SPIN)
-          std::cout << " min " << it->minValue
+          std::cout << " min " << it->minValue << " max " << it->maxValue;
-                    << " max " << it->maxValue;
-
       else if (it->type == COMBO)
           for (ComboValues::const_iterator itc = it->comboValues.begin();
               itc != it->comboValues.end(); ++itc)
@@ -260,7 +252,7 @@ void print_uci_options() {
 /// get_option_value_bool() returns the current value of a UCI parameter of
 /// type "check".
 
-bool get_option_value_bool(const std::string& optionName) {
+bool get_option_value_bool(const string& optionName) {
 
   return get_option_value<bool>(optionName);
 }
@@ -271,7 +263,7 @@ bool get_option_value_bool(const std::string& optionName) {
 /// it could also be used with a "combo" parameter, where all the available
 /// values are integers.
 
-int get_option_value_int(const std::string& optionName) {
+int get_option_value_int(const string& optionName) {
 
   return get_option_value<int>(optionName);
 }
@@ -280,9 +272,9 @@ int get_option_value_int(const std::string& optionName) {
 /// get_option_value_string() returns the current value of a UCI parameter as
 /// a string. It is used with parameters of type "combo" and "string".
 
-const std::string get_option_value_string(const std::string& optionName) {
+string get_option_value_string(const string& optionName) {
 
-   return get_option_value<std::string>(optionName);
+   return get_option_value<string>(optionName);
 }
 
 
@@ -290,28 +282,27 @@ const std::string get_option_value_string(const std::string& optionName) {
 /// the function does not check that the new value is legal for the given
 /// parameter: This is assumed to be the responsibility of the GUI.
 
-void set_option_value(const std::string& optionName,
+void set_option_value(const string& name, const string& value) {
-                      const std::string& newValue) {
 
   // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
-  // newValue according to standard C++ convention before to store it.
+  // value according to standard C++ convention before to store it.
-  std::string v(newValue);
+  string v(value);
   if (v == "true")
       v = "1";
   else if (v == "false")
       v = "0";
 
-  if (options.find(optionName) != options.end())
+  if (options.find(name) != options.end())
-      options[optionName].currentValue = v;
+      options[name].currentValue = v;
   else
-      std::cout << "No such option: " << optionName << std::endl;
+      std::cout << "No such option: " << name << std::endl;
 }
 
 
 /// push_button() is used to tell the engine that a UCI parameter of type
 /// "button" has been selected:
 
-void push_button(const std::string& buttonName) {
+void push_button(const string& buttonName) {
 
   set_option_value(buttonName, "true");
 }
@@ -321,7 +312,7 @@ void push_button(const std::string& buttonName) {
 /// been selected since the last time the function was called, in this case
 /// it also resets the button.
 
-bool button_was_pressed(const std::string& buttonName) {
+bool button_was_pressed(const string& buttonName) {
 
   if (!get_option_value<bool>(buttonName))
 	  return false;

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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,14 +27,6 @@
 
 #include <string>
 
-
-////
-//// Variables
-////
-
-extern bool Chess960;
-
-
 ////
 //// Prototypes
 ////
@@ -43,10 +35,9 @@ extern void init_uci_options();
 extern void print_uci_options();
 extern bool get_option_value_bool(const std::string& optionName);
 extern int get_option_value_int(const std::string& optionName);
-extern const std::string get_option_value_string(const std::string &optionName);
+extern std::string get_option_value_string(const std::string& optionName);
 extern bool button_was_pressed(const std::string& buttonName);
-extern void set_option_value(const std::string &optionName,
+extern void set_option_value(const std::string& optionName,const std::string& newValue);
-                             const std::string &newValue);
 extern void push_button(const std::string& buttonName);
 
 

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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   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 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -37,7 +37,9 @@ enum ValueType {
   VALUE_TYPE_UPPER = 1,  // Upper bound
   VALUE_TYPE_LOWER = 2,  // Lower bound
   VALUE_TYPE_EXACT = 3,  // Exact score
-  VALUE_TYPE_EVAL  = 4   // Evaluation cache
+  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
 };
 
 
@@ -50,6 +52,44 @@ enum Value {
 };
 
 
+/// Score enum keeps a midgame and an endgame value in a single
+/// integer (enum), first LSB 16 bits are used to store endgame
+/// value, while upper bits are used for midgame value.
+
+// Compiler is free to choose the enum type as long as can keep
+// its data, so ensure Score to be an integer type.
+enum Score { 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)); }
+#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); }
+
+inline Score operator-(Score s) { return Score(-int(s)); }
+inline Score operator+(Score s1, Score s2) { return Score(int(s1) + int(s2)); }
+inline Score operator-(Score s1, Score s2) { return Score(int(s1) - int(s2)); }
+inline void operator+=(Score& s1, Score s2) { s1 = Score(int(s1) + int(s2)); }
+inline void operator-=(Score& s1, Score s2) { s1 = Score(int(s1) - int(s2)); }
+inline Score operator*(int i, Score s) { return Score(i * int(s)); }
+
+// Division must be handled separately for each term
+inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); }
+
+// Only declared but not defined. We don't want to multiply two scores due to
+// a very high risk of overflow. So user should explicitly convert to integer.
+inline Score operator*(Score s1, Score s2);
+
+
 ////
 //// Constants and variables
 ////
@@ -62,16 +102,16 @@ enum Value {
 ///
 /// Values modified by Joona Kiiski
 
-const Value PawnValueMidgame   = Value(0x0CC);
+const Value PawnValueMidgame   = Value(0x0C6);
-const Value PawnValueEndgame   = Value(0x101);
+const Value PawnValueEndgame   = Value(0x102);
-const Value KnightValueMidgame = Value(0x332);
+const Value KnightValueMidgame = Value(0x331);
 const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x345);
+const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x356);
+const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame   = Value(0x4F8);
+const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame   = Value(0x500);
+const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame  = Value(0x9D5);
+const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame  = Value(0x9FB);
+const Value QueenValueEndgame  = Value(0x9FE);
 
 const Value PieceValueMidgame[17] = {
   Value(0),
@@ -93,10 +133,9 @@ const Value PieceValueEndgame[17] = {
   Value(0), Value(0), Value(0)
 };
 
-/// Bonus for having the side to move
+/// Bonus for having the side to move (modified by Joona Kiiski)
 
-const Value TempoValueMidgame = Value(48);
+const Score TempoValue = make_score(48, 22);
-const Value TempoValueEndgame = Value(21);
 
 
 ////