Stockfish 1.6.2

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

src/Makefile

@@ -25,11 +25,8 @@ EXE = stockfish
 ### ==========================================================================
 ### Compiler speed switches for both GCC and ICC. These settings are generally
 ### fast on a broad range of systems, but may be changed experimentally
-###
-### NOTE: Some versions of gcc miscompile value.h with -O2 or -O3, this is the
-### safe setup, try changing to -O3 or -O2 and verify it works for you.
 ### ==========================================================================
-GCCFLAGS = -O1 -msse
+GCCFLAGS = -O3 -msse
 ICCFLAGS = -fast -msse
 ICCFLAGS-OSX = -fast -mdynamic-no-pic
 

src/bitboard.cpp

@@ -348,19 +348,21 @@ union b_union {
 
 Square pop_1st_bit(Bitboard* bb) {
 
-   b_union* u;
+   b_union u;
    Square ret;
 
-   u = (b_union*)bb;
+   u.b = *bb;
 
-   if (u->dw.l)
+   if (u.dw.l)
    {
-       ret = Square(BitTable[((u->dw.l ^ (u->dw.l - 1)) * 0x783a9b23) >> 26]);
+       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
-       u->dw.l &= (u->dw.l - 1);
+       u.dw.l &= (u.dw.l - 1);
+       *bb = u.b;
        return ret;
    }
-   ret = Square(BitTable[((~(u->dw.h ^ (u->dw.h - 1))) * 0x783a9b23) >> 26]);
+   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
-   u->dw.h &= (u->dw.h - 1);
+   u.dw.h &= (u.dw.h - 1);
+   *bb = u.b;
    return ret;
 }
 

src/evaluate.cpp

@@ -251,9 +251,10 @@ namespace {
   // in init_safety().
   Value SafetyTable[100];
 
-  // Pawn and material hash tables, indexed by the current thread id
+  // Pawn and material hash tables, indexed by the current thread id.
-  MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  // Note that they will be initialized at 0 being global variables.
-  PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  MaterialInfoTable* MaterialTable[THREAD_MAX];
+  PawnInfoTable* PawnTable[THREAD_MAX];
 
   // Sizes of pawn and material hash tables
   const int PawnTableSize = 16384;

src/misc.cpp

@@ -50,7 +50,7 @@ using namespace std;
 /// Version number. If this is left empty, the current date (in the format
 /// YYMMDD) is used as a version number.
 
-static const string EngineVersion = "1.6.1";
+static const string EngineVersion = "1.6.2";
 static const string AppName = "Stockfish";
 static const string AppTag  = "";
 

src/search.cpp

@@ -1142,9 +1142,6 @@ namespace {
         search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID);
         ttMove = ss[ply].pv[ply];
         tte = TT.retrieve(pos.get_key());
-
-        // If tte->move() != MOVE_NONE then it equals ttMove
-        assert(!(tte && tte->move()) || tte->move() == ttMove);
     }
 
     // Initialize a MovePicker object for the current position, and prepare

src/tt.cpp

@@ -55,7 +55,7 @@ TranspositionTable::~TranspositionTable() {
 
 void TranspositionTable::set_size(unsigned mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 4096);
+  assert(mbSize >= 4 && mbSize <= 2048);
 
   unsigned newSize = 1024;
 

src/ucioption.cpp

@@ -122,8 +122,8 @@ namespace {
     o["Randomness"] = Option(0, 0, 10);
     o["Minimum Split Depth"] = Option(4, 4, 7);
     o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
-    o["Threads"] = Option(1, 1, 8);
+    o["Threads"] = Option(1, 1, THREAD_MAX);
-    o["Hash"] = Option(32, 4, 4096);
+    o["Hash"] = Option(32, 4, 2048);
     o["Clear Hash"] = Option(false, BUTTON);
     o["New Game"] = Option(false, BUTTON);
     o["Ponder"] = Option(true);

src/value.h

@@ -56,10 +56,22 @@ enum Value {
 /// integer (enum), first LSB 16 bits are used to store endgame
 /// value, while upper bits are used for midgame value.
 
-enum Score {};
+// Compiler is free to choose the enum type as long as can keep
+// its data, so ensure Score to be an integer type.
+enum Score { ENSURE_32_BITS_SIZE_P = (1 << 16), ENSURE_32_BITS_SIZE_N = -(1 << 16)};
 
+// Extracting the _signed_ lower and upper 16 bits it not so trivial
+// because according to the standard a simple cast to short is
+// implementation defined and so is a right shift of a signed integer.
+inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); }
+
+// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in
+// this case, although not 100% standard compliant it seems to work for Intel and MSVC.
+#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
 inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
-inline Value mg_value(Score s) { return Value((int(s) + 32768) >> 16); }
+#else
+inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); }
+#endif
 
 inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }