Stockfish 1.7

Signatures are:

./stockfish bench 128 1 12 default depth
8299338

./stockfish bench 128 1 13 default depth
15694903

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

Readme.txt

@@ -52,14 +52,13 @@ UCI parameter "Book File".
 
 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
+For big-endian machines like Power PC you need to enable the proper
-Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
+flag changing from -DNBIGENDIAN to -DBIGENDIAN in the Makefile.
 
 Stockfish has POPCNT instruction runtime detection and support. This can
 give an extra speed on Core i7 or similar systems. To enable this feature
-(disabled by default) simply uncomment #define USE_POPCNT in bitcount.h
+compile with 'make icc-profile-popcnt'
-before to compile.
 
 On 64 bit Unix-like systems the 'bsfq' assembly instruction will be used
 for bit counting. Detection is automatic at compile time, but in case you

src/Makefile

@@ -21,6 +21,10 @@
 ### Executable name. Do not change
 EXE = stockfish
 
+### Installation dir definitions
+PREFIX = /usr/local
+BINDIR = $(PREFIX)/bin
+
 
 ### ==========================================================================
 ### Compiler speed switches for both GCC and ICC. These settings are generally
@@ -39,6 +43,14 @@ 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
@@ -47,9 +59,9 @@ PGOBENCH = ./$(EXE) bench 32 1 10 default depth
 
 
 ### General compiler settings. Do not change
-GCCFLAGS += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing
+GCCFLAGS += -g -Wall -fno-exceptions -fno-rtti
-ICCFLAGS += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing -wd383,869,981,10187,10188,11505,11503
+ICCFLAGS += -g -Wall -fno-exceptions -fno-rtti -wd383,869,981,10187,10188,11505,11503
-ICCFLAGS-OSX += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing -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
@@ -72,8 +84,10 @@ help:
 	@echo "Makefile options:"
 	@echo ""
 	@echo "make                >  Default: Compiler = g++"
+	@echo "make gcc-popcnt     >  Compiler = g++ + popcnt-support"
 	@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++"
@@ -82,14 +96,18 @@ help:
 	@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 hpux           >  HP-UX. Compiler = aCC"
 	@echo "make strip          >  Strip executable"
 	@echo "make clean          >  Clean up"
 	@echo ""
 
 all: $(EXE) .depend
 
+test check: default
+	@$(PGOBENCH)
+
 clean:
-	$(RM) *.o .depend *~ $(EXE)
+	$(RM) *.o .depend *~ $(EXE) core bench.txt
 
 
 ### Possible targets. You may add your own ones here
@@ -99,6 +117,13 @@ gcc:
 	CXXFLAGS="$(GCCFLAGS)" \
 	all
 
+gcc-popcnt:
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS) -DUSE_POPCNT" \
+	all
+
+
 icc:
 	$(MAKE) \
 	CXX='icpc' \
@@ -133,11 +158,46 @@ icc-profile:
 	$(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:
 	$(MAKE) \
 	CXX='g++' \
 	CXXFLAGS="$(GCCFLAGS)" \
 	CXXFLAGS+='-arch ppc' \
+	CXXFLAGS+='-DBIGENDIAN' \
 	LDFLAGS+='-arch ppc' \
 	all
 
@@ -146,6 +206,7 @@ osx-ppc64:
 	CXX='g++' \
 	CXXFLAGS="$(GCCFLAGS)" \
 	CXXFLAGS+='-arch ppc64' \
+	CXXFLAGS+='-DBIGENDIAN' \
 	LDFLAGS+='-arch ppc64' \
 	all
 
@@ -153,16 +214,16 @@ osx-x86:
 	$(MAKE) \
 	CXX='g++' \
 	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch i386' \
+	CXXFLAGS+='-arch i386 -mdynamic-no-pic' \
-	LDFLAGS+='-arch i386' \
+	LDFLAGS+='-arch i386 -mdynamic-no-pic' \
 	all
 
 osx-x86_64:
 	$(MAKE) \
 	CXX='g++' \
 	CXXFLAGS="$(GCCFLAGS)" \
-	CXXFLAGS+='-arch x86_64' \
+	CXXFLAGS+='-arch x86_64 -mdynamic-no-pic' \
-	LDFLAGS+='-arch x86_64' \
+	LDFLAGS+='-arch x86_64 -mdynamic-no-pic' \
 	all
 	
 osx-icc32:
@@ -245,6 +306,12 @@ osx-icc64-profile:
 	$(MAKE) osx-icc64-profile-use
 	@rm -rf profdir bench.txt
 
+hpux:
+	$(MAKE) \
+	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG' \
+	CXXFLAGS="" \
+	LDFLAGS="" \
+	all
 
 
 strip:
@@ -255,9 +322,14 @@ strip:
 $(EXE): $(OBJS)
 	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
 
+### Installation
+install: default
+	-mkdir -p -m 755 $(BINDIR)
+	-cp $(EXE) $(BINDIR)
+	-strip $(BINDIR)/$(EXE)
 
 ### Dependencies. Do not change
 .depend:
-	$(CXX) -msse -MM $(OBJS:.o=.cpp) > $@
+	-@$(CXX) -msse -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null
 
-include .depend
+-include .depend

src/application.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -49,6 +49,7 @@ Application::Application() {
     Position::init_piece_square_tables();
     init_eval(1);
     init_bitbases();
+    init_search();
     init_threads();
 
     // Make random number generation less deterministic, for book moves
@@ -58,7 +59,7 @@ Application::Application() {
 
 Application::~Application() {
 
-  stop_threads();
+  exit_threads();
   quit_eval();
 }
 

src/application.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/benchmark.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -84,9 +84,9 @@ void benchmark(const string& commandLine) {
   }
   csStr >> threads;
   csVal >> val;
-  if (val < 1 || val > THREAD_MAX)
+  if (val < 1 || val > MAX_THREADS)
   {
-      cerr << "The number of threads must be between 1 and " << THREAD_MAX << endl;
+      cerr << "The number of threads must be between 1 and " << MAX_THREADS << endl;
       Application::exit_with_failure();
   }
   set_option_value("Hash", ttSize);
@@ -104,7 +104,7 @@ void benchmark(const string& commandLine) {
 
   if (limitType == "time")
       secsPerPos = val * 1000;
-  else if (limitType == "depth")
+  else if (limitType == "depth" || limitType == "perft")
       maxDepth = val;
   else
       maxNodes = val;
@@ -153,7 +153,9 @@ void benchmark(const string& commandLine) {
       int dummy[2] = {0, 0};
       Position pos(*it);
       cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
-      if (!think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+      if (limitType == "perft")
+          totalNodes += perft(pos, maxDepth * OnePly);
+      else if (!think(pos, false, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
           break;
       totalNodes += nodes_searched();
   }

src/benchmark.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/bitbase.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/bitbase.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/bitboard.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -297,8 +297,8 @@ void init_bitboards() {
 
 #if defined(IS_64BIT) && !defined(USE_BSFQ)
 
-CACHE_LINE_ALIGNMENT
+static CACHE_LINE_ALIGNMENT
-static const int BitTable[64] = {
+const int BitTable[64] = {
   0, 1, 2, 7, 3, 13, 8, 19, 4, 25, 14, 28, 9, 34, 20, 40, 5, 17, 26, 38, 15,
   46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63, 6, 12, 18, 24, 27, 33, 39,
   16, 37, 45, 47, 30, 53, 49, 56, 62, 11, 23, 32, 36, 44, 52, 55, 61, 22, 43,
@@ -317,8 +317,8 @@ Square pop_1st_bit(Bitboard* b) {
 
 #elif !defined(USE_BSFQ)
 
-CACHE_LINE_ALIGNMENT
+static CACHE_LINE_ALIGNMENT
-static const int BitTable[64] = {
+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,
@@ -336,30 +336,72 @@ union b_union {
 
     Bitboard b;
     struct {
+#if defined (BIGENDIAN)
+        uint32_t h;
+        uint32_t l;
+#else
         uint32_t l;
         uint32_t h;
+#endif
     } dw;
 };
 
-// WARNING: Needs -fno-strict-aliasing compiler option
 Square pop_1st_bit(Bitboard* bb) {
 
    b_union u;
+   Square ret;
 
    u.b = *bb;
 
    if (u.dw.l)
    {
-      *((uint32_t*)bb) = u.dw.l & (u.dw.l - 1);
+       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
-      return 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]);
-  *((uint32_t*)bb+1) = u.dw.h & (u.dw.h - 1); // Little endian only?
+   u.dw.h &= (u.dw.h - 1);
-  return Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
+   *bb = u.b;
+   return ret;
 }
 
 #endif
 
+// Optimized bitScanReverse32() implementation by Pascal Georges. Note
+// that first bit is 1, this allow to differentiate between 0 and 1.
+static CACHE_LINE_ALIGNMENT
+const char MsbTable[256] = {
+  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
+  5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7,
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+  7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+  8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8
+};
+
+int bitScanReverse32(uint32_t b)
+{
+   int result = 0;
+
+   if (b > 0xFFFF)
+   {
+      b >>= 16;
+      result += 16;
+   }
+   if (b > 0xFF)
+   {
+      b >>= 8;
+      result += 8;
+   }
+   return result + MsbTable[b];
+}
+
 namespace {
 
   // All functions below are used to precompute various bitboards during

src/bitboard.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -349,6 +349,7 @@ extern Square pop_1st_bit(Bitboard* b);
 
 extern void print_bitboard(Bitboard b);
 extern void init_bitboards();
+extern int bitScanReverse32(uint32_t b);
 
 
 #endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -22,62 +22,22 @@
 #if !defined(BITCOUNT_H_INCLUDED)
 #define BITCOUNT_H_INCLUDED
 
-// To enable POPCNT support uncomment USE_POPCNT define. For PGO compile on a Core i7
-// you may want to collect profile data first with USE_POPCNT disabled and then, in a
-// second profiling session, with USE_POPCNT enabled so to exercise both paths. Don't
-// forget to leave USE_POPCNT enabled for the final optimized compile though ;-)
-
-//#define USE_POPCNT
-
-
 #include "types.h"
 
-// Select type of intrinsic bit count instruction to use
+// 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(IS_64BIT) && defined(USE_POPCNT) // Intel compiler
+#if !defined(USE_POPCNT)
-
-#include <nmmintrin.h>
-
-inline bool cpu_has_popcnt() {
-
-  int CPUInfo[4] = {-1};
-  __cpuid(CPUInfo, 0x00000001);
-  return (CPUInfo[2] >> 23) & 1;
-}
-
-// Define a dummy template to workaround a compile error if _mm_popcnt_u64() is not defined.
-//
-// If _mm_popcnt_u64() is defined in <nmmintrin.h> it will be choosen first due to
-// C++ overload rules that always prefer a function to a template with the same name.
-// If not, we avoid a compile error and because cpu_has_popcnt() should return false,
-// our templetized _mm_popcnt_u64() is never called anyway.
-template<typename T> inline unsigned _mm_popcnt_u64(T) { return 0; } // Is never called
-
-#define POPCNT_INTRINSIC(x) _mm_popcnt_u64(x)
-
-#elif defined(_MSC_VER) && defined(IS_64BIT) && 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;
-}
-
-// See comment of _mm_popcnt_u64<>() few lines above for an explanation.
-template<typename T> inline unsigned __popcnt64(T) { return 0; } // Is never called
-
-#define POPCNT_INTRINSIC(x) __popcnt64(x)
-
-#else // Safe fallback for unsupported compilers or when USE_POPCNT is disabled
-
-inline bool cpu_has_popcnt() { return false; }
-
 #define POPCNT_INTRINSIC(x) 0
+#elif defined(_MSC_VER)
+#define POPCNT_INTRINSIC(x) (int)__popcnt64(x)
+#elif defined(__GNUC__)
 
-#endif // cpu_has_popcnt() and POPCNT_INTRINSIC() definitions
+#define POPCNT_INTRINSIC(x) ({ \
+   unsigned long __ret; \
+   __asm__("popcnt %1, %0" : "=r" (__ret) : "r" (x)); \
+   __ret; })
+
+#endif
 
 
 /// Software implementation of bit count functions
@@ -144,10 +104,23 @@ inline int count_1s_max_15(Bitboard b) {
 }
 
 
+// Detect hardware POPCNT support
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+
 // Global constant initialized at startup that is set to true if
 // CPU on which application runs supports POPCNT intrinsic. Unless
 // USE_POPCNT is not defined.
+#if defined(USE_POPCNT)
 const bool CpuHasPOPCNT = cpu_has_popcnt();
+#else
+const bool CpuHasPOPCNT = false;
+#endif
 
 
 // Global constant used to print info about the use of 64 optimized

src/book.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -390,7 +390,7 @@ void Book::close() {
 /// Book::file_name() returns the file name of the currently active book,
 /// or the empty string if no book is open.
 
-const string Book::file_name() const {
+const string Book::file_name() { // Not const to compile on HP-UX 11.X
 
   return is_open() ? fileName : "";
 }

src/book.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -53,11 +53,14 @@ struct BookEntry {
 };
 
 class Book : private std::ifstream {
+  Book(const Book&); // just decleared..
+  Book& operator=(const Book&); // ..to avoid a warning
 public:
+  Book() {}
   ~Book();
   void open(const std::string& fName);
   void close();
-  const std::string file_name() const;
+  const std::string file_name();
   Move get_move(const Position& pos);
 
 private:

src/color.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/depth.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -49,6 +49,7 @@ inline void operator+= (Depth &d1, Depth d2) { d1 += int(d2); }
 inline Depth operator- (Depth d, int i) { return Depth(int(d) - i); }
 inline Depth operator- (Depth d1, Depth d2) { return Depth(int(d1) - int(d2)); }
 inline void operator-= (Depth &d, int i) { d = Depth(int(d) - i); }
+inline void operator-= (Depth &d1, Depth d2) { d1 -= int(d2); }
 inline Depth operator* (Depth d, int i) { return Depth(int(d) * i); }
 inline Depth operator* (int i, Depth d) { return Depth(int(d) * i); }
 inline void operator*= (Depth &d, int i) { d = Depth(int(d) * i); }

src/direction.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/direction.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/endgame.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/endgame.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/evaluate.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -25,6 +25,8 @@
 //// Includes
 ////
 
+#include <iostream>
+
 #include "material.h"
 #include "pawns.h"
 
@@ -45,8 +47,10 @@ class Position;
 
 struct EvalInfo {
 
+  EvalInfo() { futilityMargin[0] = futilityMargin[1] = Value(0); }
+
   // Middle game and endgame evaluations
-  Value mgValue, egValue;
+  Score value;
 
   // Pointers to material and pawn hash table entries
   MaterialInfo* mi;
@@ -89,11 +93,11 @@ 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.
+  // in the quiescence search. One for each color.
-  Value futilityMargin;
+  Value futilityMargin[2];
 };
 
 
@@ -102,7 +106,6 @@ struct EvalInfo {
 ////
 
 extern Value evaluate(const Position& pos, EvalInfo& ei, int threadID);
-extern Value quick_evaluate(const Position& pos);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);

src/history.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -42,8 +42,7 @@ History::History() { clear(); }
 
 void History::clear() {
   memset(history, 0, 2 * 8 * 64 * sizeof(int));
-  memset(successCount, 0, 2 * 8 * 64 * sizeof(int));
+  memset(maxStaticValueDelta, 0, 2 * 8 * 64 * sizeof(int));
-  memset(failureCount, 0, 2 * 8 * 64 * sizeof(int));
 }
 
 
@@ -58,13 +57,12 @@ void History::success(Piece p, Square to, Depth d) {
   assert(square_is_ok(to));
 
   history[p][to] += int(d) * int(d);
-  successCount[p][to]++;
 
   // Prevent history overflow
   if (history[p][to] >= HistoryMax)
       for (int i = 0; i < 16; i++)
           for (int j = 0; j < 64; j++)
-              history[i][j] /= 4;
+              history[i][j] /= 2;
 }
 
 
@@ -72,12 +70,18 @@ void History::success(Piece p, Square to, 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, Square to) {
+void History::failure(Piece p, Square to, Depth d) {
 
   assert(piece_is_ok(p));
   assert(square_is_ok(to));
 
-  failureCount[p][to]++;
+  history[p][to] -= int(d) * int(d);
+
+  // Prevent history underflow
+  if (history[p][to] <= -HistoryMax)
+      for (int i = 0; i < 16; i++)
+          for (int j = 0; j < 64; j++)
+              history[i][j] /= 2;
 }
 
 
@@ -93,13 +97,19 @@ int History::move_ordering_score(Piece p, Square to) const {
 }
 
 
-/// History::ok_to_prune() decides whether a move has been sufficiently
+/// History::set_gain() and History::gain() store and retrieve the
-/// unsuccessful that it makes sense to prune it entirely.
+/// gain of a move given the delta of the static position evaluations
+/// before and after the move.
 
-bool History::ok_to_prune(Piece p, Square to, Depth d) const {
+void History::set_gain(Piece p, Square to, Value delta)
-
+{
-  assert(piece_is_ok(p));
+  if (delta >= maxStaticValueDelta[p][to])
-  assert(square_is_ok(to));
+      maxStaticValueDelta[p][to] = delta;
-
+  else
-  return (int(d) * successCount[p][to] < failureCount[p][to]);
+      maxStaticValueDelta[p][to]--;
+}
+
+Value History::gain(Piece p, Square to) const
+{
+  return Value(maxStaticValueDelta[p][to]);
 }

src/history.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -28,6 +28,7 @@
 #include "depth.h"
 #include "move.h"
 #include "piece.h"
+#include "value.h"
 
 
 ////
@@ -47,14 +48,14 @@ public:
   History();
   void clear();
   void success(Piece p, Square to, Depth d);
-  void failure(Piece p, Square to);
+  void failure(Piece p, Square to, Depth d);
   int move_ordering_score(Piece p, Square to) const;
-  bool ok_to_prune(Piece p, Square to, Depth d) const;
+  void set_gain(Piece p, Square to, Value delta);
+  Value gain(Piece p, Square to) const;
 
 private:
   int history[16][64];  // [piece][square]
-  int successCount[16][64];
+  int maxStaticValueDelta[16][64];  // [piece][from_square][to_square]
-  int failureCount[16][64];
 };
 
 
@@ -70,7 +71,7 @@ private:
 /// recently have a bigger importance for move ordering than the moves which
 /// have been searched a long time ago.
 
-const int HistoryMax = 25000 * OnePly;
+const int HistoryMax = 50000 * OnePly;
 
 
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -99,5 +99,4 @@ typedef CRITICAL_SECTION Lock;
 
 #endif
 
-
 #endif // !defined(LOCK_H_INCLUDED)

src/main.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
       if (string(argv[1]) != "bench" || argc < 4 || argc > 8)
           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] "
                << "[timing file name = none]" << endl;
       else
       {

src/material.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -37,9 +37,14 @@ using namespace std;
 
 namespace {
 
+  // Values modified by Joona Kiiski
+  const Value MidgameLimit = Value(15581);
+  const Value EndgameLimit = Value(3998);
+
   // 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] = {
@@ -129,6 +134,22 @@ MaterialInfoTable::~MaterialInfoTable() {
 }
 
 
+/// MaterialInfoTable::game_phase() calculates the phase given the current
+/// position. Because the phase is strictly a function of the material, it
+/// is stored in MaterialInfo.
+
+Phase MaterialInfoTable::game_phase(const Position& pos) {
+
+  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
@@ -151,6 +172,9 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   mi->clear();
   mi->key = key;
 
+  // Store game phase
+  mi->gamePhase = MaterialInfoTable::game_phase(pos);
+
   // Let's look if we have a specialized evaluation function for this
   // particular material configuration. First we look for a fixed
   // configuration one, then a generic one if previous search failed.
@@ -269,8 +293,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
                                  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
                                    pos.piece_count(BLACK, BISHOP), pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
   Color c, them;
-  int sign;
+  int sign, pt1, pt2, pc;
-  int matValue = 0;
+  int v, vv, matValue = 0;
 
   for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
   {
@@ -304,25 +328,27 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
         matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty);
 
     them = opposite_color(c);
+    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 (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+    for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
     {
-        int c1 = sign * pieceCount[c][pt1];
+        pc = pieceCount[c][pt1];
-        if (!c1)
+        if (!pc)
             continue;
 
-        matValue += c1 * LinearCoefficients[pt1];
+        vv = LinearCoefficients[pt1];
 
-        for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
-        {
+            vv +=  pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2]
-            matValue += c1 * pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2];
+                 + pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
-            matValue += c1 * pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
+
-        }
+        v += pc * vv;
     }
+    matValue += sign * v;
   }
   mi->value = int16_t(matValue / 16);
   return mi;
@@ -348,7 +374,6 @@ EndgameFunctions::EndgameFunctions() {
   add<ScalingFunction<KBPPKB>  >("KBPPKB");
   add<ScalingFunction<KBPKN>   >("KBPKN");
   add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
 }
 
 EndgameFunctions::~EndgameFunctions() {

src/material.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -51,9 +51,10 @@ class MaterialInfo {
 public:
   MaterialInfo() : key(0) { clear(); }
 
-  Value material_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;
 
@@ -66,6 +67,7 @@ private:
   EndgameEvaluationFunctionBase* evaluationFunction;
   EndgameScalingFunctionBase* scalingFunction[2];
   int spaceWeight;
+  Phase gamePhase;
 };
 
 /// The MaterialInfoTable class represents a pawn hash table. It is basically
@@ -81,6 +83,8 @@ public:
   ~MaterialInfoTable();
   MaterialInfo* get_material_info(const Position& pos);
 
+  static Phase game_phase(const Position& pos);
+
 private:
   unsigned size;
   MaterialInfo* entries;
@@ -92,12 +96,13 @@ private:
 //// Inline functions
 ////
 
+
 /// MaterialInfo::material_value simply returns the material balance
 /// evaluation that is independent from game phase.
 
-inline Value MaterialInfo::material_value() const {
+inline Score MaterialInfo::material_value() const {
 
-  return Value(value);
+  return make_score(value, value);
 }
 
 
@@ -141,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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/misc.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,6 +27,9 @@
 #  include <sys/time.h>
 #  include <sys/types.h>
 #  include <unistd.h>
+#  if defined(__hpux)
+#     include <sys/pstat.h>
+#  endif
 
 #else
 
@@ -38,6 +41,7 @@
 
 #include <cassert>
 #include <cstdio>
+#include <cstring>
 #include <iomanip>
 #include <iostream>
 #include <sstream>
@@ -50,7 +54,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.5.1";
+static const string EngineVersion = "1.7";
 static const string AppName = "Stockfish";
 static const string AppTag  = "";
 
@@ -179,23 +183,32 @@ int get_system_time() {
 }
 
 
-/// cpu_count() tries to detect the number of CPU cores.
+/// builtin_cpu_count() tries to detect the number of CPU cores, if
+/// hyper-threading is enabled this is the number of logical processors.
 
 #if !defined(_MSC_VER)
 
 #  if defined(_SC_NPROCESSORS_ONLN)
-int cpu_count() {
+static int builtin_cpu_count() {
   return Min(sysconf(_SC_NPROCESSORS_ONLN), 8);
 }
+#  elif defined(__hpux)
+static int builtin_cpu_count() {
+  struct pst_dynamic psd;
+  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
+      return 1;
+
+  return Min(psd.psd_proc_cnt, 8);
+}
 #  else
-int cpu_count() {
+static int builtin_cpu_count() {
   return 1;
 }
 #  endif
 
 #else
 
-int cpu_count() {
+static int builtin_cpu_count() {
   SYSTEM_INFO s;
   GetSystemInfo(&s);
   return Min(s.dwNumberOfProcessors, 8);
@@ -204,6 +217,51 @@ int cpu_count() {
 #endif
 
 
+/// HT_enabled() returns true if hyper-threading is enabled on current machine
+
+static bool HT_enabled() {
+
+  char CPUString[0x20];
+  int CPUInfo[4] = {-1};
+  int nIds, nLogicalCPU, nCores;
+
+  // Detect CPU producer
+  __cpuid(CPUInfo, 0);
+  nIds = CPUInfo[0];
+
+  memset(CPUString, 0, sizeof(CPUString));
+  memcpy(&CPUString[0], &CPUInfo[1], sizeof(int));
+  memcpy(&CPUString[4], &CPUInfo[3], sizeof(int));
+  memcpy(&CPUString[8], &CPUInfo[2], sizeof(int));
+
+  // Not an Intel CPU or CPUID.4 not supported
+  if (strcmp(CPUString, "GenuineIntel") || nIds < 4)
+      return false;
+
+  // Detect if HT Technology is supported
+  __cpuid(CPUInfo, 1);
+  if (!((CPUInfo[3] >> 28) & 1))
+      return false;
+
+  nLogicalCPU = (CPUInfo[1] >> 16) & 0xFF;
+
+  // Detect number of cores
+  __cpuid(CPUInfo, 4);
+  nCores = 1 + ((CPUInfo[0] >> 26) & 0x3F);
+
+  return nLogicalCPU > nCores;
+}
+
+
+/// cpu_count() tries to detect the number of physical CPU cores taking
+/// in account hyper-threading.
+
+int cpu_count() {
+
+  return HT_enabled() ? builtin_cpu_count() / 2 : builtin_cpu_count();
+}
+
+
 /*
   From Beowulf, from Olithink
 */

src/misc.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/move.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/move.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -62,9 +62,83 @@ 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), first splits
+// positive scores from ramining then order seaprately the two sets.
+template<typename T>
+inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
+{
+    T tmp;
+    T *p, *d;
+
+    d = lastMove;
+    p = firstMove - 1;
+
+    d->score = -1; // right guard
+
+    // Split positives vs non-positives
+    do {
+        while ((++p)->score > 0);
+
+        if (p != d)
+        {
+            while (--d != p && d->score <= 0);
+
+            tmp = *p;
+            *p = *d;
+            *d = tmp;
+        }
+
+    } while (p != d);
+
+    // Sort just positive scored moves, remaining only when we get there
+    insertion_sort<T>(firstMove, p);
+    *lastPositive = p;
+}
+
+// Picks up the best move in range [curMove, lastMove), one per cycle.
+// It is faster then sorting all the moves in advance when moves are few,
+// as normally are the possible captures. Note that is not a stable alghoritm.
+template<typename T>
+inline T pick_best(T* curMove, T* lastMove)
+{
+    T bestMove, tmp;
+
+    bestMove = *curMove;
+    while (++curMove != lastMove)
+    {
+        if (*curMove < bestMove)
+        {
+            tmp = *curMove;
+            *curMove = bestMove;
+            bestMove = tmp;
+        }
+    }
+    return bestMove;
+}
 
 ////
 //// Inline functions
@@ -82,6 +156,10 @@ inline PieceType move_promotion_piece(Move m) {
   return PieceType((int(m) >> 12) & 7);
 }
 
+inline int move_is_special(Move m) {
+  return m & (0x1F << 12);
+}
+
 inline int move_is_promotion(Move m) {
   return m & (7 << 12);
 }

src/movegen.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -52,16 +52,12 @@ namespace {
     EVASION
   };
 
-  // Functions
-  bool castling_is_check(const Position&, CastlingSide);
-
   // Helper templates
   template<CastlingSide Side>
   MoveStack* generate_castle_moves(const Position&, MoveStack*);
 
   template<Color Us, MoveType Type>
-  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard = EmptyBoardBB,
+  MoveStack* generate_pawn_moves(const Position&, MoveStack*, Bitboard, Square);
-                                 Square = SQ_NONE, Bitboard = EmptyBoardBB);
 
   // Template generate_piece_moves (captures and non-captures) with specializations and overloads
   template<PieceType>
@@ -71,37 +67,29 @@ namespace {
   MoveStack* generate_piece_moves<KING>(const Position&, MoveStack*, Color, Bitboard);
 
   template<PieceType Piece, MoveType Type>
-  inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us) {
+  inline MoveStack* generate_piece_moves(const Position& p, MoveStack* m, Color us, Bitboard t) {
 
     assert(Piece == PAWN);
-    assert(Type == CAPTURE || Type == NON_CAPTURE);
+    assert(Type == CAPTURE || Type == NON_CAPTURE || Type == EVASION);
 
-    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m)
+    return (us == WHITE ? generate_pawn_moves<WHITE, Type>(p, m, t, SQ_NONE)
-                        : generate_pawn_moves<BLACK, Type>(p, m));
+                        : generate_pawn_moves<BLACK, Type>(p, m, t, SQ_NONE));
   }
 
-  // Template generate_piece_checks with specializations
+  // Templates for non-capture checks generation
+
+  template<PieceType Piece>
+  MoveStack* generate_discovered_checks(const Position&, MoveStack*, Square);
+
   template<PieceType>
-  MoveStack* generate_piece_checks(const Position&, MoveStack*, Color, Bitboard, Square);
+  MoveStack* generate_direct_checks(const Position&, MoveStack*, Color, Bitboard, Square);
 
   template<>
-  inline MoveStack* generate_piece_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
+  inline MoveStack* generate_direct_checks<PAWN>(const Position& p, MoveStack* m, Color us, Bitboard dc, Square ksq) {
 
     return (us == WHITE ? generate_pawn_moves<WHITE, CHECK>(p, m, dc, ksq)
                         : generate_pawn_moves<BLACK, CHECK>(p, m, dc, ksq));
   }
-
-  // Template generate_piece_evasions with specializations
-  template<PieceType>
-  MoveStack* generate_piece_evasions(const Position&, MoveStack*, Color, Bitboard, Bitboard);
-
-  template<>
-  inline MoveStack* generate_piece_evasions<PAWN>(const Position& p, MoveStack* m,
-                                                  Color us, Bitboard t, Bitboard pnd) {
-
-    return (us == WHITE ? generate_pawn_moves<WHITE, EVASION>(p, m, pnd, SQ_NONE, t)
-                        : generate_pawn_moves<BLACK, EVASION>(p, m, pnd, SQ_NONE, t));
-  }
 }
 
 
@@ -125,7 +113,7 @@ MoveStack* generate_captures(const Position& pos, MoveStack* mlist) {
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
-  mlist = generate_piece_moves<PAWN, CAPTURE>(pos, mlist, us);
+  mlist = generate_piece_moves<PAWN, CAPTURE>(pos, mlist, us, target);
   return  generate_piece_moves<KING>(pos, mlist, us, target);
 }
 
@@ -141,7 +129,7 @@ MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
   Color us = pos.side_to_move();
   Bitboard target = pos.empty_squares();
 
-  mlist = generate_piece_moves<PAWN, NON_CAPTURE>(pos, mlist, us);
+  mlist = generate_piece_moves<PAWN, NON_CAPTURE>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
   mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
   mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
@@ -152,175 +140,111 @@ MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
 }
 
 
-/// generate_non_capture_checks() generates all pseudo-legal non-captures and
+/// generate_non_capture_checks() generates all pseudo-legal non-captures and knight
 /// underpromotions that give check. Returns a pointer to the end of the move list.
 
-MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc) {
+MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(!pos.is_check());
 
+  Bitboard b, dc;
+  Square from;
   Color us = pos.side_to_move();
   Square ksq = pos.king_square(opposite_color(us));
 
   assert(pos.piece_on(ksq) == piece_of_color_and_type(opposite_color(us), KING));
 
-  // Pieces moves
+  // Discovered non-capture checks
-  mlist = generate_piece_checks<PAWN>(pos, mlist, us, dc, ksq);
+  b = dc = pos.discovered_check_candidates(us);
-  mlist = generate_piece_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<BISHOP>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<ROOK>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<QUEEN>(pos, mlist, us, dc, ksq);
-  mlist = generate_piece_checks<KING>(pos, mlist, us, dc, ksq);
 
-  // Castling moves that give check. Very rare but nice to have!
+  while (b)
-  if (   pos.can_castle_queenside(us)
+  {
-      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_D)
+     from = pop_1st_bit(&b);
-      && castling_is_check(pos, QUEEN_SIDE))
+     switch (pos.type_of_piece_on(from))
-      mlist = generate_castle_moves<QUEEN_SIDE>(pos, mlist);
+     {
+      case PAWN:   /* Will be generated togheter with pawns direct checks */     break;
+      case KNIGHT: mlist = generate_discovered_checks<KNIGHT>(pos, mlist, from); break;
+      case BISHOP: mlist = generate_discovered_checks<BISHOP>(pos, mlist, from); break;
+      case ROOK:   mlist = generate_discovered_checks<ROOK>(pos, mlist, from);   break;
+      case KING:   mlist = generate_discovered_checks<KING>(pos, mlist, from);   break;
+      default: assert(false); break;
+     }
+  }
 
-  if (   pos.can_castle_kingside(us)
+  // Direct non-capture checks
-      && (square_rank(ksq) == square_rank(pos.king_square(us)) || square_file(ksq) == FILE_F)
+  mlist = generate_direct_checks<PAWN>(pos, mlist, us, dc, ksq);
-      && castling_is_check(pos, KING_SIDE))
+  mlist = generate_direct_checks<KNIGHT>(pos, mlist, us, dc, ksq);
-      mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
+  mlist = generate_direct_checks<BISHOP>(pos, mlist, us, dc, ksq);
-
+  mlist = generate_direct_checks<ROOK>(pos, mlist, us, dc, ksq);
-  return mlist;
+  return  generate_direct_checks<QUEEN>(pos, mlist, us, dc, ksq);
 }
 
 
-/// generate_evasions() generates all check evasions when the side to move is
+/// generate_evasions() generates all pseudo-legal check evasions when
-/// in check. Unlike the other move generation functions, this one generates
+/// the side to move is in check. Returns a pointer to the end of the move list.
-/// only legal moves. Returns a pointer to the end of the move list.
 
-MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned) {
+MoveStack* generate_evasions(const Position& pos, MoveStack* mlist) {
 
   assert(pos.is_ok());
   assert(pos.is_check());
 
-  Square from, to;
+  Bitboard b, target;
+  Square from, checksq;
+  int checkersCnt = 0;
   Color us = pos.side_to_move();
-  Color them = opposite_color(us);
   Square ksq = pos.king_square(us);
-  Bitboard sliderAttacks = EmptyBoardBB;
   Bitboard checkers = pos.checkers();
+  Bitboard sliderAttacks = EmptyBoardBB;
 
   assert(pos.piece_on(ksq) == piece_of_color_and_type(us, KING));
-
+  assert(checkers);
-  // The bitboard of occupied pieces without our king
-  Bitboard b_noKing = pos.occupied_squares();
-  clear_bit(&b_noKing, ksq);
 
   // Find squares attacked by slider checkers, we will remove
-  // them from the king evasions set so to avoid a couple
+  // them from the king evasions set so to early skip known
-  // of cycles in the slow king evasions legality check loop
+  // illegal moves and avoid an useless legality check later.
-  // and to be able to use attackers_to().
+  b = checkers;
-  Bitboard b = checkers & pos.pieces(BISHOP, QUEEN);
+  do
-  while (b)
   {
-      from = pop_1st_bit(&b);
+      checkersCnt++;
-      sliderAttacks |= bishop_attacks_bb(from, b_noKing);
+      checksq = pop_1st_bit(&b);
-  }
 
-  b = checkers & pos.pieces(ROOK, QUEEN);
+      assert(pos.color_of_piece_on(checksq) == opposite_color(us));
-  while (b)
+
+      switch (pos.type_of_piece_on(checksq))
       {
-      from = pop_1st_bit(&b);
+      case BISHOP: sliderAttacks |= BishopPseudoAttacks[checksq]; break;
-      sliderAttacks |= rook_attacks_bb(from, b_noKing);
+      case ROOK:   sliderAttacks |= RookPseudoAttacks[checksq];   break;
+      case QUEEN:
+          // In case of a queen remove also squares attacked in the other direction to
+          // avoid possible illegal moves when queen and king are on adjacent squares.
+          if (direction_is_straight(checksq, ksq))
+              sliderAttacks |= RookPseudoAttacks[checksq] | pos.attacks_from<BISHOP>(checksq);
+          else
+              sliderAttacks |= BishopPseudoAttacks[checksq] | pos.attacks_from<ROOK>(checksq);
+      default:
+          break;
       }
+  } while (b);
 
   // Generate evasions for king, capture and non capture moves
-  Bitboard enemy = pos.pieces_of_color(them);
+  b = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
-  Bitboard b1 = pos.attacks_from<KING>(ksq) & ~pos.pieces_of_color(us) & ~sliderAttacks;
+  from = ksq;
-  while (b1)
+  SERIALIZE_MOVES(b);
-  {
-      // Note that we can use attackers_to() only because we have already
-      // removed from b1 the squares attacked by slider checkers.
-      to = pop_1st_bit(&b1);
-      if (!(pos.attackers_to(to) & enemy))
-          (*mlist++).move = make_move(ksq, to);
-  }
 
-  // Generate evasions for other pieces only if not double check. We use a
+  // Generate evasions for other pieces only if not double check
-  // simple bit twiddling hack here rather than calling count_1s in order to
+  if (checkersCnt > 1)
-  // save some time (we know that pos.checkers() has at most two nonzero bits).
-  if (!(checkers & (checkers - 1))) // Only one bit set?
-  {
-      Square checksq = first_1(checkers);
-
-      assert(pos.color_of_piece_on(checksq) == them);
-
-      // Generate captures of the checking piece
-
-      // Pawn captures
-      b1 = pos.attacks_from<PAWN>(checksq, them) & pos.pieces(PAWN, us) & ~pinned;
-      while (b1)
-      {
-          from = pop_1st_bit(&b1);
-          if (relative_rank(us, checksq) == RANK_8)
-          {
-              (*mlist++).move = make_promotion_move(from, checksq, QUEEN);
-              (*mlist++).move = make_promotion_move(from, checksq, ROOK);
-              (*mlist++).move = make_promotion_move(from, checksq, BISHOP);
-              (*mlist++).move = make_promotion_move(from, checksq, KNIGHT);
-          } else
-              (*mlist++).move = make_move(from, checksq);
-      }
-
-      // Pieces captures
-      b1 = (  (pos.attacks_from<KNIGHT>(checksq) & pos.pieces(KNIGHT, us))
-            | (pos.attacks_from<BISHOP>(checksq) & pos.pieces(BISHOP, QUEEN, us))
-            | (pos.attacks_from<ROOK>(checksq)   & pos.pieces(ROOK, QUEEN, us)) ) & ~pinned;
-
-      while (b1)
-      {
-          from = pop_1st_bit(&b1);
-          (*mlist++).move = make_move(from, checksq);
-      }
-
-      // Blocking check evasions are possible only if the checking piece is a slider
-      if (sliderAttacks)
-      {
-          Bitboard blockSquares = squares_between(checksq, ksq);
-
-          assert((pos.occupied_squares() & blockSquares) == EmptyBoardBB);
-
-          if (blockSquares)
-          {
-              mlist = generate_piece_evasions<PAWN>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_evasions<KNIGHT>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_evasions<BISHOP>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_evasions<ROOK>(pos, mlist, us, blockSquares, pinned);
-              mlist = generate_piece_evasions<QUEEN>(pos, mlist, us, blockSquares, pinned);
-          }
-      }
-
-      // Finally, the special case of en passant captures. An en passant
-      // capture can only be a check evasion if the check is not a discovered
-      // check. If pos.ep_square() is set, the last move made must have been
-      // a double pawn push. If, furthermore, the checking piece is a pawn,
-      // an en passant check evasion may be possible.
-      if (pos.ep_square() != SQ_NONE && (checkers & pos.pieces(PAWN, them)))
-      {
-          to = pos.ep_square();
-          b1 = pos.attacks_from<PAWN>(to, them) & pos.pieces(PAWN, us);
-
-          // The checking pawn cannot be a discovered (bishop) check candidate
-          // otherwise we were in check also before last double push move.
-          assert(!bit_is_set(pos.discovered_check_candidates(them), checksq));
-          assert(count_1s(b1) == 1 || count_1s(b1) == 2);
-
-          b1 &= ~pinned;
-          while (b1)
-          {
-              from = pop_1st_bit(&b1);
-              // Move is always legal because checking pawn is not a discovered
-              // check candidate and our capturing pawn has been already tested
-              // against pinned pieces.
-              (*mlist++).move = make_ep_move(from, to);
-          }
-      }
-  }
       return mlist;
+
+  // Find squares where a blocking evasion or a capture of the
+  // checker piece is possible.
+  target = squares_between(checksq, ksq) | checkers;
+
+  mlist = generate_piece_moves<PAWN, EVASION>(pos, mlist, us, target);
+  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
+  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
+  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
+  return  generate_piece_moves<QUEEN>(pos, mlist, us, target);
 }
 
 
@@ -332,24 +256,25 @@ MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLega
 
   assert(pos.is_ok());
 
+  MoveStack *last, *cur = mlist;
   Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
-  if (pos.is_check())
-      return generate_evasions(pos, mlist, pinned);
-
   // Generate pseudo-legal moves
-  MoveStack* last = generate_captures(pos, mlist);
+  if (pos.is_check())
-  last = generate_noncaptures(pos, last);
+      last = generate_evasions(pos, mlist);
+  else
+      last = generate_noncaptures(pos, generate_captures(pos, mlist));
+
   if (pseudoLegal)
       return last;
 
   // Remove illegal moves from the list
-  for (MoveStack* cur = mlist; cur != last; cur++)
+  while (cur != last)
-      if (!pos.pl_move_is_legal(cur->move, pinned))
+      if (pos.pl_move_is_legal(cur->move, pinned))
-      {
+          cur++;
+      else
           cur->move = (--last)->move;
-          cur--;
+
-      }
   return last;
 }
 
@@ -361,10 +286,11 @@ MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLega
 bool move_is_legal(const Position& pos, const Move m) {
 
   MoveStack mlist[256];
-  MoveStack* last = generate_moves(pos, mlist, true);
+  MoveStack *cur, *last = generate_moves(pos, mlist, true);
-  for (MoveStack* cur = mlist; cur != last; cur++)
+
+   for (cur = mlist; cur != last; cur++)
       if (cur->move == m)
-          return pos.pl_move_is_legal(m);
+          return pos.pl_move_is_legal(m, pos.pinned_pieces(pos.side_to_move()));
 
   return false;
 }
@@ -372,25 +298,23 @@ bool move_is_legal(const Position& pos, const Move m) {
 
 /// Fast version of move_is_legal() that takes a position a move and a
 /// bitboard of pinned pieces as input, and tests whether the move is legal.
-/// This version must only be used when the side to move is not in check.
 
 bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
 
   assert(pos.is_ok());
-  assert(!pos.is_check());
   assert(move_is_ok(m));
   assert(pinned == pos.pinned_pieces(pos.side_to_move()));
 
-  // Use a slower but simpler function for uncommon cases
-  if (move_is_ep(m) || move_is_castle(m))
-      return move_is_legal(pos, m);
-
   Color us = pos.side_to_move();
   Color them = opposite_color(us);
   Square from = move_from(m);
   Square to = move_to(m);
   Piece pc = pos.piece_on(from);
 
+  // Use a slower but simpler function for uncommon cases
+  if (move_is_ep(m) || move_is_castle(m))
+      return move_is_legal(pos, m);
+
   // If the from square is not occupied by a piece belonging to the side to
   // move, the move is obviously not legal.
   if (color_of_piece(pc) != us)
@@ -459,13 +383,13 @@ bool move_is_legal(const Position& pos, const Move m, Bitboard pinned) {
           return false;
       }
       // The move is pseudo-legal, check if it is also legal
-      return pos.pl_move_is_legal(m, pinned);
+      return pos.is_check() ? pos.pl_move_is_evasion(m, pinned) : pos.pl_move_is_legal(m, pinned);
   }
 
   // Luckly we can handle all the other pieces in one go
-  return (   bit_is_set(pos.attacks_from(pc, from), to)
+  return    bit_is_set(pos.attacks_from(pc, from), to)
-          && pos.pl_move_is_legal(m, pinned)
+        && (pos.is_check() ? pos.pl_move_is_evasion(m, pinned) : pos.pl_move_is_legal(m, pinned))
-          && !move_is_promotion(m));
+        && !move_is_promotion(m);
 }
 
 
@@ -474,8 +398,8 @@ namespace {
   template<PieceType Piece>
   MoveStack* generate_piece_moves(const Position& pos, MoveStack* mlist, Color us, Bitboard target) {
 
-    Square from;
     Bitboard b;
+    Square from;
     const Square* ptr = pos.piece_list_begin(us, Piece);
 
     while ((from = *ptr++) != SQ_NONE)
@@ -497,24 +421,6 @@ namespace {
     return mlist;
   }
 
-  template<PieceType Piece>
-  MoveStack* generate_piece_evasions(const Position& pos, MoveStack* mlist,
-                                     Color us, Bitboard target, Bitboard pinned) {
-    Square from;
-    Bitboard b;
-    const Square* ptr = pos.piece_list_begin(us, Piece);
-
-    while ((from = *ptr++) != SQ_NONE)
-    {
-        if (pinned && bit_is_set(pinned, from))
-            continue;
-
-        b = pos.attacks_from<Piece>(from) & target;
-        SERIALIZE_MOVES(b);
-    }
-    return mlist;
-  }
-
   template<Color Us, SquareDelta Direction>
   inline Bitboard move_pawns(Bitboard p) {
 
@@ -528,8 +434,8 @@ namespace {
         return p;
   }
 
-  template<Color Us, SquareDelta Diagonal>
+  template<Color Us, MoveType Type, SquareDelta Diagonal>
-  MoveStack* generate_pawn_diagonal_captures(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces, bool promotion) {
+  inline MoveStack* generate_pawn_captures(MoveStack* mlist, Bitboard pawns, Bitboard enemyPieces) {
 
     // Calculate our parametrized parameters at compile time
     const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
@@ -538,136 +444,152 @@ namespace {
     const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
     const SquareDelta TTDELTA_NE = (Diagonal == DELTA_NE ? TDELTA_NE : TDELTA_NW);
 
+    Bitboard b1, b2;
     Square to;
 
     // Captures in the a1-h8 (a8-h1 for black) diagonal or in the h1-a8 (h8-a1 for black)
-    Bitboard b1 = move_pawns<Us, Diagonal>(pawns) & ~TFileABB & enemyPieces;
+    b1 = move_pawns<Us, Diagonal>(pawns) & ~TFileABB & enemyPieces;
 
-    // Capturing promotions
+    // Capturing promotions and under-promotions
-    if (promotion)
+    if (b1 & TRank8BB)
     {
-        Bitboard b2 = b1 & TRank8BB;
+        b2 = b1 & TRank8BB;
         b1 &= ~TRank8BB;
         while (b2)
         {
             to = pop_1st_bit(&b2);
+
+            if (Type == CAPTURE || Type == EVASION)
                 (*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, QUEEN);
+
+            if (Type == NON_CAPTURE || Type == EVASION)
+            {
+                (*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, ROOK);
+                (*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, BISHOP);
+                (*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, KNIGHT);
+            }
+
+            // This is the only possible under promotion that can give a check
+            // not already included in the queen-promotion. It is not sure that
+            // the promoted knight will give check, but it doesn't worth to verify.
+            if (Type == CHECK)
+                (*mlist++).move = make_promotion_move(to - TTDELTA_NE, to, KNIGHT);
         }
     }
 
-    // Capturing non-promotions
+    // Serialize standard captures
+    if (Type == CAPTURE || Type == EVASION)
         SERIALIZE_MOVES_D(b1, -TTDELTA_NE);
+
     return mlist;
   }
 
   template<Color Us, MoveType Type>
-  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard dcp,
+  MoveStack* generate_pawn_moves(const Position& pos, MoveStack* mlist, Bitboard target, Square ksq) {
-                                 Square ksq, Bitboard blockSquares) {
 
     // Calculate our parametrized parameters at compile time
     const Color Them = (Us == WHITE ? BLACK : WHITE);
     const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB);
     const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
     const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
-    const SquareDelta TDELTA_NE = (Us == WHITE ? DELTA_NE : DELTA_SE);
-    const SquareDelta TDELTA_NW = (Us == WHITE ? DELTA_NW : DELTA_SW);
     const SquareDelta TDELTA_N = (Us == WHITE ? DELTA_N : DELTA_S);
 
-    Bitboard b1, b2, dcPawns1, dcPawns2;
     Square to;
-    Bitboard pawns = (Type == EVASION ? pos.pieces(PAWN, Us) & ~dcp : pos.pieces(PAWN, Us));
+    Bitboard b1, b2, enemyPieces, emptySquares;
-    bool possiblePromotion = pawns & TRank7BB;
+    Bitboard pawns = pos.pieces(PAWN, Us);
 
-    if (Type == CAPTURE)
+    // Standard captures and capturing promotions and underpromotions
+    if (Type == CAPTURE || Type == EVASION || (pawns & TRank7BB))
     {
-        // Standard captures and capturing promotions in both directions
+        enemyPieces = (Type == CAPTURE ? target : pos.pieces_of_color(opposite_color(Us)));
-        Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
+
-        mlist = generate_pawn_diagonal_captures<Us, DELTA_NE>(mlist, pawns, enemyPieces, possiblePromotion);
+        if (Type == EVASION)
-        mlist = generate_pawn_diagonal_captures<Us, DELTA_NW>(mlist, pawns, enemyPieces, possiblePromotion);
+            enemyPieces &= target; // Capture only the checker piece
+
+        mlist = generate_pawn_captures<Us, Type, DELTA_NE>(mlist, pawns, enemyPieces);
+        mlist = generate_pawn_captures<Us, Type, DELTA_NW>(mlist, pawns, enemyPieces);
     }
 
-    if (possiblePromotion)
+    // Non-capturing promotions and underpromotions
+    if (pawns & TRank7BB)
     {
-        // When generating checks consider under-promotion moves (both captures
+        b1 = move_pawns<Us, DELTA_N>(pawns) & TRank8BB & pos.empty_squares();
-        // and non captures) only if can give a discovery check. Note that dcp
-        // is dc bitboard or pinned bitboard when Type == EVASION.
-        Bitboard pp = (Type == CHECK ? pawns & dcp : pawns);
 
-        if (Type != EVASION && Type != CAPTURE)
+        if (Type == EVASION)
-        {
+            b1 &= target; // Only blocking promotion pushes
-            Bitboard enemyPieces = pos.pieces_of_color(opposite_color(Us));
-
-            // Underpromotion captures in the a1-h8 (a8-h1 for black) direction
-            b1 = move_pawns<Us, DELTA_NE>(pp) & ~FileABB & enemyPieces & TRank8BB;
-            while (b1)
-            {
-                to = pop_1st_bit(&b1);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, ROOK);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, BISHOP);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NE, to, KNIGHT);
-            }
-
-            // Underpromotion captures in the h1-a8 (h8-a1 for black) direction
-            b1 = move_pawns<Us, DELTA_NW>(pp) & ~FileHBB & enemyPieces & TRank8BB;
-            while (b1)
-            {
-                to = pop_1st_bit(&b1);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, ROOK);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, BISHOP);
-                (*mlist++).move = make_promotion_move(to - TDELTA_NW, to, KNIGHT);
-            }
-        }
-
-        // Underpromotion pawn pushes. Also queen promotions for evasions and captures.
-        b1 = move_pawns<Us, DELTA_N>(pp) & TRank8BB;
-        b1 &= (Type == EVASION ? blockSquares : pos.empty_squares());
 
         while (b1)
         {
             to = pop_1st_bit(&b1);
-            if (Type == EVASION || Type == CAPTURE)
+
+            if (Type == CAPTURE || Type == EVASION)
                 (*mlist++).move = make_promotion_move(to - TDELTA_N, to, QUEEN);
 
-            if (Type != CAPTURE)
+            if (Type == NON_CAPTURE || Type == EVASION)
             {
                 (*mlist++).move = make_promotion_move(to - TDELTA_N, to, ROOK);
                 (*mlist++).move = make_promotion_move(to - TDELTA_N, to, BISHOP);
                 (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
             }
+
+            // This is the only possible under promotion that can give a check
+            // not already included in the queen-promotion.
+            if (Type == CHECK && bit_is_set(pos.attacks_from<KNIGHT>(to), pos.king_square(Them)))
+                (*mlist++).move = make_promotion_move(to - TDELTA_N, to, KNIGHT);
         }
     }
 
+    // Standard pawn pushes and double pushes
     if (Type != CAPTURE)
     {
-        Bitboard emptySquares = pos.empty_squares();
+        emptySquares = (Type == NON_CAPTURE ? target : pos.empty_squares());
-        dcPawns1 = dcPawns2 = EmptyBoardBB;
-        if (Type == CHECK && (pawns & dcp))
-        {
-            // Pawn moves which gives discovered check. This is possible only if the
-            // pawn is not on the same file as the enemy king, because we don't
-            // generate captures.
-            dcPawns1 = move_pawns<Us, DELTA_N>(pawns & dcp & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
-            dcPawns2 = move_pawns<Us, DELTA_N>(dcPawns1 & TRank3BB) & emptySquares;
-        }
 
-        // Single pawn pushes
+        // Single and double pawn pushes
         b1 = move_pawns<Us, DELTA_N>(pawns) & emptySquares & ~TRank8BB;
-        b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns1 :
+        b2 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
-              (Type == EVASION ? b1 & blockSquares : b1));
-        SERIALIZE_MOVES_D(b2, -TDELTA_N);
 
-        // Double pawn pushes
+        // Filter out unwanted pushes according to the move type
-        b1 = move_pawns<Us, DELTA_N>(b1 & TRank3BB) & emptySquares;
+        if (Type == EVASION)
-        b2 = (Type == CHECK ? (b1 & pos.attacks_from<PAWN>(ksq, Them)) | dcPawns2 :
+        {
-              (Type == EVASION ? b1 & blockSquares : b1));
+            b1 &= target;
+            b2 &= target;
+        }
+        else if (Type == CHECK)
+        {
+            // Pawn moves which give direct cheks
+            b1 &= pos.attacks_from<PAWN>(ksq, Them);
+            b2 &= pos.attacks_from<PAWN>(ksq, Them);
+
+            // Pawn moves which gives discovered check. This is possible only if
+            // the pawn is not on the same file as the enemy king, because we
+            //  don't generate captures.
+            if (pawns & target) // For CHECK type target is dc bitboard
+            {
+                Bitboard dc1 = move_pawns<Us, DELTA_N>(pawns & target & ~file_bb(ksq)) & emptySquares & ~TRank8BB;
+                Bitboard dc2 = move_pawns<Us, DELTA_N>(dc1 & TRank3BB) & emptySquares;
+
+                b1 |= dc1;
+                b2 |= dc2;
+            }
+        }
+        SERIALIZE_MOVES_D(b1, -TDELTA_N);
         SERIALIZE_MOVES_D(b2, -TDELTA_N -TDELTA_N);
     }
-    else if (pos.ep_square() != SQ_NONE) // En passant captures
+
+    // En passant captures
+    if ((Type == CAPTURE || Type == EVASION) && pos.ep_square() != SQ_NONE)
     {
         assert(Us != WHITE || square_rank(pos.ep_square()) == RANK_6);
         assert(Us != BLACK || square_rank(pos.ep_square()) == RANK_3);
 
+        // An en passant capture can be an evasion only if the checking piece
+        // is the double pushed pawn and so is in the target. Otherwise this
+        // is a discovery check and we are forced to do otherwise.
+        if (Type == EVASION && !bit_is_set(target, pos.ep_square() - TDELTA_N))
+            return mlist;
+
         b1 = pawns & pos.attacks_from<PAWN>(pos.ep_square(), Them);
+
         assert(b1 != EmptyBoardBB);
 
         while (b1)
@@ -680,43 +602,49 @@ namespace {
   }
 
   template<PieceType Piece>
-  MoveStack* generate_piece_checks(const Position& pos, MoveStack* mlist, Color us,
+  MoveStack* generate_discovered_checks(const Position& pos, MoveStack* mlist, Square from) {
-                                   Bitboard dc, Square ksq) {
 
-    Bitboard target = pos.pieces(Piece, us);
+    assert(Piece != QUEEN);
 
-    // Discovered non-capture checks
+    Bitboard b = pos.attacks_from<Piece>(from) & pos.empty_squares();
-    Bitboard b = target & dc;
-
-    assert(Piece != QUEEN || !b);
-
-    while (b)
-    {
-        Square from = pop_1st_bit(&b);
-        Bitboard bb = pos.attacks_from<Piece>(from) & pos.empty_squares();
     if (Piece == KING)
-            bb &= ~QueenPseudoAttacks[ksq];
+    {
-
+        Square ksq = pos.king_square(opposite_color(pos.side_to_move()));
-        SERIALIZE_MOVES(bb);
+        b &= ~QueenPseudoAttacks[ksq];
+    }
+    SERIALIZE_MOVES(b);
+    return mlist;
   }
 
-    // Direct non-capture checks
+  template<PieceType Piece>
-    b = target & ~dc;
+  MoveStack* generate_direct_checks(const Position& pos, MoveStack* mlist, Color us,
-    Bitboard checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
+                                   Bitboard dc, Square ksq) {
-    if (Piece != KING && checkSqs)
+    assert(Piece != KING);
+
+    Bitboard checkSqs, b;
+    Square from;
+    const Square* ptr = pos.piece_list_begin(us, Piece);
+
+    if ((from = *ptr++) == SQ_NONE)
+        return mlist;
+
+    checkSqs = pos.attacks_from<Piece>(ksq) & pos.empty_squares();
+
+    do
     {
-        while (b)
-        {
-            Square from = pop_1st_bit(&b);
         if (   (Piece == QUEEN  && !(QueenPseudoAttacks[from]  & checkSqs))
             || (Piece == ROOK   && !(RookPseudoAttacks[from]   & checkSqs))
             || (Piece == BISHOP && !(BishopPseudoAttacks[from] & checkSqs)))
             continue;
 
-            Bitboard bb = pos.attacks_from<Piece>(from) & checkSqs;
+        if (dc && bit_is_set(dc, from))
-            SERIALIZE_MOVES(bb);
+            continue;
-        }
+
-    }
+        b = pos.attacks_from<Piece>(from) & checkSqs;
+        SERIALIZE_MOVES(b);
+
+    } while ((from = *ptr++) != SQ_NONE);
+
     return mlist;
   }
 
@@ -762,17 +690,4 @@ namespace {
     }
     return mlist;
   }
-
-  bool castling_is_check(const Position& pos, CastlingSide side) {
-
-    // After castling opponent king is attacked by the castled rook?
-    File rookFile = (side == QUEEN_SIDE ? FILE_D : FILE_F);
-    Color us = pos.side_to_move();
-    Square ksq = pos.king_square(us);
-    Bitboard occ = pos.occupied_squares();
-
-    clear_bit(&occ, ksq); // Remove our king from the board
-    Square rsq = make_square(rookFile, square_rank(ksq));
-    return bit_is_set(rook_attacks_bb(rsq, occ), pos.king_square(opposite_color(us)));
-  }
 }

src/movegen.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -34,8 +34,8 @@
 
 extern MoveStack* generate_captures(const Position& pos, MoveStack* mlist);
 extern MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist);
-extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc);
+extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist);
-extern MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned);
+extern MoveStack* generate_evasions(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);

src/movepick.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -23,7 +23,6 @@
 //// Includes
 ////
 
-#include <algorithm>
 #include <cassert>
 
 #include "history.h"
@@ -53,7 +52,7 @@ namespace {
 
   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_EVASIONS, 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};
 }
@@ -72,13 +71,15 @@ namespace {
 /// move ordering is at the current node.
 
 MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
-                       const History& h, SearchStack* ss) : pos(p), H(h) {
+                       const History& h, SearchStack* ss, Value beta) : pos(p), H(h) {
   int searchTT = ttm;
   ttMoves[0].move = ttm;
-  finished = false;
   lastBadCapture = badCaptures;
+  badCaptureThreshold = 0;
 
-  if (ss)
+  pinned = p.pinned_pieces(pos.side_to_move());
+
+  if (ss && !p.is_check())
   {
       ttMoves[1].move = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
       searchTT |= ttMoves[1].move;
@@ -87,21 +88,30 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
   } else
       ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
 
-  Color us = pos.side_to_move();
-
-  dc = p.discovered_check_candidates(us);
-  pinned = p.pinned_pieces(us);
-
   if (p.is_check())
       phasePtr = EvasionsPhaseTable;
   else if (d > Depth(0))
-      phasePtr = MainSearchPhaseTable + !searchTT;
+  {
-  else if (d == Depth(0))
+      // Consider sligtly negative captures as good if at low
-      phasePtr = QsearchWithChecksPhaseTable + !searchTT;
+      // depth and far from beta.
-  else
+      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * OnePly)
-      phasePtr = QsearchWithoutChecksPhaseTable + !searchTT;
+          badCaptureThreshold = -PawnValueMidgame;
 
-  phasePtr--;
+      phasePtr = MainSearchPhaseTable;
+  } else if (d == Depth(0))
+      phasePtr = QsearchWithChecksPhaseTable;
+  else
+  {
+      phasePtr = QsearchWithoutChecksPhaseTable;
+
+      // Skip TT move if is not a capture or a promotion, this avoids
+      // qsearch tree explosion due to a possible perpetual check or
+      // similar rare cases when TT table is full.
+      if (ttm != MOVE_NONE && !pos.move_is_capture_or_promotion(ttm))
+          searchTT = ttMoves[0].move = MOVE_NONE;
+  }
+
+  phasePtr += !searchTT - 1;
   go_next_phase();
 }
 
@@ -123,7 +133,6 @@ void MovePicker::go_next_phase() {
   case PH_GOOD_CAPTURES:
       lastMove = generate_captures(pos, moves);
       score_captures();
-      std::sort(moves, lastMove);
       return;
 
   case PH_KILLERS:
@@ -134,7 +143,7 @@ void MovePicker::go_next_phase() {
   case PH_NONCAPTURES:
       lastMove = generate_noncaptures(pos, moves);
       score_noncaptures();
-      std::sort(moves, lastMove);
+      sort_moves(moves, lastMove, &lastGoodNonCapture);
       return;
 
   case PH_BAD_CAPTURES:
@@ -142,29 +151,26 @@ void MovePicker::go_next_phase() {
       // to get SEE move ordering.
       curMove = badCaptures;
       lastMove = lastBadCapture;
-      std::sort(badCaptures, lastMove);
       return;
 
   case PH_EVASIONS:
       assert(pos.is_check());
-      lastMove = generate_evasions(pos, moves, pinned);
+      lastMove = generate_evasions(pos, moves);
-      score_evasions();
+      score_evasions_or_checks();
-      std::sort(moves, lastMove);
       return;
 
   case PH_QCAPTURES:
       lastMove = generate_captures(pos, moves);
       score_captures();
-      std::sort(moves, lastMove);
       return;
 
   case PH_QCHECKS:
-      // Perhaps we should order moves move here?  FIXME
+      lastMove = generate_non_capture_checks(pos, moves);
-      lastMove = generate_non_capture_checks(pos, moves, dc);
+      score_evasions_or_checks();
       return;
 
   case PH_STOP:
-      lastMove = curMove + 1; // hack to be friendly for get_next_move()
+      lastMove = curMove + 1; // Avoids another go_next_phase() call
       return;
 
   default:
@@ -202,8 +208,8 @@ void MovePicker::score_captures() {
       if (move_is_promotion(m))
           cur->score = QueenValueMidgame;
       else
-          cur->score = int(pos.midgame_value_of_piece_on(move_to(m)))
+          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
-                      -int(pos.type_of_piece_on(move_from(m)));
+                      - pos.type_of_piece_on(move_from(m));
   }
 }
 
@@ -224,29 +230,36 @@ void MovePicker::score_noncaptures() {
       piece = pos.piece_on(from);
       hs = H.move_ordering_score(piece, to);
 
-      // Ensure history is always preferred to pst
+      // Ensure history has always highest priority
       if (hs > 0)
-          hs += 1000;
+          hs += 10000;
 
-      // pst based scoring
+      // Gain table based scoring
-      cur->score = hs + pos.pst_delta<Position::MidGame>(piece, from, to);
+      cur->score = hs + 16 * H.gain(piece, to);
   }
 }
 
-void MovePicker::score_evasions() {
+void MovePicker::score_evasions_or_checks() {
-
+  // Try good captures ordered by MVV/LVA, then non-captures if
+  // destination square is not under attack, ordered by history
+  // value, and at the end bad-captures and non-captures with a
+  // negative SEE. This last group is ordered by the SEE score.
   Move m;
+  int seeScore;
+
+  // Skip if we don't have at least two moves to order
+  if (lastMove < moves + 2)
+      return;
 
   for (MoveStack* cur = moves; cur != lastMove; cur++)
   {
       m = cur->move;
-      if (m == ttMoves[0].move)
+      if ((seeScore = pos.see_sign(m)) < 0)
-          cur->score = 2 * HistoryMax;
+          cur->score = seeScore - HistoryMax; // Be sure are at the bottom
-      else if (!pos.square_is_empty(move_to(m)))
+      else if (pos.move_is_capture(m))
-      {
+          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
-          int seeScore = pos.see(m);
+                      - pos.type_of_piece_on(move_from(m)) + HistoryMax;
-          cur->score = seeScore + (seeScore >= 0 ? HistoryMax : 0);
+      else
-      } else
           cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
   }
 }
@@ -256,36 +269,35 @@ void MovePicker::score_evasions() {
 /// are no more moves left.
 /// It picks the move with the biggest score from a list of generated moves taking
 /// care not to return the tt move if has already been searched previously.
+/// Note that this function is not thread safe so should be lock protected by
+/// caller when accessed through a shared MovePicker object.
 
 Move MovePicker::get_next_move() {
 
-  assert(!pos.is_check() || *phasePtr == PH_EVASIONS || *phasePtr == PH_STOP);
-  assert( pos.is_check() || *phasePtr != PH_EVASIONS);
-
   Move move;
 
   while (true)
   {
       while (curMove != lastMove)
       {
-          move = (curMove++)->move;
-
           switch (phase) {
 
           case PH_TT_MOVES:
+              move = (curMove++)->move;
               if (   move != MOVE_NONE
                   && move_is_legal(pos, move, pinned))
                   return move;
               break;
 
           case PH_GOOD_CAPTURES:
+              move = pick_best(curMove++, lastMove).move;
               if (   move != ttMoves[0].move
                   && move != ttMoves[1].move
                   && pos.pl_move_is_legal(move, pinned))
               {
                   // Check for a non negative SEE now
                   int seeValue = pos.see_sign(move);
-                  if (seeValue >= 0)
+                  if (seeValue >= badCaptureThreshold)
                       return move;
 
                   // Losing capture, move it to the badCaptures[] array, note
@@ -298,6 +310,7 @@ Move MovePicker::get_next_move() {
               break;
 
           case PH_KILLERS:
+              move = (curMove++)->move;
               if (   move != MOVE_NONE
                   && move != ttMoves[0].move
                   && move != ttMoves[1].move
@@ -307,6 +320,12 @@ Move MovePicker::get_next_move() {
               break;
 
           case PH_NONCAPTURES:
+
+              // Sort negative scored moves only when we get there
+              if (curMove == lastGoodNonCapture)
+                  insertion_sort(lastGoodNonCapture, lastMove);
+
+              move = (curMove++)->move;
               if (   move != ttMoves[0].move
                   && move != ttMoves[1].move
                   && move != killers[0].move
@@ -315,13 +334,20 @@ Move MovePicker::get_next_move() {
                   return move;
               break;
 
-          case PH_EVASIONS:
           case PH_BAD_CAPTURES:
+              move = pick_best(curMove++, lastMove).move;
               return move;
 
+          case PH_EVASIONS:
           case PH_QCAPTURES:
+              move = pick_best(curMove++, lastMove).move;
+              if (   move != ttMoves[0].move
+                  && pos.pl_move_is_legal(move, pinned))
+                  return move;
+              break;
+
           case PH_QCHECKS:
-              // Maybe postpone the legality check until after futility pruning?
+              move = (curMove++)->move;
               if (   move != ttMoves[0].move
                   && pos.pl_move_is_legal(move, pinned))
                   return move;
@@ -339,21 +365,3 @@ Move MovePicker::get_next_move() {
   }
 }
 
-/// A variant of get_next_move() which takes a lock as a parameter, used to
-/// prevent multiple threads from picking the same move at a split point.
-
-Move MovePicker::get_next_move(Lock &lock) {
-
-   lock_grab(&lock);
-   if (finished)
-   {
-       lock_release(&lock);
-       return MOVE_NONE;
-   }
-   Move m = get_next_move();
-   if (m == MOVE_NONE)
-       finished = true;
-
-   lock_release(&lock);
-   return m;
-}

src/movepick.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -27,7 +27,6 @@
 
 #include "depth.h"
 #include "history.h"
-#include "lock.h"
 #include "position.h"
 
 
@@ -50,26 +49,23 @@ class MovePicker {
   MovePicker& operator=(const MovePicker&); // silence a warning under MSVC
 
 public:
-  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
+  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL, Value beta = -VALUE_INFINITE);
   Move get_next_move();
-  Move get_next_move(Lock& lock);
   int number_of_evasions() const;
-  Bitboard discovered_check_candidates() const;
 
 private:
   void score_captures();
   void score_noncaptures();
-  void score_evasions();
+  void score_evasions_or_checks();
   void go_next_phase();
 
   const Position& pos;
   const History& H;
   MoveStack ttMoves[2], killers[2];
-  bool finished;
+  int badCaptureThreshold, phase;
-  int phase;
   const uint8_t* phasePtr;
-  MoveStack *curMove, *lastMove, *lastBadCapture;
+  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *lastBadCapture;
-  Bitboard dc, pinned;
+  Bitboard pinned;
   MoveStack moves[256], badCaptures[64];
 };
 
@@ -88,12 +84,4 @@ inline int MovePicker::number_of_evasions() const {
   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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -38,64 +38,36 @@ namespace {
 
   /// Constants and variables
 
-  // Doubled pawn penalty by file, middle game
+  #define S(mg, eg) make_score(mg, eg)
-  const Value DoubledPawnMidgamePenalty[8] = {
+
-    Value(13), Value(20), Value(23), Value(23),
+  // Doubled pawn penalty by file
-    Value(23), Value(23), Value(20), Value(13)
+  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(43), Value(48), Value(48), Value(48),
+    S(25, 30), S(36, 35), S(40, 35), S(40, 35),
-    Value(48), Value(48), Value(48), Value(43)
+    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(25), Value(36), Value(40), Value(40),
+    S(20, 28), S(29, 31), S(33, 31), S(33, 31),
-    Value(40), Value(40), Value(36), Value(25)
+    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(30), Value(35), Value(35), Value(35),
+    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
-    Value(35), Value(35), Value(35), Value(30)
+    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(20), Value(29), Value(33), Value(33),
+    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
-    Value(33), Value(33), Value(29), Value(20)
+    S(34,68), S(83,166), S(0, 0), S( 0, 0)
-  };
-
-  // Backward pawn penalty by file, endgame
-  const Value BackwardPawnEndgamePenalty[8] = {
-    Value(28), Value(31), Value(31), Value(31),
-    Value(31), Value(31), Value(31), Value(28)
-  };
-
-  // Pawn chain membership bonus by file, middle game
-  const Value ChainMidgameBonus[8] = {
-    Value(11), Value(13), Value(13), Value(14),
-    Value(14), Value(13), Value(13), Value(11)
-  };
-
-  // Pawn chain membership bonus by file, endgame
-  const Value ChainEndgameBonus[8] = {
-    Value(-1), Value(-1), Value(-1), Value(-1),
-    Value(-1), Value(-1), Value(-1), Value(-1)
-  };
-
-  // Candidate passed pawn bonus by rank, middle game
-  const Value CandidateMidgameBonus[8] = {
-    Value( 0), Value( 6), Value(6), Value(14),
-    Value(34), Value(83), Value(0), Value( 0)
-  };
-
-  // Candidate passed pawn bonus by rank, endgame
-  const Value CandidateEndgameBonus[8] = {
-    Value( 0), Value( 13), Value(13), Value(29),
-    Value(68), Value(166), Value( 0), Value( 0)
   };
 
   // Pawn storm tables for positions with opposite castling
@@ -190,43 +162,53 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
   pi->clear();
   pi->key = key;
 
-  Value mgValue[2] = {Value(0), Value(0)};
-  Value egValue[2] = {Value(0), Value(0)};
-
   // Calculate pawn attacks
-  pi->pawnAttacks[WHITE] = ((pos.pieces(PAWN, WHITE) << 9) & ~FileABB) | ((pos.pieces(PAWN, WHITE) << 7) & ~FileHBB);
+  Bitboard whitePawns = pos.pieces(PAWN, WHITE);
-  pi->pawnAttacks[BLACK] = ((pos.pieces(PAWN, BLACK) >> 7) & ~FileABB) | ((pos.pieces(PAWN, BLACK) >> 9) & ~FileHBB);
+  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.pieces(PAWN, us);
+}
-    Bitboard theirPawns = pos.pieces(PAWN, 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 (!(pawns & file_bb(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);
+          pi->halfOpenFiles[Us] |= (1 << f);
       }
 
   // Loop through all pawns of the current color and score each pawn
-    while (pawns)
+  while ((s = *ptr++) != SQ_NONE)
   {
-        Square s = pop_1st_bit(&pawns);
+      f = square_file(s);
-        File f = square_file(s);
+      r = square_rank(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));
 
       // Passed, isolated or doubled pawn?
-        bool passed   = Position::pawn_is_passed(theirPawns, us, s);
+      passed   = Position::pawn_is_passed(theirPawns, Us, s);
-        bool isolated = Position::pawn_is_isolated(ourPawns, s);
+      isolated = Position::pawn_is_isolated(ourPawns, s);
-        bool doubled  = Position::pawn_is_doubled(ourPawns, 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
@@ -238,64 +220,54 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
       // enemy pawn on an adjacent file gets an additional bonus.
 
       // Kingside pawn storms
-        int 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)
           {
+              // Give a bonus according to the distance of the nearest enemy pawn
               Square s2 = pop_1st_bit(&b);
+              int v = StormLeverBonus[f] - 2 * square_distance(s, s2);
+
+              // If enemy pawn has no pawn beside itself is particularly vulnerable.
+              // Big bonus, especially against a weakness on the rook file
               if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-                {
+                  v *= (square_file(s2) == FILE_H ? 4 : 2);
-                    // The enemy pawn has no pawn beside itself, which makes it
+
-                    // particularly vulnerable. Big bonus, especially against a
+              bonus += v;
-                    // weakness on the rook file.
-                    if (square_file(s2) == FILE_H)
-                        bonus += 4*StormLeverBonus[f] - 8*square_distance(s, s2);
-                    else
-                        bonus += 2*StormLeverBonus[f] - 4*square_distance(s, s2);
-                } else
-                    // There is at least one enemy pawn beside the enemy pawn we look
-                    // at, which means that the pawn has somewhat better chances of
-                    // defending itself by advancing. Smaller bonus.
-                    bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
           }
       }
-        pi->ksStormValue[us] += bonus;
+      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)
           {
+              // Give a bonus according to the distance of the nearest enemy pawn
               Square s2 = pop_1st_bit(&b);
+              int v = StormLeverBonus[f] - 4 * square_distance(s, s2);
+
+              // If enemy pawn has no pawn beside itself is particularly vulnerable.
+              // Big bonus, especially against a weakness on the rook file
               if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-                {
+                  v *= (square_file(s2) == FILE_A ? 4 : 2);
-                    // The enemy pawn has no pawn beside itself, which makes it
+
-                    // particularly vulnerable. Big bonus, especially against a
+              bonus += v;
-                    // weakness on the rook file.
-                    if (square_file(s2) == FILE_A)
-                        bonus += 4*StormLeverBonus[f] - 16*square_distance(s, s2);
-                    else
-                        bonus += 2*StormLeverBonus[f] - 8*square_distance(s, s2);
-                } else
-                    // There is at least one enemy pawn beside the enemy pawn we look
-                    // at, which means that the pawn has somewhat better chances of
-                    // defending itself by advancing. Smaller bonus.
-                    bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
           }
       }
-        pi->qsStormValue[us] += bonus;
+      pi->qsStormValue[Us] += bonus;
 
       // Member of a pawn chain (but not the backward one)? We could speed up
       // the test a little by introducing an array of masks indexed by color
       // and square for doing the test, but because everything is hashed,
       // it probably won't make any noticable difference.
-        bool chain =  ourPawns
+      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
       //
@@ -303,12 +275,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.
-        bool backward;
+      if (   (passed | isolated | chain)
-        if (   passed
+          || (ourPawns & behind_bb(Us, r) & neighboring_files_bb(f))
-            || isolated
+          || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
-            || chain
-            || (pos.attacks_from<PAWN>(s, us) & theirPawns)
-            || (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
           backward = false;
       else
       {
@@ -316,31 +285,29 @@ 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 = pos.attacks_from<PAWN>(s, us);
+          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 & (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 & (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
-        bool candidate;
       candidate =   !passed
                  && !(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)))
           passed = false;
 
       // Score this pawn
@@ -349,45 +316,27 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
 
       if (isolated)
       {
-            mgValue[us] -= IsolatedPawnMidgamePenalty[f];
+          value -= IsolatedPawnPenalty[f];
-            egValue[us] -= IsolatedPawnEndgamePenalty[f];
           if (!(theirPawns & file_bb(f)))
-            {
+              value -= IsolatedPawnPenalty[f] / 2;
-                mgValue[us] -= IsolatedPawnMidgamePenalty[f] / 2;
-                egValue[us] -= IsolatedPawnEndgamePenalty[f] / 2;
-            }
       }
       if (doubled)
-        {
+          value -= DoubledPawnPenalty[f];
-            mgValue[us] -= DoubledPawnMidgamePenalty[f];
+
-            egValue[us] -= DoubledPawnEndgamePenalty[f];
-        }
       if (backward)
       {
-            mgValue[us] -= BackwardPawnMidgamePenalty[f];
+          value -= BackwardPawnPenalty[f];
-            egValue[us] -= BackwardPawnEndgamePenalty[f];
           if (!(theirPawns & file_bb(f)))
-            {
+              value -= BackwardPawnPenalty[f] / 2;
-                mgValue[us] -= BackwardPawnMidgamePenalty[f] / 2;
-                egValue[us] -= BackwardPawnEndgamePenalty[f] / 2;
-            }
       }
       if (chain)
-        {
+          value += ChainBonus[f];
-            mgValue[us] += ChainMidgameBonus[f];
-            egValue[us] += ChainEndgameBonus[f];
-        }
-        if (candidate)
-        {
-            mgValue[us] += CandidateMidgameBonus[relative_rank(us, s)];
-            egValue[us] += CandidateEndgameBonus[relative_rank(us, s)];
-        }
-    } // while(pawns)
-  } // for(colors)
 
-  pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
+      if (candidate)
-  pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
+          value += CandidateBonus[relative_rank(Us, s)];
-  return pi;
+  }
+
+  return value;
 }
 
 

src/pawns.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -47,8 +47,7 @@ class PawnInfo {
 public:
   PawnInfo() { clear(); }
 
-  Value mg_value() const;
+  Score pawns_value() const;
-  Value eg_value() const;
   Value kingside_storm_value(Color c) const;
   Value queenside_storm_value(Color c) const;
   Bitboard pawn_attacks(Color c) const;
@@ -65,7 +64,7 @@ private:
   Key key;
   Bitboard passedPawns;
   Bitboard pawnAttacks[2];
-  int16_t mgValue, egValue;
+  Score value;
   int16_t ksStormValue[2], qsStormValue[2];
   uint8_t halfOpenFiles[2];
   Square kingSquares[2];
@@ -85,6 +84,9 @@ public:
   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;
 };
@@ -94,12 +96,8 @@ 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 {

src/piece.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/piece.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/position.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -44,34 +44,69 @@ using std::string;
 //// Variables
 ////
 
-int Position::castleRightsMask[64];
-
 Key Position::zobrist[2][8][64];
 Key Position::zobEp[64];
 Key Position::zobCastle[16];
 Key Position::zobMaterial[2][8][16];
 Key Position::zobSideToMove;
+Key Position::zobExclusion;
 
-Value Position::MgPieceSquareTable[16][64];
+Score Position::PieceSquareTable[16][64];
-Value Position::EgPieceSquareTable[16][64];
 
 static bool RequestPending = false;
 
-////
-//// Functions
-////
 
 /// Constructors
 
+CheckInfo::CheckInfo(const Position& pos) {
+
+  Color us = pos.side_to_move();
+  Color them = opposite_color(us);
+
+  ksq = pos.king_square(them);
+  dcCandidates = pos.discovered_check_candidates(us);
+
+  checkSq[PAWN] = pos.attacks_from<PAWN>(ksq, them);
+  checkSq[KNIGHT] = pos.attacks_from<KNIGHT>(ksq);
+  checkSq[BISHOP] = pos.attacks_from<BISHOP>(ksq);
+  checkSq[ROOK] = pos.attacks_from<ROOK>(ksq);
+  checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK];
+  checkSq[KING] = EmptyBoardBB;
+}
+
+
+/// Position c'tors. Here we always create a slower but safer copy of
+/// the original position or the FEN string, we want the new born Position
+/// object do not depend on any external data. Instead if we know what we
+/// are doing and we need speed we can create a position with default
+/// c'tor Position() and then use just fast_copy().
+
+Position::Position() {}
+
 Position::Position(const Position& pos) {
-  copy(pos);
+
+  memcpy(this, &pos, sizeof(Position));
+  detach(); // Always detach() in copy c'tor to avoid surprises
 }
 
 Position::Position(const string& fen) {
+
   from_fen(fen);
 }
 
 
+/// Position::detach() copies the content of the current state and castling
+/// masks inside the position itself. This is needed when the st pointee could
+/// become stale, as example because the caller is about to going out of scope.
+
+void Position::detach() {
+
+  startState = *st;
+  st = &startState;
+  st->previous = NULL; // as a safe guard
+}
+
+
 /// Position::from_fen() initializes the position object with the given FEN
 /// string. This function is not very robust - make sure that input FENs are
 /// correct (this is assumed to be the responsibility of the GUI).
@@ -191,11 +226,16 @@ void Position::from_fen(const string& fen) {
   while (fen[i] == ' ')
       i++;
 
-  // En passant square
+  // En passant square -- ignore if no capture is possible
   if (    i <= fen.length() - 2
       && (fen[i] >= 'a' && fen[i] <= 'h')
       && (fen[i+1] == '3' || fen[i+1] == '6'))
+  {
+      Square fenEpSquare = square_from_string(fen.substr(i, 2));
+      Color them = opposite_color(sideToMove);
+      if (attacks_from<PAWN>(fenEpSquare, them) & this->pieces(PAWN, sideToMove))
           st->epSquare = square_from_string(fen.substr(i, 2));
+  }
 
   // Various initialisation
   for (Square sq = SQ_A1; sq <= SQ_H8; sq++)
@@ -213,8 +253,7 @@ void Position::from_fen(const string& fen) {
   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
   st->materialKey = compute_material_key();
-  st->mgValue = compute_value<MidGame>();
+  st->value = compute_value();
-  st->egValue = compute_value<EndGame>();
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 }
@@ -253,11 +292,25 @@ const string Position::to_fen() const {
   }
   fen += (sideToMove == WHITE ? "w " : "b ");
   if (st->castleRights != NO_CASTLES)
+  {
+     if (initialKFile == FILE_E && initialQRFile == FILE_A && initialKRFile == FILE_H)
      {
         if (can_castle_kingside(WHITE))  fen += 'K';
         if (can_castle_queenside(WHITE)) fen += 'Q';
         if (can_castle_kingside(BLACK))  fen += 'k';
         if (can_castle_queenside(BLACK)) fen += 'q';
+     }
+     else
+     {
+        if (can_castle_kingside(WHITE))
+           fen += char(toupper(file_to_char(initialKRFile)));
+        if (can_castle_queenside(WHITE))
+           fen += char(toupper(file_to_char(initialQRFile)));
+        if (can_castle_kingside(BLACK))
+           fen += file_to_char(initialKRFile);
+        if (can_castle_queenside(BLACK))
+           fen += file_to_char(initialQRFile);
+     }
   } else
       fen += '-';
 
@@ -288,8 +341,9 @@ void Position::print(Move m) const {
   std::cout << std::endl;
   if (m != MOVE_NONE)
   {
+      Position p(*this);
       string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
-      std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
+      std::cout << "Move is: " << col << move_to_san(p, m) << std::endl;
   }
   for (Rank rank = RANK_8; rank >= RANK_1; rank--)
   {
@@ -314,34 +368,24 @@ void Position::print(Move m) const {
 }
 
 
-/// Position::copy() creates a copy of the input position.
-
-void Position::copy(const Position& pos) {
-
-  memcpy(this, &pos, sizeof(Position));
-  saveState(); // detach and copy state info
-}
-
-
 /// Position:hidden_checkers<>() returns a bitboard of all pinned (against the
 /// king) pieces for the given color and for the given pinner type. Or, when
 /// template parameter FindPinned is false, the pieces of the given color
 /// candidate for a discovery check against the enemy king.
-/// Note that checkersBB bitboard must be already updated.
+/// Bitboard checkersBB must be already updated when looking for pinners.
 
 template<bool FindPinned>
 Bitboard Position::hidden_checkers(Color c) const {
 
-  Bitboard pinners, result = EmptyBoardBB;
+  Bitboard result = EmptyBoardBB;
+  Bitboard pinners = pieces_of_color(FindPinned ? opposite_color(c) : c);
 
   // Pinned pieces protect our king, dicovery checks attack
   // the enemy king.
   Square ksq = king_square(FindPinned ? c : opposite_color(c));
 
-  // Pinners are sliders, not checkers, that give check when
+  // Pinners are sliders, not checkers, that give check when candidate pinned is removed
-  // candidate pinned is removed.
+  pinners &= (pieces(ROOK, QUEEN) & RookPseudoAttacks[ksq]) | (pieces(BISHOP, QUEEN) & BishopPseudoAttacks[ksq]);
-  pinners =  (pieces(ROOK, QUEEN, FindPinned ? opposite_color(c) : c) & RookPseudoAttacks[ksq])
-           | (pieces(BISHOP, QUEEN, FindPinned ? opposite_color(c) : c) & BishopPseudoAttacks[ksq]);
 
   if (FindPinned && pinners)
       pinners &= ~st->checkersBB;
@@ -362,7 +406,8 @@ Bitboard Position::hidden_checkers(Color c) const {
 
 
 /// Position:pinned_pieces() returns a bitboard of all pinned (against the
-/// king) pieces for the given color.
+/// king) pieces for the given color. Note that checkersBB bitboard must
+/// be already updated.
 
 Bitboard Position::pinned_pieces(Color c) const {
 
@@ -372,7 +417,8 @@ Bitboard Position::pinned_pieces(Color c) const {
 
 /// Position:discovered_check_candidates() returns a bitboard containing all
 /// pieces for the given side which are candidates for giving a discovered
-/// check.
+/// check. Contrary to pinned_pieces() here there is no need of checkersBB
+/// to be already updated.
 
 Bitboard Position::discovered_check_candidates(Color c) const {
 
@@ -458,19 +504,11 @@ void Position::find_checkers() {
 
 /// Position::pl_move_is_legal() tests whether a pseudo-legal move is legal
 
-bool Position::pl_move_is_legal(Move m) const {
-
-  // If we're in check, all pseudo-legal moves are legal, because our
-  // check evasion generator only generates true legal moves.
-  return is_check() || pl_move_is_legal(m, pinned_pieces(side_to_move()));
-}
-
 bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 
   assert(is_ok());
   assert(move_is_ok(m));
   assert(pinned == pinned_pieces(side_to_move()));
-  assert(!is_check());
 
   // Castling moves are checked for legality during move generation.
   if (move_is_castle(m))
@@ -519,107 +557,109 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
 }
 
 
+/// Position::pl_move_is_evasion() tests whether a pseudo-legal move is a legal evasion
+
+bool Position::pl_move_is_evasion(Move m, Bitboard pinned) const
+{
+  assert(is_check());
+
+  Color us = side_to_move();
+  Square from = move_from(m);
+  Square to = move_to(m);
+
+  // King moves and en-passant captures are verified in pl_move_is_legal()
+  if (type_of_piece_on(from) == KING || move_is_ep(m))
+      return pl_move_is_legal(m, pinned);
+
+  Bitboard target = checkers();
+  Square checksq = pop_1st_bit(&target);
+
+  if (target) // double check ?
+      return false;
+
+  // Our move must be a blocking evasion or a capture of the checking piece
+  target = squares_between(checksq, king_square(us)) | checkers();
+  return bit_is_set(target, to) && pl_move_is_legal(m, pinned);
+}
+
+
 /// Position::move_is_check() tests whether a pseudo-legal move is a check
 
 bool Position::move_is_check(Move m) const {
 
-  Bitboard dc = discovered_check_candidates(side_to_move());
+  return move_is_check(m, CheckInfo(*this));
-  return move_is_check(m, dc);
 }
 
-bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
+bool Position::move_is_check(Move m, const CheckInfo& ci) const {
 
   assert(is_ok());
   assert(move_is_ok(m));
-  assert(dcCandidates == discovered_check_candidates(side_to_move()));
+  assert(ci.dcCandidates == discovered_check_candidates(side_to_move()));
+  assert(color_of_piece_on(move_from(m)) == side_to_move());
+  assert(piece_on(ci.ksq) == piece_of_color_and_type(opposite_color(side_to_move()), KING));
 
-  Color us = side_to_move();
-  Color them = opposite_color(us);
   Square from = move_from(m);
   Square to = move_to(m);
-  Square ksq = king_square(them);
+  PieceType pt = type_of_piece_on(from);
 
-  assert(color_of_piece_on(from) == us);
+  // Direct check ?
-  assert(piece_on(ksq) == piece_of_color_and_type(them, KING));
+  if (bit_is_set(ci.checkSq[pt], to))
-
-  // Proceed according to the type of the moving piece
-  switch (type_of_piece_on(from))
-  {
-  case PAWN:
-
-      if (bit_is_set(attacks_from<PAWN>(ksq, them), to)) // Normal check?
       return true;
 
-      if (   dcCandidates // Discovered check?
+  // Discovery check ?
-          && bit_is_set(dcCandidates, from)
+  if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
-          && (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
-          return true;
-
-      if (move_is_promotion(m)) // Promotion with check?
   {
+      // For pawn and king moves we need to verify also direction
+      if (  (pt != PAWN && pt != KING)
+          ||(direction_between_squares(from, ci.ksq) != direction_between_squares(to, ci.ksq)))
+          return true;
+  }
+
+  // Can we skip the ugly special cases ?
+  if (!move_is_special(m))
+      return false;
+
+  Color us = side_to_move();
   Bitboard b = occupied_squares();
+
+  // Promotion with check ?
+  if (move_is_promotion(m))
+  {
       clear_bit(&b, from);
 
       switch (move_promotion_piece(m))
       {
       case KNIGHT:
-              return bit_is_set(attacks_from<KNIGHT>(to), ksq);
+          return bit_is_set(attacks_from<KNIGHT>(to), ci.ksq);
       case BISHOP:
-              return bit_is_set(bishop_attacks_bb(to, b), ksq);
+          return bit_is_set(bishop_attacks_bb(to, b), ci.ksq);
       case ROOK:
-              return bit_is_set(rook_attacks_bb(to, b), ksq);
+          return bit_is_set(rook_attacks_bb(to, b), ci.ksq);
       case QUEEN:
-              return bit_is_set(queen_attacks_bb(to, b), ksq);
+          return bit_is_set(queen_attacks_bb(to, b), ci.ksq);
       default:
           assert(false);
       }
   }
+
   // En passant capture with check?  We have already handled the case
   // of direct checks and ordinary discovered check, the only case we
   // need to handle is the unusual case of a discovered check through the
   // captured pawn.
-      else if (move_is_ep(m))
+  if (move_is_ep(m))
   {
       Square capsq = make_square(square_file(to), square_rank(from));
-          Bitboard b = occupied_squares();
       clear_bit(&b, from);
       clear_bit(&b, capsq);
       set_bit(&b, to);
-          return  (rook_attacks_bb(ksq, b) & pieces(ROOK, QUEEN, us))
+      return  (rook_attacks_bb(ci.ksq, b) & pieces(ROOK, QUEEN, us))
-                ||(bishop_attacks_bb(ksq, b) & pieces(BISHOP, QUEEN, us));
+            ||(bishop_attacks_bb(ci.ksq, b) & pieces(BISHOP, QUEEN, us));
   }
-      return false;
-
-  // Test discovered check and normal check according to piece type
-  case KNIGHT:
-    return   (dcCandidates && bit_is_set(dcCandidates, from))
-          || bit_is_set(attacks_from<KNIGHT>(ksq), to);
-
-  case BISHOP:
-    return   (dcCandidates && bit_is_set(dcCandidates, from))
-          || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to));
-
-  case ROOK:
-    return   (dcCandidates && bit_is_set(dcCandidates, from))
-          || (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to));
-
-  case QUEEN:
-      // Discovered checks are impossible!
-      assert(!bit_is_set(dcCandidates, from));
-      return (   (direction_is_straight(ksq, to) && bit_is_set(attacks_from<ROOK>(ksq), to))
-              || (direction_is_diagonal(ksq, to) && bit_is_set(attacks_from<BISHOP>(ksq), to)));
-
-  case KING:
-      // Discovered check?
-      if (   bit_is_set(dcCandidates, from)
-          && (direction_between_squares(from, ksq) != direction_between_squares(to, ksq)))
-          return true;
 
   // Castling with check ?
   if (move_is_castle(m))
   {
       Square kfrom, kto, rfrom, rto;
-          Bitboard b = occupied_squares();
       kfrom = from;
       rfrom = to;
 
@@ -635,50 +675,10 @@ bool Position::move_is_check(Move m, Bitboard dcCandidates) const {
       clear_bit(&b, rfrom);
       set_bit(&b, rto);
       set_bit(&b, kto);
-          return bit_is_set(rook_attacks_bb(rto, b), ksq);
+      return bit_is_set(rook_attacks_bb(rto, b), ci.ksq);
   }
+
   return false;
-
-  default: // NO_PIECE_TYPE
-      break;
-  }
-  assert(false);
-  return false;
-}
-
-
-/// Position::update_checkers() udpates chekers info given the move. It is called
-/// in do_move() and is faster then find_checkers().
-
-template<PieceType Piece>
-inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square from,
-                                      Square to, Bitboard dcCandidates) {
-
-  const bool Bishop = (Piece == QUEEN || Piece == BISHOP);
-  const bool Rook   = (Piece == QUEEN || Piece == ROOK);
-  const bool Slider = Bishop || Rook;
-
-  // Direct checks
-  if (  (   (Bishop && bit_is_set(BishopPseudoAttacks[ksq], to))
-         || (Rook   && bit_is_set(RookPseudoAttacks[ksq], to)))
-      && bit_is_set(attacks_from<Piece>(ksq), to)) // slow, try to early skip
-      set_bit(pCheckersBB, to);
-
-  else if (   Piece != KING
-           && !Slider
-           && bit_is_set(Piece == PAWN ? attacks_from<PAWN>(ksq, opposite_color(sideToMove))
-                                       : attacks_from<Piece>(ksq), to))
-      set_bit(pCheckersBB, to);
-
-  // Discovery checks
-  if (Piece != QUEEN && bit_is_set(dcCandidates, from))
-  {
-      if (Piece != ROOK)
-          (*pCheckersBB) |= (attacks_from<ROOK>(ksq) & pieces(ROOK, QUEEN, side_to_move()));
-
-      if (Piece != BISHOP)
-          (*pCheckersBB) |= (attacks_from<BISHOP>(ksq) & pieces(BISHOP, QUEEN, side_to_move()));
-  }
 }
 
 
@@ -688,10 +688,11 @@ inline void Position::update_checkers(Bitboard* pCheckersBB, Square ksq, Square
 
 void Position::do_move(Move m, StateInfo& newSt) {
 
-  do_move(m, newSt, discovered_check_candidates(side_to_move()));
+  CheckInfo ci(*this);
+  do_move(m, newSt, ci, move_is_check(m, ci));
 }
 
-void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
+void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) {
 
   assert(is_ok());
   assert(move_is_ok(m));
@@ -702,10 +703,10 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   // ones which are recalculated from scratch anyway, then switch our state
   // pointer to point to the new, ready to be updated, state.
   struct ReducedStateInfo {
-    Key key, pawnKey, materialKey;
+    Key pawnKey, materialKey;
-    int castleRights, rule50;
+    int castleRights, rule50, pliesFromNull;
     Square epSquare;
-    Value mgValue, egValue;
+    Score value;
     Value npMaterial[2];
   };
 
@@ -724,6 +725,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   // Increment the 50 moves rule draw counter. Resetting it to zero in the
   // case of non-reversible moves is taken care of later.
   st->rule50++;
+  st->pliesFromNull++;
 
   if (move_is_castle(m))
   {
@@ -741,16 +743,15 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
 
   Piece piece = piece_on(from);
   PieceType pt = type_of_piece(piece);
+  PieceType capture = ep ? PAWN : type_of_piece_on(to);
 
   assert(color_of_piece_on(from) == us);
   assert(color_of_piece_on(to) == them || square_is_empty(to));
   assert(!(ep || pm) || piece == piece_of_color_and_type(us, PAWN));
   assert(!pm || relative_rank(us, to) == RANK_8);
 
-  st->capture = ep ? PAWN : type_of_piece_on(to);
+  if (capture)
-
+      do_capture_move(key, capture, them, to, ep);
-  if (st->capture)
-      do_capture_move(key, st->capture, them, to, ep);
 
   // Update hash key
   key ^= zobrist[us][pt][from] ^ zobrist[us][pt][to];
@@ -800,7 +801,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       st->pawnKey ^= zobrist[us][PAWN][from] ^ zobrist[us][PAWN][to];
 
       // Set en passant square, only if moved pawn can be captured
-      if (abs(int(to) - int(from)) == 16)
+      if ((to ^ from) == 16)
       {
           if (attacks_from<PAWN>(from + (us == WHITE ? DELTA_N : DELTA_S), us) & pieces(PAWN, them))
           {
@@ -811,8 +812,10 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   }
 
   // Update incremental scores
-  st->mgValue += pst_delta<MidGame>(piece, from, to);
+  st->value += pst_delta(piece, from, to);
-  st->egValue += pst_delta<EndGame>(piece, from, to);
+
+  // Set capture piece
+  st->capture = capture;
 
   if (pm) // promotion ?
   {
@@ -847,10 +850,8 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       st->pawnKey ^= zobrist[us][PAWN][to];
 
       // Partially revert and update incremental scores
-      st->mgValue -= pst<MidGame>(us, PAWN, to);
+      st->value -= pst(us, PAWN, to);
-      st->mgValue += pst<MidGame>(us, promotion, to);
+      st->value += pst(us, promotion, to);
-      st->egValue -= pst<EndGame>(us, PAWN, to);
-      st->egValue += pst<EndGame>(us, promotion, to);
 
       // Update material
       st->npMaterial[us] += piece_value_midgame(promotion);
@@ -860,29 +861,33 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   st->key = key;
 
   // Update checkers bitboard, piece must be already moved
+  st->checkersBB = EmptyBoardBB;
+
+  if (moveIsCheck)
+  {
       if (ep | pm)
           st->checkersBB = attackers_to(king_square(them)) & pieces_of_color(us);
       else
       {
-      st->checkersBB = EmptyBoardBB;
+          // Direct checks
-      Square ksq = king_square(them);
+          if (bit_is_set(ci.checkSq[pt], to))
-      switch (pt)
+              st->checkersBB = SetMaskBB[to];
+
+          // Discovery checks
+          if (ci.dcCandidates && bit_is_set(ci.dcCandidates, from))
           {
-      case PAWN:   update_checkers<PAWN>(&(st->checkersBB), ksq, from, to, dcCandidates);   break;
+              if (pt != ROOK)
-      case KNIGHT: update_checkers<KNIGHT>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
+                  st->checkersBB |= (attacks_from<ROOK>(ci.ksq) & pieces(ROOK, QUEEN, us));
-      case BISHOP: update_checkers<BISHOP>(&(st->checkersBB), ksq, from, to, dcCandidates); break;
+
-      case ROOK:   update_checkers<ROOK>(&(st->checkersBB), ksq, from, to, dcCandidates);   break;
+              if (pt != BISHOP)
-      case QUEEN:  update_checkers<QUEEN>(&(st->checkersBB), ksq, from, to, dcCandidates);  break;
+                  st->checkersBB |= (attacks_from<BISHOP>(ci.ksq) & pieces(BISHOP, QUEEN, us));
-      case KING:   update_checkers<KING>(&(st->checkersBB), ksq, from, to, dcCandidates);   break;
+          }
-      default: assert(false); break;
       }
   }
 
   // Finish
   sideToMove = opposite_color(sideToMove);
-
+  st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
 
   assert(is_ok());
 }
@@ -918,8 +923,7 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
     key ^= zobrist[them][capture][capsq];
 
     // Update incremental scores
-    st->mgValue -= pst<MidGame>(them, capture, capsq);
+    st->value -= pst(them, capture, capsq);
-    st->egValue -= pst<EndGame>(them, capture, capsq);
 
     // If the captured piece was a pawn, update pawn hash key,
     // otherwise update non-pawn material.
@@ -1016,10 +1020,8 @@ void Position::do_castle_move(Move m) {
   index[rto] = tmp;
 
   // Update incremental scores
-  st->mgValue += pst_delta<MidGame>(king, kfrom, kto);
+  st->value += pst_delta(king, kfrom, kto);
-  st->egValue += pst_delta<EndGame>(king, kfrom, kto);
+  st->value += pst_delta(rook, rfrom, rto);
-  st->mgValue += pst_delta<MidGame>(rook, rfrom, rto);
-  st->egValue += pst_delta<EndGame>(rook, rfrom, rto);
 
   // Update hash key
   st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
@@ -1045,9 +1047,7 @@ void Position::do_castle_move(Move m) {
 
   // Finish
   sideToMove = opposite_color(sideToMove);
-
+  st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
 
   assert(is_ok());
 }
@@ -1239,9 +1239,9 @@ void Position::do_null_move(StateInfo& backupSt) {
   // a backup storage not as a new state to be used.
   backupSt.key      = st->key;
   backupSt.epSquare = st->epSquare;
-  backupSt.mgValue  = st->mgValue;
+  backupSt.value    = st->value;
-  backupSt.egValue  = st->egValue;
   backupSt.previous = st->previous;
+  backupSt.pliesFromNull = st->pliesFromNull;
   st->previous = &backupSt;
 
   // Save the current key to the history[] array, in order to be able to
@@ -1258,10 +1258,9 @@ void Position::do_null_move(StateInfo& backupSt) {
   sideToMove = opposite_color(sideToMove);
   st->epSquare = SQ_NONE;
   st->rule50++;
+  st->pliesFromNull = 0;
+  st->value += (sideToMove == WHITE) ?  TempoValue : -TempoValue;
   gamePly++;
-
-  st->mgValue += (sideToMove == WHITE)? TempoValueMidgame : -TempoValueMidgame;
-  st->egValue += (sideToMove == WHITE)? TempoValueEndgame : -TempoValueEndgame;
 }
 
 
@@ -1276,9 +1275,9 @@ void Position::undo_null_move() {
   StateInfo* backupSt = st->previous;
   st->key      = backupSt->key;
   st->epSquare = backupSt->epSquare;
-  st->mgValue  = backupSt->mgValue;
+  st->value    = backupSt->value;
-  st->egValue  = backupSt->egValue;
   st->previous = backupSt->previous;
+  st->pliesFromNull = backupSt->pliesFromNull;
 
   // Update the necessary information
   sideToMove = opposite_color(sideToMove);
@@ -1346,6 +1345,10 @@ int Position::see(Square from, Square to) const {
   Piece capture = piece_on(to);
   Bitboard occ = occupied_squares();
 
+  // King cannot be recaptured
+  if (type_of_piece(piece) == KING)
+      return seeValues[capture];
+
   // Handle en passant moves
   if (st->epSquare == to && type_of_piece_on(from) == PAWN)
   {
@@ -1454,19 +1457,6 @@ int Position::see(Square from, Square to) const {
 }
 
 
-/// Position::saveState() copies the content of the current state
-/// inside startState and makes st point to it. This is needed
-/// when the st pointee could become stale, as example because
-/// the caller is about to going out of scope.
-
-void Position::saveState() {
-
-  startState = *st;
-  st = &startState;
-  st->previous = NULL; // as a safe guard
-}
-
-
 /// Position::clear() erases the position object to a pristine state, with an
 /// empty board, white to move, and no castling rights.
 
@@ -1484,8 +1474,8 @@ void Position::clear() {
   for (int i = 0; i < 64; i++)
       board[i] = EMPTY;
 
-  for (int i = 0; i < 7; i++)
+  for (int i = 0; i < 8; i++)
-      for (int j = 0; j < 8; j++)
+      for (int j = 0; j < 16; j++)
           pieceList[0][i][j] = pieceList[1][i][j] = SQ_NONE;
 
   sideToMove = WHITE;
@@ -1619,10 +1609,9 @@ Key Position::compute_material_key() const {
 /// game and the endgame. These functions are used to initialize the incremental
 /// scores when a new position is set up, and to verify that the scores are correctly
 /// updated by do_move and undo_move when the program is running in debug mode.
-template<Position::GamePhase Phase>
+Score Position::compute_value() const {
-Value Position::compute_value() const {
 
-  Value result = Value(0);
+  Score result = make_score(0, 0);
   Bitboard b;
   Square s;
 
@@ -1634,12 +1623,11 @@ Value Position::compute_value() const {
           {
               s = pop_1st_bit(&b);
               assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += pst<Phase>(c, pt, s);
+              result += pst(c, pt, s);
           }
       }
 
-  const Value TempoValue = (Phase == MidGame ? TempoValueMidgame : TempoValueEndgame);
+  result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
-  result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
   return result;
 }
 
@@ -1670,6 +1658,7 @@ Value Position::compute_non_pawn_material(Color c) const {
 /// Position::is_draw() tests whether the position is drawn by material,
 /// repetition, or the 50 moves rule. It does not detect stalemates, this
 /// must be done by the search.
+// FIXME: Currently we are not handling 50 move rule correctly when in check
 
 bool Position::is_draw() const {
 
@@ -1683,7 +1672,7 @@ bool Position::is_draw() const {
       return true;
 
   // Draw by repetition?
-  for (int i = 2; i < Min(gamePly, st->rule50); i += 2)
+  for (int i = 4; i <= Min(Min(gamePly, st->rule50), st->pliesFromNull); i += 2)
       if (history[gamePly - i] == st->key)
           return true;
 
@@ -1697,8 +1686,7 @@ bool Position::is_draw() const {
 bool Position::is_mate() const {
 
   MoveStack moves[256];
-
+  return is_check() && (generate_moves(*this, moves, false) == moves);
-  return is_check() && (generate_evasions(*this, moves, pinned_pieces(sideToMove)) == moves);
 }
 
 
@@ -1719,11 +1707,10 @@ bool Position::has_mate_threat(Color c) {
 
   MoveStack mlist[120];
   bool result = false;
-  Bitboard dc = discovered_check_candidates(sideToMove);
   Bitboard pinned = pinned_pieces(sideToMove);
 
   // Generate pseudo-legal non-capture and capture check moves
-  MoveStack* last = generate_non_capture_checks(*this, mlist, dc);
+  MoveStack* last = generate_non_capture_checks(*this, mlist);
   last = generate_captures(*this, last);
 
   // Loop through the moves, and see if one of them is mate
@@ -1773,6 +1760,8 @@ void Position::init_zobrist() {
 
   for (int i = 0; i < 16; i++)
       zobMaterial[0][KING][i] = zobMaterial[1][KING][i] = Key(0ULL);
+
+  zobExclusion = genrand_int64();
 }
 
 
@@ -1790,16 +1779,12 @@ void Position::init_piece_square_tables() {
       for (Piece p = WP; p <= WK; p++)
       {
           i = (r == 0)? 0 : (genrand_int32() % (r*2) - r);
-          MgPieceSquareTable[p][s] = Value(MgPST[p][s] + i);
+          PieceSquareTable[p][s] = make_score(MgPST[p][s] + i, EgPST[p][s] + i);
-          EgPieceSquareTable[p][s] = Value(EgPST[p][s] + i);
       }
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       for (Piece p = BP; p <= BK; p++)
-      {
+          PieceSquareTable[p][s] = -PieceSquareTable[p-8][flip_square(s)];
-          MgPieceSquareTable[p][s] = -MgPieceSquareTable[p-8][flip_square(s)];
-          EgPieceSquareTable[p][s] = -EgPieceSquareTable[p-8][flip_square(s)];
-      }
 }
 
 
@@ -1854,8 +1839,7 @@ void Position::flipped_copy(const Position& pos) {
   st->materialKey = compute_material_key();
 
   // Incremental scores
-  st->mgValue = compute_value<MidGame>();
+  st->value = compute_value();
-  st->egValue = compute_value<EndGame>();
 
   // Material
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
@@ -1882,6 +1866,7 @@ bool Position::is_ok(int* failedStep) const {
   static const bool debugNonPawnMaterial = false;
   static const bool debugPieceCounts = false;
   static const bool debugPieceList = false;
+  static const bool debugCastleSquares = false;
 
   if (failedStep) *failedStep = 1;
 
@@ -1982,15 +1967,9 @@ bool Position::is_ok(int* failedStep) const {
 
   // Incremental eval OK?
   if (failedStep) (*failedStep)++;
-  if (debugIncrementalEval)
+  if (debugIncrementalEval && st->value != compute_value())
-  {
-      if (st->mgValue != compute_value<MidGame>())
       return false;
 
-      if (st->egValue != compute_value<EndGame>())
-          return false;
-  }
-
   // Non-pawn material OK?
   if (failedStep) (*failedStep)++;
   if (debugNonPawnMaterial)
@@ -2024,6 +2003,25 @@ bool Position::is_ok(int* failedStep) const {
                       return false;
               }
   }
+
+  if (failedStep) (*failedStep)++;
+  if (debugCastleSquares) {
+      for (Color c = WHITE; c <= BLACK; c++) {
+          if (can_castle_kingside(c) && piece_on(initial_kr_square(c)) != piece_of_color_and_type(c, ROOK))
+              return false;
+          if (can_castle_queenside(c) && piece_on(initial_qr_square(c)) != piece_of_color_and_type(c, ROOK))
+              return false;
+      }
+      if (castleRightsMask[initial_kr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OO))
+          return false;
+      if (castleRightsMask[initial_qr_square(WHITE)] != (ALL_CASTLES ^ WHITE_OOO))
+          return false;
+      if (castleRightsMask[initial_kr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OO))
+          return false;
+      if (castleRightsMask[initial_qr_square(BLACK)] != (ALL_CASTLES ^ BLACK_OOO))
+          return false;
+  }
+
   if (failedStep) *failedStep = 0;
   return true;
 }

src/position.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -63,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 {
@@ -87,12 +99,13 @@ 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;
   StateInfo* previous;
@@ -133,9 +146,9 @@ public:
   };
 
   // Constructors
-  Position() {}
+  Position();
-  Position(const Position& pos);
+  explicit Position(const Position& pos);
-  Position(const std::string& fen);
+  explicit Position(const std::string& fen);
 
   // Text input/output
   void from_fen(const std::string& fen);
@@ -143,7 +156,6 @@ public:
   void print(Move m = MOVE_NONE) const;
 
   // Copying
-  void copy(const Position& pos);
   void flipped_copy(const Position& pos);
 
   // The piece on a given square
@@ -202,14 +214,18 @@ public:
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // 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_capture_or_promotion(Move m) const;
   bool move_is_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) const;
 
+  // Piece captured with previous moves
+  PieceType captured_piece() const;
+
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
   static bool pawn_is_passed(Bitboard theirPawns, Color c, Square s);
@@ -220,9 +236,9 @@ public:
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void saveState();
+  void detach();
   void do_move(Move m, StateInfo& st);
-  void do_move(Move m, StateInfo& st, 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();
@@ -235,15 +251,14 @@ public:
 
   // 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;
-  template<GamePhase> Value pst_delta(Piece piece, Square from, Square to) const;
 
   // Game termination checks
   bool is_mate() const;
@@ -283,9 +298,6 @@ private:
   void undo_castle_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;
 
@@ -295,8 +307,8 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
+  Score pst(Color c, PieceType pt, Square s) const;
-  template<GamePhase> Value compute_value() const;
+  Score compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
   // Board
@@ -316,19 +328,19 @@ private:
   Color sideToMove;
   int gamePly;
   Key history[MaxGameLength];
+  int castleRightsMask[64];
   File initialKFile, initialKRFile, initialQRFile;
   StateInfo startState;
   StateInfo* st;
 
   // Static variables
-  static int castleRightsMask[64];
   static Key zobrist[2][8][64];
   static Key zobEp[64];
   static Key zobCastle[16];
   static Key zobMaterial[2][8][16];
   static Key zobSideToMove;
-  static Value MgPieceSquareTable[16][64];
+  static Score PieceSquareTable[16][64];
-  static Value EgPieceSquareTable[16][64];
+  static Key zobExclusion;
 };
 
 
@@ -493,6 +505,10 @@ 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;
 }
@@ -501,46 +517,22 @@ inline Key Position::get_material_key() const {
   return st->materialKey;
 }
 
-template<Position::GamePhase Ph>
+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 (Ph == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
-                        : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
 }
 
-template<Position::GamePhase Ph>
+inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
-inline Value Position::pst_delta(Piece piece, Square from, Square to) const {
+  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
-  return (Ph == MidGame ? MgPieceSquareTable[piece][to] - MgPieceSquareTable[piece][from]
-                        : EgPieceSquareTable[piece][to] - EgPieceSquareTable[piece][from]);
 }
 
-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 st->npMaterial[c];
 }
 
-inline Phase Position::game_phase() const {
-
-  // Values modified by Joona Kiiski
-  static const Value MidgameLimit = Value(15581);
-  static const Value EndgameLimit = Value(3998);
-
-  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_passed_pawn_push(Move m) const {
 
   Color c = side_to_move();
@@ -568,8 +560,17 @@ inline bool Position::has_pawn_on_7th(Color c) const {
 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)) && !move_is_castle(m)) || move_is_ep(m);
+inline bool Position::move_is_capture_or_promotion(Move m) const {
+
+  // Move must not be MOVE_NONE !
+  return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+}
+
+inline PieceType Position::captured_piece() const {
+  return st->capture;
 }
 
 #endif // !defined(POSITION_H_INCLUDED)

src/psqtab.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/san.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -63,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 string move_to_san(const Position& pos, Move m) {
+const string move_to_san(Position& pos, Move m) {
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
@@ -123,10 +123,10 @@ const string move_to_san(const Position& pos, Move m) {
   // Position::move_is_check doesn't detect all checks (not castling moves,
   // promotions and en passant captures).
   StateInfo st;
-  Position p(pos);
+  pos.do_move(m, st);
-  p.do_move(m, st);
+  if (pos.is_check())
-  if (p.is_check())
+      san += pos.is_mate() ? "#" : "+";
-      san += p.is_mate()? "#" : "+";
+  pos.undo_move(m);
 
   return san;
 }
@@ -142,13 +142,14 @@ Move move_from_san(const Position& pos, const string& movestr) {
   assert(pos.is_ok());
 
   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;
@@ -157,7 +158,7 @@ Move move_from_san(const Position& pos, const 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;
@@ -367,11 +368,12 @@ namespace {
         return AMBIGUITY_NONE;
 
     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)

src/san.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -36,7 +36,7 @@
 //// Prototypes
 ////
 
-extern const std::string move_to_san(const Position& pos, Move m);
+extern const std::string move_to_san(Position& pos, Move m);
 extern Move move_from_san(const Position& pos, const std::string& str);
 extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
 extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, ValueType type, Move pv[]);

src/scale.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/search.h

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

src/thread.h

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

src/tt.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -25,7 +25,9 @@
 #include <cassert>
 #include <cmath>
 #include <cstring>
+#if !(defined(__hpux) || defined(__ppc__) || defined(__ppc64__) || defined(__arm__))
 #  include <xmmintrin.h>
+#endif
 
 #include "movegen.h"
 #include "tt.h"
@@ -53,11 +55,9 @@ TranspositionTable::~TranspositionTable() {
 /// TranspositionTable::set_size sets the size of the transposition table,
 /// measured in megabytes.
 
-void TranspositionTable::set_size(unsigned mbSize) {
+void TranspositionTable::set_size(size_t mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 4096);
+  size_t newSize = 1024;
-
-  unsigned newSize = 1024;
 
   // We store a cluster of ClusterSize number of TTEntry for each position
   // and newSize is the maximum number of storable positions.
@@ -125,6 +125,7 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
           if (tte->key() && t == VALUE_TYPE_EV_LO)
               return;
 
+          // Preserve any exsisting ttMove
           if (m == MOVE_NONE)
               m = tte->move();
 
@@ -169,11 +170,14 @@ TTEntry* TranspositionTable::retrieve(const Key posKey) const {
 /// 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.
+#if defined(__hpux) || defined(__ppc__) || defined(__ppc64__) || defined(__arm__)
+void TranspositionTable::prefetch(const Key) const {} // Not supported on HP UX
+#else
 
 void TranspositionTable::prefetch(const Key posKey) const {
 
 #if defined(__INTEL_COMPILER) || defined(__ICL)
-   // This hack prevents prefetches to be optimized away by the
+   // This hack prevents prefetches to be optimized away by
    // Intel compiler. Both MSVC and gcc seems not affected.
    __asm__ ("");
 #endif
@@ -183,6 +187,7 @@ void TranspositionTable::prefetch(const Key posKey) const {
   _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
 }
 
+#endif
 
 /// TranspositionTable::new_search() is called at the beginning of every new
 /// search. It increments the "generation" variable, which is used to
@@ -208,6 +213,8 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 
   for (int i = 0; pv[i] != MOVE_NONE; i++)
   {
+      TTEntry *tte = retrieve(p.get_key());
+      if (!tte || tte->move() != pv[i])
           store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]);
       p.do_move(pv[i], st);
   }
@@ -220,7 +227,7 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
 /// will often get single-move PVs when the search stops while failing high,
 /// and a single-move PV means that we don't have a ponder move.
 
-void TranspositionTable::extract_pv(const Position& pos, Move pv[], int pvSize) {
+void TranspositionTable::extract_pv(const Position& pos, Move pv[], const int PLY_MAX) {
 
   const TTEntry* tte;
   StateInfo st;
@@ -236,7 +243,7 @@ void TranspositionTable::extract_pv(const Position& pos, Move pv[], int pvSize)
          && tte->move() != MOVE_NONE
          && move_is_legal(p, tte->move())
          && (!p.is_draw() || ply < 2)
-         && ply < pvSize)
+         && ply < PLY_MAX)
   {
       pv[ply] = tte->move();
       p.do_move(pv[ply++], st);

src/tt.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -95,14 +95,14 @@ class TranspositionTable {
 public:
   TranspositionTable();
   ~TranspositionTable();
-  void set_size(unsigned mbSize);
+  void set_size(size_t mbSize);
   void clear();
   void store(const Key posKey, Value v, ValueType type, Depth d, Move m);
   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[], int pvSize);
+  void extract_pv(const Position& pos, Move pv[], const int PLY_MAX);
   int full() const;
 
 private:
@@ -114,7 +114,7 @@ private:
   unsigned writes; // heavy SMP read/write access here
   unsigned char pad_after[64];
 
-  unsigned size;
+  size_t size;
   TTCluster* entries;
   uint8_t generation;
 };

src/types.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -33,7 +33,7 @@ typedef __int16 int16;
 typedef unsigned __int16 uint16_t;
 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;
@@ -73,4 +73,28 @@ typedef uint64_t Bitboard;
 #define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
 #endif
 
+// Define a __cpuid() function for gcc compilers, for Intel and MSVC
+// is already available as an intrinsic.
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+inline void __cpuid(int CPUInfo[4], int InfoType)
+{
+  int* eax = CPUInfo + 0;
+  int* ebx = CPUInfo + 1;
+  int* ecx = CPUInfo + 2;
+  int* edx = CPUInfo + 3;
+
+  *eax = InfoType;
+  *ecx = 0;
+  __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+                  : "0" (*eax), "2" (*ecx));
+}
+#else
+inline void __cpuid(int CPUInfo[4], int)
+{
+   CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0;
+}
+#endif
+
 #endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -61,6 +61,7 @@ namespace {
   void set_option(UCIInputParser& uip);
   void set_position(UCIInputParser& uip);
   bool go(UCIInputParser& uip);
+  void perft(UCIInputParser& uip);
 }
 
 
@@ -106,7 +107,8 @@ namespace {
     UCIInputParser uip(command);
     string token;
 
-    uip >> token; // operator>>() skips any whitespace
+    if (!(uip >> token)) // operator>>() skips any whitespace
+        return true;
 
     if (token == "quit")
         return false;
@@ -123,7 +125,7 @@ namespace {
     }
     else if (token == "ucinewgame")
     {
-        push_button("Clear Hash");
+        push_button("New Game");
         Position::init_piece_square_tables();
         RootPosition.from_fen(StartPosition);
     }
@@ -147,23 +149,19 @@ namespace {
     else if (token == "eval")
     {
         EvalInfo ei;
-        cout << "Incremental mg: " << RootPosition.mg_value()
+        cout << "Incremental mg: " << mg_value(RootPosition.value())
-             << "\nIncremental eg: " << RootPosition.eg_value()
+             << "\nIncremental eg: " << eg_value(RootPosition.value())
              << "\nFull eval: " << evaluate(RootPosition, ei, 0) << endl;
     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()
              << "\nmaterial key: " << RootPosition.get_material_key()
              << "\npawn key: " << RootPosition.get_pawn_key() << endl;
+    else if (token == "perft")
+        perft(uip);
     else
-    {
         cout << "Unknown command: " << command << endl;
-        while (!uip.eof())
+
-        {
-            uip >> token;
-            cout << token << endl;
-        }
-    }
     return true;
   }
 
@@ -178,33 +176,33 @@ namespace {
 
     string token;
 
-    uip >> token; // operator>>() skips any whitespace
+    if (!(uip >> token)) // operator>>() skips any whitespace
+        return;
 
     if (token == "startpos")
         RootPosition.from_fen(StartPosition);
     else if (token == "fen")
     {
         string fen;
-        while (token != "moves" && !uip.eof())
+        while (uip >> token && token != "moves")
         {
-            uip >> token;
             fen += token;
             fen += ' ';
         }
         RootPosition.from_fen(fen);
     }
 
-    if (!uip.eof())
+    if (uip.good())
     {
         if (token != "moves")
           uip >> token;
+
         if (token == "moves")
         {
             Move move;
             StateInfo st;
-            while (!uip.eof())
+            while (uip >> token)
             {
-                uip >> token;
                 move = move_from_string(RootPosition, token);
                 RootPosition.do_move(move, st);
                 if (RootPosition.rule_50_counter() == 0)
@@ -212,7 +210,7 @@ namespace {
             }
             // Our StateInfo st is about going out of scope so copy
             // its content inside RootPosition before they disappear.
-            RootPosition.saveState();
+            RootPosition.detach();
         }
     }
   }
@@ -226,27 +224,22 @@ namespace {
 
   void set_option(UCIInputParser& uip) {
 
-    string token, name;
+    string token, name, value;
 
-    uip >> token;
+    if (!(uip >> token)) // operator>>() skips any whitespace
-    if (token == "name")
+        return;
-    {
-        uip >> name;
-        while (!uip.eof())
-        {
-            uip >> token;
-            if (token == "value")
-                break;
 
+    if (token == "name" && uip >> name)
+    {
+        while (uip >> token && token != "value")
             name += (" " + token);
-        }
-        if (token == "value")
-        {
-            // Reads until end of line and left trim white space
-            getline(uip, token);
-            token.erase(0, token.find_first_not_of(" \n\r\t"));
 
-            set_option_value(name, token);
+        if (token == "value" && uip >> value)
+        {
+            while (uip >> token)
+                value += (" " + token);
+
+            set_option_value(name, value);
         } else
             push_button(name);
     }
@@ -273,10 +266,8 @@ namespace {
 
     searchMoves[0] = MOVE_NONE;
 
-    while (!uip.eof())
+    while (uip >> token)
     {
-        uip >> token;
-
         if (token == "infinite")
             infinite = true;
         else if (token == "ponder")
@@ -300,22 +291,35 @@ namespace {
         else if (token == "searchmoves")
         {
             int numOfMoves = 0;
-            while (!uip.eof())
+            while (uip >> token)
-            {
-                uip >> token;
                 searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
-            }
+
             searchMoves[numOfMoves] = MOVE_NONE;
         }
     }
 
-    if (moveTime)
-        infinite = true;  // HACK
-
     assert(RootPosition.is_ok());
 
     return think(RootPosition, infinite, ponder, RootPosition.side_to_move(),
                  time, inc, movesToGo, depth, nodes, moveTime, searchMoves);
   }
 
+  void perft(UCIInputParser& uip) {
+
+    string token;
+    int depth, tm, n;
+    Position pos(RootPosition);
+
+    if (!(uip >> depth))
+        return;
+
+    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-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/ucioption.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -88,26 +88,10 @@ namespace {
     o["Space"] = Option(100, 0, 200);
     o["Aggressiveness"] = Option(100, 0, 200);
     o["Cowardice"] = Option(100, 0, 200);
-    o["King Safety Curve"] = Option("Quadratic", COMBO);
-
-       o["King Safety Curve"].comboValues.push_back("Quadratic");
-       o["King Safety Curve"].comboValues.push_back("Linear");  /*, "From File"*/
-
-    o["King Safety Coefficient"] = Option(40, 1, 100);
-    o["King Safety X Intercept"] = Option(0, 0, 20);
-    o["King Safety Max Slope"] = Option(30, 10, 100);
-    o["King Safety Max Value"] = Option(500, 100, 1000);
-    o["Queen Contact Check Bonus"] = Option(3, 0, 8);
-    o["Queen Check Bonus"] = Option(2, 0, 4);
-    o["Rook Check Bonus"] = Option(1, 0, 4);
-    o["Bishop Check Bonus"] = Option(1, 0, 4);
-    o["Knight Check Bonus"] = Option(1, 0, 4);
-    o["Discovered Check Bonus"] = Option(3, 0, 8);
-    o["Mate Threat Bonus"] = Option(3, 0, 8);
     o["Check Extension (PV nodes)"] = Option(2, 0, 2);
     o["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
-    o["Single Reply Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Single Evasion Extension (PV nodes)"] = Option(2, 0, 2);
-    o["Single Reply Extension (non-PV nodes)"] = Option(2, 0, 2);
+    o["Single Evasion Extension (non-PV nodes)"] = Option(2, 0, 2);
     o["Mate Threat Extension (PV nodes)"] = Option(0, 0, 2);
     o["Mate Threat Extension (non-PV nodes)"] = Option(0, 0, 2);
     o["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
@@ -116,19 +100,16 @@ 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(10, 1, 100);
-    o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
-    o["Threat Depth"] = Option(5, 0, 100);
     o["Randomness"] = Option(0, 0, 10);
     o["Minimum Split Depth"] = Option(4, 4, 7);
     o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
-    o["Threads"] = Option(1, 1, 8);
+    o["Threads"] = Option(1, 1, MAX_THREADS);
-    o["Hash"] = Option(32, 4, 4096);
+    o["Hash"] = Option(32, 4, 8192);
     o["Clear Hash"] = Option(false, BUTTON);
+    o["New Game"] = Option(false, BUTTON);
     o["Ponder"] = Option(true);
     o["OwnBook"] = Option(true);
     o["MultiPV"] = Option(1, 1, 500);
-    o["UCI_ShowCurrLine"] = Option(false);
     o["UCI_Chess960"] = Option(false);
     o["UCI_AnalyseMode"] = Option(false);
 
@@ -169,6 +150,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;
+  }
+
 }
 
 ////
@@ -183,15 +176,18 @@ void init_uci_options() {
 
   load_defaults(options);
 
-  // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
+  // Set optimal value for parameter "Minimum Split Depth"
-  // According to Ken Dail's tests, Glaurung plays much better with 7 than
+  // according to number of available cores.
-  // with 8 threads.  This is weird, but it is probably difficult to find out
-  // why before I have a 8-core computer to experiment with myself.
   assert(options.find("Threads") != options.end());
   assert(options.find("Minimum Split Depth") != options.end());
 
-  options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
+  Option& thr = options["Threads"];
-  options["Threads"].currentValue = stringify(Min(cpu_count(), 7));
+  Option& msd = options["Minimum Split Depth"];
+
+  thr.defaultValue = thr.currentValue = stringify(cpu_count());
+
+  if (cpu_count() >= 8)
+      msd.defaultValue = msd.currentValue = stringify(7);
 }
 
 
@@ -279,10 +275,28 @@ void set_option_value(const string& name, const string& value) {
   else if (v == "false")
       v = "0";
 
-  if (options.find(name) != options.end())
+  if (options.find(name) == options.end())
-      options[name].currentValue = v;
+  {
-  else
       std::cout << "No such option: " << name << std::endl;
+      return;
+  }
+
+  // Normally it's up to the GUI to check for option's limits,
+  // but we could receive the new value directly from the user
+  // by teminal window. So let's check the bounds anyway.
+  Option& opt = options[name];
+
+  if (opt.type == CHECK && v != "0" && v != "1")
+      return;
+
+  else if (opt.type == SPIN)
+  {
+      int val = atoi(v.c_str());
+      if (val < opt.minValue || val > opt.maxValue)
+          return;
+  }
+
+  opt.currentValue = v;
 }
 
 

src/ucioption.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/value.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by

src/value.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -48,10 +48,49 @@ enum Value {
   VALUE_KNOWN_WIN = 15000,
   VALUE_MATE = 30000,
   VALUE_INFINITE = 30001,
-  VALUE_NONE = 30002
+  VALUE_NONE = 30002,
+  VALUE_ENSURE_SIGNED = -1
 };
 
 
+/// 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
 ////
@@ -97,8 +136,7 @@ const Value PieceValueEndgame[17] = {
 
 /// 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(22);
 
 
 ////