Stockfish 2.1

stockfish bench signature is: 6487630

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

Readme.txt

@@ -1,33 +1,28 @@
 1. Introduction
 ---------------
 
-Glaurung is a free UCI chess engine.  It is not a complete chess
-program, but requires some UCI compatible GUI (like XBoard with
-PolyGlot, eboard, José, Arena, Sigma Chess, Shredder, Chess Partner,
-or Fritz) in order to be used comfortably.  Read the documentation for
-your GUI of choice for information about how to use Glaurung with your
-GUI.
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program, but requires some UCI compatible GUI
+(like XBoard with PolyGlot, eboard, Josè, Arena, Sigma Chess, Shredder,
+Chess Partner, or Fritz) in order to be used comfortably.  Read the
+documentation for your GUI of choice for information about how to use
+Stockfish with your GUI.
 
-Glaurung 2 is a completely rewritten version of Glaurung.  Apart from
-the parallel search code, almost no code is shared with Glaurung
-1.2.1, the previous stable version.  The new program is clearly
-stronger than the old, but has a less attractive style of play,
-because there are still a few major holes in its evaluation function
-(most notably space and development).
-
-This version of Glaurung supports up to 8 CPUs, but has not been
-tested thoroughly with more than 2.  The program tries to detect the
+This version of Stockfish supports up to 32 CPUs, but has not been
+tested thoroughly with more than 4.  The program tries to detect the
 number of CPUs on your computer and set the number of search threads
 accordingly, but please be aware that the detection is not always
 correct.  It is therefore recommended to inspect the value of the
 "Threads" UCI parameter, and to make sure it equals the number of CPU
-cores on your computer.
+cores on your computer. If you are using more than four threads, it
+is recommended to raise the value of "Minimum Split Depth" UCI parameter
+to 6.
 
 
 2. Files
 --------
 
-This distribution of Glaurung consists of the following files:
+This distribution of Stockfish consists of the following files:
 
   * Readme.txt, the file you are currently reading.
 
@@ -35,284 +30,55 @@ This distribution of Glaurung consists of the following files:
     License.
 
   * src/, a subdirectory containing the full source code, including a
-    Makefile that can be used to compile Glaurung on Unix-like
-    systems.  For further information about how to compile Glaurung
+    Makefile that can be used to compile Stockfish on Unix-like
+    systems.  For further information about how to compile Stockfish
     yourself, read section 4 below.
 
-  * MacOSX/, a subdirectory containing excutables for Apple Macintosh
-    computers running Mac OS X 10.4 (Tiger) and newer.  There are two
-    executables, one for OS X 10.4, and one for OS X 10.5.  The
-    executable for OS X 10.4 will work in 10.5 as well, but the one
-    for 10.5 is faster.
-
-  * LinuxX86/, a subdirectory containing 32-bit and 64-bit x86 GNU/Linux
-    executables.
-
-  * Windows/, a subdirectory containing 32-bit and 64-bit Windows
-    executables.
-
-  * polyglot.ini, for using Glaurung with Fabien Letouzey's PolyGlot
+  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
     adapter.
 
 
 3. Opening books
 ----------------
 
-This version of Glaurung has experimental support for PolyGlot opening
-books.  For information about how to create such books, consult the
-PolyGlot documentation.  The book file can be selected by setting the
-UCI parameter "Book File".
-
-A book file contributed by Salvo Spitaleri can be found on the
-Glaurung web page.
+This version of Stockfish has support for PolyGlot opening books.
+For information about how to create such books, consult the PolyGlot
+documentation.  The book file can be selected by setting the UCI
+parameter "Book File".
 
 
 4. Compiling it yourself
 ------------------------
 
 On Unix-like systems, it should usually be possible to compile
-Glaurung 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
-Glaurung are endianness-sensitive, and won't work on a big-endian CPU.
-Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
-of bitboard.h is commented out should solve this problem.
-Commenting out the line with "#define USE_32BIT_ATTACKS" near the
+Stockfish directly from the source code with the included Makefile.
 
-There is also a problem with compiling Glaurung on certain 64-bit 
-systems, regardless of the endianness.  If Glaurung segfaults 
-immediately after startup, try to comment out the line with 
-"#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
-recompile.
+For big-endian machines like Power PC you need to enable the proper
+flag changing from -DNBIGENDIAN to -DBIGENDIAN in the Makefile.
 
-Finally, even if Glaurung does work without any changes on your
-computer, it might be possible to improve the performance by changing
-some of the #define directives in bitboard.h.  The default settings
-are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
-to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
-BITCOUNT_SWAR_64.  For computers with very little memory (like
-handheld devices), it is possible to conserve memory by defining
-USE_COMPACT_ROOK_ATTACKS. 
+Stockfish has POPCNT instruction runtime detection and support. This can
+give an extra speed on Core i7 or similar systems. To enable this feature
+compile with 'make icc-profile-popcnt'
+
+On 64 bit systems the 'bsfq' assembly instruction will be used for bit
+counting. Detection is automatic at compile time, but in case you experience
+compile problems you can comment out #define USE_BSFQ line in types.h
+
+In general is recommended to run 'make help' to see a list of make targets
+with corresponding descriptions.
 
 
-
-5. History
-----------
-
-2007-05-06: Glaurung 2 - epsilon
---------------------------------
-
-The first public release, and the first version of my new program
-which is able to match the old Glaurung 1.2.1 on a single CPU.  Lots
-of features and chess knowledge is still missing.
-
-2007-05-10: Glaurung 2 - epsilon/2
-----------------------------------
-
-This version is very close to 2 - epsilon.  The major changes are:
-
-  * A number of compatibility problems which appeared when trying to
-    compile Glaurung 2 - epsilon on various operating systems and CPUs
-    have been solved.
-
-  * Fixed a major bug in the detection of rooks trapped inside a
-    friendly king.
-
-  * Added knowledge about several types of drawn endgames.
-
-  * Fixed a few FRC related bugs.  FRC now works, but because of
-    serious holes in the evaluation function the program plays very
-    badly.
-
-  * A slightly more sophisticated king safety evaluation.
-
-2007-06-07: Glaurung 2 - epsilon/3
-----------------------------------
-
-The first public version with support for multiple CPUs.  Unless you
-have a dual-core (or better) computer, use Glaurung with a PolyGlot
-book, or runs games with ponder on, you may want to skip this version,
-which is almost certainly no stronger than 2 - epsilon/2 when running
-on a single CPU.  The main changes compared to the previous version
-are:
-
-  * Parallel search, with support for 1-4 CPUs.  The program currently
-    always allocates a separate pawn hash table and material hash
-    table for four threads, which is a pure waste of RAM if your
-    computer has just a single CPU.  This will be fixed in a future
-    version.
-
-  * Fixed a bug in book randomization.  When using Polyglot books, the
-    previous version would always select exactly the same move in the
-    same position after a restart of the program.  Thanks to Pavel
-    Háse for pointing this out.
-
-  * Fixed a UCI pondering bug: Glaurung no longer instantly prints its
-    best move when the maximum depth is reached during a ponder
-    search, as the previous version did.  According to the UCI
-    protocol, it is not allowed to print the best move before the
-    engine has received the "stop" or "quit" command.
-
-  * Additional search information:  The new version displays hash
-    saturation and the current line(s) of search.
-
-  * Several minor bug fixes and optimizations in the search and
-    evaluation. 
-
-2007-06-08: Glaurung 2 - epsilon/4
-----------------------------------
-
-A bugfix release, with only a single important change:
-
-   * Fixed a very serious pondering bug.  As pointed out by Marc
-     Lacrosse, the previous version would lose on time in almost every
-     single game with pondering enabled.  The new version handles
-     pondering correctly (or so I hope).  When playing with ponder
-     off, the new version is identical to version 2 - epsilon/3.
-
-2007-06-25: Glaurung 2 - epsilon/5
-----------------------------------
-
-Another minor update, including the following improvements and bug
-fixes:
-
-   * As Werner Schüle discovered, the previous version would sometimes
-     stop thinking and lose on time right before delivering checkmate
-     (which is of course a very unfortunate moment to lose on time).
-     I haven't been able to reproduce Werner's problem on my computer
-     (probably because I run a different OS), but I have fixed the bug
-     which I suspect caused the time losses.  I hope the time losses
-     will no longer occur with 2 - epsilon/5.
-
-   * The program is now slightly less resource-hungry on computers
-     with less than 4 CPU cores: The previous version would always
-     allocated separate pawn and material hash tables for four
-     threads, even when running on a single-core CPU.  The new version
-     only allocates pawn and material hash tables for the threads
-     which are actually used.
-
-   * A minor reorganization of the memory layout has made the parallel
-     search about 10% more efficient (at least on my computer, but the
-     results are likely to vary considerably on different systems).
-
-   * The Intel Mac OS X binary is much faster than before, thanks to
-     the Intel C++ compiler (previous versions were compiled with
-     GCC).
-
-   * A few other very minor bug fixes and enhancements.
-
-2007-11-21: Glaurung 2.0
-------------------------
-
-The first stable (or so I hope) and feature-complete version of
-Glaurung 2.  The following are the main changes compared to the
-previous version:
-
-   * The license has been changed from GPL version 2 to GPL version 3.
-
-   * MultiPV mode.
-
-   * Support for the "searchmoves" option in the UCI "go" command.
-     This means that it is possible to ask Glaurung to exclude some
-     moves from its analysis, or to restrict its analysis to just a
-     handful of moves selected by the user.  This feature must also be
-     supported by the GUI under which Glaurung is run.  Glaurung's own
-     GUI does currently not support this feature.
-
-   * Chess960 support now works.  The program still plays this game 
-     very badly, because of lack of opening knowledge.
-
-   * Much more aggressive pruning in the last few plies of the main
-     search.
-
-   * Somewhat better scaling on multi-CPU systems, and support for up
-     to 8 CPUs.
-
-   * Lots of new UCI parameters.
-
-   * Improved time managment, especially in games with pondering on 
-     (i.e. when the engine is allowed to think when it's the
-     opponent's turn to move).
-
-   * Some evaluation improvements, and some new basic endgame
-     patterns.
-
-   * The program should no longer crash if the game lasts longer than
-     1000 plies.
- 
-   * Many minor bug fixes and other tiny improvements throughout the
-     code.  
- 
-   * More generously commented code, and numerous cosmetic changes in
-     coding style.
-
-2007-11-22: Glaurung 2.0.1
---------------------------
-
-   * Fixed (or so I hope) a bug which would occasionally cause one of
-     the search threads to get stuck forever in its idle loop.
-
-2008-05-14: Glaurung 2.1
-------------------------
-
-This version contains far too many changes to list them all, but most
-of them are minor and cosmetic.  The most important and noticable
-changes are a lot of new UCI parameters, and many improvements in the
-evaluation function.  The highlights are:
-
-   * Extensive changes in the evaluation function.  The addition of
-     king safety is the most important improvement, but there are also
-     numerous little improvements elsewhere in the evaluation.  There
-     is still much work left to do in the evaluation function, though.
-     Space and development are still missing, and the tuning is likely
-     to be very poor.  Currently, the program is optimized for an
-     entertaining style rather than maximum strength.
-
-   * More accurate forward pruning.  The previous version used the
-     null move refutation move to improve the pruning accuracy by
-     means of a very simple trick: It did not allow pruning of any
-     moves with the piece captured by the null move refutation move.
-     In Glaurung 2.1, this has been enhanced: It does not allow
-     pruning of moves which defend the destination square of the null
-     move refutation move, nor of moves which block the ray of the
-     piece in the case that the moving piece in the null move
-     refutation move is a slider.
-
-   * More conservative use of LMR at PV nodes.  The previous version
-     searched the first 6 moves with full depth, 2.1 by default
-     searches the first 14 moves with full depth (but there is a new
-     UCI parameter for configuring this).  I am not at all sure
-     whether this is an improvement.  More thorough testing is
-     required. 
-
-   * Feedback from the evaluation to the search.  The search passes an
-     object of type 'EvalInfo' to the eval, and the eval fills this
-     struct with various potentially useful information (like the sets
-     of squares attacked by each piece type, the middle game and
-     endgame components of the eval, etc.).  At the moment, almost
-     none of this information is actually used by the search.  The
-     only exception is that the evaluation function is now used to
-     adjust the futility pruning margin in the quiescence search.
-
-   * Less extensions.  This hurts the programs performance a lot in most
-     test suites, but I hope it improves the branching factor in deep
-     searches.
-
-   * A very long list of new UCI parameters, especially for tuning the
-     evaluation. 
-
-
-6. Terms of use
+5. Terms of use
 ---------------
 
-Glaurung is free, and distributed under the GNU General Public License
+Stockfish is free, and distributed under the GNU General Public License
 (GPL).  Essentially, this means that you are free to do almost exactly
 what you want with the program, including distributing it among your
 friends, making it available for download from your web site, selling
 it (either by itself or as part of some bigger software package), or
 using it as the starting point for a software project of your own.
 
-The only real limitation is that whenever you distribute Glaurung in
+The only real limitation is that whenever you distribute Stockfish in
 some way, you must always include the full source code, or a pointer
 to where the source code can be found.  If you make any changes to the
 source code, these changes must also be made available under the GPL.
@@ -320,9 +86,3 @@ source code, these changes must also be made available under the GPL.
 For full details, read the copy of the GPL found in the file named
 Copying.txt.
 
-
-7. Feedback
------------
-
-The author's e-mail address is tord@glaurungchess.com
-

polyglot.ini

@@ -2,13 +2,13 @@
 [PolyGlot]
 
 EngineDir = .
-EngineCommand = ./glaurung
+EngineCommand = ./stockfish
 
 Book = false
 BookFile = book.bin
 
-Log = true
-LogFile = glaurung.log
+Log = false
+LogFile = stockfish.log
 
 Resign = true
 ResignScore = 600
@@ -19,52 +19,21 @@ Hash = 128
 Threads = 1
 OwnBook = false
 Book File = book.bin
+Best Book Move = false
 Use Search Log = false
+Search Log Filename = SearchLog.txt
 Mobility (Middle Game) = 100
 Mobility (Endgame) = 100
-Pawn Structure (Middle Game) = 100
-Pawn Structure (Endgame) = 100
 Passed Pawns (Middle Game) = 100
 Passed Pawns (Endgame) = 100
+Space = 100
 Aggressiveness = 100
 Cowardice = 100
-King Safety Curve = Quadratic
-Quadratic = Linear
-King Safety Coefficient = 40
-King Safety X Intercept = 0
-King Safety Max Slope = 30
-King Safety Max Value = 500
-Queen Contact Check Bonus = 4
-Rook Contact Check Bonus = 2
-Queen Check Bonus = 2
-Rook Check Bonus = 1
-Bishop Check Bonus = 1
-Knight Check Bonus = 1
-Discovered Check Bonus = 3
-Mate Threat Bonus = 3
-Check Extension (PV nodes) = 2
-Check Extension (non-PV nodes) = 1
-Single Reply Extension (PV nodes) = 2
-Single Reply Extension (non-PV nodes) = 2
-Mate Threat Extension (PV nodes) = 0
-Mate Threat Extension (non-PV nodes) = 0
-Pawn Push to 7th Extension (PV nodes) = 1
-Pawn Push to 7th Extension (non-PV nodes) = 1
-Passed Pawn Extension (PV nodes) = 1
-Passed Pawn Extension (non-PV nodes) = 0
-Pawn Endgame Extension (PV nodes) = 2
-Pawn Endgame Extension (non-PV nodes) = 2
-Full Depth Moves (PV nodes) = 14
-Full Depth Moves (non-PV nodes) = 3
-Threat Depth = 5
-Selective Plies = 7
-Futility Pruning (Main Search) = true
-Futility Pruning (Quiescence Search) = true
-Futility Margin 0 = 50
-Futility Margin 1 = 100
-Futility Margin 2 = 300
-Maximum Razoring Depth = 3
-Razoring Margin = 300
-Randomness = 0
 Minimum Split Depth = 4
 Maximum Number of Threads per Split Point = 5
+Use Sleeping Threads = false
+Skill Level = 20
+Emergency Move Horizon = 40
+Emergency Base Time = 200
+Emergency Move Time = 70
+Minimum Thinking Time = 20

src/COPYING

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

src/Makefile

@@ -1,14 +1,13 @@
-# Glaurung, a UCI chess playing engine.
-# Copyright (C) 2004-2007 Tord Romstad
-
-# This file is part of Glaurung.
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+# Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+# Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 #
-# Glaurung is free software: you can redistribute it and/or modify
+# Stockfish is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Glaurung is distributed in the hope that it will be useful,
+# Stockfish is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
@@ -17,129 +16,510 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-###
-### Files
-###
+### ==========================================================================
+### Section 1. General Configuration
+### ==========================================================================
 
-EXE = glaurung
+### Executable name
+EXE = stockfish
 
-OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
-	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
-	position.o square.o direction.o tt.o value.o uci.o ucioption.o \
-	mersenne.o book.o bitbase.o san.o benchmark.o
+### Installation dir definitions
+PREFIX = /usr/local
+BINDIR = $(PREFIX)/bin
+
+### Built-in benchmark for pgo-builds
+PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+
+### Object files
+OBJS = benchmark.o bitbase.o bitboard.o book.o endgame.o evaluate.o main.o \
+	material.o misc.o move.o movegen.o movepick.o pawns.o position.o \
+	search.o thread.o timeman.o tt.o uci.o ucioption.o
+
+### ==========================================================================
+### Section 2. High-level Configuration
+### ==========================================================================
+#
+# flag                --- Comp switch --- Description
+# ----------------------------------------------------------------------------
+#
+# debug = no/yes      --- -DNDEBUG    --- Enable/Disable debug mode
+# optimize = yes/no   --- (-O3/-fast etc.) --- Enable/Disable optimizations
+# arch = (name)       --- (-arch)     --- Target architecture
+# os = (name)         ---             --- Target operating system
+# bits = 64/32        --- -DIS_64BIT  --- 64-/32-bit operating system
+# bigendian = no/yes  --- -DBIGENDIAN --- big/little-endian byte order
+# prefetch = no/yes   --- -DUSE_PREFETCH  --- Use prefetch x86 asm-instruction
+# bsfq = no/yes       --- -DUSE_BSFQ  --- Use bsfq x86_64 asm-instruction
+#                                     --- (Works only with GCC and ICC 64-bit)
+# popcnt = no/yes     --- -DUSE_POPCNT --- Use popcnt x86_64 asm-instruction
+#
+# Note that Makefile is space sensitive, so when adding new architectures
+# or modifying existing flags, you have to make sure there are no extra spaces
+# at the end of the line for flag values.
+
+### 2.1. General
+debug = no
+optimize = yes
+
+### 2.2 Architecture specific
+
+# General-section
+ifeq ($(ARCH),general-64)
+	arch = any
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),general-32)
+	arch = any
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),bigendian-64)
+	arch = any
+	os = any
+	bits = 64
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),bigendian-32)
+	arch = any
+	os = any
+	bits = 32
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+# x86-section
+ifeq ($(ARCH),x86-64)
+	arch = x86_64
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = no
+endif
+
+ifeq ($(ARCH),x86-64-modern)
+	arch = x86_64
+	os = any
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = yes
+endif
+
+ifeq ($(ARCH),x86-32)
+	arch = i386
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = yes
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),x86-32-old)
+	arch = i386
+	os = any
+	bits = 32
+	bigendian = no
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+# osx-section
+ifeq ($(ARCH),osx-ppc-64)
+	arch = ppc64
+	os = osx
+	bits = 64
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-ppc-32)
+	arch = ppc
+	os = osx
+	bits = 32
+	bigendian = yes
+	prefetch = no
+	bsfq = no
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-x86-64)
+	arch = x86_64
+	os = osx
+	bits = 64
+	bigendian = no
+	prefetch = yes
+	bsfq = yes
+	popcnt = no
+endif
+
+ifeq ($(ARCH),osx-x86-32)
+	arch = i386
+	os = osx
+	bits = 32
+	bigendian = no
+	prefetch = yes
+	bsfq = no
+	popcnt = no
+endif
 
 
-###
-### Rules
-###
+### ==========================================================================
+### Section 3. Low-level configuration
+### ==========================================================================
+
+### 3.1 Selecting compiler (default = gcc)
+ifeq ($(COMP),)
+	COMP=gcc
+endif
+
+ifeq ($(COMP),mingw)
+	comp=mingw
+	CXX=g++
+	profile_prepare = gcc-profile-prepare
+	profile_make = gcc-profile-make
+	profile_use = gcc-profile-use
+	profile_clean = gcc-profile-clean
+endif
+
+ifeq ($(COMP),gcc)
+	comp=gcc
+	CXX=g++
+	profile_prepare = gcc-profile-prepare
+	profile_make = gcc-profile-make
+	profile_use = gcc-profile-use
+	profile_clean = gcc-profile-clean
+endif
+
+ifeq ($(COMP),icc)
+	comp=icc
+	CXX=icpc
+	profile_prepare = icc-profile-prepare
+	profile_make = icc-profile-make
+	profile_use = icc-profile-use
+	profile_clean = icc-profile-clean
+endif
+
+### 3.2 General compiler settings
+CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+
+ifeq ($(comp),gcc)
+	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra -Wshadow
+endif
+
+ifeq ($(comp),mingw)
+	CXXFLAGS += -Wextra -Wshadow
+endif
+
+ifeq ($(comp),icc)
+	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+endif
+
+ifeq ($(os),osx)
+	CXXFLAGS += -arch $(arch)
+endif
+
+### 3.3 General linker settings
+LDFLAGS = -lpthread $(EXTRALDFLAGS)
+
+ifeq ($(os),osx)
+	LDFLAGS += -arch $(arch)
+endif
+
+### 3.4 Debugging
+ifeq ($(debug),no)
+	CXXFLAGS += -DNDEBUG
+endif
+
+### 3.5 Optimization
+ifeq ($(optimize),yes)
+
+	ifeq ($(comp),gcc)
+		CXXFLAGS += -O3
+
+		ifeq ($(os),osx)
+			ifeq ($(arch),i386)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+			ifeq ($(arch),x86_64)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+		endif
+	endif
+
+	ifeq ($(comp),mingw)
+		CXXFLAGS += -O3
+	endif
+
+	ifeq ($(comp),icc)
+		ifeq ($(os),osx)
+			CXXFLAGS += -fast -mdynamic-no-pic
+		else
+			CXXFLAGS += -O3
+		endif
+	endif
+endif
+
+### 3.6. Bits
+ifeq ($(bits),64)
+	CXXFLAGS += -DIS_64BIT
+endif
+
+### 3.7 Endianess
+ifeq ($(bigendian),yes)
+	CXXFLAGS += -DBIGENDIAN
+endif
+
+### 3.8 prefetch
+ifeq ($(prefetch),yes)
+	CXXFLAGS += -msse
+	DEPENDFLAGS += -msse
+else
+	CXXFLAGS += -DNO_PREFETCH
+endif
+
+### 3.9 bsfq
+ifeq ($(bsfq),yes)
+	CXXFLAGS += -DUSE_BSFQ
+endif
+
+### 3.10 popcnt
+ifeq ($(popcnt),yes)
+	CXXFLAGS += -DUSE_POPCNT
+endif
+
+### ==========================================================================
+### Section 4. Public targets
+### ==========================================================================
+
+default:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) build
+
+help:
+	@echo ""
+	@echo "To compile stockfish, type: "
+	@echo ""
+	@echo "make target ARCH=arch [COMP=comp]"
+	@echo ""
+	@echo "Supported targets:"
+	@echo ""
+	@echo "build                > Build unoptimized version"
+	@echo "profile-build        > Build PGO-optimized version"
+	@echo "popcnt-profile-build > Build PGO-optimized version with optional popcnt-support"
+	@echo "strip                > Strip executable"
+	@echo "install              > Install executable"
+	@echo "clean                > Clean up"
+	@echo "testrun              > Make sample run"
+	@echo ""
+	@echo "Supported archs:"
+	@echo ""
+	@echo "x86-64               > x86 64-bit"
+	@echo "x86-64-modern        > x86 64-bit with runtime support for popcnt-instruction"
+	@echo "x86-32               > x86 32-bit excluding very old hardware without SSE-support"
+	@echo "x86-32-old           > x86 32-bit including also very old hardware"
+	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
+	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
+	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
+	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
+	@echo "general-64           > unspecified 64-bit"
+	@echo "general-32           > unspecified 32-bit"
+	@echo "bigendian-64         > unspecified 64-bit with bigendian byte order"
+	@echo "bigendian-32         > unspecified 32-bit with bigendian byte order"
+	@echo ""
+	@echo "Supported comps:"
+	@echo ""
+	@echo "gcc                  > Gnu compiler (default)"
+	@echo "icc                  > Intel compiler"
+	@echo "mingw                > Gnu compiler with MinGW under Windows"
+	@echo ""
+	@echo "Non-standard targets:"
+	@echo ""
+	@echo "make hpux           >  Compile for HP-UX. Compiler = aCC"
+	@echo ""
+	@echo "Examples. If you don't know what to do, you likely want to run: "
+	@echo ""
+	@echo "make profile-build ARCH=x86-64    (This is for 64-bit systems)"
+	@echo "make profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo ""
+
+build:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
+
+profile-build:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+	@echo ""
+	@echo "Step 0/4. Preparing for profile build."
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
+	@echo ""
+	@echo "Step 1/4. Building executable for benchmark ..."
+	@touch *.cpp *.h
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
+	@echo ""
+	@echo "Step 2/4. Running benchmark for pgo-build ..."
+	@$(PGOBENCH) > /dev/null
+	@echo ""
+	@echo "Step 3/4. Building final executable ..."
+	@touch *.cpp
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
+	@echo ""
+	@echo "Step 4/4. Deleting profile data ..."
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
+
+popcnt-profile-build:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
+	@echo ""
+	@echo "Step 0/6. Preparing for profile build."
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
+	@echo ""
+	@echo "Step 1/6. Building executable for benchmark (popcnt disabled)..."
+	@touch *.cpp *.h
+	$(MAKE) ARCH=x86-64 COMP=$(COMP) $(profile_make)
+	@echo ""
+	@echo "Step 2/6. Running benchmark for pgo-build (popcnt disabled)..."
+	@$(PGOBENCH) > /dev/null
+	@echo ""
+	@echo "Step 3/6. Building executable for benchmark (popcnt enabled)..."
+	@touch *.cpp *.h
+	$(MAKE) ARCH=x86-64-modern COMP=$(COMP) $(profile_make)
+	@echo ""
+	@echo "Step 4/6. Running benchmark for pgo-build (popcnt enabled)..."
+	@$(PGOBENCH) > /dev/null
+	@echo ""
+	@echo "Step 5/6. Building final executable ..."
+	@touch *.cpp *.h
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use)
+	@echo ""
+	@echo "Step 6/6. Deleting profile data ..."
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_clean)
+	@echo ""
+
+strip:
+	strip $(EXE)
+
+install:
+	-mkdir -p -m 755 $(BINDIR)
+	-cp $(EXE) $(BINDIR)
+	-strip $(BINDIR)/$(EXE)
+
+clean:
+	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
+
+testrun:
+	@$(PGOBENCH)
+
+### ==========================================================================
+### Section 5. Private targets
+### ==========================================================================
 
 all: $(EXE) .depend
 
-clean: 
-	$(RM) *.o .depend glaurung
-
-
-###
-### Compiler:
-###
-
-CXX = g++
-# CXX = g++-4.2
-# CXX = icpc
-
-
-###
-### Dependencies
-###
+config-sanity:
+	@echo ""
+	@echo "Config:"
+	@echo "debug: '$(debug)'"
+	@echo "optimize: '$(optimize)'"
+	@echo "arch: '$(arch)'"
+	@echo "os: '$(os)'"
+	@echo "bits: '$(bits)'"
+	@echo "bigendian: '$(bigendian)'"
+	@echo "prefetch: '$(prefetch)'"
+	@echo "bsfq: '$(bsfq)'"
+	@echo "popcnt: '$(popcnt)'"
+	@echo ""
+	@echo "Flags:"
+	@echo "CXX: $(CXX)"
+	@echo "CXXFLAGS: $(CXXFLAGS)"
+	@echo "LDFLAGS: $(LDFLAGS)"
+	@echo ""
+	@echo "Testing config sanity. If this fails, try 'make help' ..."
+	@echo ""
+	@test "$(debug)" = "yes" || test "$(debug)" = "no"
+	@test "$(optimize)" = "yes" || test "$(optimize)" = "no"
+	@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
+	 test "$(arch)" = "ppc64" || test "$(arch)" = "ppc"
+	@test "$(os)" = "any" || test "$(os)" = "osx"
+	@test "$(bits)" = "32" || test "$(bits)" = "64"
+	@test "$(bigendian)" = "yes" || test "$(bigendian)" = "no"
+	@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
+	@test "$(bsfq)" = "yes" || test "$(bsfq)" = "no"
+	@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
+	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw"
 
 $(EXE): $(OBJS)
-	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
+	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
+
+gcc-profile-prepare:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) gcc-profile-clean
+
+gcc-profile-make:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-generate' \
+	EXTRALDFLAGS='-lgcov' \
+	all
+
+gcc-profile-use:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-fprofile-use' \
+	all
+
+gcc-profile-clean:
+	@rm -rf *.gcda *.gcno bench.txt
+
+icc-profile-prepare:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) icc-profile-clean
+	@mkdir profdir
+
+icc-profile-make:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
+	all
+
+icc-profile-use:
+	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
+	EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
+	all
+
+icc-profile-clean:
+	@rm -rf profdir bench.txt
 
 .depend:
-	$(CXX) -MM $(OBJS:.o=.cpp) > $@
+	-@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null
 
-include .depend
+-include .depend
 
 
-###
-### Compiler and linker switches
-###
+### ==========================================================================
+### Section 6. Non-standard targets
+### ==========================================================================
 
-# Enable/disable debugging:
+hpux:
+	$(MAKE) \
+	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG -DNO_PREFETCH' \
+	CXXFLAGS="" \
+	LDFLAGS="" \
+	all
 
-CXXFLAGS += -DNDEBUG
-
-
-# Compile with full warnings, and symbol names
-
-CXXFLAGS += -Wall -g
-
-
-# General optimization flags.  Note that -O2 might be faster than -O3 on some
-# systems; this requires testing.
-
-CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing
-
-
-# Compiler optimization flags for the Intel C++ compiler in Mac OS X:
-
-# CXXFLAGS += -mdynamic-no-pic -no-prec-div -ipo -static -xP
-
-
-# Profiler guided optimization with the Intel C++ compiler.  To use it, first
-# create the directory ./profdata if it does not already exist, and delete its
-# contents if it does exist.  Then compile with -prof_gen, and run the 
-# resulting binary for a while (for instance, do ./glaurung bench 128 1, and
-# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and 
-# recompile with -prof_use.
-
-# CXXFLAGS += -prof_gen -prof_dir ./profdata
-# CXXFLAGS += -prof_use -prof_dir ./profdata
-
-
-# Profiler guided optimization with GCC.  I've never been able to make this 
-# work.
-
-# CXXFLAGS += -fprofile-generate
-# LDFLAGS += -fprofile-generate
-# CXXFLAGS += -fprofile-use
-# CXXFLAGS += -fprofile-use
-
-
-# General linker flags
-
-LDFLAGS += -lm -lpthread
-
-
-# Compiler switches for generating binaries for various CPUs in Mac OS X.
-# Note that 'arch ppc' and 'arch ppc64' only works with g++, and not with
-# the intel compiler.
-
-# CXXFLAGS += -arch ppc
-# CXXFLAGS += -arch ppc64
-# CXXFLAGS += -arch i386
-# CXXFLAGS += -arch x86_64
-# LDFLAGS += -arch ppc
-# LDFLAGS += -arch ppc64
-# LDFLAGS += -arch i386
-# LDFLAGS += -arch x86_64
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with 
-# GCC 4.0.  I haven't found a way to make it work with GCC 4.2.
-
-# CXXFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# CXXFLAGS += -mmacosx-version-min=10.4
-# LDFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -Wl,-syslibroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -mmacosx-version-min=10.4
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling with ICC.  Doesn't
-# work yet. :-(
-
-# CXXFLAGS += -DMAC_OS_X_VERSION_MIN_REQUIRED=1040
-# CXXFLAGS += -DMAC_OS_X_VERSION_MAX_ALLOWED=1040
-# CXXFLAGS += -D__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__=1040
-# CXXFLAGS += -F/Developer/SDKs/MacOSX10.4u.sdk/
-# LDFLAGS += -Wl,-syslibroot -Wl,/Developer/SDKs/MacOSX10.4u.sdk

src/benchmark.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,24 +17,20 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <fstream>
+#include <iostream>
+#include <vector>
 
-////
-//// Includes
-////
-
-#include "benchmark.h"
+#include "position.h"
 #include "search.h"
-#include "thread.h"
 #include "ucioption.h"
 
+using namespace std;
 
-////
-//// Variables
-////
-
-const std::string BenchmarkPositions[15] = {
-  "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
-  "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
+static const string Defaults[] = {
+  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
+  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
+  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
   "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14",
   "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14",
@@ -45,47 +42,112 @@ const std::string BenchmarkPositions[15] = {
   "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16",
   "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
   "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
-  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b  - 3 22",
-  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
+  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
+  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26",
+  ""
 };
 
 
-////
-//// Functions
-////
+/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
+/// of positions for a given limit each.  There are five parameters; the
+/// transposition table size, the number of search threads that should
+/// be used, the limit value spent for each position (optional, default
+/// is ply 12), an optional file name where to look for positions in fen
+/// format (default are the BenchmarkPositions defined above) and the type
+/// of the limit value: depth (default), time in secs or number of nodes.
+/// The analysis is written to a file named bench.txt.
 
-/// benchmark() runs a simple benchmark by letting Glaurung analyze 15
-/// positions for 60 seconds each.  There are two parameters; the
-/// transposition table size and the number of search threads that should
-/// be used.  The analysis is written to a file named bench.txt.
+void benchmark(int argc, char* argv[]) {
 
-void benchmark(const std::string &ttSize, const std::string &threads) {
-  Position pos;
-  Move moves[1] = {MOVE_NONE};
-  int i;
+  vector<string> fenList;
+  SearchLimits limits;
+  int64_t totalNodes;
+  int time;
 
-  i = atoi(ttSize.c_str());
-  if(i < 4 || i > 1024) {
-    std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
-    exit(EXIT_FAILURE);
+  // Load default positions
+  for (int i = 0; !Defaults[i].empty(); i++)
+      fenList.push_back(Defaults[i]);
+
+  // Assign default values to missing arguments
+  string ttSize  = argc > 2 ? argv[2] : "128";
+  string threads = argc > 3 ? argv[3] : "1";
+  string valStr  = argc > 4 ? argv[4] : "12";
+  string fenFile = argc > 5 ? argv[5] : "default";
+  string valType = argc > 6 ? argv[6] : "depth";
+
+  Options["Hash"].set_value(ttSize);
+  Options["Threads"].set_value(threads);
+  Options["OwnBook"].set_value("false");
+
+  // Search should be limited by nodes, time or depth ?
+  if (valType == "nodes")
+      limits.maxNodes = atoi(valStr.c_str());
+  else if (valType == "time")
+      limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
+  else
+      limits.maxDepth = atoi(valStr.c_str());
+
+  // Do we need to load positions from a given FEN file ?
+  if (fenFile != "default")
+  {
+      string fen;
+      ifstream f(fenFile.c_str());
+
+      if (f.is_open())
+      {
+          fenList.clear();
+
+          while (getline(f, fen))
+              if (!fen.empty())
+                  fenList.push_back(fen);
+
+          f.close();
+      }
+      else
+      {
+          cerr << "Unable to open FEN file " << fenFile << endl;
+          exit(EXIT_FAILURE);
+      }
   }
 
-  i = atoi(threads.c_str());
-  if(i < 1 || i > THREAD_MAX) {
-    std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
-              << std::endl;
-    exit(EXIT_FAILURE);
+  // Ok, let's start the benchmark !
+  totalNodes = 0;
+  time = get_system_time();
+
+  for (size_t i = 0; i < fenList.size(); i++)
+  {
+      Move moves[] = { MOVE_NONE };
+      Position pos(fenList[i], false, 0);
+
+      cerr << "\nBench position: " << i + 1 << '/' << fenList.size() << endl;
+
+      if (valType == "perft")
+      {
+          int64_t cnt = perft(pos, limits.maxDepth * ONE_PLY);
+          totalNodes += cnt;
+
+          cerr << "\nPerft " << limits.maxDepth << " nodes counted: " << cnt << endl;
+      }
+      else
+      {
+          if (!think(pos, limits, moves))
+              break;
+
+          totalNodes += pos.nodes_searched();
+      }
   }
 
-  set_option_value("Hash", ttSize);
-  set_option_value("Threads", threads);
-  set_option_value("OwnBook", "false");
-  set_option_value("Use Search Log", "true");
-  set_option_value("Search Log Filename", "bench.txt");
+  time = get_system_time() - time;
 
-  for(i = 0; i < 15; i++) {
-    pos.from_fen(BenchmarkPositions[i]);
-    think(pos, true, false, 0, 0, 0, 0, 0, 60000, moves);
-  }
+  cerr << "\n==============================="
+       << "\nTotal time (ms) : " << time
+       << "\nNodes searched  : " << totalNodes
+       << "\nNodes/second    : " << (int)(totalNodes / (time / 1000.0)) << endl << endl;
 
+  // MS Visual C++ debug window always unconditionally closes when program
+  // exits, this is bad because we want to read results before.
+  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
+  cerr << "Press any key to exit" << endl;
+  cin >> time;
+  #endif
 }

src/benchmark.h

@@ -1,37 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(BENCHMARK_H_INCLUDED)
-#define BENCHMARK_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <string>
-
-
-////
-//// Prototypes
-////
-
-extern void benchmark(const std::string &ttSize, const std::string &threads);
-
-
-#endif // !defined(BENCHMARK_H_INCLUDED)

src/bitbase.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,22 +17,10 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
 
-#include "bitbase.h"
 #include "bitboard.h"
-#include "move.h"
-#include "square.h"
-
-
-////
-//// Local definitions
-////
+#include "types.h"
 
 namespace {
 
@@ -45,304 +34,251 @@ namespace {
 
   struct KPKPosition {
     void from_index(int index);
-    int to_index() const;
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;
-    Bitboard wk_attacks() const;
-    Bitboard bk_attacks() const;
-    Bitboard pawn_attacks() const;
+    Bitboard wk_attacks()   const { return StepAttacksBB[WK][whiteKingSquare]; }
+    Bitboard bk_attacks()   const { return StepAttacksBB[BK][blackKingSquare]; }
+    Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
   };
 
+  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
+  const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq
 
-  Result *Bitbase;
-  const int IndexMax = 2*24*64*64;
-  int UnknownCount = 0;
-
-  void initialize();
-  bool next_iteration();
-  Result classify_wtm(const KPKPosition &p);
-  Result classify_btm(const KPKPosition &p);
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm);
-  int compress_result(Result r);
+  // Each uint32_t stores results of 32 positions, one per bit
+  uint32_t KPKBitbase[IndexMax / 32];
 
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]);
+  Result classify_btm(const KPKPosition& pos, const Result bb[]);
+  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
 }
 
 
-////
-//// Functions
-////
+uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
 
-void generate_kpk_bitbase(uint8_t bitbase[]) {
-  // Allocate array and initialize:
-  Bitbase = new Result[IndexMax];
-  initialize();
+  int index = compute_index(wksq, bksq, wpsq, stm);
 
-  // Iterate until all positions are classified:
-  while(next_iteration());
+  return KPKBitbase[index / 32] & (1 << (index & 31));
+}
 
-  // Compress bitbase into the supplied parameter:
-  int i, j, b;
-  for(i = 0; i < 24576; i++) {
-    for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
-    bitbase[i] = b;
+
+void init_kpk_bitbase() {
+
+  Result bb[IndexMax];
+  KPKPosition pos;
+  bool repeat;
+
+  // Initialize table
+  for (int i = 0; i < IndexMax; i++)
+  {
+      pos.from_index(i);
+      bb[i] = !pos.is_legal()          ? RESULT_INVALID
+             : pos.is_immediate_draw() ? RESULT_DRAW
+             : pos.is_immediate_win()  ? RESULT_WIN : RESULT_UNKNOWN;
   }
 
-  // Release allocated memory:
-  delete [] Bitbase;
+  // Iterate until all positions are classified (30 cycles needed)
+  do {
+      repeat = false;
+
+      for (int i = 0; i < IndexMax; i++)
+          if (bb[i] == RESULT_UNKNOWN)
+          {
+              pos.from_index(i);
+
+              bb[i] = (pos.sideToMove == WHITE) ? classify_wtm(pos, bb)
+                                                : classify_btm(pos, bb);
+              if (bb[i] != RESULT_UNKNOWN)
+                  repeat = true;
+          }
+
+  } while (repeat);
+
+  // Map 32 position results into one KPKBitbase[] entry
+  for (int i = 0; i < IndexMax / 32; i++)
+      for (int j = 0; j < 32; j++)
+          if (bb[32 * i + j] == RESULT_WIN || bb[32 * i + j] == RESULT_LOSS)
+              KPKBitbase[i] |= (1 << j);
 }
 
 
 namespace {
 
+ // A KPK bitbase index is an integer in [0, IndexMax] range
+ //
+ // Information is mapped in this way
+ //
+ // bit     0: side to move (WHITE or BLACK)
+ // bit  1- 6: black king square (from SQ_A1 to SQ_H8)
+ // bit  7-12: white king square (from SQ_A1 to SQ_H8)
+ // bit 13-14: white pawn file (from FILE_A to FILE_D)
+ // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
+
+  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) {
+
+    assert(square_file(wpsq) <= FILE_D);
+
+    int p = int(square_file(wpsq)) + 4 * int(square_rank(wpsq) - 1);
+    int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p;
+
+    assert(r >= 0 && r < IndexMax);
+
+    return r;
+  }
+
   void KPKPosition::from_index(int index) {
-    int s;
+
+    int s = (index / 8192) % 24;
+
     sideToMove = Color(index % 2);
     blackKingSquare = Square((index / 2) % 64);
     whiteKingSquare = Square((index / 128) % 64);
-    s = (index / 8192) % 24;
     pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
   }
 
-
-  int KPKPosition::to_index() const {
-    return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
-                         sideToMove);
-  }
-    
-
   bool KPKPosition::is_legal() const {
-    if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
-       pawnSquare == blackKingSquare)
-      return false;
-    if(sideToMove == WHITE) {
-      if(bit_is_set(this->wk_attacks(), blackKingSquare))
-        return false;
-      if(bit_is_set(this->pawn_attacks(), blackKingSquare))
+
+    if (   whiteKingSquare == pawnSquare
+        || whiteKingSquare == blackKingSquare
+        || blackKingSquare == pawnSquare)
         return false;
+
+    if (sideToMove == WHITE)
+    {
+        if (   bit_is_set(wk_attacks(), blackKingSquare)
+            || bit_is_set(pawn_attacks(), blackKingSquare))
+            return false;
     }
-    else {
-      if(bit_is_set(this->bk_attacks(), whiteKingSquare))
+    else if (bit_is_set(bk_attacks(), whiteKingSquare))
         return false;
-    }
+
     return true;
   }
 
-
   bool KPKPosition::is_immediate_draw() const {
-    if(sideToMove == BLACK) {
-      Bitboard wka = this->wk_attacks();
-      Bitboard bka = this->bk_attacks();
 
-      // Case 1: Stalemate
-      if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
-        return true;
+    if (sideToMove == BLACK)
+    {
+        Bitboard wka = wk_attacks();
+        Bitboard bka = bk_attacks();
 
-      // Case 2: King can capture pawn
-      if(bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
-        return true;
+        // Case 1: Stalemate
+        if ((bka & ~(wka | pawn_attacks())) == EmptyBoardBB)
+            return true;
+
+        // Case 2: King can capture pawn
+        if (bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
+            return true;
     }
-    else {
-      // Case 1: Stalemate
-      if(whiteKingSquare == SQ_A8 && pawnSquare == SQ_A7 &&
-         (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
-        return true;
+    else
+    {
+        // Case 1: Stalemate (possible pawn files are only from A to D)
+        if (   whiteKingSquare == SQ_A8
+            && pawnSquare == SQ_A7
+            && (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
+            return true;
     }
-
     return false;
   }
 
-
   bool KPKPosition::is_immediate_win() const {
-    // The position is an immediate win if it is white to move and the white
-    // pawn can be promoted without getting captured:
-    return
-      sideToMove == WHITE &&
-      square_rank(pawnSquare) == RANK_7 &&
-      (square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
-       bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
+
+    // The position is an immediate win if it is white to move and the
+    // white pawn can be promoted without getting captured.
+    return   sideToMove == WHITE
+          && square_rank(pawnSquare) == RANK_7
+          && whiteKingSquare != pawnSquare + DELTA_N
+          && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
+              || bit_is_set(wk_attacks(), pawnSquare + DELTA_N));
   }
 
-
-  Bitboard KPKPosition::wk_attacks() const {
-    return StepAttackBB[WK][whiteKingSquare];
-  }
-
-
-  Bitboard KPKPosition::bk_attacks() const {
-    return StepAttackBB[BK][blackKingSquare];
-  }
-
-
-  Bitboard KPKPosition::pawn_attacks() const {
-    return StepAttackBB[WP][pawnSquare];
-  }
-
-
-  void initialize() {
-    KPKPosition p;
-    for(int i = 0; i < IndexMax; i++) {
-      p.from_index(i);
-      if(!p.is_legal())
-        Bitbase[i] = RESULT_INVALID;
-      else if(p.is_immediate_draw())
-        Bitbase[i] = RESULT_DRAW;
-      else if(p.is_immediate_win())
-        Bitbase[i] = RESULT_WIN;
-      else {
-        Bitbase[i] = RESULT_UNKNOWN;
-        UnknownCount++;
-      }
-    }
-  }
-
-
-  bool next_iteration() {
-    KPKPosition p;
-    int previousUnknownCount = UnknownCount;
-    
-    for(int i = 0; i < IndexMax; i++)
-      if(Bitbase[i] == RESULT_UNKNOWN) {
-        p.from_index(i);
-
-        Bitbase[i] = (p.sideToMove == WHITE)? classify_wtm(p) : classify_btm(p);
-
-        if(Bitbase[i] == RESULT_WIN || Bitbase[i] == RESULT_LOSS ||
-           Bitbase[i] == RESULT_DRAW)
-          UnknownCount--;
-      }
-
-    return UnknownCount != previousUnknownCount;
-  }
-
-
-  Result classify_wtm(const KPKPosition &p) {
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]) {
 
     // If one move leads to a position classified as RESULT_LOSS, the result
-    // of the current position is RESULT_WIN.  If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified as
-    // RESULT_DRAW.  Otherwise, the current position is classified as
-    // RESULT_UNKNOWN.
+    // of the current position is RESULT_WIN. If all moves lead to positions
+    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
+    // otherwise the current position is classified as RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
+    Result r;
 
     // King moves
-    b = p.wk_attacks();
-    while(b) {
-      s = pop_1st_bit(&b);
-      switch(Bitbase[compute_index(s, p.blackKingSquare, p.pawnSquare,
-                                   BLACK)]) {
-      case RESULT_LOSS:
-        return RESULT_WIN;
+    b = pos.wk_attacks();
+    while (b)
+    {
+        s = pop_1st_bit(&b);
+        r = bb[compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK)];
 
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
+        if (r == RESULT_LOSS)
+            return RESULT_WIN;
 
-      case RESULT_DRAW: case RESULT_INVALID:
-        break;
-
-      default:
-        assert(false);
-      }
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
     }
 
     // Pawn moves
-    if(square_rank(p.pawnSquare) < RANK_7) {
-      s = p.pawnSquare + DELTA_N;
-      switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
-                                   BLACK)]) {
-      case RESULT_LOSS:
-        return RESULT_WIN;
+    if (square_rank(pos.pawnSquare) < RANK_7)
+    {
+        s = pos.pawnSquare + DELTA_N;
+        r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
 
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
+        if (r == RESULT_LOSS)
+            return RESULT_WIN;
 
-      case RESULT_DRAW: case RESULT_INVALID:
-        break;
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
 
-      default:
-        assert(false);
-      }
+        // Double pawn push
+        if (   square_rank(s) == RANK_3
+            && s != pos.whiteKingSquare
+            && s != pos.blackKingSquare)
+        {
+            s += DELTA_N;
+            r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
 
-      if(square_rank(s) == RANK_3 &&
-         s != p.whiteKingSquare && s != p.blackKingSquare) {
-        s += DELTA_N;
-        switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
-                                     BLACK)]) {
-        case RESULT_LOSS:
-          return RESULT_WIN;
+            if (r == RESULT_LOSS)
+                return RESULT_WIN;
 
-        case RESULT_UNKNOWN:
-          unknownFound = true;
-          break;
-          
-        case RESULT_DRAW: case RESULT_INVALID:
-          break;
-          
-        default:
-          assert(false);
+            if (r == RESULT_UNKNOWN)
+                unknownFound = true;
         }
-      }
     }
-    
-    return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
+    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
   }
 
 
-  Result classify_btm(const KPKPosition &p) {
+  Result classify_btm(const KPKPosition& pos, const Result bb[]) {
 
     // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW.  If all moves lead to positions
+    // of the current position is RESULT_DRAW. If all moves lead to positions
     // classified as RESULT_WIN, the current position is classified as
-    // RESULT_LOSS.  Otherwise, the current position is classified as
+    // RESULT_LOSS. Otherwise, the current position is classified as
     // RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
+    Result r;
 
     // King moves
-    b = p.bk_attacks();
-    while(b) {
-      s = pop_1st_bit(&b);
-      switch(Bitbase[compute_index(p.whiteKingSquare, s, p.pawnSquare,
-                                   WHITE)]) {
-      case RESULT_DRAW:
-        return RESULT_DRAW;
+    b = pos.bk_attacks();
+    while (b)
+    {
+        s = pop_1st_bit(&b);
+        r = bb[compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE)];
 
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
+        if (r == RESULT_DRAW)
+            return RESULT_DRAW;
 
-      case RESULT_WIN: case RESULT_INVALID:
-        break;
-
-      default:
-        assert(false);
-      }
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
     }
-
-    return unknownFound? RESULT_UNKNOWN : RESULT_LOSS;
-  }
-
-
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
-    int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
-    int result = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*p;
-    assert(result >= 0 && result < IndexMax);
-    return result;
-  }
-
-
-  int compress_result(Result r) {
-    return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
+    return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS;
   }
 
 }

src/bitbase.h

@@ -1,37 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(BITBASE_H_INCLUDED)
-#define BITBASE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "types.h"
-
-
-////
-//// Prototypes
-////
-
-extern void generate_kpk_bitbase(uint8_t bitbase[]);
-
-
-#endif // !defined(BITBASE_H_INCLUDED)

src/bitboard.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,214 +17,61 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <iostream>
 
 #include "bitboard.h"
-#include "direction.h"
+#include "bitcount.h"
 
-
-////
-//// Constants and variables
-////
-
-const Bitboard SquaresByColorBB[2] = {BlackSquaresBB, WhiteSquaresBB};
-
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB, 
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};  
-
-const Bitboard RankBB[8] = {
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
-  {
-    Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-  },
-  {
-    Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB
-  }
-};
-
-const Bitboard InFrontBB[2][8] = {
-  {
-    Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  {
-    EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
-
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-
-Bitboard RankAttacks[8][64], FileAttacks[8][64];
-
-#elif defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
-  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
-  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
-  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
-  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
-  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
-  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
-  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
-  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
-  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
-  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
-  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
-  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
-  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
-  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
-  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
-  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
-  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
-  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
-  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
-  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
-  0x5ac08a4735370479ULL,
-};
-
-const int RShift[64] = {
-  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL, 
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL, 
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL, 
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL, 
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL, 
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL, 
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL, 
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL, 
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL, 
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL, 
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL, 
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL, 
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL, 
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL, 
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL, 
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL, 
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL, 
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL, 
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL, 
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL, 
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL, 
-  0x410201ce5c030092ULL
-};
-
-const int RShift[64] = {
-  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
-};
-
-#endif // defined(USE_32BIT_ATTACKS)
-
-#if !defined(USE_COMPACT_ROOK_ATTACKS)
-Bitboard RMask[64];
-int RAttackIndex[64];
-Bitboard RAttacks[0x19000];
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
+#if defined(IS_64BIT)
 
 const uint64_t BMult[64] = {
-  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
-  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
-  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
-  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
-  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
-  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
-  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
-  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
-  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
-  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
-  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
-  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
-  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
-  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
-  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
-  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
-  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
-  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
-  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
-  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
-  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
-  0xdc01f6dca4bebbdcULL,
-}; 
-
-const int BShift[64] = {
-  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
-  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
-  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
-
-const uint64_t BMult[64] = {
-  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL, 
-  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL, 
-  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL, 
-  0x2000142828050024ULL, 0x1004024d5000ULL, 0x102044400800200ULL, 
-  0x8108108820112000ULL, 0xa880818210c00046ULL, 0x4008008801082000ULL, 
-  0x60882404049400ULL, 0x104402004240810ULL, 0xa002084250200ULL, 
-  0x100b0880801100ULL, 0x4080201220101ULL, 0x44008080a00000ULL, 
-  0x202200842000ULL, 0x5006004882d00808ULL, 0x200045080802ULL, 
-  0x86100020200601ULL, 0xa802080a20112c02ULL, 0x80411218080900ULL, 
-  0x200a0880080a0ULL, 0x9a01010000104000ULL, 0x28008003100080ULL, 
-  0x211021004480417ULL, 0x401004188220806ULL, 0x825051400c2006ULL, 
-  0x140c0210943000ULL, 0x242800300080ULL, 0xc2208120080200ULL, 
+  0x0440049104032280ULL, 0x1021023C82008040ULL, 0x0404040082000048ULL,
+  0x48C4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
+  0x0181011002E06040ULL, 0x9101004104200E00ULL, 0x1240848848310401ULL,
+  0x2000142828050024ULL, 0x00001004024D5000ULL, 0x0102044400800200ULL,
+  0x8108108820112000ULL, 0xA880818210C00046ULL, 0x4008008801082000ULL,
+  0x0060882404049400ULL, 0x0104402004240810ULL, 0x000A002084250200ULL,
+  0x00100B0880801100ULL, 0x0004080201220101ULL, 0x0044008080A00000ULL,
+  0x0000202200842000ULL, 0x5006004882D00808ULL, 0x0000200045080802ULL,
+  0x0086100020200601ULL, 0xA802080A20112C02ULL, 0x0080411218080900ULL,
+  0x000200A0880080A0ULL, 0x9A01010000104000ULL, 0x0028008003100080ULL,
+  0x0211021004480417ULL, 0x0401004188220806ULL, 0x00825051400C2006ULL,
+  0x00140C0210943000ULL, 0x0000242800300080ULL, 0x00C2208120080200ULL,
   0x2430008200002200ULL, 0x1010100112008040ULL, 0x8141050100020842ULL,
-  0x822081014405ULL, 0x800c049e40400804ULL, 0x4a0404028a000820ULL, 
-  0x22060201041200ULL, 0x360904200840801ULL, 0x881a08208800400ULL, 
-  0x60202c00400420ULL, 0x1204440086061400ULL, 0x8184042804040ULL, 
-  0x64040315300400ULL, 0xc01008801090a00ULL, 0x808010401140c00ULL, 
-  0x4004830c2020040ULL, 0x80005002020054ULL, 0x40000c14481a0490ULL, 
-  0x10500101042048ULL, 0x1010100200424000ULL, 0x640901901040ULL, 
-  0xa0201014840ULL, 0x840082aa011002ULL, 0x10010840084240aULL, 
-  0x420400810420608ULL, 0x8d40230408102100ULL, 0x4a00200612222409ULL, 
-  0xa08520292120600ULL
+  0x0000822081014405ULL, 0x800C049E40400804ULL, 0x4A0404028A000820ULL,
+  0x0022060201041200ULL, 0x0360904200840801ULL, 0x0881A08208800400ULL,
+  0x0060202C00400420ULL, 0x1204440086061400ULL, 0x0008184042804040ULL,
+  0x0064040315300400ULL, 0x0C01008801090A00ULL, 0x0808010401140C00ULL,
+  0x04004830C2020040ULL, 0x0080005002020054ULL, 0x40000C14481A0490ULL,
+  0x0010500101042048ULL, 0x1010100200424000ULL, 0x0000640901901040ULL,
+  0x00000A0201014840ULL, 0x00840082AA011002ULL, 0x010010840084240AULL,
+  0x0420400810420608ULL, 0x8D40230408102100ULL, 0x4A00200612222409ULL,
+  0x0A08520292120600ULL
+};
+
+const uint64_t RMult[64] = {
+  0x0A8002C000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+  0x0380180080141000ULL, 0x1A00060008211044ULL, 0x410001000A0C0008ULL,
+  0x9500060004008100ULL, 0x0100024284A20700ULL, 0x0000802140008000ULL,
+  0x0080C01002A00840ULL, 0x0402004282011020ULL, 0x9862000820420050ULL,
+  0x0001001448011100ULL, 0x6432800200800400ULL, 0x040100010002000CULL,
+  0x0002800D0010C080ULL, 0x90C0008000803042ULL, 0x4010004000200041ULL,
+  0x0003010010200040ULL, 0x0A40828028001000ULL, 0x0123010008000430ULL,
+  0x0024008004020080ULL, 0x0060040001104802ULL, 0x00582200028400D1ULL,
+  0x4000802080044000ULL, 0x0408208200420308ULL, 0x0610038080102000ULL,
+  0x3601000900100020ULL, 0x0000080080040180ULL, 0x00C2020080040080ULL,
+  0x0080084400100102ULL, 0x4022408200014401ULL, 0x0040052040800082ULL,
+  0x0B08200280804000ULL, 0x008A80A008801000ULL, 0x4000480080801000ULL,
+  0x0911808800801401ULL, 0x822A003002001894ULL, 0x401068091400108AULL,
+  0x000004A10A00004CULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
+  0x000100A000D50041ULL, 0x00810050020B0020ULL, 0x0204000800808004ULL,
+  0x00020048100A000CULL, 0x0112000831020004ULL, 0x0009000040810002ULL,
+  0x0440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
+  0x4B824A2010010100ULL, 0x04080801810C0080ULL, 0x00000400802A0080ULL,
+  0x8224080110026400ULL, 0x40002C4104088200ULL, 0x01002100104A0282ULL,
+  0x1208400811048021ULL, 0x3201014A40D02001ULL, 0x0005100019200501ULL,
+  0x0101000208001005ULL, 0x0002008450080702ULL, 0x001002080301D00CULL,
+  0x410201CE5C030092ULL
 };
 
 const int BShift[64] = {
@@ -233,147 +81,238 @@ const int BShift[64] = {
   59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
 };
 
-#endif // defined(USE_32BIT_ATTACKS)
+const int RShift[64] = {
+  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
+};
+
+#else // if !defined(IS_64BIT)
+
+const uint64_t BMult[64] = {
+  0x54142844C6A22981ULL, 0x710358A6EA25C19EULL, 0x704F746D63A4A8DCULL,
+  0xBFED1A0B80F838C5ULL, 0x90561D5631E62110ULL, 0x2804260376E60944ULL,
+  0x84A656409AA76871ULL, 0xF0267F64C28B6197ULL, 0x70764EBB762F0585ULL,
+  0x92AA09E0CFE161DEULL, 0x41EE1F6BB266F60EULL, 0xDDCBF04F6039C444ULL,
+  0x5A3FAB7BAC0D988AULL, 0xD3727877FA4EAA03ULL, 0xD988402D868DDAAEULL,
+  0x812B291AFA075C7CULL, 0x94FAF987B685A932ULL, 0x3ED867D8470D08DBULL,
+  0x92517660B8901DE8ULL, 0x2D97E43E058814B4ULL, 0x880A10C220B25582ULL,
+  0xC7C6520D1F1A0477ULL, 0xDBFC7FBCD7656AA6ULL, 0x78B1B9BFB1A2B84FULL,
+  0x2F20037F112A0BC1ULL, 0x657171EA2269A916ULL, 0xC08302B07142210EULL,
+  0x0880A4403064080BULL, 0x3602420842208C00ULL, 0x852800DC7E0B6602ULL,
+  0x595A3FBBAA0F03B2ULL, 0x9F01411558159D5EULL, 0x2B4A4A5F88B394F2ULL,
+  0x4AFCBFFC292DD03AULL, 0x4A4094A3B3F10522ULL, 0xB06F00B491F30048ULL,
+  0xD5B3820280D77004ULL, 0x8B2E01E7C8E57A75ULL, 0x2D342794E886C2E6ULL,
+  0xC302C410CDE21461ULL, 0x111F426F1379C274ULL, 0xE0569220ABB31588ULL,
+  0x5026D3064D453324ULL, 0xE2076040C343CD8AULL, 0x93EFD1E1738021EEULL,
+  0xB680804BED143132ULL, 0x44E361B21986944CULL, 0x44C60170EF5C598CULL,
+  0xF4DA475C195C9C94ULL, 0xA3AFBB5F72060B1DULL, 0xBC75F410E41C4FFCULL,
+  0xB51C099390520922ULL, 0x902C011F8F8EC368ULL, 0x950B56B3D6F5490AULL,
+  0x3909E0635BF202D0ULL, 0x5744F90206EC10CCULL, 0xDC59FD76317ABBC1ULL,
+  0x881C7C67FCBFC4F6ULL, 0x47CA41E7E440D423ULL, 0xEB0C88112048D004ULL,
+  0x51C60E04359AEF1AULL, 0x1AA1FE0E957A5554ULL, 0xDD9448DB4F5E3104ULL,
+  0xDC01F6DCA4BEBBDCULL,
+};
+
+const uint64_t RMult[64] = {
+  0xD7445CDEC88002C0ULL, 0xD0A505C1F2001722ULL, 0xE065D1C896002182ULL,
+  0x9A8C41E75A000892ULL, 0x8900B10C89002AA8ULL, 0x9B28D1C1D60005A2ULL,
+  0x015D6C88DE002D9AULL, 0xB1DBFC802E8016A9ULL, 0x149A1042D9D60029ULL,
+  0xB9C08050599E002FULL, 0x132208C3AF300403ULL, 0xC1000CE2E9C50070ULL,
+  0x9D9AA13C99020012ULL, 0xB6B078DAF71E0046ULL, 0x9D880182FB6E002EULL,
+  0x52889F467E850037ULL, 0xDA6DC008D19A8480ULL, 0x468286034F902420ULL,
+  0x7140AC09DC54C020ULL, 0xD76FFFFA39548808ULL, 0xEA901C4141500808ULL,
+  0xC91004093F953A02ULL, 0x02882AFA8F6BB402ULL, 0xAEBE335692442C01ULL,
+  0x0E904A22079FB91EULL, 0x13A514851055F606ULL, 0x76C782018C8FE632ULL,
+  0x1DC012A9D116DA06ULL, 0x3C9E0037264FFFA6ULL, 0x2036002853C6E4A2ULL,
+  0xE3FE08500AFB47D4ULL, 0xF38AF25C86B025C2ULL, 0xC0800E2182CF9A40ULL,
+  0x72002480D1F60673ULL, 0x2500200BAE6E9B53ULL, 0xC60018C1EEFCA252ULL,
+  0x0600590473E3608AULL, 0x46002C4AB3FE51B2ULL, 0xA200011486BCC8D2ULL,
+  0xB680078095784C63ULL, 0x2742002639BF11AEULL, 0xC7D60021A5BDB142ULL,
+  0xC8C04016BB83D820ULL, 0xBD520028123B4842ULL, 0x9D1600344AC2A832ULL,
+  0x6A808005631C8A05ULL, 0x604600A148D5389AULL, 0xE2E40103D40DEA65ULL,
+  0x945B5A0087C62A81ULL, 0x012DC200CD82D28EULL, 0x2431C600B5F9EF76ULL,
+  0xFB142A006A9B314AULL, 0x06870E00A1C97D62ULL, 0x2A9DB2004A2689A2ULL,
+  0xD3594600CAF5D1A2ULL, 0xEE0E4900439344A7ULL, 0x89C4D266CA25007AULL,
+  0x3E0013A2743F97E3ULL, 0x0180E31A0431378AULL, 0x3A9E465A4D42A512ULL,
+  0x98D0A11A0C0D9CC2ULL, 0x8E711C1ABA19B01EULL, 0x8DCDC836DD201142ULL,
+  0x5AC08A4735370479ULL,
+};
+
+const int BShift[64] = {
+  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
+  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
+  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
+};
+
+const int RShift[64] = {
+  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
+};
+
+#endif // defined(IS_64BIT)
+
+// Global bitboards definitions with static storage duration are
+// automatically set to zero before enter main().
+Bitboard RMask[64];
+int RAttackIndex[64];
+Bitboard RAttacks[0x19000];
 
 Bitboard BMask[64];
 int BAttackIndex[64];
 Bitboard BAttacks[0x1480];
 
-Bitboard SetMaskBB[64];
-Bitboard ClearMaskBB[64];
+Bitboard SetMaskBB[65];
+Bitboard ClearMaskBB[65];
 
-Bitboard StepAttackBB[16][64];
-Bitboard RayBB[64][8];
+Bitboard SquaresByColorBB[2];
+Bitboard FileBB[8];
+Bitboard RankBB[8];
+Bitboard NeighboringFilesBB[8];
+Bitboard ThisAndNeighboringFilesBB[8];
+Bitboard InFrontBB[2][8];
+Bitboard StepAttacksBB[16][64];
 Bitboard BetweenBB[64][64];
-
+Bitboard SquaresInFrontMask[2][64];
 Bitboard PassedPawnMask[2][64];
-Bitboard OutpostMask[2][64];
+Bitboard AttackSpanMask[2][64];
 
 Bitboard BishopPseudoAttacks[64];
 Bitboard RookPseudoAttacks[64];
 Bitboard QueenPseudoAttacks[64];
 
+uint8_t BitCount8Bit[256];
 
-////
-//// Local definitions
-////
 
 namespace {
+
   void init_masks();
-  void init_ray_bitboards();
-  void init_attacks();
-  void init_between_bitboards();
-  Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
-                           int fmin, int fmax, int rmin, int rmax);
-  Bitboard index_to_bitboard(int index, Bitboard mask);
-  void init_sliding_attacks(Bitboard attacks[],
-                            int attackIndex[], Bitboard mask[],
-                            const int shift[2], const Bitboard mult[],
-                            int deltas[][2]);
+  void init_step_attacks();
   void init_pseudo_attacks();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  void init_file_and_rank_attacks();
-#endif
-};
+  void init_between_bitboards();
+  Bitboard index_to_bitboard(int index, Bitboard mask);
+  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
+                           int fmin, int fmax, int rmin, int rmax);
+  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
+                            const int shift[], const Bitboard mult[], int deltas[][2]);
+}
 
 
-////
-//// Functions
-////
-
 /// print_bitboard() prints a bitboard in an easily readable format to the
-/// standard output.  This is sometimes useful for debugging.
+/// standard output. This is sometimes useful for debugging.
 
 void print_bitboard(Bitboard b) {
-  for(Rank r = RANK_8; r >= RANK_1; r--) {
-    std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
-    for(File f = FILE_A; f <= FILE_H; f++)
-      std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
-    std::cout << "|" << std::endl;
+
+  for (Rank r = RANK_8; r >= RANK_1; r--)
+  {
+      std::cout << "+---+---+---+---+---+---+---+---+" << '\n';
+      for (File f = FILE_A; f <= FILE_H; f++)
+          std::cout << "| " << (bit_is_set(b, make_square(f, r)) ? 'X' : ' ') << ' ';
+
+      std::cout << "|\n";
   }
   std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 }
 
 
-/// init_bitboards() initializes various bitboard arrays.  It is called during
-/// program initialization.
-
-void init_bitboards() {
-  int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
-  int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
-  init_masks();
-  init_ray_bitboards();
-  init_attacks();
-  init_between_bitboards();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  init_file_and_rank_attacks();
-#else
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift,
-                       RMult, rookDeltas);
-#endif
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift,
-                       BMult, bishopDeltas);
-  init_pseudo_attacks();
-}
-
-
-#if defined(USE_FOLDED_BITSCAN)
-
-static const int BitTable[64] = {
-  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2, 
-  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52, 
-  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28, 
-  58, 20, 37, 17, 36, 8
-};
-
-
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = int(b) ^ int(b >> 32);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
 
-Square pop_1st_bit(Bitboard *b) {
-  Bitboard bb = *b ^ (*b - 1);
-  uint32_t fold = int(bb) ^ int(bb >> 32);
-  *b &= (*b - 1);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
+#if defined(IS_64BIT) && !defined(USE_BSFQ)
 
-#else
-
-static const int BitTable[64] = {
-  0, 1, 2, 7, 3, 13, 8, 19, 4, 25, 14, 28, 9, 34, 20, 40, 5, 17, 26, 38, 15,
-  46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63, 6, 12, 18, 24, 27, 33, 39,
-  16, 37, 45, 47, 30, 53, 49, 56, 62, 11, 23, 32, 36, 44, 52, 55, 61, 22, 43,
-  51, 60, 42, 59, 58
+static CACHE_LINE_ALIGNMENT
+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, 51, 60, 42, 59, 58
 };
 
-
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
 Square first_1(Bitboard b) {
   return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
-Square pop_1st_bit(Bitboard *b) {
+Square pop_1st_bit(Bitboard* b) {
   Bitboard bb = *b;
   *b &= (*b - 1);
   return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-#endif // defined(USE_FOLDED_BITSCAN)
+#elif !defined(USE_BSFQ)
 
+static CACHE_LINE_ALIGNMENT
+const int BitTable[64] = {
+  63, 30,  3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29,  2,
+  51, 21, 43, 45, 10, 18, 47,  1, 54,  9, 57,  0, 35, 62, 31, 40,  4, 49,  5,
+  52, 26, 60,  6, 23, 44, 46, 27, 56, 16,  7, 39, 48, 24, 59, 14, 12, 55, 38,
+  28, 58, 20, 37, 17, 36, 8
+};
+
+Square first_1(Bitboard b) {
+
+  b ^= (b - 1);
+  uint32_t fold = int(b) ^ int(b >> 32);
+  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
+}
+
+// Use type-punning
+union b_union {
+
+    Bitboard b;
+    struct {
+#if defined (BIGENDIAN)
+        uint32_t h;
+        uint32_t l;
+#else
+        uint32_t l;
+        uint32_t h;
+#endif
+    } dw;
+};
+
+Square pop_1st_bit(Bitboard* bb) {
+
+   b_union u;
+   Square ret;
+
+   u.b = *bb;
+
+   if (u.dw.l)
+   {
+       ret = Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
+       u.dw.l &= (u.dw.l - 1);
+       *bb = u.b;
+       return ret;
+   }
+   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
+   u.dw.h &= (u.dw.h - 1);
+   *bb = u.b;
+   return ret;
+}
+
+#endif // !defined(USE_BSFQ)
+
+
+/// init_bitboards() initializes various bitboard arrays. It is called during
+/// program initialization.
+
+void init_bitboards() {
+
+  int rookDeltas[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+  int bishopDeltas[4][2] = {{1,1},{-1,1},{1,-1},{-1,-1}};
+
+  init_masks();
+  init_step_attacks();
+  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
+  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
+  init_pseudo_attacks();
+  init_between_bitboards();
+}
 
 namespace {
 
@@ -383,159 +322,165 @@ namespace {
   // be necessary to touch any of them.
 
   void init_masks() {
-    for(Square s = SQ_A1; s <= SQ_H8; s++) {
-      SetMaskBB[s] = (1ULL << s);
-      ClearMaskBB[s] = ~SetMaskBB[s];
+
+    SquaresByColorBB[DARK]  =  0xAA55AA55AA55AA55ULL;
+    SquaresByColorBB[LIGHT] = ~SquaresByColorBB[DARK];
+
+    FileBB[FILE_A] = FileABB;
+    RankBB[RANK_1] = Rank1BB;
+
+    for (int f = FILE_B; f <= FILE_H; f++)
+    {
+        FileBB[f] = FileBB[f - 1] << 1;
+        RankBB[f] = RankBB[f - 1] << 8;
     }
-    for(Color c = WHITE; c <= BLACK; c++)
-      for(Square s = SQ_A1; s <= SQ_H8; s++) {
-        PassedPawnMask[c][s] =
-          in_front_bb(c, s) & this_and_neighboring_files_bb(s);
-        OutpostMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
-      }
-  }
 
-
-  void init_ray_bitboards() {
-    int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-    for(int i = 0; i < 128; i = i + 9 & ~8) {
-      for(int j = 0; j < 8; j++) {
-        RayBB[(i&7)|((i>>4)<<3)][j] = EmptyBoardBB;
-        for(int k = i + d[j]; (k & 0x88) == 0; k += d[j])
-          set_bit(&(RayBB[(i&7)|((i>>4)<<3)][j]), Square((k&7)|((k>>4)<<3)));
-      }
+    for (int f = FILE_A; f <= FILE_H; f++)
+    {
+        NeighboringFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+        ThisAndNeighboringFilesBB[f] = FileBB[f] | NeighboringFilesBB[f];
     }
-  }
 
+    for (int rw = RANK_7, rb = RANK_2; rw >= RANK_1; rw--, rb++)
+    {
+        InFrontBB[WHITE][rw] = InFrontBB[WHITE][rw + 1] | RankBB[rw + 1];
+        InFrontBB[BLACK][rb] = InFrontBB[BLACK][rb - 1] | RankBB[rb - 1];
+    }
 
-  void init_attacks() {
-    int i, j, k, l;
-    int step[16][8] =  {
-      {0},
-      {7,9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}, {0}, {0},
-      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}
-    };
+    SetMaskBB[SQ_NONE] = EmptyBoardBB;
+    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
 
-    for(i = 0; i < 64; i++) {
-      for(j = 0; j <= int(BK); j++) {
-        StepAttackBB[j][i] = EmptyBoardBB;
-        for(k = 0; k < 8 && step[j][k] != 0; k++) {
-          l = i + step[j][k];
-          if(l >= 0 && l < 64 && abs((i&7) - (l&7)) < 3)
-            StepAttackBB[j][i] |= (1ULL << l);
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    {
+        SetMaskBB[s] = (1ULL << s);
+        ClearMaskBB[s] = ~SetMaskBB[s];
+    }
+
+    for (Color c = WHITE; c <= BLACK; c++)
+        for (Square s = SQ_A1; s <= SQ_H8; s++)
+        {
+            SquaresInFrontMask[c][s] = in_front_bb(c, s) & file_bb(s);
+            PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s);
+            AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
         }
-      }
-    }
+
+    for (Bitboard b = 0; b < 256; b++)
+        BitCount8Bit[b] = (uint8_t)count_1s<CNT32>(b);
   }
 
+  void init_step_attacks() {
 
-  Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
-                           int fmin=0, int fmax=7, int rmin=0, int rmax=7) {
-    Bitboard result = 0ULL;
-    int rk = sq / 8, fl = sq % 8, r, f, i;
-    for(i = 0; i < dirs; i++) {
-      int dx = deltas[i][0], dy = deltas[i][1];
-      for(f = fl+dx, r = rk+dy;
-          (dx==0 || (f>=fmin && f<=fmax)) && (dy==0 || (r>=rmin && r<=rmax));
-          f += dx, r += dy) {
-        result |= (1ULL << (f + r*8));
-        if(block & (1ULL << (f + r*8))) break;
-      }
-    }
-    return result;
-  }
-
-
-  void init_between_bitboards() {
-    SquareDelta step[8] = {
-      DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+    const int step[][9] =  {
+      {0},
+      {7,9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
+      {9,7,-7,-9,8,1,-1,-8,0}, {0}, {0},
+      {-7,-9,0}, {17,15,10,6,-6,-10,-15,-17,0}, {0}, {0}, {0},
+      {9,7,-7,-9,8,1,-1,-8,0}
     };
-    SignedDirection d;
-    for(Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-      for(Square s2 = SQ_A1; s2 <= SQ_H8; s2++) {
-        BetweenBB[s1][s2] = EmptyBoardBB;
-        d = signed_direction_between_squares(s1, s2);
-        if(d != SIGNED_DIR_NONE)
-          for(Square s3 = s1 + step[d]; s3 != s2; s3 += step[d])
-            set_bit(&(BetweenBB[s1][s2]), s3);
-      }
+
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+        for (Piece pc = WP; pc <= BK; pc++)
+            for (int k = 0; step[pc][k] != 0; k++)
+            {
+                Square to = s + Square(step[pc][k]);
+
+                if (square_is_ok(to) && square_distance(s, to) < 3)
+                    set_bit(&StepAttacksBB[pc][s], to);
+           }
   }
 
+  Bitboard sliding_attacks(int sq, Bitboard occupied, int deltas[][2],
+                           int fmin, int fmax, int rmin, int rmax) {
+    int dx, dy, f, r;
+    int rk = sq / 8;
+    int fl = sq % 8;
+    Bitboard attacks = EmptyBoardBB;
+
+    for (int i = 0; i < 4; i++)
+    {
+        dx = deltas[i][0];
+        dy = deltas[i][1];
+        f = fl + dx;
+        r = rk + dy;
+
+        while (   (dx == 0 || (f >= fmin && f <= fmax))
+               && (dy == 0 || (r >= rmin && r <= rmax)))
+        {
+            attacks |= (1ULL << (f + r * 8));
+
+            if (occupied & (1ULL << (f + r * 8)))
+                break;
+
+            f += dx;
+            r += dy;
+        }
+    }
+    return attacks;
+  }
 
   Bitboard index_to_bitboard(int index, Bitboard mask) {
-    int i, j, bits = count_1s(mask);
-    Bitboard result = 0ULL;
-    for(i = 0; i < bits; i++) {
-      j = pop_1st_bit(&mask);
-      if(index & (1 << i)) result |= (1ULL << j);
+
+    Bitboard result = EmptyBoardBB;
+    int sq, cnt = 0;
+
+    while (mask)
+    {
+        sq = pop_1st_bit(&mask);
+
+        if (index & (1 << cnt++))
+            result |= (1ULL << sq);
     }
     return result;
   }
 
+  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
+                            const int shift[], const Bitboard mult[], int deltas[][2]) {
+    Bitboard b, v;
+    int i, j, index;
 
-  void init_sliding_attacks(Bitboard attacks[],
-                            int attackIndex[], Bitboard mask[],
-                            const int shift[2], const Bitboard mult[],
-                            int deltas[][2]) {
-    int i, j, k, index = 0;
-    Bitboard b;
-    for(i = 0; i < 64; i++) {
-      attackIndex[i] = index;
-      mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);      
-      j = (1 << (64 - shift[i]));
-      for(k = 0; k < j; k++) {
-#if defined(USE_32BIT_ATTACKS)
-        b = index_to_bitboard(k, mask[i]);
-        attacks[index + 
-                 (unsigned(int(b) * int(mult[i]) ^ 
-                           int(b >> 32) * int(mult[i] >> 32)) 
-                  >> shift[i])] =
-          sliding_attacks(i, b, 4, deltas);
-#else
-        b = index_to_bitboard(k, mask[i]);
-        attacks[index + ((b * mult[i]) >> shift[i])] =
-          sliding_attacks(i, b, 4, deltas);
-#endif
-      }
-      index += j;
+    for (i = index = 0; i < 64; i++)
+    {
+        attackIndex[i] = index;
+        mask[i] = sliding_attacks(i, 0, deltas, 1, 6, 1, 6);
+        j = 1 << ((CpuIs64Bit ? 64 : 32) - shift[i]);
+
+        for (int k = 0; k < j; k++)
+        {
+            b = index_to_bitboard(k, mask[i]);
+            v = CpuIs64Bit ? b * mult[i] : unsigned(b * mult[i] ^ (b >> 32) * (mult[i] >> 32));
+            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, deltas, 0, 7, 0, 7);
+        }
+        index += j;
     }
   }
 
-
   void init_pseudo_attacks() {
-    Square s;
-    for(s = SQ_A1; s <= SQ_H8; s++) {
-      BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
-      RookPseudoAttacks[s] = rook_attacks_bb(s, EmptyBoardBB);
-      QueenPseudoAttacks[s] = queen_attacks_bb(s, EmptyBoardBB);
+
+    for (Square s = SQ_A1; s <= SQ_H8; s++)
+    {
+        BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
+        RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
+        QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);
     }
   }
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  void init_file_and_rank_attacks() {
-    int i, j, k, l, m, s;
-    Bitboard b1, b2;
-    for(i = 0; i < 64; i++) {
+  void init_between_bitboards() {
 
-      for(m = 0; m <= 1; m++) {
-        b1 = 0ULL;
-        for(j = 0; j < 6; j++) if(i & (1<<j)) b1 |= (1ULL << ((j+1)*(1+m*7)));
-        for(j = 0; j < 8; j++) {
-          b2 = 0ULL;
-          for(k = 0, s = 1; k < 2; k++, s *= -1) {
-            for(l = j+s; l >= 0 && l <= 7; l += s) {
-              b2 |= (m? RankBB[l] : FileBB[l]);
-              if(b1 & (1ULL << (l*(1+m*7)))) break;
+    Square s1, s2, s3, d;
+    int f, r;
+
+    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
+            if (bit_is_set(QueenPseudoAttacks[s1], s2))
+            {
+                f = file_distance(s1, s2);
+                r = rank_distance(s1, s2);
+
+                d = (s2 - s1) / Max(f, r);
+
+                for (s3 = s1 + d; s3 != s2; s3 += d)
+                    set_bit(&(BetweenBB[s1][s2]), s3);
             }
-          }
-          if(m) FileAttacks[j][(b1*0xd6e8802041d0c441ULL) >> 58] = b2;
-          else RankAttacks[j][i] = b2;
-        }
-      }
-    }
   }
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
 
 }

src/bitboard.h

@@ -1,13 +1,15 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,98 +18,53 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(BITBOARD_H_INCLUDED)
 #define BITBOARD_H_INCLUDED
 
-
-////
-//// Defines
-////
-
-//#define USE_COMPACT_ROOK_ATTACKS
-//#define USE_32BIT_ATTACKS 
-#define USE_FOLDED_BITSCAN
-
-#define BITCOUNT_SWAR_64
-//#define BITCOUNT_SWAR_32
-//#define BITCOUNT_LOOP
-
-
-
-////
-//// Includes
-////
-
-#include "direction.h"
-#include "piece.h"
-#include "square.h"
 #include "types.h"
 
-
-////
-//// Types
-////
-
-typedef uint64_t Bitboard;
-
-
-////
-//// Constants and variables
-////
-
-const Bitboard EmptyBoardBB = 0ULL;
-
-const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
-const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
-
-extern const Bitboard SquaresByColorBB[2];
+const Bitboard EmptyBoardBB = 0;
 
 const Bitboard FileABB = 0x0101010101010101ULL;
-const Bitboard FileBBB = 0x0202020202020202ULL;
-const Bitboard FileCBB = 0x0404040404040404ULL;
-const Bitboard FileDBB = 0x0808080808080808ULL;
-const Bitboard FileEBB = 0x1010101010101010ULL;
-const Bitboard FileFBB = 0x2020202020202020ULL;
-const Bitboard FileGBB = 0x4040404040404040ULL;
-const Bitboard FileHBB = 0x8080808080808080ULL;
+const Bitboard FileBBB = FileABB << 1;
+const Bitboard FileCBB = FileABB << 2;
+const Bitboard FileDBB = FileABB << 3;
+const Bitboard FileEBB = FileABB << 4;
+const Bitboard FileFBB = FileABB << 5;
+const Bitboard FileGBB = FileABB << 6;
+const Bitboard FileHBB = FileABB << 7;
 
-extern const Bitboard FileBB[8];
-extern const Bitboard NeighboringFilesBB[8];
-extern const Bitboard ThisAndNeighboringFilesBB[8];  
+const Bitboard Rank1BB = 0xFF;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
 
-const Bitboard Rank1BB = 0xFFULL;
-const Bitboard Rank2BB = 0xFF00ULL;
-const Bitboard Rank3BB = 0xFF0000ULL;
-const Bitboard Rank4BB = 0xFF000000ULL;
-const Bitboard Rank5BB = 0xFF00000000ULL;
-const Bitboard Rank6BB = 0xFF0000000000ULL;
-const Bitboard Rank7BB = 0xFF000000000000ULL;
-const Bitboard Rank8BB = 0xFF00000000000000ULL;
+extern Bitboard SquaresByColorBB[2];
+extern Bitboard FileBB[8];
+extern Bitboard NeighboringFilesBB[8];
+extern Bitboard ThisAndNeighboringFilesBB[8];
+extern Bitboard RankBB[8];
+extern Bitboard InFrontBB[2][8];
 
-extern const Bitboard RankBB[8];
-extern const Bitboard RelativeRankBB[2][8];
-extern const Bitboard InFrontBB[2][8];
+extern Bitboard SetMaskBB[65];
+extern Bitboard ClearMaskBB[65];
 
-extern Bitboard SetMaskBB[64];
-extern Bitboard ClearMaskBB[64];
-
-extern Bitboard StepAttackBB[16][64];
-extern Bitboard RayBB[64][8];
+extern Bitboard StepAttacksBB[16][64];
 extern Bitboard BetweenBB[64][64];
 
+extern Bitboard SquaresInFrontMask[2][64];
 extern Bitboard PassedPawnMask[2][64];
-extern Bitboard OutpostMask[2][64];
+extern Bitboard AttackSpanMask[2][64];
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-extern Bitboard RankAttacks[8][64], FileAttacks[8][64];
-#else
 extern const uint64_t RMult[64];
 extern const int RShift[64];
 extern Bitboard RMask[64];
 extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
 
 extern const uint64_t BMult[64];
 extern const int BShift[64];
@@ -119,47 +76,46 @@ extern Bitboard BishopPseudoAttacks[64];
 extern Bitboard RookPseudoAttacks[64];
 extern Bitboard QueenPseudoAttacks[64];
 
+extern uint8_t BitCount8Bit[256];
 
-////
-//// Inline functions
-////
 
 /// Functions for testing whether a given bit is set in a bitboard, and for
 /// setting and clearing bits.
 
-inline Bitboard set_mask_bb(Square s) {
-  //  return 1ULL << s;
-  return SetMaskBB[s];
-}
-
-inline Bitboard clear_mask_bb(Square s) {
-  //  return ~set_mask_bb(s);
-  return ClearMaskBB[s];
-}
-
 inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & set_mask_bb(s);
+  return b & SetMaskBB[s];
 }
 
 inline void set_bit(Bitboard *b, Square s) {
-  *b |= set_mask_bb(s);
+  *b |= SetMaskBB[s];
 }
 
 inline void clear_bit(Bitboard *b, Square s) {
-  *b &= clear_mask_bb(s);
+  *b &= ClearMaskBB[s];
 }
 
 
-/// rank_bb() and file_bb() gives a bitboard containing all squares on a given
-/// file or rank.  It is also possible to pass a square as input to these
-/// functions.
+/// Functions used to update a bitboard after a move. This is faster
+/// then calling a sequence of clear_bit() + set_bit()
+
+inline Bitboard make_move_bb(Square from, Square to) {
+  return SetMaskBB[from] | SetMaskBB[to];
+}
+
+inline void do_move_bb(Bitboard *b, Bitboard move_bb) {
+  *b ^= move_bb;
+}
+
+
+/// rank_bb() and file_bb() take a file or a square as input and return
+/// a bitboard representing all squares on the given file or rank.
 
 inline Bitboard rank_bb(Rank r) {
   return RankBB[r];
 }
 
 inline Bitboard rank_bb(Square s) {
-  return rank_bb(square_rank(s));
+  return RankBB[square_rank(s)];
 }
 
 inline Bitboard file_bb(File f) {
@@ -167,11 +123,11 @@ inline Bitboard file_bb(File f) {
 }
 
 inline Bitboard file_bb(Square s) {
-  return file_bb(square_file(s));
+  return FileBB[square_file(s)];
 }
 
 
-/// neighboring_files_bb takes a file or a square as input, and returns a
+/// neighboring_files_bb takes a file or a square as input and returns a
 /// bitboard representing all squares on the neighboring files.
 
 inline Bitboard neighboring_files_bb(File f) {
@@ -179,31 +135,19 @@ inline Bitboard neighboring_files_bb(File f) {
 }
 
 inline Bitboard neighboring_files_bb(Square s) {
-  return neighboring_files_bb(square_file(s));
+  return NeighboringFilesBB[square_file(s)];
 }
 
 
-/// this_and_neighboring_files_bb takes a file or a square as input, and
-/// returns a bitboard representing all squares on the given and neighboring
-/// files.
+/// this_and_neighboring_files_bb takes a file or a square as input and returns
+/// a bitboard representing all squares on the given and neighboring files.
 
 inline Bitboard this_and_neighboring_files_bb(File f) {
   return ThisAndNeighboringFilesBB[f];
 }
 
 inline Bitboard this_and_neighboring_files_bb(Square s) {
-  return this_and_neighboring_files_bb(square_file(s));
-}
-
-
-/// relative_rank_bb() takes a color and a rank as input, and returns a bitboard
-/// representing all squares on the given rank from the given color's point of
-/// view.  For instance, relative_rank_bb(WHITE, 7) gives all squares on the
-/// 7th rank, while relative_rank_bb(BLACK, 7) gives all squares on the 2nd
-/// rank.
-
-inline Bitboard relative_rank_bb(Color c, Rank r) {
-  return RelativeRankBB[c][r];
+  return ThisAndNeighboringFilesBB[square_file(s)];
 }
 
 
@@ -218,77 +162,42 @@ inline Bitboard in_front_bb(Color c, Rank r) {
 }
 
 inline Bitboard in_front_bb(Color c, Square s) {
-  return in_front_bb(c, square_rank(s));
+  return InFrontBB[c][square_rank(s)];
 }
 
 
-/// ray_bb() gives a bitboard representing all squares along the ray in a
-/// given direction from a given square.
-
-inline Bitboard ray_bb(Square s, SignedDirection d) {
-  return RayBB[s][d];
-}
-
-
-/// Functions for computing sliding attack bitboards.  rook_attacks_bb(),
+/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
 /// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
 /// bitboard of occupied squares as input, and return a bitboard representing
 /// all squares attacked by a rook, bishop or queen on the given square.
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-
-inline Bitboard file_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> square_file(s)) & 0x01010101010100ULL;
-  return
-    FileAttacks[square_rank(s)][(b*0xd6e8802041d0c441ULL)>>58] & file_bb(s);
-}
-
-inline Bitboard rank_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> ((s & 56) + 1)) & 63;
-  return RankAttacks[square_file(s)][b] & rank_bb(s);
-}
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  return file_attacks_bb(s, blockers) | rank_attacks_bb(s, blockers);
-}
-
-#elif defined(USE_32BIT_ATTACKS)
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + 
-                  (unsigned(int(b) * int(RMult[s]) ^
-                            int(b >> 32) * int(RMult[s] >> 32)) 
-                   >> RShift[s])];
-}
-
-#else
+#if defined(IS_64BIT)
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & RMask[s];
   return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
 }
 
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + 
-                  (unsigned(int(b) * int(BMult[s]) ^
-                            int(b >> 32) * int(BMult[s] >> 32)) 
-                   >> BShift[s])];
-}
-
-#else // defined(USE_32BIT_ATTACKS)
-
 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & BMask[s];
   return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
 }
 
-#endif // defined(USE_32BIT_ATTACKS)
+#else // if !defined(IS_64BIT)
+
+inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
+  Bitboard b = blockers & RMask[s];
+  return RAttacks[RAttackIndex[s] +
+        (unsigned(int(b) * int(RMult[s]) ^ int(b >> 32) * int(RMult[s] >> 32)) >> RShift[s])];
+}
+
+inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
+  Bitboard b = blockers & BMask[s];
+  return BAttacks[BAttackIndex[s] +
+        (unsigned(int(b) * int(BMult[s]) ^ int(b >> 32) * int(BMult[s] >> 32)) >> BShift[s])];
+}
+
+#endif
 
 inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
   return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
@@ -307,115 +216,80 @@ inline Bitboard squares_between(Square s1, Square s2) {
 
 /// squares_in_front_of takes a color and a square as input, and returns a
 /// bitboard representing all squares along the line in front of the square,
-/// from the point of view of the given color.  For instance, 
-/// squares_in_front_of(BLACK, SQ_E4) returns a bitboard with the squares
-/// e3, e2 and e1 set.
+/// from the point of view of the given color. Definition of the table is:
+/// SquaresInFrontOf[c][s] = in_front_bb(c, s) & file_bb(s)
 
 inline Bitboard squares_in_front_of(Color c, Square s) {
-  return in_front_bb(c, s) & file_bb(s);
-}
-
-
-/// squares_behind is similar to squares_in_front, but returns the squares
-/// behind the square instead of in front of the square.
-
-inline Bitboard squares_behind(Color c, Square s) {
-  return in_front_bb(opposite_color(c), s) & file_bb(s);
+  return SquaresInFrontMask[c][s];
 }
 
 
 /// passed_pawn_mask takes a color and a square as input, and returns a
 /// bitboard mask which can be used to test if a pawn of the given color on
-/// the given square is a passed pawn.
+/// the given square is a passed pawn. Definition of the table is:
+/// PassedPawnMask[c][s] = in_front_bb(c, s) & this_and_neighboring_files_bb(s)
 
 inline Bitboard passed_pawn_mask(Color c, Square s) {
   return PassedPawnMask[c][s];
 }
 
 
-/// outpost_mask takes a color and a square as input, and returns a bitboard
-/// mask which can be used to test whether a piece on the square can possibly
-/// be driven away by an enemy pawn.
+/// attack_span_mask takes a color and a square as input, and returns a bitboard
+/// representing all squares that can be attacked by a pawn of the given color
+/// when it moves along its file starting from the given square. Definition is:
+/// AttackSpanMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
 
-inline Bitboard outpost_mask(Color c, Square s) {
-  return OutpostMask[c][s];
+inline Bitboard attack_span_mask(Color c, Square s) {
+  return AttackSpanMask[c][s];
 }
 
 
-/// isolated_pawn_mask takes a square as input, and returns a bitboard mask 
-/// which can be used to test whether a pawn on the given square is isolated.
+/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// either on a straight or on a diagonal line.
 
-inline Bitboard isolated_pawn_mask(Square s) {
-  return neighboring_files_bb(s);
+inline bool squares_aligned(Square s1, Square s2, Square s3) {
+  return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
+        & ((1ULL << s1) | (1ULL << s2) | (1ULL << s3));
 }
 
 
-/// count_1s() counts the number of nonzero bits in a bitboard.
+/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// pop_1st_bit() finds and clears the least significant nonzero bit in a
+/// nonzero bitboard.
 
-#if defined(BITCOUNT_LOOP)
+#if defined(USE_BSFQ)
 
-inline int count_1s(Bitboard b) {
-  int r;
-  for(r = 0; b; r++, b &= b - 1);
-  return r;
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+
+FORCE_INLINE Square first_1(Bitboard b) {
+   unsigned long index;
+   _BitScanForward64(&index, b);
+   return (Square) index;
+}
+#else
+
+FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen
+  Bitboard dummy;
+  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
+  return (Square) dummy;
+}
+#endif
+
+FORCE_INLINE Square pop_1st_bit(Bitboard* b) {
+  const Square s = first_1(*b);
+  *b &= ~(1ULL<<s);
+  return s;
 }
 
-inline int count_1s_max_15(Bitboard b) {
-  return count_1s(b);
-}
+#else // if !defined(USE_BSFQ)
 
-#elif defined(BITCOUNT_SWAR_32)
+extern Square first_1(Bitboard b);
+extern Square pop_1st_bit(Bitboard* b);
 
-inline int count_1s(Bitboard b) {
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = (v + (v >> 4)) & 0x0F0F0F0F;
-  w = (w + (w >> 4)) & 0x0F0F0F0F;
-  v = ((v+w) * 0x01010101) >> 24; // mul is fast on amd procs
-  return int(v);
-}
+#endif
 
-inline int count_1s_max_15(Bitboard b) {
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = ((v+w) * 0x11111111) >> 28;
-  return int(v);
-}
-
-#elif defined(BITCOUNT_SWAR_64)
-
-inline int count_1s(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
-}
-
-inline int count_1s_max_15(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
-}
-
-#endif // BITCOUNT
-
-
-////
-//// Prototypes
-////
 
 extern void print_bitboard(Bitboard b);
 extern void init_bitboards();
-extern Square first_1(Bitboard b);
-extern Square pop_1st_bit(Bitboard *b);
-
 
 #endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -0,0 +1,98 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  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
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if !defined(BITCOUNT_H_INCLUDED)
+#define BITCOUNT_H_INCLUDED
+
+#include "types.h"
+
+enum BitCountType {
+    CNT64,
+    CNT64_MAX15,
+    CNT32,
+    CNT32_MAX15,
+    CNT_POPCNT
+};
+
+/// count_1s() counts the number of nonzero bits in a bitboard.
+/// We have different optimized versions according if platform
+/// is 32 or 64 bits, and to the maximum number of nonzero bits.
+/// We also support hardware popcnt instruction. See Readme.txt
+/// on how to pgo compile with popcnt support.
+template<BitCountType> inline int count_1s(Bitboard);
+
+template<>
+inline int count_1s<CNT64>(Bitboard b) {
+  b -= ((b>>1) & 0x5555555555555555ULL);
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  b *= 0x0101010101010101ULL;
+  return int(b >> 56);
+}
+
+template<>
+inline int count_1s<CNT64_MAX15>(Bitboard b) {
+  b -= (b>>1) & 0x5555555555555555ULL;
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b *= 0x1111111111111111ULL;
+  return int(b >> 60);
+}
+
+template<>
+inline int count_1s<CNT32>(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
+  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  v *= 0x01010101; // mul is fast on amd procs
+  return int(v >> 24);
+}
+
+template<>
+inline int count_1s<CNT32_MAX15>(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v += w; // 0-8 in 4 bits
+  v *= 0x11111111;
+  return int(v >> 28);
+}
+
+template<>
+inline int count_1s<CNT_POPCNT>(Bitboard b) {
+#if !defined(USE_POPCNT)
+  return int(b != 0); // Avoid 'b not used' warning
+#elif defined(_MSC_VER) && defined(__INTEL_COMPILER)
+  return _mm_popcnt_u64(b);
+#elif defined(_MSC_VER)
+  return (int)__popcnt64(b);
+#elif defined(__GNUC__)
+  unsigned long ret;
+  __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b));
+  return ret;
+#endif
+}
+
+#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -19,38 +20,21 @@
 
 /*
   The code in this file is based on the opening book code in PolyGlot
-  by Fabien Letouzey.  PolyGlot is available under the GNU General
+  by Fabien Letouzey. PolyGlot is available under the GNU General
   Public License, and can be downloaded from http://wbec-ridderkerk.nl
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
-#include <cstdio>
+#include <iostream>
 
 #include "book.h"
-#include "mersenne.h"
 #include "movegen.h"
 
-
-////
-//// Global variables
-////
-
-Book OpeningBook;
-
-
-////
-//// Local definitions
-////
+using namespace std;
 
 namespace {
 
-  /// Random numbers from PolyGlot, used to compute book hash keys.
-
+  // Random numbers from PolyGlot, used to compute book hash keys
   const uint64_t Random64[781] = {
     0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
     0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
@@ -315,135 +299,184 @@ namespace {
     0xF8D626AAAF278509ULL
   };
 
+  // Indices to the Random64[] array
+  const int PieceIdx     = 0;
+  const int CastleIdx    = 768;
+  const int EnPassantIdx = 772;
+  const int TurnIdx      = 780;
 
-  /// Indices to the Random64[] array
+  // book_key() builds up a PolyGlot hash key out of a position
+  uint64_t book_key(const Position& pos) {
 
-  const int RandomPiece = 0;
-  const int RandomCastle = 768;
-  const int RandomEnPassant = 772;
-  const int RandomTurn = 780;
+    // Piece offset is calculated as (64 * PolyPieceType + square), where
+    // PolyPieceType is: BP = 0, WP = 1, BN = 2, WN = 3 .... BK = 10, WK = 11
+    static const int PieceToPoly[] = { 0, 1, 3, 5, 7, 9, 11, 0, 0, 0, 2, 4, 6, 8, 10 };
 
+    uint64_t result = 0;
+    Bitboard b = pos.occupied_squares();
 
-  /// Convert pieces to the range 0..1
-  
-  const int PieceTo12[] = {
-    0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11
-  };
-
-
-  /// Prototypes
-  
-  uint64_t book_key(const Position &pos);
-  uint64_t book_piece_key(Piece p, Square s);
-  uint64_t book_castle_key(const Position &pos);
-  uint64_t book_ep_key(const Position &pos);
-  uint64_t book_color_key(const Position &pos);
-
-  uint64_t read_integer(FILE *file, int size);
-
-}
-
-
-////
-//// Functions
-////
-
-
-/// Constructor
-
-Book::Book() {
-  bookFile = NULL;
-  bookSize = 0;
-}
-
-
-/// Book::open() opens a book file with a given file name.
-
-void Book::open(const std::string &fName) {
-  fileName = fName;
-  bookFile = fopen(fileName.c_str(), "rb");
-  if(bookFile != NULL) {
-    if(fseek(bookFile, 0, SEEK_END) == -1) {
-      std::cerr << "Failed to open book file " << fileName << std::endl;
-      exit(EXIT_FAILURE);
-    }
-    bookSize = ftell(bookFile) / 16;
-    if(bookSize == -1) {
-      std::cerr << "Failed to open book file " << fileName << std::endl;
-      exit(EXIT_FAILURE);
+    while (b)
+    {
+        Square s = pop_1st_bit(&b);
+        int p = PieceToPoly[int(pos.piece_on(s))];
+        result ^= Random64[PieceIdx + 64 * p + int(s)];
     }
+
+    if (pos.can_castle_kingside(WHITE))
+        result ^= Random64[CastleIdx + 0];
+
+    if (pos.can_castle_queenside(WHITE))
+        result ^= Random64[CastleIdx + 1];
+
+    if (pos.can_castle_kingside(BLACK))
+        result ^= Random64[CastleIdx + 2];
+
+    if (pos.can_castle_queenside(BLACK))
+        result ^= Random64[CastleIdx + 3];
+
+    if (pos.ep_square() != SQ_NONE)
+        result ^= Random64[EnPassantIdx + square_file(pos.ep_square())];
+
+    if (pos.side_to_move() == WHITE)
+        result ^= Random64[TurnIdx];
+
+    return result;
   }
+
 }
 
 
-/// Book::close() closes the currently open book file.
+/// Book c'tor. Make random number generation less deterministic, for book moves
+Book::Book() {
+
+  for (int i = abs(get_system_time() % 10000); i > 0; i--)
+      RKiss.rand<unsigned>();
+}
+
+
+/// Book destructor. Be sure file is closed before we leave.
+
+Book::~Book() {
+
+  close();
+}
+
+
+/// Book::close() closes the file only if it is open, otherwise
+/// we can end up in a little mess due to how std::ifstream works.
 
 void Book::close() {
-  if(bookFile != NULL && fclose(bookFile) == EOF) {
-    std::cerr << "Failed to close book file" << std::endl;
-    exit(EXIT_FAILURE);
+
+  if (bookFile.is_open())
+      bookFile.close();
+
+  bookName = "";
+}
+
+
+/// Book::open() opens a book file with a given file name
+
+void Book::open(const string& fileName) {
+
+  // Close old file before opening the new
+  close();
+
+  bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary);
+
+  // Silently return when asked to open a non-exsistent file
+  if (!bookFile.is_open())
+      return;
+
+  // Get the book size in number of entries
+  bookFile.seekg(0, ios::end);
+  bookSize = long(bookFile.tellg()) / sizeof(BookEntry);
+
+  if (!bookFile.good())
+  {
+      cerr << "Failed to open book file " << fileName << endl;
+      exit(EXIT_FAILURE);
   }
+
+  // Set only if successful
+  bookName = fileName;
 }
 
 
-/// Book::is_open() tests whether a book file has been opened.
+/// Book::get_move() gets a book move for a given position. Returns
+/// MOVE_NONE if no book move is found. If findBestMove is true then
+/// return always the highest rated book move.
 
-bool Book::is_open() const {
-  return bookFile != NULL && bookSize != 0;
-}
+Move Book::get_move(const Position& pos, bool findBestMove) {
 
+  if (!bookFile.is_open() || bookSize == 0)
+      return MOVE_NONE;
 
-/// Book::file_name() returns the file name of the currently active book,
-/// or the empty string if no book is open.
+  BookEntry entry;
+  int bookMove = MOVE_NONE;
+  unsigned score, scoresSum = 0, bestScore = 0;
+  uint64_t key = book_key(pos);
 
-const std::string Book::file_name() const {
-  return this->is_open()? fileName : "";
-}
+  // Choose a book move among the possible moves for the given position
+  for (int idx = find_entry(key); idx < bookSize; idx++)
+  {
+      entry = read_entry(idx);
 
+      if (entry.key != key)
+          break;
 
-/// Book::get_move() gets a book move for a given position.  Returns
-/// MOVE_NONE if no book move is found.
-
-Move Book::get_move(const Position &pos) const {
-  if(this->is_open()) {
-    int bestMove = 0, bestScore = 0, move, score;
-    uint64_t key = book_key(pos);
-    BookEntry entry;
-
-    for(int i = this->find_key(key); i < bookSize; i++) {
-      this->read_entry(entry, i);
-      if(entry.key != key)
-        break;
-      move = entry.move;
       score = entry.count;
-      assert(score > 0);
 
-      bestScore += score;
-      if(int(genrand_int32() % bestScore) < score)
-        bestMove = move;
-    }
-
-    if(bestMove != 0) {
-      MoveStack moves[256];
-      int n, j;
-      n = generate_legal_moves(pos, moves);
-      for(j = 0; j < n; j++)
-        if((int(moves[j].move) & 07777) == bestMove)
-          return moves[j].move;
-    }
+      if (!findBestMove)
+      {
+          // Choose book move according to its score. If a move has a very
+          // high score it has more probability to be choosen then a one with
+          // lower score. Note that first entry is always chosen.
+          scoresSum += score;
+          if (RKiss.rand<unsigned>() % scoresSum < score)
+              bookMove = entry.move;
+      }
+      else if (score > bestScore)
+      {
+          bestScore = score;
+          bookMove = entry.move;
+      }
   }
+
+  // A PolyGlot book move is encoded as follows:
+  //
+  // bit  0- 5: destination square (from 0 to 63)
+  // bit  6-11: origin square (from 0 to 63)
+  // bit 12-13-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
+  //
+  // Castling moves follow "king captures rook" representation. So in case
+  // book move is a promotion we have to convert to our representation, in
+  // all other cases we can directly compare with a Move after having
+  // masked out special Move's flags that are not supported by PolyGlot.
+  int p = (bookMove >> 12) & 7;
+
+  if (p)
+      bookMove = int(make_promotion_move(move_from(Move(bookMove)),
+                 move_to(Move(bookMove)), PieceType(p + 1)));
+
+  // Verify the book move (if any) is legal
+  MoveStack mlist[MAX_MOVES];
+  MoveStack* last = generate<MV_LEGAL>(pos, mlist);
+  for (MoveStack* cur = mlist; cur != last; cur++)
+      if ((int(cur->move) & ~(3 << 14)) == bookMove) // Mask out special flags
+          return cur->move;
+
   return MOVE_NONE;
 }
 
 
-/// Book::find_key() takes a book key as input, and does a binary search
-/// through the book file for the given key.  The index to the first book
-/// entry with the same key as the input is returned.  When the key is not
+/// Book::find_entry() takes a book key as input, and does a binary search
+/// through the book file for the given key. The index to the first book
+/// entry with the same key as the input is returned. When the key is not
 /// found in the book file, bookSize is returned.
 
-int Book::find_key(uint64_t key) const {
+int Book::find_entry(uint64_t key) {
+
   int left, right, mid;
-  BookEntry entry;
 
   // Binary search (finds the leftmost entry)
   left = 0;
@@ -451,128 +484,42 @@ int Book::find_key(uint64_t key) const {
 
   assert(left <= right);
 
-  while(left < right) {
-    mid = (left + right) / 2;
-    assert(mid >= left && mid < right);
+  while (left < right)
+  {
+      mid = (left + right) / 2;
 
-    this->read_entry(entry, mid);
+      assert(mid >= left && mid < right);
 
-    if(key <= entry.key)
-      right = mid;
-    else
-      left = mid + 1;
+      if (key <= read_entry(mid).key)
+          right = mid;
+      else
+          left = mid + 1;
   }
 
   assert(left == right);
 
-  this->read_entry(entry, left);
-
-  return (entry.key == key)? left : bookSize;
+  return read_entry(left).key == key ? left : bookSize;
 }
 
 
-/// Book::read_entry() takes a BookEntry reference and an integer index as
-/// input, and looks up the opening book entry at the given index in the book
-/// file.  The book entry is copied to the first input parameter.
+/// Book::read_entry() takes an integer index, and returns the BookEntry
+/// at the given index in the book file.
 
-void Book::read_entry(BookEntry& entry, int n) const {
-  assert(n >= 0 && n < bookSize);
-  assert(bookFile != NULL);
+BookEntry Book::read_entry(int idx) {
 
-  if(fseek(bookFile, n*16, SEEK_SET) == -1) {
-    std::cerr << "Failed to read book entry at index " << n << std::endl;
-    exit(EXIT_FAILURE);
+  assert(idx >= 0 && idx < bookSize);
+  assert(bookFile.is_open());
+
+  BookEntry e;
+
+  bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg);
+
+  *this >> e.key >> e.move >> e.count >> e.learn;
+
+  if (!bookFile.good())
+  {
+      cerr << "Failed to read book entry at index " << idx << endl;
+      exit(EXIT_FAILURE);
   }
-
-  entry.key = read_integer(bookFile, 8);
-  entry.move = read_integer(bookFile, 2);
-  entry.count = read_integer(bookFile, 2);
-  entry.n = read_integer(bookFile, 2);
-  entry.sum = read_integer(bookFile, 2);
-}
-
-
-////
-//// Local definitions
-////
-
-namespace {
-
-  uint64_t book_key(const Position &pos) {
-    uint64_t result = 0ULL;
-
-    for(Color c = WHITE; c <= BLACK; c++) {
-      Bitboard b = pos.pieces_of_color(c);
-      Square s;
-      Piece p;
-      while(b != EmptyBoardBB) {
-        s = pop_1st_bit(&b);
-        p = pos.piece_on(s);
-        assert(piece_is_ok(p));
-        assert(color_of_piece(p) == c);
-
-        result ^= book_piece_key(p, s);
-      }
-    }
-
-    result ^= book_castle_key(pos);
-    result ^= book_ep_key(pos);
-    result ^= book_color_key(pos);
-
-    return result;
-  }
-        
-
-  uint64_t book_piece_key(Piece p, Square s) {
-    return Random64[RandomPiece + (PieceTo12[int(p)]^1)*64 + int(s)];
-  }
-
-
-  uint64_t book_castle_key(const Position &pos) {
-    uint64_t result = 0ULL;
-
-    if(pos.can_castle_kingside(WHITE))
-      result ^= Random64[RandomCastle+0];
-    if(pos.can_castle_queenside(WHITE))
-      result ^= Random64[RandomCastle+1];
-    if(pos.can_castle_kingside(BLACK))
-      result ^= Random64[RandomCastle+2];
-    if(pos.can_castle_queenside(BLACK))
-      result ^= Random64[RandomCastle+3];
-    return result;
-  }
-
-  
-  uint64_t book_ep_key(const Position &pos) {
-    return (pos.ep_square() == SQ_NONE)?
-      0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
-  }
-
-  
-  uint64_t book_color_key(const Position &pos) {
-    return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL;
-  }
-  
-
-  uint64_t read_integer(FILE *file, int size) {
-    uint64_t n = 0ULL;;
-    int i;
-    int b;
-
-    assert(file != NULL);
-    assert(size > 0 && size <= 8);
-
-    for(i = 0; i < size; i++) {
-      b = fgetc(file);
-      if(b == EOF) {
-        std::cerr << "Failed to read " << size << " bytes from book file"
-                  << std::endl;
-        exit(EXIT_FAILURE);
-      }
-      assert(b >= 0 && b < 256);
-      n = (n << 8) | b;
-    }
-    return n;
-  }
-
+  return e;
 }

src/book.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,74 +17,55 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-/*
-  The code in this file is based on the opening book code in PolyGlot
-  by Fabien Letouzey.  PolyGlot is available under the GNU General
-  Public License, and can be downloaded from http://wbec-ridderkerk.nl
-*/
-
-
 #if !defined(BOOK_H_INCLUDED)
 #define BOOK_H_INCLUDED
 
-
-////
-//// Includes
-////
-
+#include <fstream>
 #include <string>
 
 #include "move.h"
 #include "position.h"
+#include "rkiss.h"
 
 
-////
-//// Types
-////
-
+// A Polyglot book is a series of "entries" of 16 bytes. All integers are
+// stored highest byte first (regardless of size). The entries are ordered
+// according to key. Lowest key first.
 struct BookEntry {
   uint64_t key;
   uint16_t move;
   uint16_t count;
-  uint16_t n;
-  uint16_t sum;
+  uint32_t learn;
 };
 
 class Book {
-
 public:
-  // Constructors
   Book();
-
-  // Open and close book files
-  void open(const std::string &fName);
+  ~Book();
+  void open(const std::string& fileName);
   void close();
-
-  // Testing if a book is opened
-  bool is_open() const;
-
-  // The file name of the currently active book
-  const std::string file_name() const;
-
-  // Get a book move for a given position
-  Move get_move(const Position &pos) const;
+  Move get_move(const Position& pos, bool findBestMove);
+  const std::string name() const { return bookName; }
 
 private:
-  int find_key(uint64_t key) const;
-  void read_entry(BookEntry &entry, int n) const;
+  // read n chars from the file stream and converts them in an
+  // integer number. Integers are stored with highest byte first.
+  template<int n> uint64_t get_int();
 
-  std::string fileName;
-  FILE *bookFile;
+  template<typename T>
+  Book& operator>>(T& n) { n = (T)get_int<sizeof(T)>(); return *this; }
+
+  BookEntry read_entry(int idx);
+  int find_entry(uint64_t key);
+
+  std::ifstream bookFile;
+  std::string bookName;
   int bookSize;
+  RKISS RKiss;
 };
 
-
-////
-//// Global variables
-////
-
-extern Book OpeningBook;
-
+// Yes, we indulge a bit here ;-)
+template<int n> inline uint64_t Book::get_int() { return 256 * get_int<n-1>() + bookFile.get(); }
+template<> inline uint64_t Book::get_int<1>() { return bookFile.get(); }
 
 #endif // !defined(BOOK_H_INCLUDED)

src/color.cpp

@@ -1,35 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include "color.h"
-
-
-////
-//// Functions
-////
-
-/// color_is_ok(), for debugging:
-
-bool color_is_ok(Color c) {
-  return c == WHITE || c == BLACK;
-}

src/color.h

@@ -1,60 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(COLOR_H_INCLUDED)
-#define COLOR_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "misc.h"
-
-
-////
-//// Types
-////
-
-enum Color {
-  WHITE, 
-  BLACK, 
-  COLOR_NONE
-};
-
-
-////
-//// Inline functions
-////
-
-inline Color operator+ (Color c, int i) { return Color(int(c) + i); }
-inline void operator++ (Color &c, int i) { c = Color(int(c) + 1); }
-
-inline Color opposite_color(Color c) {
-  return Color(int(c) ^ 1);
-}
-
-
-////
-//// Prototypes
-////
-
-extern bool color_is_ok(Color c);
-
-
-#endif // !defined(COLOR_H_INCLUDED)

src/depth.h

@@ -1,61 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(DEPTH_H_INCLUDED)
-#define DEPTH_H_INCLUDED
-
-////
-//// Types
-////
-
-enum Depth {
-  DEPTH_ZERO = 0,
-  DEPTH_MAX = 200  // 100 * OnePly;
-};
-
-
-////
-//// Constants
-////
-
-/// Note: If OnePly is changed, the constant HistoryMax in history.h should
-/// probably also be changed.
-
-const Depth OnePly = Depth(2);
-
-
-////
-//// Inline functions
-////
-
-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- (Depth d1, Depth d2) { return Depth(int(d1) - int(d2)); }
-inline void operator-= (Depth & d, int i) { d = Depth(int(d) - i); }
-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); }
-inline Depth operator/ (Depth d, int i) { return Depth(int(d) / i); }
-inline void operator/= (Depth &d, int i) { d = Depth(int(d) / i); }
-
-
-#endif // !defined(DEPTH_H_INCLUDED)

src/direction.cpp

@@ -1,62 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include "direction.h"
-#include "square.h"
-
-
-////
-//// Variables
-////
-
-uint8_t DirectionTable[64][64];
-uint8_t SignedDirectionTable[64][64];
-
-
-////
-//// Functions
-////
-
-void init_direction_table() {
-  SquareDelta deltas[8] = {
-    DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
-  };
-  for(Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-    for(Square s2 = SQ_A1; s2 <= SQ_H8; s2++) {
-      DirectionTable[s1][s2] = uint8_t(DIR_NONE);
-      SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
-      if(s1 == s2) continue;
-      for(SignedDirection d = SIGNED_DIR_E; d <= SIGNED_DIR_SE; d++) {
-        SquareDelta delta = deltas[d];
-        Square s3, s4;
-        for(s4 = s1 + delta, s3 = s1;
-            square_distance(s4, s3) == 1 && s4 != s2 && square_is_ok(s4);
-            s3 = s4, s4 += delta);
-        if(s4 == s2 && square_distance(s4, s3) == 1) {
-          SignedDirectionTable[s1][s2] = uint8_t(d);
-          DirectionTable[s1][s2] = uint8_t(d/2);
-          break;
-        }
-      }
-    }
-}

src/direction.h

@@ -1,82 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(DIRECTION_H_INCLUDED)
-#define DIRECTION_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "square.h"
-#include "types.h"
-
-
-////
-//// Types
-////
-
-enum Direction {
-  DIR_E = 0, DIR_N = 1, DIR_NE = 2, DIR_NW = 3, DIR_NONE = 4
-};
-
-enum SignedDirection {
-  SIGNED_DIR_E = 0, SIGNED_DIR_W = 1,
-  SIGNED_DIR_N = 2, SIGNED_DIR_S = 3,
-  SIGNED_DIR_NE = 4, SIGNED_DIR_SW = 5,
-  SIGNED_DIR_NW = 6, SIGNED_DIR_SE = 7,
-  SIGNED_DIR_NONE = 8
-};
-
-
-////
-//// Variables
-////
-
-extern uint8_t DirectionTable[64][64];
-extern uint8_t SignedDirectionTable[64][64];
-
-
-////
-//// Inline functions
-////
-
-inline void operator++ (Direction &d, int) { d = Direction(int(d) + 1); }
-
-inline void operator++ (SignedDirection &d, int) {
-  d = SignedDirection(int(d) + 1);
-}
-
-inline Direction direction_between_squares(Square s1, Square s2) {
-  return Direction(DirectionTable[s1][s2]);
-}
-
-inline SignedDirection signed_direction_between_squares(Square s1, Square s2) {
-  return SignedDirection(SignedDirectionTable[s1][s2]);
-}
-
-
-////
-//// Prototypes
-////
-
-extern void init_direction_table();
-
-
-#endif // !defined(DIRECTION_H_INCLUDED)

src/endgame.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,227 +17,96 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(ENDGAME_H_INCLUDED)
 #define ENDGAME_H_INCLUDED
 
-////
-//// Includes
-////
+#include <string>
+#include <map>
 
 #include "position.h"
-#include "scale.h"
-#include "value.h"
+#include "types.h"
 
 
-////
-//// Types
-////
+/// EndgameType lists all supported endgames
 
-/// Abstract base class for all special endgame evaluation functions:
+enum EndgameType {
 
-class EndgameEvaluationFunction {
-public:
-  EndgameEvaluationFunction(Color c);
-  virtual ~EndgameEvaluationFunction() { }
+  // Evaluation functions
 
-  virtual Value apply(const Position &pos) =0;
+  KXK,   // Generic "mate lone king" eval
+  KBNK,  // KBN vs K
+  KPK,   // KP vs K
+  KRKP,  // KR vs KP
+  KRKB,  // KR vs KB
+  KRKN,  // KR vs KN
+  KQKR,  // KQ vs KR
+  KBBKN, // KBB vs KN
+  KNNK,  // KNN vs K
+  KmmKm, // K and two minors vs K and one or two minors
 
-protected:
+
+  // Scaling functions
+
+  KBPsK,   // KB+pawns vs K
+  KQKRPs,  // KQ vs KR+pawns
+  KRPKR,   // KRP vs KR
+  KRPPKRP, // KRPP vs KRP
+  KPsK,    // King and pawns vs king
+  KBPKB,   // KBP vs KB
+  KBPPKB,  // KBPP vs KB
+  KBPKN,   // KBP vs KN
+  KNPK,    // KNP vs K
+  KPKP     // KP vs KP
+};
+
+
+/// Base and derived templates for endgame evaluation and scaling functions
+
+template<typename T>
+struct EndgameBase {
+
+  typedef EndgameBase<T> Base;
+
+  virtual ~EndgameBase() {}
+  virtual Color color() const = 0;
+  virtual T apply(const Position&) const = 0;
+};
+
+
+template<typename T, EndgameType>
+struct Endgame : public EndgameBase<T> {
+
+  explicit Endgame(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
+  Color color() const { return strongerSide; }
+  T apply(const Position&) const;
+
+private:
   Color strongerSide, weakerSide;
 };
 
 
-/// Subclasses for various concrete endgames:
+/// Endgames class stores in two std::map the pointers to endgame evaluation
+/// and scaling base objects. Then we use polymorphism to invoke the actual
+/// endgame function calling its apply() method that is virtual.
+
+class Endgames {
+
+  typedef std::map<Key, EndgameBase<Value>* > EFMap;
+  typedef std::map<Key, EndgameBase<ScaleFactor>* > SFMap;
 
-// Generic "mate lone king" eval:
-class KXKEvaluationFunction : public EndgameEvaluationFunction {
 public:
-  KXKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
+  Endgames();
+  ~Endgames();
+  template<class T> T* get(Key key) const;
+
+private:
+  template<class T> void add(const std::string& keyCode);
+
+  // Here we store two maps, for evaluate and scaling functions...
+  std::pair<EFMap, SFMap> maps;
+
+  // ...and here is the accessing template function
+  template<typename T> const std::map<Key, T*>& get() const;
 };
 
-// KBN vs K:
-class KBNKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KBNKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KP vs K:
-class KPKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KPKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KP:
-class KRKPEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKPEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KB:
-class KRKBEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKBEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KN:
-class KRKNEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKNEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KQ vs KR:
-class KQKREvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KQKREvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-
-/// Abstract base class for all evaluation scaling functions:
-
-class ScalingFunction {
-public:
-  ScalingFunction(Color c);
-  virtual ~ScalingFunction() { }
-
-  virtual ScaleFactor apply(const Position &pos) =0;
-
-protected:
-  Color strongerSide, weakerSide;
-};
-
-
-/// Subclasses for various concrete endgames:
-
-// KBP vs K:
-class KBPKScalingFunction : public ScalingFunction {
-public:
-  KBPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KQ vs KRP:
-class KQKRPScalingFunction: public ScalingFunction {
-public:
-  KQKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRP vs KR:
-class KRPKRScalingFunction : public ScalingFunction {
-public:
-  KRPKRScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRPP vs KRP:
-class KRPPKRPScalingFunction : public ScalingFunction {
-public:
-  KRPPKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// King and pawns vs king:
-class KPsKScalingFunction : public ScalingFunction {
-public:
-  KPsKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KB:
-class KBPKBScalingFunction : public ScalingFunction {
-public:
-  KBPKBScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KN:
-class KBPKNScalingFunction : public ScalingFunction {
-public:
-  KBPKNScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KNP vs K:
-class KNPKScalingFunction : public ScalingFunction {
-public:
-  KNPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KP vs KP:
-class KPKPScalingFunction : public ScalingFunction {
-public:
-  KPKPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-
-////
-//// Constants and variables
-////
-
-// Generic "mate lone king" eval:
-extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
-
-// KBN vs K:
-extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
-
-// KP vs K:
-extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
-
-// KR vs KP:
-extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
-
-// KR vs KB:
-extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
-
-// KR vs KN:
-extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
-
-// KQ vs KR:
-extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
-
-// KBP vs K:
-extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
-
-// KQ vs KRP:
-extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
-
-// KRP vs KR:
-extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
-
-// KRPP vs KRP:
-extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
-
-// King and pawns vs king:
-extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
-
-// KBP vs KB:
-extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
-
-// KBP vs KN:
-extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
-
-// KNP vs K:
-extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
-
-// KP vs KP:
-extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
-
-
-////
-//// Prototypes
-////
-
-extern void init_bitbases();
-
-
 #endif // !defined(ENDGAME_H_INCLUDED)

src/evaluate.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,93 +17,15 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(EVALUATE_H_INCLUDED)
 #define EVALUATE_H_INCLUDED
 
-////
-//// Includes
-////
+#include "types.h"
 
-#include "material.h"
-#include "pawns.h"
-#include "position.h"
-
-
-////
-//// Types
-////
-
-/// The EvalInfo struct contains various information computed and collected
-/// by the evaluation function.  An EvalInfo object is passed as one of the
-/// arguments to the evaluation function, and the search can make use of its
-/// contents to make intelligent search decisions.
-///
-/// At the moment, this is not utilized very much:  The only part of the
-/// EvalInfo object which is used by the search is futilityMargin.
-
-struct EvalInfo {
-  
-  // Middle game and endgame evaluations:
-  Value mgValue, egValue;
-
-  // Pointers to material and pawn hash table entries:
-  MaterialInfo *mi;
-  PawnInfo *pi;
-
-  // attackedBy[color][piece type] is a bitboard representing all squares
-  // attacked by a given color and piece type.  attackedBy[color][0] contains
-  // all squares attacked by the given color.
-  Bitboard attackedBy[2][8];
-  Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
-  Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
-  // attackZone[color] is the zone around the enemy king which is considered
-  // by the king safety evaluation.  This consists of the squares directly
-  // adjacent to the king, and the three (or two, for a king on an edge file)
-  // squares two ranks in front of the king.  For instance, if black's king
-  // is on g8, attackZone[WHITE] is a bitboard containing the squares f8, h8,
-  // f7, g7, h7, f6, g6 and h6.
-  Bitboard attackZone[2];
-
-  // attackCount[color] is the number of pieces of the given color which
-  // attack a square adjacent to the enemy king.
-  int attackCount[2];
-
-  // attackWeight[color] is the sum of the "weight" of the pieces of the given
-  // color which attack a square adjacent to the enemy king.  The weights of
-  // the individual piece types are given by the variables QueenAttackWeight,
-  // RookAttackWeight, BishopAttackWeight and KnightAttackWeight in
-  // evaluate.cpp.
-  int attackWeight[2];
-
-  // attacked[color] is the number of enemy piece attacks to squares directly
-  // adjacent to the king of the given color.  Pieces which attack more
-  // than one square are counted multiple times.  For instance, if black's
-  // king is on g8 and there's a white knight on g5, this knight adds
-  // 2 to attacked[BLACK].
-  int attacked[2];
-
-  // mateThreat[color] is a move for the given side which gives a direct mate.
-  Move mateThreat[2];
-
-  // Middle game and endgame mobility scores.
-  Value mgMobility, egMobility;
-
-  // Extra futility margin.  This is added to the standard futility margin
-  // in the quiescence search.  
-  Value futilityMargin;
-};
-
-
-////
-//// Prototypes
-////
-
-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);
+class Position;
 
+extern Value evaluate(const Position& pos, Value& margin);
+extern std::string trace_evaluate(const Position& pos);
+extern void read_evaluation_uci_options(Color sideToMove);
 
 #endif // !defined(EVALUATE_H_INCLUDED)

src/history.cpp

@@ -1,100 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-
-#include "history.h"
-
-
-////
-//// Functions
-////
-
-/// Constructor
-
-History::History() {
-  this->clear();
-}
-
-
-/// History::clear() clears the history tables.
-
-void History::clear() {
-  memset(history, 0, 2 * 8 * 64 * sizeof(int));
-  memset(successCount, 0, 2 * 8 * 64 * sizeof(int));
-  memset(failureCount, 0, 2 * 8 * 64 * sizeof(int));
-}
-
-
-/// History::success() registers a move as being successful.  This is done
-/// whenever a non-capturing move causes a beta cutoff in the main search.
-/// The three parameters are the moving piece, the move itself, and the
-/// search depth.
-
-void History::success(Piece p, Move m, Depth d) {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
-
-  history[p][move_to(m)] += int(d) * int(d);
-  successCount[p][move_to(m)]++;
-
-  // Prevent history overflow:
-  if(history[p][move_to(m)] >= HistoryMax)
-    for(int i = 0; i < 16; i++)
-      for(int j = 0; j < 64; j++)
-        history[i][j] /= 2;
-}
-
-
-/// History::failure() registers a move as being unsuccessful.  The function is
-/// called for each non-capturing move which failed to produce a beta cutoff
-/// at a node where a beta cutoff was finally found.
-
-void History::failure(Piece p, Move m) {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
-
-  failureCount[p][move_to(m)]++;
-}
-
-
-/// History::move_ordering_score() returns an integer value used to order the
-/// non-capturing moves in the MovePicker class.
-
-int History::move_ordering_score(Piece p, Move m) const {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
-
-  return history[p][move_to(m)];
-}
-
-
-/// History::ok_to_prune() decides whether a move has been sufficiently
-/// unsuccessful that it makes sense to prune it entirely. 
-
-bool History::ok_to_prune(Piece p, Move m, Depth d) const {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
-
-  return (int(d) * successCount[p][move_to(m)] < failureCount[p][move_to(m)]);
-}

src/history.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,61 +17,54 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(HISTORY_H_INCLUDED)
 #define HISTORY_H_INCLUDED
 
-////
-//// Includes
-////
+#include <cstring>
+#include "types.h"
 
-#include "depth.h"
-#include "move.h"
-#include "piece.h"
-
-
-////
-//// Types
-////
-
-/// The History class stores statistics about how often different moves have
-/// been successful or unsuccessful during the current search.  These
-/// statistics are used for reduction and move ordering decisions.
+/// The History class stores statistics about how often different moves
+/// have been successful or unsuccessful during the current search. These
+/// statistics are used for reduction and move ordering decisions. History
+/// entries are stored according only to moving piece and destination square,
+/// in particular two moves with different origin but same destination and
+/// same piece will be considered identical.
 
 class History {
 
 public:
-  History();
   void clear();
-  void success(Piece p, Move m, Depth d);
-  void failure(Piece p, Move m);
-  int move_ordering_score(Piece p, Move m) const;
-  bool ok_to_prune(Piece p, Move m, Depth d) const;
+  Value value(Piece p, Square to) const;
+  void update(Piece p, Square to, Value bonus);
+  Value gain(Piece p, Square to) const;
+  void update_gain(Piece p, Square to, Value g);
+
+  static const Value MaxValue = Value(2000);
 
 private:
-  int history[16][64];  // [piece][square]
-  int successCount[16][64];
-  int failureCount[16][64];
+  Value history[16][64];  // [piece][to_square]
+  Value maxGains[16][64]; // [piece][to_square]
 };
 
+inline void History::clear() {
+  memset(history,  0, 16 * 64 * sizeof(Value));
+  memset(maxGains, 0, 16 * 64 * sizeof(Value));
+}
 
-////
-//// Constants and variables
-////
+inline Value History::value(Piece p, Square to) const {
+  return history[p][to];
+}
 
-/// HistoryMax controls how often the history counters will be scaled down:
-/// When the history score for a move gets bigger than HistoryMax, all
-/// entries in the table are divided by 2.  It is difficult to guess what
-/// the ideal value of this constant is.  Scaling down the scores often has
-/// the effect that parts of the search tree which have been searched
-/// recently have a bigger importance for move ordering than the moves which
-/// have been searched a long time ago.
-///
-/// Note that HistoryMax should probably be changed whenever the constant
-/// OnePly in depth.h is changed.  This is somewhat annoying.  Perhaps it
-/// would be better to scale down the history table at regular intervals?
+inline void History::update(Piece p, Square to, Value bonus) {
+  if (abs(history[p][to] + bonus) < MaxValue) history[p][to] += bonus;
+}
 
-const int HistoryMax = 50000;
+inline Value History::gain(Piece p, Square to) const {
+  return maxGains[p][to];
+}
 
+inline void History::update_gain(Piece p, Square to, Value g) {
+  maxGains[p][to] = Max(g, maxGains[p][to] - 1);
+}
 
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,86 +17,63 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(LOCK_H_INCLUDED)
 #define LOCK_H_INCLUDED
 
-
-// x86 assembly language locks or OS spin locks may perform faster than
-// mutex locks on some platforms.  On my machine, mutexes seem to be the
-// best.
-
-//#define ASM_LOCK
-//#define OS_SPIN_LOCK
-
-
-#if defined(ASM_LOCK)
-
-
-typedef volatile int Lock;
-
-static inline void LockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("1:          movl    $1, %0" "\n\t"
-      "            xchgl   (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jz      3f" "\n\t" "2:          pause" "\n\t"
-      "            movl    (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jnz     2b" "\n\t" "            jmp     1b" "\n\t" "3:"
-      "\n\t":"=&q"(dummy)
-      :"q"(lock)
-      :"cc");
-}
-
-static inline void UnlockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("movl    $0, (%1)":"=&q"(dummy)
-      :"q"(lock));
-}
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) LockX86(x)
-#  define lock_release(x) UnlockX86(x)
-#  define lock_destroy(x)
-
-
-#elif defined(OS_SPIN_LOCK)
-
-
-#  include <libkern/OSAtomic.h>
-
-typedef OSSpinLock Lock;
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) OSSpinLockLock(x)
-#  define lock_release(x) OSSpinLockUnlock(x)
-#  define lock_destroy(x)
-
-
-#elif !defined(_MSC_VER)
+#if !defined(_MSC_VER)
 
 #  include <pthread.h>
 
 typedef pthread_mutex_t Lock;
+typedef pthread_cond_t WaitCondition;
 
-#  define lock_init(x, y) pthread_mutex_init(x, y)
+#  define lock_init(x) pthread_mutex_init(x, NULL)
 #  define lock_grab(x) pthread_mutex_lock(x)
 #  define lock_release(x) pthread_mutex_unlock(x)
 #  define lock_destroy(x) pthread_mutex_destroy(x)
-
+#  define cond_destroy(x) pthread_cond_destroy(x)
+#  define cond_init(x) pthread_cond_init(x, NULL)
+#  define cond_signal(x) pthread_cond_signal(x)
+#  define cond_wait(x,y) pthread_cond_wait(x,y)
 
 #else
 
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
 
-#  include <windows.h>
+// Default fast and race free locks and condition variables
+#if !defined(OLD_LOCKS)
+
+typedef SRWLOCK Lock;
+typedef CONDITION_VARIABLE WaitCondition;
+
+#  define lock_init(x) InitializeSRWLock(x)
+#  define lock_grab(x) AcquireSRWLockExclusive(x)
+#  define lock_release(x) ReleaseSRWLockExclusive(x)
+#  define lock_destroy(x) (x)
+#  define cond_destroy(x) (x)
+#  define cond_init(x) InitializeConditionVariable(x)
+#  define cond_signal(x) WakeConditionVariable(x)
+#  define cond_wait(x,y) SleepConditionVariableSRW(x, y, INFINITE,0)
+
+// Fallback solution to build for Windows XP and older versions, note that
+// cond_wait() is racy between lock_release() and WaitForSingleObject().
+#else
 
 typedef CRITICAL_SECTION Lock;
-#  define lock_init(x, y) InitializeCriticalSection(x)
+typedef HANDLE WaitCondition;
+
+#  define lock_init(x) InitializeCriticalSection(x)
 #  define lock_grab(x) EnterCriticalSection(x)
 #  define lock_release(x) LeaveCriticalSection(x)
 #  define lock_destroy(x) DeleteCriticalSection(x)
-
+#  define cond_init(x) { *x = CreateEvent(0, FALSE, FALSE, 0); }
+#  define cond_destroy(x) CloseHandle(*x)
+#  define cond_signal(x) SetEvent(*x)
+#  define cond_wait(x,y) { lock_release(y); WaitForSingleObject(*x, INFINITE); lock_grab(y); }
+#endif
 
 #endif
 
-
 #endif // !defined(LOCK_H_INCLUDED)

src/main.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,80 +17,71 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+// To profile with callgrind uncomment following line
+//#define USE_CALLGRIND
 
-////
-//// Includes
-////
-
-#include <cstdlib>
+#include <cstdio>
 #include <iostream>
+#include <string>
 
-#include "benchmark.h"
 #include "bitboard.h"
-#include "direction.h"
-#include "endgame.h"
 #include "evaluate.h"
-#include "material.h"
-#include "mersenne.h"
-#include "misc.h"
-#include "movepick.h"
 #include "position.h"
-#include "search.h"
 #include "thread.h"
-#include "uci.h"
+#include "search.h"
 #include "ucioption.h"
 
+#ifdef USE_CALLGRIND
+#include <valgrind/callgrind.h>
+#endif
 
-//// 
-//// Functions
-////
+using namespace std;
 
-int main(int argc, char *argv[]) {
+extern bool execute_uci_command(const string& cmd);
+extern void benchmark(int argc, char* argv[]);
+extern void init_kpk_bitbase();
 
-  // Disable IO buffering
-  setbuf(stdin, NULL);
-  setbuf(stdout, NULL);
-  std::cout.rdbuf()->pubsetbuf(NULL, 0);
-  std::cin.rdbuf()->pubsetbuf(NULL, 0);
+int main(int argc, char* argv[]) {
 
-  // Initialization
+  // Disable IO buffering for C and C++ standard libraries
+  setvbuf(stdin, NULL, _IONBF, 0);
+  setvbuf(stdout, NULL, _IONBF, 0);
+  cout.rdbuf()->pubsetbuf(NULL, 0);
+  cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  init_mersenne();
-  init_direction_table();
+  // Startup initializations
   init_bitboards();
-  init_uci_options();
   Position::init_zobrist();
   Position::init_piece_square_tables();
-  MaterialInfo::init();
-  MovePicker::init_phase_table();
-  init_eval(1);
-  init_bitbases();
-  init_threads();
+  init_kpk_bitbase();
+  init_search();
+  Threads.init();
 
-  // Make random number generation less deterministic, for book moves
-  int i = abs(get_system_time() % 10000);
-  for(int j = 0; j < i; j++)
-    genrand_int32();
+#ifdef USE_CALLGRIND
+  CALLGRIND_START_INSTRUMENTATION;
+#endif
 
-  // Process command line arguments
-  if(argc >= 2) {
-    if(std::string(argv[1]) == "bench") {
-      if(argc != 4) {
-        std::cout << "Usage: glaurung bench <hash> <threads>" << std::endl;
-        exit(0);
-      }
-      benchmark(std::string(argv[2]), std::string(argv[3]));
-      return 0;
-    }
+  if (argc < 2)
+  {
+      // Print copyright notice
+      cout << engine_name() << " by " << engine_authors() << endl;
+
+      if (CpuHasPOPCNT)
+          cout << "Good! CPU has hardware POPCNT." << endl;
+
+      // Wait for a command from the user, and passes this command to
+      // execute_uci_command() and also intercepts EOF from stdin to
+      // ensure that we exit gracefully if the GUI dies unexpectedly.
+      string cmd;
+      while (getline(cin, cmd) && execute_uci_command(cmd)) {}
   }
+  else if (string(argv[1]) == "bench" && argc < 8)
+      benchmark(argc, argv);
+  else
+      cout << "Usage: stockfish bench [hash size = 128] [threads = 1] "
+           << "[limit = 12] [fen positions file = default] "
+           << "[limited by depth, time, nodes or perft = depth]" << endl;
 
-  // Print copyright notice
-  std::cout << engine_name() << ".  "
-            << "Copyright (C) 2004-2008 Tord Romstad."
-            << std::endl;
-
-  // Enter UCI mode
-  uci_main_loop();
-
+  Threads.exit();
   return 0;
 }

src/material.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,164 +17,76 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
+#include <cstring>
 
 #include "material.h"
 
-
-////
-//// Local definitions
-////
+using namespace std;
 
 namespace {
 
-  const Value BishopPairMidgameBonus = Value(100);
-  const Value BishopPairEndgameBonus = Value(100);
+  // Values modified by Joona Kiiski
+  const Value MidgameLimit = Value(15581);
+  const Value EndgameLimit = Value(3998);
 
-  Key KPKMaterialKey, KKPMaterialKey;
-  Key KBNKMaterialKey, KKBNMaterialKey;
-  Key KRKPMaterialKey, KPKRMaterialKey;
-  Key KRKBMaterialKey, KBKRMaterialKey;
-  Key KRKNMaterialKey, KNKRMaterialKey;
-  Key KQKRMaterialKey, KRKQMaterialKey;
-  Key KRPKRMaterialKey, KRKRPMaterialKey;
-  Key KRPPKRPMaterialKey, KRPKRPPMaterialKey;
-  Key KNNKMaterialKey, KKNNMaterialKey;
-  Key KBPKBMaterialKey, KBKBPMaterialKey;
-  Key KBPKNMaterialKey, KNKBPMaterialKey;
-  Key KNPKMaterialKey, KKNPMaterialKey;
-  Key KPKPMaterialKey;
+  // Scale factors used when one side has no more pawns
+  const int NoPawnsSF[4] = { 6, 12, 32 };
 
-};
+  // Polynomial material balance parameters
+  const Value RedundantQueenPenalty = Value(320);
+  const Value RedundantRookPenalty  = Value(554);
 
+  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
 
-////
-//// Functions
-////
+  const int QuadraticCoefficientsSameColor[][8] = {
+  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
+  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
 
-/// MaterialInfo::init() is called during program initialization.  It 
-/// precomputes material hash keys for a few basic endgames, in order
-/// to make it easy to recognize such endgames when they occur.
+  const int QuadraticCoefficientsOppositeColor[][8] = {
+  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
+  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
 
-void MaterialInfo::init() {
-  KPKMaterialKey = Position::zobMaterial[WHITE][PAWN][1];
-  KKPMaterialKey = Position::zobMaterial[BLACK][PAWN][1];
-  KBNKMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][1];
-  KKBNMaterialKey =
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KRKPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKRMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKBMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKRMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKNMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKRMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KQKRMaterialKey =
-    Position::zobMaterial[WHITE][QUEEN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKQMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][QUEEN][1];
-  KRPKRMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPPKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[WHITE][PAWN][2] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPKRPPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][2];
-  KNNKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][2];
-  KKNNMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][2];
-  KBPKBMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKBPMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KBPKNMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKBPMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KNPKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][PAWN][1];
-  KKNPMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKPMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-}
+  // Endgame evaluation and scaling functions accessed direcly and not through
+  // the function maps because correspond to more then one material hash key.
+  Endgame<Value, KmmKm> EvaluateKmmKm[] = { Endgame<Value, KmmKm>(WHITE), Endgame<Value, KmmKm>(BLACK) };
+  Endgame<Value, KXK>   EvaluateKXK[]   = { Endgame<Value, KXK>(WHITE),   Endgame<Value, KXK>(BLACK) };
 
+  Endgame<ScaleFactor, KBPsK>  ScaleKBPsK[]  = { Endgame<ScaleFactor, KBPsK>(WHITE),  Endgame<ScaleFactor, KBPsK>(BLACK) };
+  Endgame<ScaleFactor, KQKRPs> ScaleKQKRPs[] = { Endgame<ScaleFactor, KQKRPs>(WHITE), Endgame<ScaleFactor, KQKRPs>(BLACK) };
+  Endgame<ScaleFactor, KPsK>   ScaleKPsK[]   = { Endgame<ScaleFactor, KPsK>(WHITE),   Endgame<ScaleFactor, KPsK>(BLACK) };
+  Endgame<ScaleFactor, KPKP>   ScaleKPKP[]   = { Endgame<ScaleFactor, KPKP>(WHITE),   Endgame<ScaleFactor, KPKP>(BLACK) };
 
-/// Constructor for the MaterialInfoTable class.
-
-MaterialInfoTable::MaterialInfoTable(unsigned numOfEntries) {
-  size = numOfEntries;
-  entries = new MaterialInfo[size];
-  if(entries == NULL) {
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
-              << " bytes for material hash table." << std::endl;
-    exit(EXIT_FAILURE);
+  // Helper templates used to detect a given material distribution
+  template<Color Us> bool is_KXK(const Position& pos) {
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return   pos.non_pawn_material(Them) == VALUE_ZERO
+          && pos.piece_count(Them, PAWN) == 0
+          && pos.non_pawn_material(Us)   >= RookValueMidgame;
   }
-  this->clear();
-}
+
+  template<Color Us> bool is_KBPsKs(const Position& pos) {
+    return   pos.non_pawn_material(Us)   == BishopValueMidgame
+          && pos.piece_count(Us, BISHOP) == 1
+          && pos.piece_count(Us, PAWN)   >= 1;
+  }
+
+  template<Color Us> bool is_KQKRPs(const Position& pos) {
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return   pos.piece_count(Us, PAWN)    == 0
+          && pos.non_pawn_material(Us)    == QueenValueMidgame
+          && pos.piece_count(Us, QUEEN)   == 1
+          && pos.piece_count(Them, ROOK)  == 1
+          && pos.piece_count(Them, PAWN)  >= 1;
+  }
+
+} // namespace
 
 
-/// Destructor for the MaterialInfoTable class.
+/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
 
-MaterialInfoTable::~MaterialInfoTable() {
-  delete [] entries;
-}
-
-
-/// MaterialInfoTable::clear() clears a material hash table by setting
-/// all entries to 0.
-
-void MaterialInfoTable::clear() {
-  memset(entries, 0, size * sizeof(MaterialInfo));
-}
+void MaterialInfoTable::init() { Base::init(); if (!funcs) funcs = new Endgames(); }
+MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
 
 
 /// MaterialInfoTable::get_material_info() takes a position object as input,
@@ -182,225 +95,191 @@ void MaterialInfoTable::clear() {
 /// is stored there, so we don't have to recompute everything when the
 /// same material configuration occurs again.
 
-MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
+MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
+
   Key key = pos.get_material_key();
-  int index = key & (size - 1);
-  MaterialInfo *mi = entries + index;
+  MaterialInfo* mi = probe(key);
 
   // If mi->key matches the position's material hash key, it means that we
   // have analysed this material configuration before, and we can simply
-  // return the information we found the last time instead of recomputing it:
-  if(mi->key == key)
-    return mi;
+  // return the information we found the last time instead of recomputing it.
+  if (mi->key == key)
+      return mi;
 
-  // Clear the MaterialInfo object, and set its key:
-  mi->clear();
+  // Initialize MaterialInfo entry
+  memset(mi, 0, sizeof(MaterialInfo));
   mi->key = key;
+  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
 
-  // A special case before looking for a specialized evaluation function:
-  // KNN vs K is a draw:
-  if(key == KNNKMaterialKey || key == KKNNMaterialKey) {
-    mi->factor[WHITE] = mi->factor[BLACK] = 0;
-    return mi;
-  }
+  // Store game phase
+  mi->gamePhase = MaterialInfoTable::game_phase(pos);
 
   // Let's look if we have a specialized evaluation function for this
-  // particular material configuration:
-  if(key == KPKMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPK;
-    return mi;
+  // particular material configuration. First we look for a fixed
+  // configuration one, then a generic one if previous search failed.
+  if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
+      return mi;
+
+  if (is_KXK<WHITE>(pos))
+  {
+      mi->evaluationFunction = &EvaluateKXK[WHITE];
+      return mi;
   }
-  else if(key == KKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKP;
-    return mi;
+
+  if (is_KXK<BLACK>(pos))
+  {
+      mi->evaluationFunction = &EvaluateKXK[BLACK];
+      return mi;
   }
-  else if(key == KBNKMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBNK;
-    return mi;
-  }
-  else if(key == KKBNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKBN;
-    return mi;
-  }
-  else if(key == KRKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKP;
-    return mi;
-  }
-  else if(key == KPKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPKR;
-    return mi;
-  }
-  else if(key == KRKBMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKB;
-    return mi;
-  }
-  else if(key == KBKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBKR;
-    return mi;
-  }
-  else if(key == KRKNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKN;
-    return mi;
-  }
-  else if(key == KNKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKNKR;
-    return mi;
-  }
-  else if(key == KQKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKQKR;
-    return mi;
-  }
-  else if(key == KRKQMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKQ;
-    return mi;
-  }
-  else if(pos.non_pawn_material(BLACK) == Value(0) &&
-          pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(WHITE) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKXK;
-    return mi;
-  }
-  else if(pos.non_pawn_material(WHITE) == Value(0) &&
-          pos.pawn_count(WHITE) == 0 &&
-          pos.non_pawn_material(BLACK) >= RookValueEndgame) {
-    mi->evaluationFunction = &EvaluateKKX;
-    return mi;
+
+  if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN))
+  {
+      // Minor piece endgame with at least one minor piece per side and
+      // no pawns. Note that the case KmmK is already handled by KXK.
+      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
+      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
+
+      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      {
+          mi->evaluationFunction = &EvaluateKmmKm[WHITE];
+          return mi;
+      }
   }
 
   // OK, we didn't find any special evaluation function for the current
-  // material configuration.  Is there a suitable scaling function?
+  // material configuration. Is there a suitable scaling function?
   //
-  // The code below is rather messy, and it could easily get worse later,
-  // if we decide to add more special cases.  We face problems when there
-  // are several conflicting applicable scaling functions and we need to
-  // decide which one to use.
+  // We face problems when there are several conflicting applicable
+  // scaling functions and we need to decide which one to use.
+  EndgameBase<ScaleFactor>* sf;
 
-  if(key == KRPKRMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPKR;
-    return mi;
-  }
-  if(key == KRKRPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRKRP;
-    return mi;
-  }
-  if(key == KRPPKRPMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPPKRP;
-    return mi;
-  }
-  else if(key == KRPKRPPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRPKRPP;
-    return mi;
-  }
-  if(key == KBPKBMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKB;
-    return mi;
-  }
-  if(key == KBKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKBKBP;
-    return mi;
-  }
-  if(key == KBPKNMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKN;
-    return mi;
-  }
-  if(key == KNKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKNKBP;
-    return mi;
-  }
-  if(key == KNPKMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKNPK;
-    return mi;
-  }
-  if(key == KKNPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKKNP;
-    return mi;
+  if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
+  {
+      mi->scalingFunction[sf->color()] = sf;
+      return mi;
   }
 
-  if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
-     pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKBPK;
-  if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
-     pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKKBP;
+  // Generic scaling functions that refer to more then one material
+  // distribution. Should be probed after the specialized ones.
+  // Note that these ones don't return after setting the function.
+  if (is_KBPsKs<WHITE>(pos))
+      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
 
-  if(pos.pawn_count(WHITE) == 0 &&
-     pos.non_pawn_material(WHITE) == QueenValueMidgame &&
-     pos.queen_count(WHITE) == 1 &&
-     pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
-    mi->scalingFunction[WHITE] = &ScaleKQKRP;
-  else if(pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(BLACK) == QueenValueMidgame &&
-          pos.queen_count(BLACK) == 1 &&
-          pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKRPKQ;
+  if (is_KBPsKs<BLACK>(pos))
+      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
 
-  if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
-    if(pos.pawn_count(BLACK) == 0) {
-      assert(pos.pawn_count(WHITE) >= 2);
-      mi->scalingFunction[WHITE] = &ScaleKPsK;
-    }
-    else if(pos.pawn_count(WHITE) == 0) {
-      assert(pos.pawn_count(BLACK) >= 2);
-      mi->scalingFunction[BLACK] = &ScaleKKPs;
-    }
-    else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
-      mi->scalingFunction[WHITE] = &ScaleKPKPw;
-      mi->scalingFunction[BLACK] = &ScaleKPKPb;
-    }
-  }
+  if (is_KQKRPs<WHITE>(pos))
+      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
 
-  // Evaluate the material balance.
+  else if (is_KQKRPs<BLACK>(pos))
+      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
 
-  Color c;
-  int sign;
-  Value egValue = Value(0), mgValue = Value(0);
+  Value npm_w = pos.non_pawn_material(WHITE);
+  Value npm_b = pos.non_pawn_material(BLACK);
 
-  for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
-
-    // No pawns makes it difficult to win, even with a material advantage:
-    if(pos.pawn_count(c) == 0 &&
-       pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
-       <= BishopValueMidgame) {
-      if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
-        mi->factor[c] = 0;
-      else if(pos.non_pawn_material(c) < RookValueMidgame)
-        mi->factor[c] = 0;
-      else {
-        switch(pos.bishop_count(c)) {
-        case 2:
-          mi->factor[c] = 32; break;
-        case 1:
-          mi->factor[c] = 12; break;
-        case 0:
-          mi->factor[c] = 6; break;
-        }
+  if (npm_w + npm_b == VALUE_ZERO)
+  {
+      if (pos.piece_count(BLACK, PAWN) == 0)
+      {
+          assert(pos.piece_count(WHITE, PAWN) >= 2);
+          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+      }
+      else if (pos.piece_count(WHITE, PAWN) == 0)
+      {
+          assert(pos.piece_count(BLACK, PAWN) >= 2);
+          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+      }
+      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      {
+          // This is a special case because we set scaling functions
+          // for both colors instead of only one.
+          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
-    }
-    
-    // Bishop pair:
-    if(pos.bishop_count(c) >= 2) {
-      mgValue += sign * BishopPairMidgameBonus;
-      egValue += sign * BishopPairEndgameBonus;
-    }
-
-    // Knights are stronger when there are many pawns on the board.  The 
-    // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess": 
-    // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
-    egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
-
-    // Redundancy of major pieces, again based on Kaufman's paper:
-    if(pos.rook_count(c) >= 1) {
-      Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
-      mgValue -= sign * v;
-      egValue -= sign * v;
-    }
-      
   }
 
-  mi->mgValue = int16_t(mgValue);
-  mi->egValue = int16_t(egValue);
+  // No pawns makes it difficult to win, even with a material advantage
+  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMidgame)
+  {
+      mi->factor[WHITE] = uint8_t
+      (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(WHITE, BISHOP), 2)]);
+  }
 
+  if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMidgame)
+  {
+      mi->factor[BLACK] = uint8_t
+      (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(BLACK, BISHOP), 2)]);
+  }
+
+  // Compute the space weight
+  if (npm_w + npm_b >= 2 * QueenValueMidgame + 4 * RookValueMidgame + 2 * KnightValueMidgame)
+  {
+      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
+                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+
+      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  }
+
+  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
+  // for the bishop pair "extended piece", this allow us to be more flexible
+  // in defining bishop pair bonuses.
+  const int pieceCount[2][8] = {
+  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
+    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
+  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
+    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+
+  mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
   return mi;
 }
+
+
+/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
+/// piece type for both colors.
+
+template<Color Us>
+int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
+
+  const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+  int pt1, pt2, pc, v;
+  int value = 0;
+
+  // Redundancy of major pieces, formula based on Kaufman's paper
+  // "The Evaluation of Material Imbalances in Chess"
+  if (pieceCount[Us][ROOK] > 0)
+      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
+              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
+
+  // Second-degree polynomial material imbalance by Tord Romstad
+  for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
+  {
+      pc = pieceCount[Us][pt1];
+      if (!pc)
+          continue;
+
+      v = LinearCoefficients[pt1];
+
+      for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
+          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+
+      value += pc * v;
+  }
+  return value;
+}
+
+
+/// MaterialInfoTable::game_phase() calculates the phase given the current
+/// 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);
+
+  return  npm >= MidgameLimit ? PHASE_MIDGAME
+        : npm <= EndgameLimit ? PHASE_ENDGAME
+        : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
+}

src/material.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,25 +17,18 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MATERIAL_H_INCLUDED)
 #define MATERIAL_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "endgame.h"
 #include "position.h"
-#include "scale.h"
+#include "tt.h"
+#include "types.h"
 
-
-////
-//// Types
-////
+const int MaterialTableSize = 8192;
 
 /// MaterialInfo is a class which contains various information about a
-/// material configuration.  It contains a material balance evaluation,
+/// material configuration. It contains a material balance evaluation,
 /// a function pointer to a special endgame evaluation function (which in
 /// most cases is NULL, meaning that the standard evaluation function will
 /// be used), and "scale factors" for black and white.
@@ -48,105 +42,76 @@ class MaterialInfo {
   friend class MaterialInfoTable;
 
 public:
-  Value mg_value() const;
-  Value eg_value() const;
-  ScaleFactor scale_factor(const Position &pos, Color c) 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;
-
-  static void init();
+  Value evaluate(const Position& pos) const;
 
 private:
-  void clear();
-  
   Key key;
-  int16_t mgValue;
-  int16_t egValue;
+  int16_t value;
   uint8_t factor[2];
-  EndgameEvaluationFunction *evaluationFunction;
-  ScalingFunction *scalingFunction[2];
+  EndgameBase<Value>* evaluationFunction;
+  EndgameBase<ScaleFactor>* scalingFunction[2];
+  int spaceWeight;
+  Phase gamePhase;
 };
 
 
-/// The MaterialInfoTable class represents a pawn hash table.  It is basically
-/// just an array of MaterialInfo objects and a few methods for accessing these
-/// objects.  The most important method is get_material_info, which looks up a
-/// position in the table and returns a pointer to a MaterialInfo object.
-
-class MaterialInfoTable {
+/// The MaterialInfoTable class represents a pawn hash table. The most important
+/// method is get_material_info, which returns a pointer to a MaterialInfo object.
 
+class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
 public:
-  MaterialInfoTable(unsigned numOfEntries);
   ~MaterialInfoTable();
-  void clear();
-  MaterialInfo *get_material_info(const Position &pos);
+  void init();
+  MaterialInfo* get_material_info(const Position& pos) const;
+  static Phase game_phase(const Position& pos);
 
 private:
-  unsigned size;
-  MaterialInfo *entries;
+  template<Color Us>
+  static int imbalance(const int pieceCount[][8]);
+
+  Endgames* funcs;
 };
 
 
-////
-//// Inline functions
-////
-
-/// MaterialInfo::mg_value and MaterialInfo::eg_value simply returns the
-/// material balance evaluation for the middle game and the endgame.
-
-inline Value MaterialInfo::mg_value() const {
-  return Value(mgValue);
-}
-
-inline Value MaterialInfo::eg_value() const {
-  return Value(egValue);
-}
-
-
-/// MaterialInfo::clear() resets a MaterialInfo object to an empty state,
-/// with all slots at their default values.
-
-inline void MaterialInfo::clear() {
-  mgValue = egValue = 0;
-  factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
-  evaluationFunction = NULL;
-  scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
-}
-
-
 /// MaterialInfo::scale_factor takes a position and a color as input, and
-/// returns a scale factor for the given color.  We have to provide the
+/// returns a scale factor for the given color. We have to provide the
 /// position in addition to the color, because the scale factor need not
-/// be a constant:  It can also be a function which should be applied to
-/// the position.  For instance, in KBP vs K endgames, a scaling function
+/// to be a constant: It can also be a function which should be applied to
+/// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.
 
-inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
-  const {
-  if(scalingFunction[c] != NULL) {
-    ScaleFactor sf = scalingFunction[c]->apply(pos);
-    if(sf != SCALE_FACTOR_NONE)
-      return sf;
-  }
-  return ScaleFactor(factor[c]);
+inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
+
+  if (!scalingFunction[c])
+      return ScaleFactor(factor[c]);
+
+  ScaleFactor sf = scalingFunction[c]->apply(pos);
+  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
 }
 
+inline Value MaterialInfo::evaluate(const Position& pos) const {
+  return evaluationFunction->apply(pos);
+}
 
-/// MaterialInfo::specialized_eval_exists decides whether there is a
-/// specialized evaluation function for the current material configuration,
-/// or if the normal evaluation function should be used.
+inline Score MaterialInfo::material_value() const {
+  return make_score(value, value);
+}
+
+inline int MaterialInfo::space_weight() const {
+  return spaceWeight;
+}
+
+inline Phase MaterialInfo::game_phase() const {
+  return gamePhase;
+}
 
 inline bool MaterialInfo::specialized_eval_exists() const {
   return evaluationFunction != NULL;
 }
 
-
-/// MaterialInfo::evaluate applies a specialized evaluation function to a
-/// given position object.  It should only be called when
-/// this->specialized_eval_exists() returns 'true'.
-
-inline Value MaterialInfo::evaluate(const Position &pos) const {
-  return evaluationFunction->apply(pos);
-}
-
 #endif // !defined(MATERIAL_H_INCLUDED)

src/mersenne.cpp

@@ -1,148 +0,0 @@
-/* 
-   A C-program for MT19937, with initialization improved 2002/1/26.
-   Coded by Takuji Nishimura and Makoto Matsumoto.
-
-   Before using, initialize the state by using init_genrand(seed)  
-   or init_by_array(init_key, key_length).
-
-   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
-   All rights reserved.                          
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-     1. Redistributions of source code must retain the above copyright
-        notice, this list of conditions and the following disclaimer.
-
-     2. Redistributions in binary form must reproduce the above copyright
-        notice, this list of conditions and the following disclaimer in the
-        documentation and/or other materials provided with the distribution.
-
-     3. The names of its contributors may not be used to endorse or promote 
-        products derived from this software without specific prior written 
-        permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-   Any feedback is very welcome.
-   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
-   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
-*/
-
-#include "types.h"
-
-/* Period parameters */  
-#define N 624
-#define M 397
-#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
-#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
-#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
-
-static unsigned long mt[N]; /* the array for the state vector  */
-static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
-
-/* initializes mt[N] with a seed */
-void init_genrand(unsigned long s)
-{
-    mt[0]= s & 0xffffffffUL;
-    for (mti=1; mti<N; mti++) {
-        mt[mti] = 
-            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
-        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
-        /* In the previous versions, MSBs of the seed affect   */
-        /* only MSBs of the array mt[].                        */
-        /* 2002/01/09 modified by Makoto Matsumoto             */
-        mt[mti] &= 0xffffffffUL;
-        /* for >32 bit machines */
-    }
-}
-
-/* initialize by an array with array-length */
-/* init_key is the array for initializing keys */
-/* key_length is its length */
-/* slight change for C++, 2004/2/26 */
-void init_by_array(unsigned long init_key[], int key_length)
-{
-    int i, j, k;
-    init_genrand(19650218UL);
-    i=1; j=0;
-    k = (N>key_length ? N : key_length);
-    for (; k; k--) {
-        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
-          + init_key[j] + j; /* non linear */
-        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
-        i++; j++;
-        if (i>=N) { mt[0] = mt[N-1]; i=1; }
-        if (j>=key_length) j=0;
-    }
-    for (k=N-1; k; k--) {
-        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
-          - i; /* non linear */
-        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
-        i++;
-        if (i>=N) { mt[0] = mt[N-1]; i=1; }
-    }
-
-    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
-}
-
-/* generates a random number on [0,0xffffffff]-interval */
-uint32_t genrand_int32(void) {
-  unsigned long y;
-  static unsigned long mag01[2]={0x0UL, MATRIX_A};
-  /* mag01[x] = x * MATRIX_A  for x=0,1 */
-
-  if (mti >= N) { /* generate N words at one time */
-    int kk;
-
-    if (mti == N+1)   /* if init_genrand() has not been called, */
-      init_genrand(5489UL); /* a default initial seed is used */
-
-    for (kk=0;kk<N-M;kk++) {
-      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
-      mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1UL];
-    }
-    for (;kk<N-1;kk++) {
-      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
-      mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
-    }
-    y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
-    mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
-
-    mti = 0;
-  }
-  
-  y = mt[mti++];
-
-  /* Tempering */
-  y ^= (y >> 11);
-  y ^= (y << 7) & 0x9d2c5680UL;
-  y ^= (y << 15) & 0xefc60000UL;
-  y ^= (y >> 18);
-
-  return y;
-}
-
-uint64_t genrand_int64(void) {
-  uint64_t x, y;
-
-  x = genrand_int32(); y = genrand_int32();
-  return (x<<32)|y;
-}
-
-void init_mersenne(void) {
-  unsigned long init[4]={0x123, 0x234, 0x345, 0x456}, length=4;
-  init_by_array(init, length);
-}

src/mersenne.h

@@ -1,39 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(MERSENNE_H_INCLUDED)
-#define MERSENNE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "types.h"
-
-
-////
-//// Prototypes
-////
-
-extern uint32_t genrand_int32(void);
-extern uint64_t genrand_int64(void);
-extern void init_mersenne(void);
-
-
-#endif // !defined(MERSENNE_H_INCLUDED)

src/misc.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,115 +17,174 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #if !defined(_MSC_VER)
 
 #  include <sys/time.h>
 #  include <sys/types.h>
 #  include <unistd.h>
-
-#else
-
-#  include <windows.h>
-#  include <time.h>
-#  include "dos.h"
-int gettimeofday(struct timeval * tp, struct timezone * tzp);
-
-#endif
-
-#include <cstdio>
-#include <iomanip>
-#include <sstream>
-
-#include "misc.h"
-
-
-//// 
-//// Functions
-////
-
-/// engine_name() returns the full name of the current Glaurung version.
-/// This will be either "Glaurung YYMMDD" (where YYMMDD is the date when the
-/// program was compiled) or "Glaurung <version number>", depending on whether
-/// the constant EngineVersion (defined in misc.h) is empty.
-
-const std::string engine_name() {
-  if(EngineVersion == "") {
-    static const char monthNames[12][4] = {
-      "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
-    };
-    const char *dateString = __DATE__;
-    std::stringstream s;
-    int month = 0, day = 0;
-    
-    for(int i = 0; i < 12; i++)
-      if(strncmp(dateString, monthNames[i], 3) == 0)
-        month = i + 1;
-    day = atoi(dateString+4);
-    
-    s << "Glaurung " << (dateString+9) << std::setfill('0') << std::setw(2)
-      << month << std::setfill('0') << std::setw(2) << day;
-    
-    return s.str();
-  }
-  else
-    return "Glaurung " + EngineVersion;
-}
-
-
-/// get_system_time() returns the current system time, measured in
-/// milliseconds.
-
-int get_system_time() {
-  struct timeval t;
-  gettimeofday(&t, NULL);
-  return t.tv_sec*1000 + t.tv_usec/1000; 
-}
-
-
-/// cpu_count() tries to detect the number of CPU cores.
-
-#if !defined(_MSC_VER)
-
-#  if defined(_SC_NPROCESSORS_ONLN)
-int cpu_count() {
-  return Min(sysconf(_SC_NPROCESSORS_ONLN), 8);
-}
-#  else
-int cpu_count() {
-  return 1;
-}
+#  if defined(__hpux)
+#     include <sys/pstat.h>
 #  endif
 
 #else
 
-int cpu_count() {
-  SYSTEM_INFO s;
-  GetSystemInfo(&s);
-  return Min(s.dwNumberOfProcessors, 8);
-}
+#define _CRT_SECURE_NO_DEPRECATE
+#include <windows.h>
+#include <sys/timeb.h>
 
 #endif
 
+#if !defined(NO_PREFETCH)
+#  include <xmmintrin.h>
+#endif
+
+#include <cassert>
+#include <cstdio>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#include "bitcount.h"
+#include "misc.h"
+#include "thread.h"
+
+using namespace std;
+
+/// Version number. If EngineVersion is left empty, then AppTag plus
+/// current date (in the format YYMMDD) is used as a version number.
+
+static const string AppName = "Stockfish";
+static const string EngineVersion = "2.1";
+static const string AppTag  = "";
+
+
+/// engine_name() returns the full name of the current Stockfish version.
+/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when
+/// the program was compiled) or "Stockfish <version number>", depending
+/// on whether the constant EngineVersion is empty.
+
+const string engine_name() {
+
+  const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+  const string cpu64(CpuIs64Bit ? " 64bit" : "");
+
+  if (!EngineVersion.empty())
+      return AppName + " " + EngineVersion + cpu64;
+
+  stringstream s, date(__DATE__); // From compiler, format is "Sep 21 2008"
+  string month, day, year;
+
+  date >> month >> day >> year;
+
+  s << setfill('0') << AppName + " " + AppTag + " "
+    << year.substr(2, 2) << setw(2)
+    << (1 + months.find(month) / 4) << setw(2)
+    << day << cpu64;
+
+  return s.str();
+}
+
+
+/// Our brave developers! Required by UCI
+
+const string engine_authors() {
+
+  return "Tord Romstad, Marco Costalba and Joona Kiiski";
+}
+
+
+/// Debug stuff. Helper functions used mainly for debugging purposes
+
+static uint64_t dbg_hit_cnt0;
+static uint64_t dbg_hit_cnt1;
+static uint64_t dbg_mean_cnt0;
+static uint64_t dbg_mean_cnt1;
+
+void dbg_print_hit_rate() {
+
+  if (dbg_hit_cnt0)
+      cout << "Total " << dbg_hit_cnt0 << " Hit " << dbg_hit_cnt1
+           << " hit rate (%) " << 100 * dbg_hit_cnt1 / dbg_hit_cnt0 << endl;
+}
+
+void dbg_print_mean() {
+
+  if (dbg_mean_cnt0)
+      cout << "Total " << dbg_mean_cnt0 << " Mean "
+           << (float)dbg_mean_cnt1 / dbg_mean_cnt0 << endl;
+}
+
+void dbg_mean_of(int v) {
+
+  dbg_mean_cnt0++;
+  dbg_mean_cnt1 += v;
+}
+
+void dbg_hit_on(bool b) {
+
+  dbg_hit_cnt0++;
+  if (b)
+      dbg_hit_cnt1++;
+}
+
+void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
+void dbg_before() { dbg_hit_on(false); }
+void dbg_after()  { dbg_hit_on(true); dbg_hit_cnt0--; }
+
+
+/// get_system_time() returns the current system time, measured in milliseconds
+
+int get_system_time() {
+
+#if defined(_MSC_VER)
+  struct _timeb t;
+  _ftime(&t);
+  return int(t.time * 1000 + t.millitm);
+#else
+  struct timeval t;
+  gettimeofday(&t, NULL);
+  return t.tv_sec * 1000 + t.tv_usec / 1000;
+#endif
+}
+
+
+/// cpu_count() tries to detect the number of CPU cores
+
+int cpu_count() {
+
+#if defined(_MSC_VER)
+  SYSTEM_INFO s;
+  GetSystemInfo(&s);
+  return Min(s.dwNumberOfProcessors, MAX_THREADS);
+#else
+
+#  if defined(_SC_NPROCESSORS_ONLN)
+  return Min(sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
+#  elif defined(__hpux)
+  struct pst_dynamic psd;
+  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
+      return 1;
+  return Min(psd.psd_proc_cnt, MAX_THREADS);
+#  else
+  return 1;
+#  endif
+
+#endif
+}
+
+
+/// Check for console input. Original code from Beowulf, Olithink and Greko
 
-/*
-  From Beowulf, from Olithink
-*/
 #ifndef _WIN32
-/* Non-windows version */
-int Bioskey()
-{
-  fd_set          readfds;
+
+int input_available() {
+
+  fd_set readfds;
   struct timeval  timeout;
 
   FD_ZERO(&readfds);
   FD_SET(fileno(stdin), &readfds);
-  /* Set to timeout immediately */
-  timeout.tv_sec = 0;
+  timeout.tv_sec = 0; // Set to timeout immediately
   timeout.tv_usec = 0;
   select(16, &readfds, 0, 0, &timeout);
 
@@ -132,38 +192,79 @@ int Bioskey()
 }
 
 #else
-/* Windows-version */
-#include <windows.h>
-#include <conio.h>
-int Bioskey()
-{
-    static int      init = 0,
-                    pipe;
-    static HANDLE   inh;
-    DWORD           dw;
-    /* If we're running under XBoard then we can't use _kbhit() as the input
-     * commands are sent to us directly over the internal pipe */
 
-#if defined(FILE_CNT)
-    if (stdin->_cnt > 0)
-        return stdin->_cnt;
-#endif
-    if (!init) {
-        init = 1;
-        inh = GetStdHandle(STD_INPUT_HANDLE);
-        pipe = !GetConsoleMode(inh, &dw);
-        if (!pipe) {
-            SetConsoleMode(inh, dw & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
-            FlushConsoleInputBuffer(inh);
-        }
-    }
-    if (pipe) {
-        if (!PeekNamedPipe(inh, NULL, 0, NULL, &dw, NULL))
-            return 1;
-        return dw;
-    } else {
-        GetNumberOfConsoleInputEvents(inh, &dw);
-        return dw <= 1 ? 0 : dw;
-    }
+int input_available() {
+
+  static HANDLE inh = NULL;
+  static bool usePipe = false;
+  INPUT_RECORD rec[256];
+  DWORD nchars, recCnt;
+
+  if (!inh)
+  {
+      inh = GetStdHandle(STD_INPUT_HANDLE);
+      if (GetConsoleMode(inh, &nchars))
+      {
+          SetConsoleMode(inh, nchars & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
+          FlushConsoleInputBuffer(inh);
+      } else
+          usePipe = true;
+  }
+
+  // When using Standard C input functions, also check if there
+  // is anything in the buffer. After a call to such functions,
+  // the input waiting in the pipe will be copied to the buffer,
+  // and the call to PeekNamedPipe can indicate no input available.
+  // Setting stdin to unbuffered was not enough. [from Greko]
+  if (stdin->_cnt > 0)
+      return 1;
+
+  // When running under a GUI the input commands are sent to us
+  // directly over the internal pipe. If PeekNamedPipe() returns 0
+  // then something went wrong. Probably the parent program exited.
+  // Returning 1 will make the next call to the input function
+  // return EOF, where this should be catched then.
+  if (usePipe)
+      return PeekNamedPipe(inh, NULL, 0, NULL, &nchars, NULL) ? nchars : 1;
+
+  // Count the number of unread input records, including keyboard,
+  // mouse, and window-resizing input records.
+  GetNumberOfConsoleInputEvents(inh, &nchars);
+
+  // Read data from console without removing it from the buffer
+  if (nchars <= 0 || !PeekConsoleInput(inh, rec, Min(nchars, 256), &recCnt))
+      return 0;
+
+  // Search for at least one keyboard event
+  for (DWORD i = 0; i < recCnt; i++)
+      if (rec[i].EventType == KEY_EVENT)
+          return 1;
+
+  return 0;
 }
+
+#endif
+
+
+/// prefetch() preloads the given address in L1/L2 cache. This is a non
+/// blocking function and do not stalls the CPU waiting for data to be
+/// loaded from memory, that can be quite slow.
+#if defined(NO_PREFETCH)
+
+void prefetch(char*) {}
+
+#else
+
+void prefetch(char* addr) {
+
+#if defined(__INTEL_COMPILER) || defined(__ICL)
+   // This hack prevents prefetches to be optimized away by
+   // Intel compiler. Both MSVC and gcc seems not affected.
+   __asm__ ("");
+#endif
+
+  _mm_prefetch(addr, _MM_HINT_T2);
+  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
+}
+
 #endif

src/misc.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,45 +17,25 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MISC_H_INCLUDED)
 #define MISC_H_INCLUDED
 
-
-////
-//// Includes
-////
-
 #include <string>
-
-
-////
-//// Constants
-////
-
-
-/// Version number.  If this is left empty, the current date (in the format
-/// YYMMDD) is used as a version number.
-
-const std::string EngineVersion = "2.1";
-
-
-////
-//// Macros
-////
-
-#define Min(x, y) (((x) < (y))? (x) : (y))
-#define Max(x, y) (((x) < (y))? (y) : (x))
-
-
-////
-//// Prototypes
-////
+#include "types.h"
 
 extern const std::string engine_name();
+extern const std::string engine_authors();
 extern int get_system_time();
 extern int cpu_count();
-extern int Bioskey();
+extern int input_available();
+extern void prefetch(char* addr);
 
+extern void dbg_hit_on(bool b);
+extern void dbg_hit_on_c(bool c, bool b);
+extern void dbg_before();
+extern void dbg_after();
+extern void dbg_mean_of(int v);
+extern void dbg_print_hit_rate();
+extern void dbg_print_mean();
 
 #endif // !defined(MISC_H_INCLUDED)

src/move.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,132 +17,242 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
+#include <cstring>
+#include <iomanip>
+#include <string>
+#include <sstream>
 
 #include "move.h"
-#include "piece.h"
-#include "position.h"
-#include "ucioption.h"
+#include "movegen.h"
+#include "search.h"
 
+using std::string;
 
-////
-//// Functions
-////
-
-/// move_from_string() takes a position and a string as input, and attempts to
-/// convert the string to a move, using simple coordinate notation (g1f3,
-/// a7a8q, etc.).  In order to correctly parse en passant captures and castling
-/// moves, we need the position.  This function is not robust, and expects that
-/// the input move is legal and correctly formatted.
-
-Move move_from_string(const Position &pos, const std::string &str) {
-  Square from, to;
-  Piece piece;
-  Color us = pos.side_to_move();
-
-  if(str.length() < 4) return MOVE_NONE;
-
-  // Read the from and to squares:
-  from = square_from_string(str.substr(0, 2));
-  to = square_from_string(str.substr(2, 4));
-
-  // Find the moving piece:
-  piece = pos.piece_on(from);
-
-  // If the string has more than 4 characters, try to interpret the 5th
-  // character as a promotion:
-  if(type_of_piece(piece) == PAWN && str.length() >= 5) {
-    switch(str[4]) {
-    case 'n': case 'N': 
-      return make_promotion_move(from, to, KNIGHT);
-    case 'b': case 'B':
-      return make_promotion_move(from, to, BISHOP);
-    case 'r': case 'R':
-      return make_promotion_move(from, to, ROOK);
-    case 'q': case 'Q':
-      return make_promotion_move(from, to, QUEEN);
-    }
-  }
-
-  if(piece == king_of_color(us)) {
-    // Is this a castling move?  A king move is assumed to be a castling
-    // move if the destination square is occupied by a friendly rook, or
-    // if the distance between the source and destination squares is more
-    // than 1.
-    if(pos.piece_on(to) == rook_of_color(us))
-      return make_castle_move(from, to);
-    else if(square_distance(from, to) > 1) {
-      // This is a castling move, but we have to translate it to the
-      // internal "king captures rook" representation.
-      SquareDelta delta = (to > from)? DELTA_E : DELTA_W;
-      Square s;
-      for(s = from + delta;
-          pawn_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us);
-          s += delta);
-      if(pawn_rank(us, s) == RANK_1 && pos.piece_on(s) == rook_of_color(us))
-        return make_castle_move(from, s);
-    }
-  }
-  else if(piece == pawn_of_color(us)) {
-    // En passant move?  We assume that a pawn move is an en passant move
-    // without further testing if the destination square is epSquare.
-    if(to == pos.ep_square())
-      return make_ep_move(from, to);
-  }
-
-  return make_move(from, to);
+namespace {
+  const string time_string(int milliseconds);
+  const string score_string(Value v);
 }
 
 
-/// move_to_string() converts a move to a string in coordinate notation
-/// (g1f3, a7a8q, etc.).  The only special case is castling moves, where we
+/// move_to_uci() converts a move to a string in coordinate notation
+/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we
 /// print in the e1g1 notation in normal chess mode, and in e1h1 notation in
 /// Chess960 mode.
 
-const std::string move_to_string(Move move) {
-  std::string str;
+const string move_to_uci(Move m, bool chess960) {
 
-  if(move == MOVE_NONE)
-    str = "(none)";
-  else if(move == MOVE_NULL)
-    str = "0000";
-  else {
-    if(!Chess960) {
-      if(move_from(move) == SQ_E1 && move_is_short_castle(move)) {
-        str = "e1g1"; return str;
+  Square from = move_from(m);
+  Square to = move_to(m);
+  string promotion;
+
+  if (m == MOVE_NONE)
+      return "(none)";
+
+  if (m == MOVE_NULL)
+      return "0000";
+
+  if (move_is_short_castle(m) && !chess960)
+      return from == SQ_E1 ? "e1g1" : "e8g8";
+
+  if (move_is_long_castle(m) && !chess960)
+      return from == SQ_E1 ? "e1c1" : "e8c8";
+
+  if (move_is_promotion(m))
+      promotion = char(tolower(piece_type_to_char(move_promotion_piece(m))));
+
+  return square_to_string(from) + square_to_string(to) + promotion;
+}
+
+
+/// move_from_uci() takes a position and a string representing a move in
+/// simple coordinate notation and returns an equivalent Move if any.
+/// Moves are guaranteed to be legal.
+
+Move move_from_uci(const Position& pos, const string& str) {
+
+  MoveStack mlist[MAX_MOVES];
+  MoveStack* last = generate<MV_LEGAL>(pos, mlist);
+
+  for (MoveStack* cur = mlist; cur != last; cur++)
+      if (str == move_to_uci(cur->move, pos.is_chess960()))
+          return cur->move;
+
+  return MOVE_NONE;
+}
+
+
+/// move_to_san() takes a position and a move as input, where it is assumed
+/// that the move is a legal move from the position. The return value is
+/// a string containing the move in short algebraic notation.
+
+const string move_to_san(Position& pos, Move m) {
+
+  assert(pos.is_ok());
+  assert(move_is_ok(m));
+
+  MoveStack mlist[MAX_MOVES];
+  Square from = move_from(m);
+  Square to = move_to(m);
+  PieceType pt = pos.type_of_piece_on(from);
+  string san;
+
+  if (m == MOVE_NONE)
+      return "(none)";
+
+  if (m == MOVE_NULL)
+      return "(null)";
+
+  if (move_is_long_castle(m))
+      san = "O-O-O";
+  else if (move_is_short_castle(m))
+      san = "O-O";
+  else
+  {
+      if (pt != PAWN)
+      {
+          san = piece_type_to_char(pt);
+
+          // Collect all legal moves of piece type 'pt' with destination 'to'
+          MoveStack* last = generate<MV_LEGAL>(pos, mlist);
+          int f = 0, r = 0;
+
+          for (MoveStack* cur = mlist; cur != last; cur++)
+              if (   move_to(cur->move) == to
+                  && pos.type_of_piece_on(move_from(cur->move)) == pt)
+              {
+                  if (square_file(move_from(cur->move)) == square_file(from))
+                      f++;
+
+                  if (square_rank(move_from(cur->move)) == square_rank(from))
+                      r++;
+              }
+
+          assert(f > 0 && r > 0);
+
+          // Disambiguation if we have more then one piece with destination 'to'
+          if (f == 1 && r > 1)
+              san += file_to_char(square_file(from));
+          else if (f > 1 && r == 1)
+              san += rank_to_char(square_rank(from));
+          else if (f > 1 && r > 1)
+              san += square_to_string(from);
       }
-      else if(move_from(move) == SQ_E1 && move_is_long_castle(move)) {
-        str = "e1c1"; return str;
+
+      if (pos.move_is_capture(m))
+      {
+          if (pt == PAWN)
+              san += file_to_char(square_file(from));
+
+          san += 'x';
       }
-      if(move_from(move) == SQ_E8 && move_is_short_castle(move)) {
-        str = "e8g8"; return str;
+
+      san += square_to_string(to);
+
+      if (move_is_promotion(m))
+      {
+          san += '=';
+          san += piece_type_to_char(move_promotion_piece(m));
       }
-      else if(move_from(move) == SQ_E8 && move_is_long_castle(move)) {
-        str = "e8c8"; return str;
-      }
-    }
-    str = square_to_string(move_from(move)) + square_to_string(move_to(move));
-    if(move_promotion(move))
-      str += piece_type_to_char(move_promotion(move), false);
   }
-  return str;
+
+  // The move gives check? We don't use pos.move_gives_check() here
+  // because we need to test for a mate after the move is done.
+  StateInfo st;
+  pos.do_move(m, st);
+  if (pos.in_check())
+      san += pos.is_mate() ? "#" : "+";
+  pos.undo_move(m);
+
+  return san;
 }
 
 
-/// Overload the << operator, to make it easier to print moves.
+/// pretty_pv() creates a human-readable string from a position and a PV.
+/// It is used to write search information to the log file (which is created
+/// when the UCI parameter "Use Search Log" is "true").
 
-std::ostream &operator << (std::ostream &os, Move m) {
-  return os << move_to_string(m);
+const string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]) {
+
+  const int64_t K = 1000;
+  const int64_t M = 1000000;
+  const int startColumn = 28;
+  const size_t maxLength = 80 - startColumn;
+  const string lf = string("\n") + string(startColumn, ' ');
+
+  StateInfo state[PLY_MAX_PLUS_2], *st = state;
+  Move* m = pv;
+  string san;
+  std::stringstream s;
+  size_t length = 0;
+
+  // First print depth, score, time and searched nodes...
+  s << std::setw(2) << depth
+    << std::setw(8) << score_string(score)
+    << std::setw(8) << time_string(time);
+
+  if (pos.nodes_searched() < M)
+      s << std::setw(8) << pos.nodes_searched() / 1 << "  ";
+  else if (pos.nodes_searched() < K * M)
+      s << std::setw(7) << pos.nodes_searched() / K << "K  ";
+  else
+      s << std::setw(7) << pos.nodes_searched() / M << "M  ";
+
+  // ...then print the full PV line in short algebraic notation
+  while (*m != MOVE_NONE)
+  {
+      san = move_to_san(pos, *m);
+      length += san.length() + 1;
+
+      if (length > maxLength)
+      {
+          length = san.length() + 1;
+          s << lf;
+      }
+      s << san << ' ';
+
+      pos.do_move(*m++, *st++);
+  }
+
+  // Restore original position before to leave
+  while (m != pv) pos.undo_move(*--m);
+
+  return s.str();
 }
 
 
-/// move_is_ok(), for debugging.
+namespace {
 
-bool move_is_ok(Move m) {
-  return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
+  const string time_string(int millisecs) {
+
+    const int MSecMinute = 1000 * 60;
+    const int MSecHour   = 1000 * 60 * 60;
+
+    int hours = millisecs / MSecHour;
+    int minutes =  (millisecs % MSecHour) / MSecMinute;
+    int seconds = ((millisecs % MSecHour) % MSecMinute) / 1000;
+
+    std::stringstream s;
+
+    if (hours)
+        s << hours << ':';
+
+    s << std::setfill('0') << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
+    return s.str();
+  }
+
+
+  const string score_string(Value v) {
+
+    std::stringstream s;
+
+    if (v >= VALUE_MATE - 200)
+        s << "#" << (VALUE_MATE - v + 1) / 2;
+    else if (v <= -VALUE_MATE + 200)
+        s << "-#" << (VALUE_MATE + v) / 2;
+    else
+        s << std::setprecision(2) << std::fixed << std::showpos << float(v) / PawnValueMidgame;
+
+    return s.str();
+  }
 }

src/move.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,31 +17,32 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MOVE_H_INCLUDED)
 #define MOVE_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include <iostream>
+#include <string>
 
 #include "misc.h"
-#include "piece.h"
-#include "square.h"
+#include "types.h"
 
+// Maximum number of allowed moves per position
+const int MAX_MOVES = 256;
 
-////
-//// Types
-////
-
-class Position;
+/// A move needs 16 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)
+/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in
+/// because in any normal move destination square is always different
+/// from origin square while MOVE_NONE and MOVE_NULL have the same
+/// origin and destination square, 0 and 1 respectively.
 
 enum Move {
   MOVE_NONE = 0,
-  MOVE_NULL = 65, 
-  MOVE_MAX = 0xFFFFFF
+  MOVE_NULL = 65
 };
 
 
@@ -49,29 +51,106 @@ struct MoveStack {
   int score;
 };
 
+inline bool operator<(const MoveStack& f, const MoveStack& s) { return f.score < s.score; }
+
+// An helper insertion sort implementation, works with pointers and iterators
+template<typename T, typename K>
+inline void insertion_sort(K firstMove, K lastMove)
+{
+    T value;
+    K cur, p, d;
+
+    if (firstMove != lastMove)
+        for (cur = firstMove + 1; cur != lastMove; cur++)
+        {
+            p = d = cur;
+            value = *p--;
+            if (*p < value)
+            {
+                do *d = *p;
+                while (--d != firstMove && *--p < value);
+                *d = value;
+            }
+        }
+}
+
+// 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, 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 (bestMove < *curMove)
+        {
+            tmp = *curMove;
+            *curMove = bestMove;
+            bestMove = tmp;
+        }
+    }
+    return bestMove;
+}
 
-////
-//// Inline functions
-////
 
 inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 077);
+  return Square((int(m) >> 6) & 0x3F);
 }
 
 inline Square move_to(Move m) {
-  return Square(m & 077);
+  return Square(m & 0x3F);
 }
 
-inline PieceType move_promotion(Move m) {
-  return PieceType((int(m) >> 12) & 7);
+inline bool move_is_special(Move m) {
+  return m & (3 << 14);
 }
 
-inline bool move_is_ep(Move m) {
-  return bool((int(m) >> 15) & 1);
+inline bool move_is_promotion(Move m) {
+  return (m & (3 << 14)) == (1 << 14);
 }
 
-inline bool move_is_castle(Move m) {
-  return bool((int(m) >> 16) & 1);
+inline int move_is_ep(Move m) {
+  return (m & (3 << 14)) == (2 << 14);
+}
+
+inline int move_is_castle(Move m) {
+  return (m & (3 << 14)) == (3 << 14);
 }
 
 inline bool move_is_short_castle(Move m) {
@@ -82,31 +161,35 @@ inline bool move_is_long_castle(Move m) {
   return move_is_castle(m) && (move_to(m) < move_from(m));
 }
 
-inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
-  return Move(int(to) | (int(from) << 6) | (int(promotion) << 12));
+inline PieceType move_promotion_piece(Move m) {
+  return move_is_promotion(m) ? PieceType(((int(m) >> 12) & 3) + 2) : PIECE_TYPE_NONE;
 }
 
 inline Move make_move(Square from, Square to) {
   return Move(int(to) | (int(from) << 6));
 }
 
-inline Move make_castle_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (1 << 16));
+inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
+  return Move(int(to) | (int(from) << 6) | ((int(promotion) - 2) << 12) | (1 << 14));
 }
 
 inline Move make_ep_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (1 << 15));
+  return Move(int(to) | (int(from) << 6) | (2 << 14));
 }
 
+inline Move make_castle_move(Square from, Square to) {
+  return Move(int(to) | (int(from) << 6) | (3 << 14));
+}
 
-////
-//// Prototypes
-////
+inline bool move_is_ok(Move m) {
+  return move_from(m) != move_to(m); // Catches also MOVE_NONE
+}
 
-extern std::ostream &operator << (std::ostream &os, Move m);
-extern Move move_from_string(const Position &pos, const std::string &str);
-extern const std::string move_to_string(Move m);
-extern bool move_is_ok(Move m);
+class Position;
 
+extern const std::string move_to_uci(Move m, bool chess960);
+extern Move move_from_uci(const Position& pos, const std::string& str);
+extern const std::string move_to_san(Position& pos, Move m);
+extern const std::string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]);
 
 #endif // !defined(MOVE_H_INCLUDED)

src/movegen.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,27 +17,24 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MOVEGEN_H_INCLUDED)
 #define MOVEGEN_H_INCLUDED
 
-////
-//// Includes
-////
-
+#include "move.h"
 #include "position.h"
 
+enum MoveType {
+  MV_CAPTURE,
+  MV_NON_CAPTURE,
+  MV_CHECK,
+  MV_NON_CAPTURE_CHECK,
+  MV_EVASION,
+  MV_NON_EVASION,
+  MV_LEGAL,
+  MV_PSEUDO_LEGAL
+};
 
-////
-//// Prototypes
-////
-
-extern int generate_captures(const Position &pos, MoveStack *mlist);
-extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
-extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
-extern int generate_evasions(const Position &pos, MoveStack *mlist);
-extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern Move generate_move_if_legal(const Position &pos, Move m,
-                                   Bitboard pinned);
+template<MoveType>
+MoveStack* generate(const Position& pos, MoveStack* mlist);
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -1,13 +1,15 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,488 +18,333 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
 
-#include "history.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
-#include "value.h"
-
-
-////
-//// Local definitions
-////
+#include "types.h"
 
 namespace {
 
-  /// Types
-
   enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
-    PH_MATE_KILLER,    // Mate killer from the current ply
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE valuse <= 0
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
-    PH_NONCAPTURES,    // Non-captures and underpromotions
-    PH_EVASIONS,       // Check evasions
-    PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
+    PH_TT_MOVES,      // Transposition table move and mate killer
+    PH_GOOD_CAPTURES, // Queen promotions and captures with SEE values >= 0
+    PH_KILLERS,       // Killer moves from the current ply
+    PH_NONCAPTURES,   // Non-captures and underpromotions
+    PH_BAD_CAPTURES,  // Queen promotions and captures with SEE values < 0
+    PH_EVASIONS,      // Check evasions
+    PH_QCAPTURES,     // Captures in quiescence search
+    PH_QCHECKS,       // Non-capture checks in quiescence search
     PH_STOP
   };
 
-
-  /// Variables
-
-  MovegenPhase PhaseTable[32];
-  int MainSearchPhaseIndex;
-  int EvasionsPhaseIndex;
-  int QsearchWithChecksPhaseIndex;
-  int QsearchWithoutChecksPhaseIndex;
-
+  CACHE_LINE_ALIGNMENT
+  const uint8_t MainSearchTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP };
+  const uint8_t EvasionTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP };
+  const uint8_t QsearchWithChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP };
+  const uint8_t QsearchWithoutChecksTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP };
 }
 
 
-////
-//// Functions
-////
-
-
-/// Constructor for the MovePicker class.  Apart from the position for which
+/// Constructor for the MovePicker class. Apart from the position for which
 /// it is asked to pick legal moves, MovePicker also wants some information
 /// to help it to return the presumably good moves first, to decide which
 /// moves to return (in the quiescence search, for instance, we only want to
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
-                       Move k1, Move k2, Depth dpth) {
-  pos = &p;
-  pvNode = pvnode;
-  ttMove = ttm;
-  mateKiller = (mk == ttm)? MOVE_NONE : mk;
-  killer1 = k1;
-  killer2 = k2;
-  depth = dpth;
-  movesPicked = 0;
-  numOfMoves = 0;
-  numOfBadCaptures = 0;
-  dc = p.discovered_check_candidates(p.side_to_move());
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
+                       SearchStack* ss, Value beta) : pos(p), H(h) {
+  int searchTT = ttm;
+  ttMoves[0].move = ttm;
+  badCaptureThreshold = 0;
+  badCaptures = moves + MAX_MOVES;
 
-  if(p.is_check())
-    phaseIndex = EvasionsPhaseIndex;
-  else if(depth > Depth(0))
-    phaseIndex = MainSearchPhaseIndex;
-  else if(depth == Depth(0))
-    phaseIndex = QsearchWithChecksPhaseIndex;
+  assert(d > DEPTH_ZERO);
+
+  pinned = p.pinned_pieces(pos.side_to_move());
+
+  if (p.in_check())
+  {
+      ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
+      phasePtr = EvasionTable;
+  }
   else
-    phaseIndex = QsearchWithoutChecksPhaseIndex;
+  {
+      ttMoves[1].move = (ss->mateKiller == ttm) ? MOVE_NONE : ss->mateKiller;
+      searchTT |= ttMoves[1].move;
+      killers[0].move = ss->killers[0];
+      killers[1].move = ss->killers[1];
 
-  pinned = p.pinned_pieces(p.side_to_move());
+      // Consider sligtly negative captures as good if at low
+      // depth and far from beta.
+      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
+          badCaptureThreshold = -PawnValueMidgame;
 
-  finished = false;
-}
-
-
-/// MovePicker::get_next_move() is the most important method of the MovePicker
-/// class.  It returns a new legal move every time it is called, until there
-/// are no more moves left of the types we are interested in.
-
-Move MovePicker::get_next_move() {
-  Move move;
-
-  while(true) {
-    // If we already have a list of generated moves, pick the best move from
-    // the list, and return it:
-    move = this->pick_move_from_list();
-    if(move != MOVE_NONE) {
-      assert(move_is_ok(move));
-      return move;
-    }
-
-    // Next phase:
-    phaseIndex++;
-    switch(PhaseTable[phaseIndex]) {
-
-    case PH_TT_MOVE:
-      if(ttMove != MOVE_NONE) {
-        assert(move_is_ok(ttMove));
-        Move m = generate_move_if_legal(*pos, ttMove, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == ttMove);
-          return m;
-        }
-      }
-      break;
-
-    case PH_MATE_KILLER:
-      if(mateKiller != MOVE_NONE) {
-        assert(move_is_ok(mateKiller));
-        Move m = generate_move_if_legal(*pos, mateKiller, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == mateKiller);
-          return m;
-        }
-      }
-      break;
-
-    case PH_GOOD_CAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_captures();
-      movesPicked = 0;
-      break;
-
-    case PH_BAD_CAPTURES:
-      badCapturesPicked = 0;
-      break;
-
-    case PH_NONCAPTURES:
-      numOfMoves = generate_noncaptures(*pos, moves);
-      this->score_noncaptures();
-      movesPicked = 0;
-      break;
-
-    case PH_EVASIONS:
-      assert(pos->is_check());
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_evasions(*pos, moves);
-      this->score_evasions();
-      movesPicked = 0;
-      break;
-
-    case PH_QCAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
-      numOfMoves = generate_captures(*pos, moves);
-      this->score_qcaptures();
-      movesPicked = 0;
-      break;
-
-    case PH_QCHECKS:
-      numOfMoves = generate_checks(*pos, moves, dc);
-      movesPicked = 0;
-      break;
-
-    case PH_STOP:
-      return MOVE_NONE;
-
-    default:
-      assert(false);
-      return MOVE_NONE;
-    }
+      phasePtr = MainSearchTable;
   }
 
-  assert(false);
+  phasePtr += int(!searchTT) - 1;
+  go_next_phase();
+}
 
-  return MOVE_NONE;
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h)
+                      : pos(p), H(h) {
+  int searchTT = ttm;
+  ttMoves[0].move = ttm;
+  ttMoves[1].move = MOVE_NONE;
+
+  assert(d <= DEPTH_ZERO);
+
+  pinned = p.pinned_pieces(pos.side_to_move());
+
+  if (p.in_check())
+      phasePtr = EvasionTable;
+  else if (d >= DEPTH_QS_CHECKS)
+      phasePtr = QsearchWithChecksTable;
+  else
+  {
+      phasePtr = QsearchWithoutChecksTable;
+
+      // Skip TT move if is not a capture or a promotion, this avoids
+      // qsearch tree explosion due to a possible perpetual check or
+      // similar rare cases when TT table is full.
+      if (ttm != MOVE_NONE && !pos.move_is_capture_or_promotion(ttm))
+          searchTT = ttMoves[0].move = MOVE_NONE;
+  }
+
+  phasePtr += int(!searchTT) - 1;
+  go_next_phase();
 }
 
 
-/// 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.
+/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
+/// of moves when there are no more moves to try for the current phase.
 
-Move MovePicker::get_next_move(Lock &lock) {
-   Move m;
+void MovePicker::go_next_phase() {
 
-   lock_grab(&lock);
-   if(finished) {
-     lock_release(&lock);
-     return MOVE_NONE;
-   }
-   m = this->get_next_move();
-   if(m == MOVE_NONE)
-     finished = true;
-   lock_release(&lock);
+  curMove = moves;
+  phase = *(++phasePtr);
+  switch (phase) {
 
-   return m;
+  case PH_TT_MOVES:
+      curMove = ttMoves;
+      lastMove = curMove + 2;
+      return;
+
+  case PH_GOOD_CAPTURES:
+      lastMove = generate<MV_CAPTURE>(pos, moves);
+      score_captures();
+      return;
+
+  case PH_KILLERS:
+      curMove = killers;
+      lastMove = curMove + 2;
+      return;
+
+  case PH_NONCAPTURES:
+      lastMove = generate<MV_NON_CAPTURE>(pos, moves);
+      score_noncaptures();
+      sort_moves(moves, lastMove, &lastGoodNonCapture);
+      return;
+
+  case PH_BAD_CAPTURES:
+      // Bad captures SEE value is already calculated so just pick
+      // them in order to get SEE move ordering.
+      curMove = badCaptures;
+      lastMove = moves + MAX_MOVES;
+      return;
+
+  case PH_EVASIONS:
+      assert(pos.in_check());
+      lastMove = generate<MV_EVASION>(pos, moves);
+      score_evasions();
+      return;
+
+  case PH_QCAPTURES:
+      lastMove = generate<MV_CAPTURE>(pos, moves);
+      score_captures();
+      return;
+
+  case PH_QCHECKS:
+      lastMove = generate<MV_NON_CAPTURE_CHECK>(pos, moves);
+      return;
+
+  case PH_STOP:
+      lastMove = curMove + 1; // Avoid another go_next_phase() call
+      return;
+
+  default:
+      assert(false);
+      return;
+  }
 }
 
 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable.  It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-int MovePicker::number_of_moves() const {
-  return numOfMoves;
-}
-
-
-/// MovePicker::score_captures(), MovePicker::score_noncaptures(),
-/// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
-/// numerical move ordering score to each move in a move list.  The moves
-/// with highest scores will be picked first by
-/// MovePicker::pick_move_from_list().
+/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
+/// MovePicker::score_evasions() assign a numerical move ordering score
+/// to each move in a move list.  The moves with highest scores will be
+/// picked first by get_next_move().
 
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
   // Suprisingly, this appears to perform slightly better than SEE based
-  // move ordering.  The reason is probably that in a position with a winning
+  // move ordering. The reason is probably that in a position with a winning
   // capture, capturing a more valuable (but sufficiently defended) piece
-  // first usually doesn't hurt.  The opponent will have to recapture, and
+  // first usually doesn't hurt. The opponent will have to recapture, and
   // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece).  Exchanging
+  // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
-  for(int i = 0; i < numOfMoves; i++) {
-    int seeValue = pos->see(moves[i].move);
-    if(seeValue >= 0) {
-      if(move_promotion(moves[i].move))
-        moves[i].score = QueenValueMidgame;
-      else 
-        moves[i].score =
-          int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) -
-          int(pos->type_of_piece_on(move_from(moves[i].move)));
-    }
-    else
-      moves[i].score = seeValue;
+  // In main search we want to push captures with negative SEE values to
+  // badCaptures[] array, but instead of doing it now we delay till when
+  // the move has been picked up in pick_move_from_list(), this way we save
+  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
+  Move m;
 
+  // Use MVV/LVA ordering
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      if (move_is_promotion(m))
+          cur->score = QueenValueMidgame;
+      else
+          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
+                      - pos.type_of_piece_on(move_from(m));
   }
 }
 
 void MovePicker::score_noncaptures() {
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(m == killer1)
-      moves[i].score = HistoryMax + 2;
-    else if(m == killer2)
-      moves[i].score = HistoryMax + 1;
-    else
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+
+  Move m;
+  Square from;
+
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      from = move_from(m);
+      cur->score = H.value(pos.piece_on(from), move_to(m));
   }
 }
 
 void MovePicker::score_evasions() {
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(m == ttMove)
-      moves[i].score = 2*HistoryMax;
-    else if(!pos->square_is_empty(move_to(m))) {
-      int seeScore = pos->see(m);
-      moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
-    }
-    else
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+  // 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 ((seeScore = pos.see_sign(m)) < 0)
+          cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
+      else if (pos.move_is_capture(m))
+          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
+                      - pos.type_of_piece_on(move_from(m)) + History::MaxValue;
+      else
+          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
   }
 }
 
-void MovePicker::score_qcaptures() {
-  // Use MVV/LVA ordering.
-  for(int i = 0; i < numOfMoves; i++) {
-    Move m = moves[i].move;
-    if(move_promotion(m))
-      moves[i].score = QueenValueMidgame;
-    else
-      moves[i].score =
-        int(pos->midgame_value_of_piece_on(move_to(m))) -
-        int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
-  }
-}
+/// MovePicker::get_next_move() is the most important method of the MovePicker
+/// class. It returns a new legal move every time it is called, until there
+/// are no more moves left. 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() {
 
-/// MovePicker::pick_move_from_list() picks the move with the biggest score
-/// from a list of generated moves (moves[] or badCaptures[], depending on
-/// the current move generation phase).  It takes care not to return the
-/// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.
-
-Move MovePicker::pick_move_from_list() {
-  int bestScore = -10000000;
-  int bestIndex;
   Move move;
 
-  switch(PhaseTable[phaseIndex]) {
+  while (true)
+  {
+      while (curMove == lastMove)
+          go_next_phase();
 
-  case PH_GOOD_CAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++) {
-        if(moves[i].score < 0) {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-        }
-        else if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-      }
-      if(bestIndex != -1) { // Found a good capture
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
+      switch (phase) {
 
-  case PH_NONCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
+      case PH_TT_MOVES:
+          move = (curMove++)->move;
+          if (   move != MOVE_NONE
+              && pos.move_is_legal(move, pinned))
+              return move;
+          break;
 
-      // If this is a PV node or we have only picked a few moves, scan
-      // the entire move list for the best move.  If many moves have already
-      // been searched and it is not a PV node, we are probably failing low
-      // anyway, so we just pick the first move from the list.
-      if(pvNode || movesPicked < 12) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
+      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 >= badCaptureThreshold)
+                  return move;
+
+              // Losing capture, move it to the tail of the array, note
+              // that move has now been already checked for legality.
+              (--badCaptures)->move = move;
+              badCaptures->score = seeValue;
           }
-      }
-      else
-        bestIndex = movesPicked;
+          break;
 
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
+      case PH_KILLERS:
+          move = (curMove++)->move;
+          if (   move != MOVE_NONE
+              && pos.move_is_legal(move, pinned)
+              && move != ttMoves[0].move
+              && move != ttMoves[1].move
+              && !pos.move_is_capture(move))
+              return move;
+          break;
+
+      case PH_NONCAPTURES:
+          // Sort negative scored moves only when we get there
+          if (curMove == lastGoodNonCapture)
+              insertion_sort<MoveStack>(lastGoodNonCapture, lastMove);
+
+          move = (curMove++)->move;
+          if (   move != ttMoves[0].move
+              && move != ttMoves[1].move
+              && move != killers[0].move
+              && move != killers[1].move
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
+          break;
+
+      case PH_BAD_CAPTURES:
+          move = pick_best(curMove++, lastMove).move;
           return move;
+
+      case PH_EVASIONS:
+      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:
+          move = (curMove++)->move;
+          if (   move != ttMoves[0].move
+              && pos.pl_move_is_legal(move, pinned))
+              return move;
+          break;
+
+      case PH_STOP:
+          return MOVE_NONE;
+
+      default:
+          assert(false);
+          break;
       }
-    }
-    break;
-
-  case PH_EVASIONS:
-    assert(pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++)
-        if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        return move;
-      }
-    }
-    break;
-
-  case PH_BAD_CAPTURES:
-    assert(!pos->is_check());
-    assert(badCapturesPicked >= 0);
-    // It's probably a good idea to use SEE move ordering here, instead
-    // of just picking the first move.  FIXME
-    while(badCapturesPicked < numOfBadCaptures) {
-      move = badCaptures[badCapturesPicked++].move;
-      if(move != ttMove && move != mateKiller && 
-         pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
-
-  case PH_QCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      if(movesPicked < 4) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
-          }
-      }
-      else
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-
-        move = moves[movesPicked++].move;
-        // Remember to change the line below if we decide to hash the qsearch!
-        // Maybe also postpone the legality check until after futility pruning?
-        if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
-
-  case PH_QCHECKS:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    // Perhaps we should do something better than just picking the first
-    // move here?  FIXME
-    while(movesPicked < numOfMoves) {
-      move = moves[movesPicked++].move;
-      // Remember to change the line below if we decide to hash the qsearch!
-      if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-        return move;
-    }
-    break;
-
-  default:
-    break;
   }
-
-  return MOVE_NONE;
-}
-
-
-/// MovePicker::init_phase_table() initializes the PhaseTable[],
-/// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex variables.  It is only called once
-/// during program startup, and never again while the program is running.
-
-void MovePicker::init_phase_table() {
-  int i = 0;
-
-  // Main search
-  MainSearchPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_TT_MOVE;
-  PhaseTable[i++] = PH_MATE_KILLER;
-  PhaseTable[i++] = PH_GOOD_CAPTURES;
-  // PH_KILLER_1 and PH_KILLER_2 are not yet used.
-  // PhaseTable[i++] = PH_KILLER_1;
-  // PhaseTable[i++] = PH_KILLER_2;
-  PhaseTable[i++] = PH_NONCAPTURES;
-  PhaseTable[i++] = PH_BAD_CAPTURES;
-  PhaseTable[i++] = PH_STOP;
-
-  // Check evasions
-  EvasionsPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_EVASIONS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search with checks
-  QsearchWithChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_QCHECKS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search without checks
-  QsearchWithoutChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_STOP;
 }

src/movepick.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,74 +17,47 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "depth.h"
-#include "lock.h"
+#include "history.h"
+#include "move.h"
 #include "position.h"
+#include "types.h"
 
-
-////
-//// Types
-////
+struct SearchStack;
 
 /// MovePicker is a class which is used to pick one legal move at a time from
-/// the current position.  It is initialized with a Position object and a few
-/// moves we have reason to believe are good.  The most important method is
-/// MovePicker::pick_next_move(), which returns a new legal move each time it
+/// the current position. It is initialized with a Position object and a few
+/// moves we have reason to believe are good. The most important method is
+/// MovePicker::get_next_move(), which returns a new legal move each time it
 /// is called, until there are no legal moves left, when MOVE_NONE is returned.
 /// In order to improve the efficiency of the alpha beta algorithm, MovePicker
-/// attempts to return the moves which are most likely to be strongest first.
+/// attempts to return the moves which are most likely to get a cut-off first.
 
 class MovePicker {
 
-public:
-  MovePicker(Position &p, bool pvnode, Move ttm, Move mk, Move k1, Move k2,
-             Depth dpth);
-  Move get_next_move();
-  Move get_next_move(Lock &lock);
-  int number_of_moves() const;
-  int current_move_score() const;
-  Bitboard discovered_check_candidates();
+  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
 
-  static void init_phase_table();
+public:
+  MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value);
+  MovePicker(const Position&, Move, Depth, const History&);
+  Move get_next_move();
 
 private:
   void score_captures();
   void score_noncaptures();
   void score_evasions();
-  void score_qcaptures();
-  Move pick_move_from_list();
+  void go_next_phase();
 
-  Position *pos;
-  Move ttMove, mateKiller, killer1, killer2;
-  Bitboard pinned, dc;
-  MoveStack moves[256], badCaptures[64];
-  bool pvNode;
-  Depth depth;
-  int phaseIndex;
-  int numOfMoves, numOfBadCaptures;
-  int movesPicked, badCapturesPicked;
-  bool finished;
+  const Position& pos;
+  const History& H;
+  Bitboard pinned;
+  MoveStack ttMoves[2], killers[2];
+  int badCaptureThreshold, phase;
+  const uint8_t* phasePtr;
+  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *badCaptures;
+  MoveStack moves[MAX_MOVES];
 };
 
-
-////
-//// Inline functions
-////
-
-/// 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() {
-  return dc;
-}
-
 #endif // !defined(MOVEPICK_H_INCLUDED)

src/pawns.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,370 +17,227 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
 
+#include "bitboard.h"
+#include "bitcount.h"
 #include "pawns.h"
-
-
-////
-//// Local definitions
-////
+#include "position.h"
 
 namespace {
 
-  /// Constants and variables
+  #define S(mg, eg) make_score(mg, eg)
 
-  // Doubled pawn penalty by file, middle game.
-  const Value DoubledPawnMidgamePenalty[8] = {
-    Value(20), Value(30), Value(34), Value(34),
-    Value(34), Value(34), Value(30), Value(20)
+  // Doubled pawn penalty by opposed flag and file
+  const Score DoubledPawnPenalty[2][8] = {
+  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
+    S(23, 48), S(23, 48), S(20, 48), S(13, 43) },
+  { S(13, 43), S(20, 48), S(23, 48), S(23, 48),
+    S(23, 48), S(23, 48), S(20, 48), S(13, 43) }};
+
+  // Isolated pawn penalty by opposed flag and file
+  const Score IsolatedPawnPenalty[2][8] = {
+  { S(37, 45), S(54, 52), S(60, 52), S(60, 52),
+    S(60, 52), S(60, 52), S(54, 52), S(37, 45) },
+  { S(25, 30), S(36, 35), S(40, 35), S(40, 35),
+    S(40, 35), S(40, 35), S(36, 35), S(25, 30) }};
+
+  // Backward pawn penalty by opposed flag and file
+  const Score BackwardPawnPenalty[2][8] = {
+  { S(30, 42), S(43, 46), S(49, 46), S(49, 46),
+    S(49, 46), S(49, 46), S(43, 46), S(30, 42) },
+  { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
+    S(33, 31), S(33, 31), S(29, 31), S(20, 28) }};
+
+  // Pawn chain membership bonus by file
+  const Score ChainBonus[8] = {
+    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
+    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
   };
 
-  // Doubled pawn penalty by file, endgame.
-  const Value DoubledPawnEndgamePenalty[8] = {
-    Value(35), Value(40), Value(40), Value(40),
-    Value(40), Value(40), Value(40), Value(35)
+  // Candidate passed pawn bonus by rank
+  const Score CandidateBonus[8] = {
+    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
+    S(34,68), S(83,166), S(0, 0), S( 0, 0)
   };
 
-  // Isolated pawn penalty by file, middle game.
-  const Value IsolatedPawnMidgamePenalty[8] = {
-    Value(20), Value(30), Value(34), Value(34),
-    Value(34), Value(34), Value(30), Value(20)
-  };
+  const Score PawnStructureWeight = S(233, 201);
 
-  // Isolated pawn penalty by file, endgame.
-  const Value IsolatedPawnEndgamePenalty[8] = {
-    Value(35), Value(40), Value(40), Value(40),
-    Value(40), Value(40), Value(40), Value(35)
-  };
+  #undef S
 
-  // Backward pawn penalty by file, middle game.
-  const Value BackwardPawnMidgamePenalty[8] = {
-    Value(16), Value(24), Value(27), Value(27),
-    Value(27), Value(27), Value(24), Value(16)
-  };
-
-  // Backward pawn penalty by file, endgame.
-  const Value BackwardPawnEndgamePenalty[8] = {
-    Value(28), Value(32), Value(32), Value(32),
-    Value(32), Value(32), Value(32), Value(28)
-  };
-
-  // Pawn chain membership bonus by file, middle game. 
-  const Value ChainMidgameBonus[8] = {
-    Value(14), Value(16), Value(17), Value(18),
-    Value(18), Value(17), Value(16), Value(14)
-  };
-
-  // Pawn chain membership bonus by file, endgame. 
-  const Value ChainEndgameBonus[8] = {
-    Value(16), Value(16), Value(16), Value(16),
-    Value(16), Value(16), Value(16), Value(16)
-  };
-
-  // Candidate passed pawn bonus by rank, middle game.
-  const Value CandidateMidgameBonus[8] = {
-    Value(0), Value(12), Value(12), Value(20),
-    Value(40), Value(90), Value(0), Value(0)
-  };
-
-  // Candidate passed pawn bonus by rank, endgame.
-  const Value CandidateEndgameBonus[8] = {
-    Value(0), Value(24), Value(24), Value(40),
-    Value(80), Value(180), Value(0), Value(0)
-  };
-
-  // Evaluate pawn storms?
-  const bool EvaluatePawnStorms = true;
-
-  // Pawn storm tables for positions with opposite castling:
-  const int QStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    -22, -22, -22, -13, -4, 0, 0, 0,
-    -4, -9, -9, -9, -4, 0, 0, 0,
-    9, 18, 22, 18, 9, 0, 0, 0,
-    22, 31, 31, 22, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0
-  };
-  
-  const int KStormTable[64] = {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, -4, -13, -22, -27, -27,
-    0, 0, 0, -4, -9, -13, -18, -18,
-    0, 0, 0, 0, 9, 9, 9, 9,
-    0, 0, 0, 0, 9, 18, 27, 27,
-    0, 0, 0, 0, 9, 27, 40, 36,
-    0, 0, 0, 0, 0, 31, 40, 31,
-    0, 0, 0, 0, 0, 0, 0, 0
-  };
-
-  // Pawn storm open file bonuses by file:
-  const int KStormOpenFileBonus[8] = {
-    45, 45, 30, 0, 0, 0, 0, 0
-  };
-
-  const int QStormOpenFileBonus[8] = {
-    0, 0, 0, 0, 0, 30, 45, 30
-  };
-
-}
-
-
-////
-//// Functions
-////
-
-/// Constructor
-
-PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
-  size = numOfEntries;
-  entries = new PawnInfo[size];
-  if(entries == NULL) {
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
-              << " bytes for pawn hash table." << std::endl;
-    exit(EXIT_FAILURE);
+  inline Score apply_weight(Score v, Score w) {
+    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
+                      (int(eg_value(v)) * eg_value(w)) / 0x100);
   }
-  this->clear();
-}
-
-
-/// Destructor
-
-PawnInfoTable::~PawnInfoTable() {
-  delete [] entries;
-}
-
-
-/// PawnInfoTable::clear() clears the pawn hash table by setting all
-/// entries to 0.
-
-void PawnInfoTable::clear() {
-  memset(entries, 0, size * sizeof(PawnInfo));
 }
 
 
 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it.  The result is also 
-/// stored in a hash table, so we don't have to recompute everything when
-/// the same pawn structure occurs again.
+/// a PawnInfo object, and returns a pointer to it. The result is also stored
+/// in an hash table, so we don't have to recompute everything when the same
+/// pawn structure occurs again.
+
+PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
 
-PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
   assert(pos.is_ok());
 
   Key key = pos.get_pawn_key();
-  int index = int(key & (size - 1));
-  PawnInfo *pi = entries + index;
+  PawnInfo* pi = probe(key);
 
   // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return the
-  // information we found the last time instead of recomputing it:
-  if(pi->key == key)
-    return pi;
+  // have analysed this pawn structure before, and we can simply return
+  // the information we found the last time instead of recomputing it.
+  if (pi->key == key)
+      return pi;
 
-  // Clear the PawnInfo object, and set the key:
-  pi->clear();
+  // Initialize PawnInfo entry
   pi->key = key;
+  pi->passedPawns[WHITE] = pi->passedPawns[BLACK] = 0;
+  pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
+  pi->halfOpenFiles[WHITE] = pi->halfOpenFiles[BLACK] = 0xFF;
 
-  Value mgValue[2] = {Value(0), Value(0)};
-  Value egValue[2] = {Value(0), Value(0)};
+  // Calculate pawn attacks
+  Bitboard wPawns = pos.pieces(PAWN, WHITE);
+  Bitboard bPawns = pos.pieces(PAWN, BLACK);
+  pi->pawnAttacks[WHITE] = ((wPawns << 9) & ~FileABB) | ((wPawns << 7) & ~FileHBB);
+  pi->pawnAttacks[BLACK] = ((bPawns >> 7) & ~FileABB) | ((bPawns >> 9) & ~FileHBB);
 
-  // Loop through the pawns for both colors:
-  for(Color us = WHITE; us <= BLACK; us++) {
-    Color them = opposite_color(us);
-    Bitboard ourPawns = pos.pawns(us);
-    Bitboard theirPawns = pos.pawns(them);
-    Bitboard pawns = ourPawns;
+  // Evaluate pawns for both colors and weight the result
+  pi->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, pi)
+             - evaluate_pawns<BLACK>(pos, bPawns, wPawns, pi);
 
-    // Initialize pawn storm scores by giving bonuses for open files:
-    if(EvaluatePawnStorms)
-      for(File f = FILE_A; f <= FILE_H; f++)
-        if(pos.file_is_half_open(us, f)) {
-          pi->ksStormValue[us] += KStormOpenFileBonus[f];
-          pi->qsStormValue[us] += QStormOpenFileBonus[f];
-        }
-
-    // Loop through all pawns of the current color and score each pawn:
-    while(pawns) {
-      Square s = pop_1st_bit(&pawns);
-      File f = square_file(s);
-      Rank r = square_rank(s);
-      bool passed, doubled, isolated, backward, chain, candidate;
-      int bonus;
-
-      assert(pos.piece_on(s) == pawn_of_color(us));
-
-      // The file containing the pawn is not half open:
-      pi->halfOpenFiles[us] &= ~(1 << f);
-
-      // Passed, isolated or doubled pawn?
-      passed = pos.pawn_is_passed(us, s);
-      isolated = pos.pawn_is_isolated(us, s);
-      doubled = pos.pawn_is_doubled(us, s);
-
-      if(EvaluatePawnStorms) {
-        // We calculate kingside and queenside pawn storm
-        // scores for both colors.  These are used when evaluating
-        // middle game positions with opposite side castling.
-        //
-        // Each pawn is given a base score given by a piece square table
-        // (KStormTable[] or QStormTable[]).  This score is increased if
-        // there are enemy pawns on adjacent files in front of the pawn.
-        // This is because we want to be able to open files against the
-        // enemy king, and to avoid blocking the pawn structure (e.g. white
-        // pawns on h6, g5, black pawns on h7, g6, f7).
-        
-        // Kingside pawn storms:
-        bonus = KStormTable[relative_square(us, s)];
-        if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
-          switch(f) {
-
-          case FILE_F:
-            bonus += bonus / 4;
-            break;
-
-          case FILE_G:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_H:
-            bonus += bonus / 2;
-            break;
-
-          default:
-            break;
-          }
-        }
-        pi->ksStormValue[us] += bonus;
-
-        // Queenside pawn storms:
-        bonus = QStormTable[relative_square(us, s)];
-        if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
-          switch(f) {
-
-          case FILE_A:
-            bonus += bonus / 2;
-            break;
-
-          case FILE_B:
-            bonus += bonus / 2 + bonus / 4;
-            break;
-
-          case FILE_C:
-            bonus += bonus / 2;
-            break;
-
-          default:
-            break;
-          }
-        }
-        pi->qsStormValue[us] += bonus;
-      }
-      
-      // Member of a pawn chain?  We could speed up the test a little by 
-      // introducing an array of masks indexed by color and square for doing
-      // the test, but because everything is hashed, it probably won't make
-      // any noticable difference.
-      chain = (us == WHITE)?
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
-
-
-      // Test for backward pawn.
-
-      // If the pawn is isolated, passed, or member of a pawn chain, it cannot
-      // be backward:
-      if(passed || isolated || chain)
-        backward = false;
-      // If the pawn can capture an enemy pawn, it's not backward:
-      else if(pos.pawn_attacks(us, s) & theirPawns)
-        backward = false;
-      // Check for friendly pawns behind on neighboring files:
-      else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
-        backward = false;
-      else {
-        // We now know that there is no friendly pawns beside or behind this
-        // pawn on neighboring files.  We now check whether the pawn is
-        // backward by looking in the forward direction on the neighboring
-        // files, and seeing whether we meet a friendly or an enemy pawn first.
-        Bitboard b;
-        if(us == WHITE) {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
-          backward = (b | (b << 8)) & theirPawns;
-        }
-        else {
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
-          backward = (b | (b >> 8)) & theirPawns;
-        }
-      }
-
-      // Test for candidate passed pawn.
-      candidate =
-        (!passed && pos.file_is_half_open(them, f) &&
-         count_1s_max_15(neighboring_files_bb(f)
-                         & (in_front_bb(them, r) | rank_bb(r))
-                         & ourPawns)
-         - 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))) {
-        // candidate = true;
-        passed = false;
-      }
-
-      // Score this pawn:
-      Value mv = Value(0), ev = Value(0);
-      if(isolated) {
-        mv -= IsolatedPawnMidgamePenalty[f];
-        ev -= IsolatedPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= IsolatedPawnMidgamePenalty[f] / 2;
-          ev -= IsolatedPawnEndgamePenalty[f] / 2;
-        }
-      }
-      if(doubled)  {
-        mv -= DoubledPawnMidgamePenalty[f];
-        ev -= DoubledPawnEndgamePenalty[f];
-      }
-      if(backward)  {
-        mv -= BackwardPawnMidgamePenalty[f];
-        ev -= BackwardPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= BackwardPawnMidgamePenalty[f] / 2;
-          ev -= BackwardPawnEndgamePenalty[f] / 2;
-        }
-      }
-      if(chain) {
-        mv += ChainMidgameBonus[f];
-        ev += ChainEndgameBonus[f];
-      }
-      if(candidate) {
-        mv += CandidateMidgameBonus[pawn_rank(us, s)];
-        ev += CandidateEndgameBonus[pawn_rank(us, s)];
-      }
-
-      mgValue[us] += mv;
-      egValue[us] += ev;
-        
-      // If the pawn is passed, set the square of the pawn in the passedPawns
-      // bitboard:
-      if(passed)
-        set_bit(&(pi->passedPawns), s);
-    }
-  }
-
-  pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
-  pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
+  pi->value = apply_weight(pi->value, PawnStructureWeight);
 
   return pi;
 }
+
+
+/// 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) {
+
+  const BitCountType Max15 = CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
+  const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+  Bitboard b;
+  Square s;
+  File f;
+  Rank r;
+  bool passed, isolated, doubled, opposed, chain, backward, candidate;
+  Score value = SCORE_ZERO;
+  const Square* ptr = pos.piece_list_begin(Us, PAWN);
+
+  // Loop through all pawns of the current color and score each pawn
+  while ((s = *ptr++) != SQ_NONE)
+  {
+      assert(pos.piece_on(s) == make_piece(Us, PAWN));
+
+      f = square_file(s);
+      r = square_rank(s);
+
+      // This file cannot be half open
+      pi->halfOpenFiles[Us] &= ~(1 << f);
+
+      // Our rank plus previous one. Used for chain detection
+      b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
+
+      // Flag the pawn as passed, isolated, doubled or member of a pawn
+      // chain (but not the backward one).
+      passed   = !(theirPawns & passed_pawn_mask(Us, s));
+      doubled  =   ourPawns   & squares_in_front_of(Us, s);
+      opposed  =   theirPawns & squares_in_front_of(Us, s);
+      isolated = !(ourPawns   & neighboring_files_bb(f));
+      chain    =   ourPawns   & neighboring_files_bb(f) & b;
+
+      // Test for backward pawn
+      backward = false;
+
+      // If the pawn is passed, isolated, or member of a pawn chain it cannot
+      // be backward. If there are friendly pawns behind on neighboring files
+      // or if can capture an enemy pawn it cannot be backward either.
+      if (   !(passed | isolated | chain)
+          && !(ourPawns & attack_span_mask(Them, s))
+          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
+      {
+          // We now know that there are no friendly pawns beside or behind this
+          // pawn on neighboring files. We now check whether the pawn is
+          // backward by looking in the forward direction on the neighboring
+          // files, and seeing whether we meet a friendly or an enemy pawn first.
+          b = pos.attacks_from<PAWN>(s, Us);
+
+          // Note that we are sure to find something because pawn is not passed
+          // nor isolated, so loop is potentially infinite, but it isn't.
+          while (!(b & (ourPawns | theirPawns)))
+              Us == WHITE ? b <<= 8 : b >>= 8;
+
+          // The friendly pawn needs to be at least two ranks closer than the
+          // enemy pawn in order to help the potentially backward pawn advance.
+          backward = (b | (Us == WHITE ? b << 8 : b >> 8)) & theirPawns;
+      }
+
+      assert(opposed | passed | (attack_span_mask(Us, s) & theirPawns));
+
+      // A not passed pawn is a candidate to become passed if it is free to
+      // advance and if the number of friendly pawns beside or behind this
+      // pawn on neighboring files is higher or equal than the number of
+      // enemy pawns in the forward direction on the neighboring files.
+      candidate =   !(opposed | passed | backward | isolated)
+                 && (b = attack_span_mask(Them, s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
+                 &&  count_1s<Max15>(b) >= count_1s<Max15>(attack_span_mask(Us, s) & theirPawns);
+
+      // Passed pawns will be properly scored in evaluation because we need
+      // full attack info to evaluate passed pawns. Only the frontmost passed
+      // pawn on each file is considered a true passed pawn.
+      if (passed && !doubled)
+          set_bit(&(pi->passedPawns[Us]), s);
+
+      // Score this pawn
+      if (isolated)
+          value -= IsolatedPawnPenalty[opposed][f];
+
+      if (doubled)
+          value -= DoubledPawnPenalty[opposed][f];
+
+      if (backward)
+          value -= BackwardPawnPenalty[opposed][f];
+
+      if (chain)
+          value += ChainBonus[f];
+
+      if (candidate)
+          value += CandidateBonus[relative_rank(Us, s)];
+  }
+  return value;
+}
+
+
+/// PawnInfo::updateShelter() calculates and caches king shelter. It is called
+/// only when king square changes, about 20% of total king_shelter() calls.
+template<Color Us>
+Score PawnInfo::updateShelter(const Position& pos, Square ksq) {
+
+  const int Shift = (Us == WHITE ? 8 : -8);
+
+  Bitboard pawns;
+  int r, shelter = 0;
+
+  if (relative_rank(Us, ksq) <= RANK_4)
+  {
+      pawns = pos.pieces(PAWN, Us) & this_and_neighboring_files_bb(ksq);
+      r = ksq & (7 << 3);
+      for (int i = 0; i < 3; i++)
+      {
+          r += Shift;
+          shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (64 >> i);
+      }
+  }
+  kingSquares[Us] = ksq;
+  kingShelters[Us] = make_score(shelter, 0);
+  return kingShelters[Us];
+}
+
+// Explicit template instantiation
+template Score PawnInfo::updateShelter<WHITE>(const Position& pos, Square ksq);
+template Score PawnInfo::updateShelter<BLACK>(const Position& pos, Square ksq);

src/pawns.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,25 +17,19 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(PAWNS_H_INCLUDED)
 #define PAWNS_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "position.h"
+#include "tt.h"
+#include "types.h"
 
-
-////
-//// Types
-////
+const int PawnTableSize = 16384;
 
 /// PawnInfo is a class which contains various information about a pawn
-/// structure.  Currently, it only includes a middle game and an end game
-/// pawn structure evaluation, and a bitboard of passed pawns.  We may want
-/// to add further information in the future.  A lookup to the pawn hash table
+/// structure. Currently, it only includes a middle game and an end game
+/// pawn structure evaluation, and a bitboard of passed pawns. We may want
+/// to add further information in the future. A lookup to the pawn hash table
 /// (performed by calling the get_pawn_info method in a PawnInfoTable object)
 /// returns a pointer to a PawnInfo object.
 
@@ -43,88 +38,70 @@ class PawnInfo {
   friend class PawnInfoTable;
 
 public:
-  Value mg_value() const;
-  Value eg_value() const;
-  Value kingside_storm_value(Color c) const;
-  Value queenside_storm_value(Color c) const;
-  Bitboard passed_pawns() const;
-  bool file_is_half_open(Color c, File f) const;
-  bool has_open_file_to_left(Color c, File f) const;
-  bool has_open_file_to_right(Color c, File f) const;
+  Score pawns_value() const;
+  Bitboard pawn_attacks(Color c) const;
+  Bitboard passed_pawns(Color c) const;
+  int file_is_half_open(Color c, File f) const;
+  int has_open_file_to_left(Color c, File f) const;
+  int has_open_file_to_right(Color c, File f) const;
+
+  template<Color Us>
+  Score king_shelter(const Position& pos, Square ksq);
 
 private:
-  void clear();
+  template<Color Us>
+  Score updateShelter(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns;
-  int16_t mgValue, egValue;
-  int8_t ksStormValue[2], qsStormValue[2];
-  uint8_t halfOpenFiles[2];
+  Bitboard passedPawns[2];
+  Bitboard pawnAttacks[2];
+  Square kingSquares[2];
+  Score value;
+  int halfOpenFiles[2];
+  Score kingShelters[2];
 };
 
 
-/// The PawnInfoTable class represents a pawn hash table.  It is basically
-/// just an array of PawnInfo objects and a few methods for accessing these
-/// objects.  The most important method is get_pawn_info, which looks up a
-/// position in the table and returns a pointer to a PawnInfo object.
-
-class PawnInfoTable {
+/// The PawnInfoTable class represents a pawn hash table. The most important
+/// method is get_pawn_info, which returns a pointer to a PawnInfo object.
 
+class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
 public:
-  PawnInfoTable(unsigned numOfEntries);
-  ~PawnInfoTable();
-  void clear();
-  PawnInfo *get_pawn_info(const Position &pos);
+  PawnInfo* get_pawn_info(const Position& pos) const;
 
 private:
-  unsigned size;
-  PawnInfo *entries;
+  template<Color Us>
+  static Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
 };
 
 
-////
-//// Inline functions
-////
-
-inline Value PawnInfo::mg_value() const {
-  return Value(mgValue);
+inline Score PawnInfo::pawns_value() const {
+  return value;
 }
 
-inline Value PawnInfo::eg_value() const {
-  return Value(egValue);
+inline Bitboard PawnInfo::pawn_attacks(Color c) const {
+  return pawnAttacks[c];
 }
 
-inline Bitboard PawnInfo::passed_pawns() const {
-  return passedPawns;
+inline Bitboard PawnInfo::passed_pawns(Color c) const {
+  return passedPawns[c];
 }
 
-inline Value PawnInfo::kingside_storm_value(Color c) const {
-  return Value(ksStormValue[c]);
+inline int PawnInfo::file_is_half_open(Color c, File f) const {
+  return halfOpenFiles[c] & (1 << int(f));
 }
 
-inline Value PawnInfo::queenside_storm_value(Color c) const {
-  return Value(qsStormValue[c]);
-}
-
-inline bool PawnInfo::file_is_half_open(Color c, File f) const {
-  return (halfOpenFiles[c] & (1 << int(f)));
-}
-
-inline bool PawnInfo::has_open_file_to_left(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
   return halfOpenFiles[c] & ((1 << int(f)) - 1);
 }
 
-inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
-inline void PawnInfo::clear() {
-  mgValue = egValue = 0;
-  passedPawns = EmptyBoardBB;
-  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
-  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
-  halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
+template<Color Us>
+inline Score PawnInfo::king_shelter(const Position& pos, Square ksq) {
+  return kingSquares[Us] == ksq ? kingShelters[Us] : updateShelter<Us>(pos, ksq);
 }
 
-
 #endif // !defined(PAWNS_H_INCLUDED)

src/phase.h

@@ -1,33 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(PHASE_H_INCLUDED)
-#define PHASE_H_INCLUDED
-
-////
-//// Types
-////
-
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-#endif // !defined(PHASE_H_INCLUDED)

src/piece.cpp

@@ -1,94 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cstring>
-
-#include "piece.h"
-
-
-////
-//// Constants and variables
-////
-
-const int SlidingArray[18] = {
-  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-};
-
-const SquareDelta Directions[16][16] = {
-  {DELTA_ZERO},
-  {DELTA_NW, DELTA_NE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_SW, DELTA_SE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-};   
-
-const SquareDelta PawnPush[2] = {
-  DELTA_N, DELTA_S
-};
-
-
-////
-//// Functions
-////
-
-/// Translating piece types to/from English piece letters:
-
-static const char PieceChars[] = " pnbrqk";
-
-char piece_type_to_char(PieceType pt, bool upcase = false) {
-  return upcase? toupper(PieceChars[pt]) : PieceChars[pt];
-}
-
-PieceType piece_type_from_char(char c) {
-  const char *ch = strchr(PieceChars, tolower(c));
-  return ch? PieceType(ch - PieceChars) : NO_PIECE_TYPE;
-}
-
-
-/// piece_is_ok() and piece_type_is_ok(), for debugging:
-
-bool piece_is_ok(Piece pc) {
-  return
-    piece_type_is_ok(type_of_piece(pc)) &&
-    color_is_ok(color_of_piece(pc));
-}
-
-bool piece_type_is_ok(PieceType pc) {
-  return pc >= PAWN && pc <= KING;
-}

src/piece.h

@@ -1,132 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(PIECE_H_INCLUDED)
-#define PIECE_H_INCLUDED
-
-//// 
-//// Includes
-////
-
-#include "color.h"
-#include "misc.h"
-#include "square.h"
-
-
-//// 
-//// Types
-////
-
-enum PieceType {
-  NO_PIECE_TYPE = 0,
-  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
-};
-
-enum Piece {
-  NO_PIECE = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
-  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14,
-  EMPTY = 16, OUTSIDE = 17
-};
-
-
-////
-//// Constants and variables
-////
-
-const PieceType PieceTypeMin = PAWN;
-const PieceType PieceTypeMax = KING;
-
-extern const int SlidingArray[18];
-extern const SquareDelta Directions[16][16];   
-extern const SquareDelta PawnPush[2];
-
-
-//// 
-//// Inline functions
-////
-
-inline Piece operator+ (Piece p, int i) { return Piece(int(p) + i); }
-inline void operator++ (Piece &p, int) { p = Piece(int(p) + 1); }
-inline Piece operator- (Piece p, int i) { return Piece(int(p) - i); }
-inline void operator-- (Piece &p, int) { p = Piece(int(p) - 1); }
-inline PieceType operator+ (PieceType p, int i) {return PieceType(int(p) + i);}
-inline void operator++ (PieceType &p, int) { p = PieceType(int(p) + 1); }
-inline PieceType operator- (PieceType p, int i) {return PieceType(int(p) - i);}
-inline void operator-- (PieceType &p, int) { p = PieceType(int(p) - 1); }
-
-inline PieceType type_of_piece(Piece p)  {
-  return PieceType(int(p) & 7);
-}
-
-inline Color color_of_piece(Piece p) {
-  return Color(int(p) >> 3);
-}
-
-inline Piece piece_of_color_and_type(Color c, PieceType pt) {
-  return Piece((int(c) << 3) | int(pt));
-}
-
-inline Piece pawn_of_color(Color c) {
-  return piece_of_color_and_type(c, PAWN);
-}
-
-inline Piece knight_of_color(Color c) {
-  return piece_of_color_and_type(c, KNIGHT);
-}
-
-inline Piece bishop_of_color(Color c) {
-  return piece_of_color_and_type(c, BISHOP);
-}
-
-inline Piece rook_of_color(Color c) {
-  return piece_of_color_and_type(c, ROOK);
-}
-
-inline Piece queen_of_color(Color c) {
-  return piece_of_color_and_type(c, QUEEN);
-}
-
-inline Piece king_of_color(Color c) {
-  return piece_of_color_and_type(c, KING);
-}
-
-inline int piece_is_slider(Piece p) {
-  return SlidingArray[int(p)];
-}
-
-inline int piece_type_is_slider(PieceType pt) {
-  return SlidingArray[int(pt)];
-}
-
-inline SquareDelta pawn_push(Color c) {
-  return PawnPush[c];
-}
-  
-
-////
-//// Prototypes
-////
-
-extern char piece_type_to_char(PieceType pt, bool upcase);
-extern PieceType piece_type_from_char(char c);
-extern bool piece_is_ok(Piece pc);
-extern bool piece_type_is_ok(PieceType pt);
-
-
-#endif // !defined(PIECE_H_INCLUDED)

src/position.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,111 +17,113 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "bitboard.h"
-#include "color.h"
-#include "direction.h"
 #include "move.h"
-#include "piece.h"
-#include "phase.h"
-#include "square.h"
-#include "value.h"
-
-
-////
-//// Constants
-////
-
-/// FEN string for the initial position:
-const std::string StartPosition = 
-  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+#include "types.h"
 
 /// Maximum number of plies per game (220 should be enough, because the
 /// maximum search depth is 100, and during position setup we reset the
-/// move counter for every non-reversible move):
+/// move counter for every non-reversible move).
 const int MaxGameLength = 220;
 
+class Position;
 
-////
-//// Types
-////
+/// struct checkInfo is initialized at c'tor time and keeps
+/// info used to detect if a move gives check.
 
-/// Castle rights, encoded as bit fields:
+struct CheckInfo {
+
+    explicit CheckInfo(const Position&);
+
+    Bitboard dcCandidates;
+    Bitboard checkSq[8];
+    Square ksq;
+};
+
+/// Castle rights, encoded as bit fields
 
 enum CastleRights {
-  NO_CASTLES = 0, 
-  WHITE_OO = 1, BLACK_OO = 2, 
-  WHITE_OOO = 4, BLACK_OOO = 8,
-  ALL_CASTLES = 15
+  CASTLES_NONE = 0,
+  WHITE_OO     = 1,
+  BLACK_OO     = 2,
+  WHITE_OOO    = 4,
+  BLACK_OOO    = 8,
+  ALL_CASTLES  = 15
+};
+
+/// Game phase
+enum Phase {
+  PHASE_ENDGAME = 0,
+  PHASE_MIDGAME = 128
 };
 
 
-/// The UndoInfo struct stores information we need to restore a Position
-/// object to its previous state when we retract a move.  Whenever a move
-/// is made on the board (by calling Position::do_move), an UndoInfo object
-/// must be passed as a parameter.  When the move is unmade (by calling
-/// Position::undo_move), the same UndoInfo object must be passed again.
+/// The StateInfo struct stores information we need to restore a Position
+/// object to its previous state when we retract a move. Whenever a move
+/// is made on the board (by calling Position::do_move), an StateInfo object
+/// must be passed as a parameter.
 
-struct UndoInfo {
-  int castleRights;
+struct StateInfo {
+  Key pawnKey, materialKey;
+  int castleRights, rule50, gamePly, pliesFromNull;
   Square epSquare;
+  Score value;
+  Value npMaterial[2];
+
+  PieceType capturedType;
+  Key key;
   Bitboard checkersBB;
-  Key key, pawnKey, materialKey;
-  int rule50;
-  Move lastMove;
-  PieceType capture;
-  Value mgValue, egValue;
+  StateInfo* previous;
 };
 
 
-/// The position data structure.  A position consists of the following data:
+/// The position data structure. A position consists of the following data:
 ///
 ///    * For each piece type, a bitboard representing the squares occupied
 ///      by pieces of that type.
-///    * For each color, a bitboard representing the squares occupiecd by
+///    * For each color, a bitboard representing the squares occupied by
 ///      pieces of that color.
 ///    * A bitboard of all occupied squares.
 ///    * A bitboard of all checking pieces.
 ///    * A 64-entry array of pieces, indexed by the squares of the board.
 ///    * The current side to move.
 ///    * Information about the castling rights for both sides.
-///    * The initial files of the kings and both pairs of rooks.  This is
+///    * The initial files of the kings and both pairs of rooks. This is
 ///      used to implement the Chess960 castling rules.
 ///    * The en passant square (which is SQ_NONE if no en passant capture is
 ///      possible).
 ///    * The squares of the kings for both sides.
-///    * The last move played.
 ///    * Hash keys for the position itself, the current pawn structure, and
 ///      the current material situation.
-///    * Hash keys for all previous positions in the game (for detecting
+///    * Hash keys for all previous positions in the game for detecting
 ///      repetition draws.
 ///    * A counter for detecting 50 move rule draws.
 
 class Position {
 
-  friend class MaterialInfo;
+  Position(); // No default or copy c'tor allowed
+  Position(const Position& pos);
 
 public:
+  enum GamePhase {
+      MidGame,
+      EndGame
+  };
+
   // Constructors
-  Position();
-  Position(const Position &pos);
-  Position(const std::string &fen);
+  Position(const Position& pos, int threadID);
+  Position(const std::string& fen, bool isChess960, int threadID);
 
   // Text input/output
-  void from_fen(const std::string &fen);
+  void from_fen(const std::string& fen, bool isChess960);
   const std::string to_fen() const;
-  void print() const;
+  void print(Move m = MOVE_NONE) const;
 
   // Copying
-  void copy(const Position &pos);
-  void flipped_copy(const Position &pos);
+  void flip();
 
   // The piece on a given square
   Piece piece_on(Square s) const;
@@ -138,256 +141,216 @@ public:
   Bitboard empty_squares() const;
   Bitboard occupied_squares() const;
   Bitboard pieces_of_color(Color c) const;
-  Bitboard pieces_of_type(PieceType pt) const;
-  Bitboard pieces_of_color_and_type(Color c, PieceType pt) const;
-  Bitboard pawns() const;
-  Bitboard knights() const;
-  Bitboard bishops() const;
-  Bitboard rooks() const;
-  Bitboard queens() const;
-  Bitboard kings() const;
-  Bitboard rooks_and_queens() const;
-  Bitboard bishops_and_queens() const;
-  Bitboard sliders() const;
-  Bitboard pawns(Color c) const;
-  Bitboard knights(Color c) const;
-  Bitboard bishops(Color c) const;
-  Bitboard rooks(Color c) const;
-  Bitboard queens(Color c) const;
-  Bitboard kings(Color c) const;
-  Bitboard rooks_and_queens(Color c) const;
-  Bitboard bishops_and_queens(Color c) const;
-  Bitboard sliders_of_color(Color c) const;
+  Bitboard pieces(PieceType pt) const;
+  Bitboard pieces(PieceType pt, Color c) const;
+  Bitboard pieces(PieceType pt1, PieceType pt2) const;
+  Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
 
   // Number of pieces of each color and type
   int piece_count(Color c, PieceType pt) const;
-  int pawn_count(Color c) const;
-  int knight_count(Color c) const;
-  int bishop_count(Color c) const;
-  int rook_count(Color c) const;
-  int queen_count(Color c) const;
 
-  // The en passant square:
+  // The en passant square
   Square ep_square() const;
 
   // Current king position for each color
   Square king_square(Color c) const;
 
-  // Castling rights.
+  // Castling rights
   bool can_castle_kingside(Color c) const;
   bool can_castle_queenside(Color c) const;
   bool can_castle(Color c) const;
   Square initial_kr_square(Color c) const;
   Square initial_qr_square(Color c) const;
 
-  // Attack bitboards
-  Bitboard sliding_attacks(Square s, Direction d) const;
-  Bitboard ray_attacks(Square s, SignedDirection d) const;
-  Bitboard pawn_attacks(Color c, Square s) const;
-  Bitboard white_pawn_attacks(Square s) const;
-  Bitboard black_pawn_attacks(Square s) const;
-  Bitboard knight_attacks(Square s) const;
-  Bitboard bishop_attacks(Square s) const;
-  Bitboard rook_attacks(Square s) const;
-  Bitboard queen_attacks(Square s) const;
-  Bitboard king_attacks(Square s) const;
-
   // Bitboards for pinned pieces and discovered check candidates
   Bitboard discovered_check_candidates(Color c) const;
   Bitboard pinned_pieces(Color c) const;
 
-  // Checking pieces
+  // Checking pieces and under check information
   Bitboard checkers() const;
+  bool in_check() const;
 
-  // Piece lists:
+  // Piece lists
   Square piece_list(Color c, PieceType pt, int index) const;
-  Square pawn_list(Color c, int index) const;
-  Square knight_list(Color c, int index) const;
-  Square bishop_list(Color c, int index) const;
-  Square rook_list(Color c, int index) const;
-  Square queen_list(Color c, int index) const;
+  const Square* piece_list_begin(Color c, PieceType pt) const;
 
-  // Attack information for a given square
-  bool square_is_attacked(Square s, Color c) const;
-  Bitboard attacks_to(Square s) const;
-  Bitboard attacks_to(Square s, Color c) const;
-  bool is_check() const;
-  bool piece_attacks_square(Square f, Square t) const;
-  bool white_pawn_attacks_square(Square f, Square t) const;
-  bool black_pawn_attacks_square(Square f, Square t) const;
-  bool knight_attacks_square(Square f, Square t) const;
-  bool bishop_attacks_square(Square f, Square t) const;
-  bool rook_attacks_square(Square f, Square t) const;
-  bool queen_attacks_square(Square f, Square t) const;
-  bool king_attacks_square(Square f, Square t) const;
+  // Information about attacks to or from a given square
+  Bitboard attackers_to(Square s) const;
+  Bitboard attacks_from(Piece p, Square s) const;
+  static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
+  template<PieceType> Bitboard attacks_from(Square s) const;
+  template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool move_is_legal(Move m) const;
-  bool move_is_legal(Move m, Bitboard pinned) const;
-  bool move_is_check(Move m) const;
-  bool move_is_check(Move m, Bitboard dcCandidates) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_evasion(Move m, Bitboard pinned) const;
+  bool move_is_legal(const Move m) const;
+  bool move_is_legal(const Move m, Bitboard pinned) const;
+  bool move_gives_check(Move m) const;
+  bool move_gives_check(Move m, const CheckInfo& ci) const;
   bool move_is_capture(Move m) const;
-  bool move_is_pawn_push_to_7th(Move m) const;
+  bool move_is_capture_or_promotion(Move m) const;
   bool move_is_passed_pawn_push(Move m) const;
-  bool move_was_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) const;
 
+  // Piece captured with previous moves
+  PieceType captured_piece_type() const;
+
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
-  bool pawn_is_isolated(Color c, Square s) const;
-  bool pawn_is_doubled(Color c, Square s) const;
-
-  // Open and half-open files
-  bool file_is_open(File f) const;
-  bool file_is_half_open(Color c, File f) const;
 
   // Weak squares
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void backup(UndoInfo &u) const;
-  void restore(const UndoInfo &u);
-  void do_move(Move m, UndoInfo &u);
-  void do_move(Move m, UndoInfo &u, Bitboard dcCandidates);
-  void undo_move(Move m, const UndoInfo &u);
-  void do_null_move(UndoInfo &u);
-  void undo_null_move(const UndoInfo &u);
+  void do_setup_move(Move m);
+  void do_move(Move m, StateInfo& st);
+  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();
 
   // Static exchange evaluation
   int see(Square from, Square to) const;
   int see(Move m) const;
+  int see_sign(Move m) const;
 
   // Accessing hash keys
   Key get_key() const;
+  Key get_exclusion_key() const;
   Key get_pawn_key() const;
   Key get_material_key() const;
 
   // Incremental evaluation
-  Value mg_value() const;
-  Value eg_value() const;
+  Score value() const;
   Value non_pawn_material(Color c) const;
-  Phase game_phase() const;
+  static Score pst_delta(Piece piece, Square from, Square to);
 
   // Game termination checks
-  bool is_mate();
+  bool is_mate() const;
   bool is_draw() const;
 
-  // Check if one side threatens a mate in one
-  bool has_mate_threat(Color c);
-
-  // Number of plies since the last non-reversible move
-  int rule_50_counter() const;
+  // Number of plies from starting position
+  int startpos_ply_counter() const;
 
   // Other properties of the position
   bool opposite_colored_bishops() const;
   bool has_pawn_on_7th(Color c) const;
+  bool is_chess960() const;
 
-  // Reset the gamePly variable to 0
-  void reset_game_ply();
+  // Current thread ID searching on the position
+  int thread() const;
+
+  int64_t nodes_searched() const;
+  void set_nodes_searched(int64_t n);
 
   // Position consistency check, for debugging
-  bool is_ok() const;
+  bool is_ok(int* failedStep = NULL) const;
 
-  // Static member functions:
+  // Static member functions
   static void init_zobrist();
   static void init_piece_square_tables();
 
 private:
+
   // Initialization helper functions (used while setting up a position)
   void clear();
+  void detach();
   void put_piece(Piece p, Square s);
-  void allow_oo(Color c);
-  void allow_ooo(Color c);
+  void do_allow_oo(Color c);
+  void do_allow_ooo(Color c);
+  bool set_castling_rights(char token);
 
   // Helper functions for doing and undoing moves
+  void do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep);
   void do_castle_move(Move m);
-  void do_promotion_move(Move m, UndoInfo &u);
-  void do_ep_move(Move m);
   void undo_castle_move(Move m);
-  void undo_promotion_move(Move m, const UndoInfo &u);
-  void undo_ep_move(Move m);
   void find_checkers();
 
+  template<bool FindPinned>
+  Bitboard hidden_checkers(Color c) const;
+
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
   Key compute_pawn_key() const;
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  Value mg_pst(Color c, PieceType pt, Square s) const;
-  Value eg_pst(Color c, PieceType pt, Square s) const;
-  Value compute_mg_value() const;
-  Value compute_eg_value() const;
+  static Score pst(Color c, PieceType pt, Square s);
+  Score compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
-  // Bitboards
-  Bitboard byColorBB[2], byTypeBB[8];
-  Bitboard checkersBB;
-
   // Board
   Piece board[64];
 
+  // Bitboards
+  Bitboard byTypeBB[8], byColorBB[2];
+
   // Piece counts
   int pieceCount[2][8]; // [color][pieceType]
 
   // Piece lists
   Square pieceList[2][8][16]; // [color][pieceType][index]
-  int index[64];
+  int index[64]; // [square]
 
   // Other info
   Color sideToMove;
-  int castleRights;
+  Key history[MaxGameLength];
+  int castleRightsMask[64];
+  StateInfo startState;
   File initialKFile, initialKRFile, initialQRFile;
-  Square epSquare;
-  Square kingSquare[2];
-  Move lastMove;
-  Key key, pawnKey, materialKey, history[MaxGameLength];
-  int rule50, gamePly;
-  Value mgValue, egValue;
-  Value npMaterial[2];
+  bool chess960;
+  int startPosPlyCounter;
+  int threadID;
+  int64_t nodes;
+  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 Value EgPieceSquareTable[16][64];
+  static Score PieceSquareTable[16][64];
+  static Key zobExclusion;
+  static const Value seeValues[8];
+  static const Value PieceValueMidgame[17];
+  static const Value PieceValueEndgame[17];
 };
 
+inline int64_t Position::nodes_searched() const {
+  return nodes;
+}
 
-////
-//// Inline functions
-////
+inline void Position::set_nodes_searched(int64_t n) {
+  nodes = n;
+}
 
 inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
 inline Color Position::color_of_piece_on(Square s) const {
-  return color_of_piece(this->piece_on(s));
+  return color_of_piece(piece_on(s));
 }
 
 inline PieceType Position::type_of_piece_on(Square s) const {
-  return type_of_piece(this->piece_on(s));
+  return type_of_piece(piece_on(s));
 }
 
 inline bool Position::square_is_empty(Square s) const {
-  return this->piece_on(s) == EMPTY;
+  return piece_on(s) == PIECE_NONE;
 }
 
 inline bool Position::square_is_occupied(Square s) const {
-  return !this->square_is_empty(s);
+  return !square_is_empty(s);
 }
 
 inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return piece_value_midgame(this->piece_on(s));
+  return PieceValueMidgame[piece_on(s)];
 }
 
 inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return piece_value_endgame(this->piece_on(s));
+  return PieceValueEndgame[piece_on(s)];
 }
 
 inline Color Position::side_to_move() const {
@@ -399,156 +362,55 @@ inline Bitboard Position::occupied_squares() const {
 }
 
 inline Bitboard Position::empty_squares() const {
-  return ~(this->occupied_squares());
+  return ~occupied_squares();
 }
 
 inline Bitboard Position::pieces_of_color(Color c) const {
   return byColorBB[c];
 }
 
-inline Bitboard Position::pieces_of_type(PieceType pt) const {
+inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt)
-  const {
-  return this->pieces_of_color(c) & this->pieces_of_type(pt);
+inline Bitboard Position::pieces(PieceType pt, Color c) const {
+  return byTypeBB[pt] & byColorBB[c];
 }
 
-inline Bitboard Position::pawns() const {
-  return this->pieces_of_type(PAWN);
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
+  return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::knights() const {
-  return this->pieces_of_type(KNIGHT);
-}
-
-inline Bitboard Position::bishops() const {
-  return this->pieces_of_type(BISHOP);
-}
-
-inline Bitboard Position::rooks() const {
-  return this->pieces_of_type(ROOK);
-}
-
-inline Bitboard Position::queens() const {
-  return this->pieces_of_type(QUEEN);
-}
-
-inline Bitboard Position::kings() const {
-  return this->pieces_of_type(KING);
-}
-
-inline Bitboard Position::rooks_and_queens() const {
-  return this->rooks() | this->queens();
-}
-
-inline Bitboard Position::bishops_and_queens() const {
-  return this->bishops() | this->queens();
-}
-
-inline Bitboard Position::sliders() const {
-  return this->bishops() | this->queens() | this->rooks();
-}
-
-inline Bitboard Position::pawns(Color c) const {
-  return this->pieces_of_color_and_type(c, PAWN);
-}
-
-inline Bitboard Position::knights(Color c) const {
-  return this->pieces_of_color_and_type(c, KNIGHT);
-}
-
-inline Bitboard Position::bishops(Color c) const {
-  return this->pieces_of_color_and_type(c, BISHOP);
-}
-
-inline Bitboard Position::rooks(Color c) const {
-  return this->pieces_of_color_and_type(c, ROOK);
-}
-
-inline Bitboard Position::queens(Color c) const {
-  return this->pieces_of_color_and_type(c, QUEEN);
-}
-
-inline Bitboard Position::kings(Color c) const {
-  return this->pieces_of_color_and_type(c, KING);
-}
-
-inline Bitboard Position::rooks_and_queens(Color c) const {
-  return this->rooks_and_queens() & this->pieces_of_color(c);
-}
-
-inline Bitboard Position::bishops_and_queens(Color c) const {
-  return this->bishops_and_queens() & this->pieces_of_color(c);
-}
-
-inline Bitboard Position::sliders_of_color(Color c) const {
-  return this->sliders() & this->pieces_of_color(c);
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
+  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
 }
 
 inline int Position::piece_count(Color c, PieceType pt) const {
   return pieceCount[c][pt];
 }
 
-inline int Position::pawn_count(Color c) const {
-  return this->piece_count(c, PAWN);
+inline Square Position::piece_list(Color c, PieceType pt, int idx) const {
+  return pieceList[c][pt][idx];
 }
 
-inline int Position::knight_count(Color c) const {
-  return this->piece_count(c, KNIGHT);
-}
-
-inline int Position::bishop_count(Color c) const {
-  return this->piece_count(c, BISHOP);
-}
-
-inline int Position::rook_count(Color c) const {
-  return this->piece_count(c, ROOK);
-}
-
-inline int Position::queen_count(Color c) const {
-  return this->piece_count(c, QUEEN);
-}
-
-inline Square Position::piece_list(Color c, PieceType pt, int index) const {
-  return pieceList[c][pt][index];
-}
-
-inline Square Position::pawn_list(Color c, int index) const {
-  return this->piece_list(c, PAWN, index);
-}
-
-inline Square Position::knight_list(Color c, int index) const {
-  return this->piece_list(c, KNIGHT, index);
-}
-
-inline Square Position::bishop_list(Color c, int index) const {
-  return this->piece_list(c, BISHOP, index);
-}
-
-inline Square Position::rook_list(Color c, int index) const {
-  return this->piece_list(c, ROOK, index);
-}
-
-inline Square Position::queen_list(Color c, int index) const {
-  return this->piece_list(c, QUEEN, index);
+inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
+  return pieceList[c][pt];
 }
 
 inline Square Position::ep_square() const {
-  return epSquare;
+  return st->epSquare;
 }
 
 inline Square Position::king_square(Color c) const {
-  return kingSquare[c];
+  return pieceList[c][KING][0];
 }
 
 inline bool Position::can_castle_kingside(Color side) const {
-  return castleRights & (1+int(side));
+  return st->castleRights & (1+int(side));
 }
 
 inline bool Position::can_castle_queenside(Color side) const {
-  return castleRights & (4+4*int(side));
+  return st->castleRights & (4+4*int(side));
 }
 
 inline bool Position::can_castle(Color side) const {
@@ -563,184 +425,130 @@ inline Square Position::initial_qr_square(Color c) const {
   return relative_square(c, make_square(initialQRFile, RANK_1));
 }
 
-inline Bitboard Position::pawn_attacks(Color c, Square s) const {
-  return StepAttackBB[pawn_of_color(c)][s];
+template<>
+inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
+  return StepAttacksBB[make_piece(c, PAWN)][s];
 }
 
-inline Bitboard Position::white_pawn_attacks(Square s) const {
-  return this->pawn_attacks(WHITE, s);
+template<PieceType Piece> // Knight and King and white pawns
+inline Bitboard Position::attacks_from(Square s) const {
+  return StepAttacksBB[Piece][s];
 }
 
-inline Bitboard Position::black_pawn_attacks(Square s) const {
-  return this->pawn_attacks(BLACK, s);
+template<>
+inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
+  return bishop_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::knight_attacks(Square s) const {
-  return StepAttackBB[KNIGHT][s];
+template<>
+inline Bitboard Position::attacks_from<ROOK>(Square s) const {
+  return rook_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::rook_attacks(Square s) const {
-  return rook_attacks_bb(s, this->occupied_squares());
-}
-
-inline Bitboard Position::bishop_attacks(Square s) const {
-  return bishop_attacks_bb(s, this->occupied_squares());
-}
-
-inline Bitboard Position::queen_attacks(Square s) const {
-  return this->rook_attacks(s) | this->bishop_attacks(s);
-}
-
-inline Bitboard Position::king_attacks(Square s) const {
-  return StepAttackBB[KING][s];
+template<>
+inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
+  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
 }
 
 inline Bitboard Position::checkers() const {
-  return checkersBB;
+  return st->checkersBB;
 }
 
-inline bool Position::is_check() const {
-  return this->checkers() != EmptyBoardBB;
-}
-
-inline bool Position::white_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->white_pawn_attacks(f), t);
-}
-
-inline bool Position::black_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->black_pawn_attacks(f), t);
-}
-
-inline bool Position::knight_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->knight_attacks(f), t);
-}
-
-inline bool Position::bishop_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->bishop_attacks(f), t);
-}
-
-inline bool Position::rook_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->rook_attacks(f), t);
-}
-
-inline bool Position::queen_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->queen_attacks(f), t);
-}
-
-inline bool Position::king_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->king_attacks(f), t);
+inline bool Position::in_check() const {
+  return st->checkersBB != EmptyBoardBB;
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(this->pawns(opposite_color(c)) & passed_pawn_mask(c, s));
-}
-
-inline bool Position::pawn_is_isolated(Color c, Square s) const {
-  return !(this->pawns(c) & neighboring_files_bb(s));
-}
-
-inline bool Position::pawn_is_doubled(Color c, Square s) const {
-  return this->pawns(c) & squares_behind(c, s);
-}
-
-inline bool Position::file_is_open(File f) const {
-  return !(this->pawns() & file_bb(f));
-}
-
-inline bool Position::file_is_half_open(Color c, File f) const {
-  return !(this->pawns(c) & file_bb(f));
+  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
 }
 
 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(this->pawns(c) & outpost_mask(opposite_color(c), s));
+  return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
 }
 
 inline Key Position::get_key() const {
-  return key;
+  return st->key;
+}
+
+inline Key Position::get_exclusion_key() const {
+  return st->key ^ zobExclusion;
 }
 
 inline Key Position::get_pawn_key() const {
-  return pawnKey;
+  return st->pawnKey;
 }
 
 inline Key Position::get_material_key() const {
-  return materialKey;
+  return st->materialKey;
 }
 
-inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
-  return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Score Position::pst(Color c, PieceType pt, Square s) {
+  return PieceSquareTable[make_piece(c, pt)][s];
 }
 
-inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
-  return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Score Position::pst_delta(Piece piece, Square from, Square to) {
+  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
 }
 
-inline Value Position::mg_value() const {
-  return mgValue;
-}
-
-inline Value Position::eg_value() const {
-  return egValue;
+inline Score Position::value() const {
+  return st->value;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
-  return npMaterial[c];
-}
-
-inline Phase Position::game_phase() const {
-
-  // The purpose of the Value(325) terms below is to make sure the difference
-  // between MidgameLimit and EndgameLimit is a power of 2, which should make
-  // the division at the end of the function a bit faster.
-
-  static const Value MidgameLimit =
-    2*QueenValueMidgame+2*RookValueMidgame+6*BishopValueMidgame+Value(325);
-  static const Value EndgameLimit = 4*RookValueMidgame-Value(325);
-  Value npm = this->non_pawn_material(WHITE) + this->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_pawn_push_to_7th(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    pawn_rank(c, move_to(m)) == RANK_7;
+  return st->npMaterial[c];
 }
 
 inline bool Position::move_is_passed_pawn_push(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
+
+  Color c = side_to_move();
+  return   piece_on(move_from(m)) == make_piece(c, PAWN)
+        && pawn_is_passed(c, move_to(m));
 }
 
-inline bool Position::move_was_passed_pawn_push(Move m) const {
-  Color c = opposite_color(this->side_to_move());
-  return 
-    this->piece_on(move_to(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
-}
-
-inline int Position::rule_50_counter() const {
-  return rule50;
+inline int Position::startpos_ply_counter() const {
+  return startPosPlyCounter;
 }
 
 inline bool Position::opposite_colored_bishops() const {
-  return
-    this->bishop_count(WHITE) == 1 && this->bishop_count(BLACK) == 1 &&
-    square_color(this->bishop_list(WHITE, 0)) !=
-    square_color(this->bishop_list(BLACK, 0));
+
+  return   piece_count(WHITE, BISHOP) == 1 && piece_count(BLACK, BISHOP) == 1
+        && opposite_color_squares(piece_list(WHITE, BISHOP, 0), piece_list(BLACK, BISHOP, 0));
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
-  return this->pawns(c) & relative_rank_bb(c, RANK_7);
+  return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
 }
 
+inline bool Position::is_chess960() const {
+  return chess960;
+}
+
+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));
+}
+
+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_type() const {
+  return st->capturedType;
+}
+
+inline int Position::thread() const {
+  return threadID;
+}
+
+inline void Position::do_allow_oo(Color c) {
+  st->castleRights |= (1 + int(c));
+}
+
+inline void Position::do_allow_ooo(Color c) {
+  st->castleRights |= (4 + 4*int(c));
+}
 
 #endif // !defined(POSITION_H_INCLUDED)

src/psqtab.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,149 +17,169 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(PSQTAB_H_INCLUDED)
 #define PSQTAB_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "position.h"
+#include "types.h"
 
+namespace {
 
 ////
-//// Variables
+//// Constants modified by Joona Kiiski
 ////
 
-static const int MgPST[][64] = {
+const Value MP = PawnValueMidgame;
+const Value MK = KnightValueMidgame;
+const Value MB = BishopValueMidgame;
+const Value MR = RookValueMidgame;
+const Value MQ = QueenValueMidgame;
+
+const Value EP = PawnValueEndgame;
+const Value EK = KnightValueEndgame;
+const Value EB = BishopValueEndgame;
+const Value ER = RookValueEndgame;
+const Value EQ = QueenValueEndgame;
+
+const int MgPST[][64] = {
   { },
-  { // Pawn
-    0, 0, 0, 0, 0, 0, 0, 0,
-    166, 192, 204, 216, 216, 204, 192, 166,
-    166, 192, 210, 242, 242, 210, 192, 166, 
-    166, 192, 220, 268, 268, 220, 192, 166, 
-    166, 192, 220, 242, 242, 220, 192, 166, 
-    166, 192, 210, 216, 216, 210, 192, 166, 
-    166, 192, 204, 216, 216, 204, 192, 166, 
-    0, 0, 0, 0, 0, 0, 0, 0
+  {// Pawn
+   // A      B      C     D      E      F      G     H
+        0,    0,     0,     0,     0,     0,    0,     0,
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
+    MP-28, MP-6, MP+ 9, MP+36, MP+36, MP+ 9, MP-6, MP-28,
+    MP-28, MP-6, MP+17, MP+58, MP+58, MP+17, MP-6, MP-28,
+    MP-28, MP-6, MP+17, MP+36, MP+36, MP+17, MP-6, MP-28,
+    MP-28, MP-6, MP+ 9, MP+14, MP+14, MP+ 9, MP-6, MP-28,
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
+        0,    0,     0,     0,     0,     0,    0,     0
   },
-  { // Knight
-    704, 730, 756, 768, 768, 756, 730, 704, 
-    743, 768, 794, 807, 807, 794, 768, 743, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    807, 832, 857, 870, 870, 857, 832, 807, 
-    820, 844, 870, 883, 883, 870, 844, 820, 
-    820, 844, 870, 883, 883, 870, 844, 820, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    650, 768, 794, 807, 807, 794, 768, 650
+  {// Knight
+   //  A      B       C      D      E      F      G       H
+    MK-135, MK-107, MK-80, MK-67, MK-67, MK-80, MK-107, MK-135,
+    MK- 93, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK- 93,
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
+    MK- 25, MK+  1, MK+27, MK+41, MK+41, MK+27, MK+  1, MK- 25,
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
+    MK-193, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK-193
   },
-  { // Bishop
-    786, 786, 792, 797, 797, 792, 786, 786, 
-    812, 832, 827, 832, 832, 827, 832, 812, 
-    817, 827, 842, 837, 837, 842, 827, 817, 
-    822, 832, 837, 852, 852, 837, 832, 822, 
-    822, 832, 837, 852, 852, 837, 832, 822, 
-    817, 827, 842, 837, 837, 842, 827, 817, 
-    812, 832, 827, 832, 832, 827, 832, 812, 
-    812, 812, 817, 822, 822, 817, 812, 812
+  {// Bishop
+   // A      B      C      D      E      F      G      H
+    MB-40, MB-40, MB-35, MB-30, MB-30, MB-35, MB-40, MB-40,
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
+    MB-17, MB-17, MB-13, MB- 8, MB- 8, MB-13, MB-17, MB-17
   },
-  { // Rook
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267
+  {// Rook
+   // A      B     C     D     E     F     G     H
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12
   },
-  { // Queen
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560
+  {// Queen
+   // A     B     C     D     E     F     G     H
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8
   },
-  { // King
-    302, 328, 276, 225, 225, 276, 328, 302, 
-    276, 302, 251, 200, 200, 251, 302, 276, 
-    225, 251, 200, 149, 149, 200, 251, 225, 
-    200, 225, 175, 124, 124, 175, 225, 200, 
-    175, 200, 149, 98, 98, 149, 200, 175, 
-    149, 175, 124, 72, 72, 124, 175, 149, 
-    124, 149, 98, 47, 47, 98, 149, 124, 
-    98, 124, 72, 21, 21, 72, 124, 98, 
+  {// King
+   //A    B    C    D    E    F    G    H
+    287, 311, 262, 214, 214, 262, 311, 287,
+    262, 287, 238, 190, 190, 238, 287, 262,
+    214, 238, 190, 142, 142, 190, 238, 214,
+    190, 214, 167, 119, 119, 167, 214, 190,
+    167, 190, 142,  94,  94, 142, 190, 167,
+    142, 167, 119,  69,  69, 119, 167, 142,
+    119, 142,  94,  46,  46,  94, 142, 119,
+     94, 119,  69,  21,  21,  69, 119,  94
   }
 };
 
-
-static const int EgPST[][64] = {
+const int EgPST[][64] = {
   { },
-  { // Pawn
-    0, 0, 0, 0, 0, 0, 0, 0, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    256, 256, 256, 256, 256, 256, 256, 256, 
-    0, 0, 0, 0, 0, 0, 0, 0
+  {// Pawn
+   // A     B     C     D     E     F     G     H
+       0,    0,    0,    0,    0,    0,    0,    0,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
+       0,    0,    0,    0,    0,    0,    0,    0
   },
-  { // Knight
-    730, 756, 781, 794, 794, 781, 756, 730, 
-    756, 781, 807, 820, 820, 807, 781, 756, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    794, 820, 844, 857, 857, 844, 820, 794, 
-    794, 820, 844, 857, 857, 844, 820, 794, 
-    781, 807, 832, 844, 844, 832, 807, 781, 
-    756, 781, 807, 820, 820, 807, 781, 756, 
-    730, 756, 781, 794, 794, 781, 756, 730
+  {// Knight
+   // A       B      C      D      E      F      G      H
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104,
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104
   },
-  { // Bishop
-    786, 802, 809, 817, 817, 809, 802, 786, 
-    802, 817, 825, 832, 832, 825, 817, 802, 
-    809, 825, 832, 839, 839, 832, 825, 809, 
-    817, 832, 839, 847, 847, 839, 832, 817, 
-    817, 832, 839, 847, 847, 839, 832, 817, 
-    809, 825, 832, 839, 839, 832, 825, 809, 
-    802, 817, 825, 832, 832, 825, 817, 802, 
-    786, 802, 809, 817, 817, 809, 802, 786
+  {// Bishop
+   // A      B      C      D      E      F      G      H
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59,
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59
   },
-  { // Rook
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282
+  {// Rook
+   // A     B     C     D     E     F     G     H
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3
   },
-  { // Queen
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499, 
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499
+  {// Queen
+   // A      B      C      D      E      F      G      H
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80,
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80
   },
-  { // King
-    16, 78, 108, 139, 139, 108, 78, 16, 
-    78, 139, 170, 200, 200, 170, 139, 78, 
-    108, 170, 200, 230, 230, 200, 170, 108, 
-    139, 200, 230, 261, 261, 230, 200, 139, 
-    139, 200, 230, 261, 261, 230, 200, 139, 
-    108, 170, 200, 230, 230, 200, 170, 108, 
-    78, 139, 170, 200, 200, 170, 139, 78, 
-    16, 78, 108, 139, 139, 108, 78, 16
+  {// King
+   //A    B    C    D    E    F    G    H
+     18,  77, 105, 135, 135, 105,  77,  18,
+     77, 135, 165, 193, 193, 165, 135,  77,
+    105, 165, 193, 222, 222, 193, 165, 105,
+    135, 193, 222, 251, 251, 222, 193, 135,
+    135, 193, 222, 251, 251, 222, 193, 135,
+    105, 165, 193, 222, 222, 193, 165, 105,
+     77, 135, 165, 193, 193, 165, 135,  77,
+     18,  77, 105, 135, 135, 105,  77,  18
   }
 };
 
+} // namespace
 
 #endif // !defined(PSQTAB_H_INCLUDED)

src/rkiss.h

@@ -0,0 +1,77 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  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
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  This file is based on original code by Heinz van Saanen and is
+  available under the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+ ** George Marsaglia invented the RNG-Kiss-family in the early 90's.
+ ** This is a specific version that Heinz van Saanen derived and
+ ** tested from some public domain code by Bob Jenkins:
+ **
+ ** Quite platform independent
+ ** Passes ALL dieharder tests! Here *nix sys-rand() e.g. fails miserably:-)
+ ** ~12 times faster than my *nix sys-rand()
+ ** ~4 times faster than SSE2-version of Mersenne twister
+ ** Average cycle length: ~2^126
+ ** 64 bit seed
+ ** Return doubles with a full 53 bit mantissa
+ ** Thread safe
+*/
+
+#if !defined(RKISS_H_INCLUDED)
+#define RKISS_H_INCLUDED
+
+#include "types.h"
+
+class RKISS {
+
+  // Keep variables always together
+  struct S { uint64_t a, b, c, d; } s;
+
+  uint64_t rotate(uint64_t x, uint64_t k) const {
+    return (x << k) | (x >> (64 - k));
+  }
+
+  // Return 64 bit unsigned integer in between [0, 2^64 - 1]
+  uint64_t rand64() {
+
+    const uint64_t
+      e = s.a - rotate(s.b,  7);
+    s.a = s.b ^ rotate(s.c, 13);
+    s.b = s.c + rotate(s.d, 37);
+    s.c = s.d + e;
+    return s.d = e + s.a;
+  }
+
+  // Init seed and scramble a few rounds
+  void raninit() {
+
+    s.a = 0xf1ea5eed;
+    s.b = s.c = s.d = 0xd4e12c77;
+    for (int i = 0; i < 73; i++)
+        rand64();
+  }
+
+public:
+  RKISS() { raninit(); }
+  template<typename T> T rand() { return T(rand64()); }
+};
+
+#endif // !defined(RKISS_H_INCLUDED)

src/san.cpp

@@ -1,417 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstring>
-#include <iomanip>
-#include <string>
-#include <sstream>
-
-#include "movepick.h"
-#include "san.h"
-
-
-////
-//// Local definitions
-////
-
-namespace {
-
-  /// Types
-
-  enum Ambiguity {
-    AMBIGUITY_NONE,
-    AMBIGUITY_FILE,
-    AMBIGUITY_RANK,
-    AMBIGUITY_BOTH
-  };
-
-
-  /// Functions
-  
-  Ambiguity move_ambiguity(Position &pos, Move m);
-  const std::string time_string(int milliseconds);
-  const std::string score_string(Value v);
-}
-
-
-////
-//// Functions
-////
-
-/// move_to_san() takes a position and a move as input, where it is assumed
-/// that the move is a legal move from the position.  The return value is
-/// a string containing the move in short algebraic notation.
-
-const std::string move_to_san(Position &pos, Move m) {
-  std::string str;
-
-  assert(pos.is_ok());
-  assert(move_is_ok(m));
-
-  if(m == MOVE_NONE) {
-    str = "(none)";
-    return str;
-  }
-  else if(m == MOVE_NULL) {
-    str = "(null)";
-    return str;
-  }
-  else if(move_is_long_castle(m))
-    str = "O-O-O";
-  else if(move_is_short_castle(m))
-    str = "O-O";
-  else {
-    Square from, to;
-    Piece pc;
-
-    from = move_from(m);
-    to = move_to(m);
-    pc = pos.piece_on(move_from(m));
-
-    str = "";
-
-    if(type_of_piece(pc) == PAWN) {
-      if(pos.move_is_capture(m))
-        str += file_to_char(square_file(move_from(m)));
-    }
-    else {
-      str += piece_type_to_char(type_of_piece(pc), true);
-
-      Ambiguity amb = move_ambiguity(pos, m);
-      switch(amb) {
-
-      case AMBIGUITY_NONE:
-        break;
-
-      case AMBIGUITY_FILE:
-        str += file_to_char(square_file(from));
-        break;
-
-      case AMBIGUITY_RANK:
-        str += rank_to_char(square_rank(from));
-        break;
-
-      case AMBIGUITY_BOTH:
-        str += square_to_string(from);
-        break;
-
-      default:
-        assert(false);
-      }
-    }
-
-    if(pos.move_is_capture(m))
-      str += "x";
-
-    str += square_to_string(move_to(m));
-
-    if(move_promotion(m)) {
-      str += "=";
-      str += piece_type_to_char(move_promotion(m), true);
-    }
-  }
-
-  // Is the move check?  We don't use pos.move_is_check(m) here, because
-  // Position::move_is_check doesn't detect all checks (not castling moves,
-  // promotions and en passant captures).
-  UndoInfo u;
-  pos.do_move(m, u);
-  if(pos.is_check())
-    str += pos.is_mate()? "#" : "+";
-  pos.undo_move(m, u);
-
-  return str;
-}
-
-
-/// move_from_san() takes a position and a string as input, and tries to
-/// interpret the string as a move in short algebraic notation.  On success,
-/// the move is returned.  On failure (i.e. if the string is unparsable, or
-/// if the move is illegal or ambiguous), MOVE_NONE is returned.
-
-Move move_from_san(Position &pos, const std::string &movestr) {
-  assert(pos.is_ok());
-  
-  MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
-                             MOVE_NONE, OnePly);
-
-  // Castling moves
-  if(movestr == "O-O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_long_castle(m) && pos.move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
-  else if(movestr == "O-O") {
-    Move m;
-    while((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.move_is_legal(m))
-        return m;
-    return MOVE_NONE;
-  }
-
-  // Normal moves
-  const char *cstr = movestr.c_str();
-  const char *c;
-  char *cc;
-  char str[10];
-  int i;
-
-  // Initialize str[] by making a copy of movestr with the characters
-  // 'x', '=', '+' and '#' removed.  
-  cc = str;
-  for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++)
-    if(!strchr("x=+#", *c)) {
-      *cc = strchr("nrq", *c)? toupper(*c) : *c;
-      cc++;
-    }
-  *cc = '\0';
-
-  int left = 0, right = strlen(str) - 1;
-  PieceType pt = NO_PIECE_TYPE, promotion;
-  Square to;
-  File fromFile = FILE_NONE;
-  Rank fromRank = RANK_NONE;
-
-  // Promotion?
-  if(strchr("BNRQ", str[right])) {
-    promotion = piece_type_from_char(str[right]);
-    right--;
-  }
-  else
-    promotion = NO_PIECE_TYPE;
-
-  // Find the moving piece:
-  if(left < right) {
-    if(strchr("BNRQK", str[left])) {
-      pt = piece_type_from_char(str[left]);
-      left++;
-    }
-    else
-      pt = PAWN;
-  }
-
-  // Find the to square:
-  if(left < right) {
-    if(str[right] < '1' || str[right] > '8' ||
-       str[right-1] < 'a' || str[right-1] > 'h')
-      return MOVE_NONE;
-    to = make_square(file_from_char(str[right-1]), rank_from_char(str[right]));
-    right -= 2;
-  }
-  else
-    return MOVE_NONE;
-
-  // Find the file and/or rank of the from square:
-  if(left <= right) {
-    if(strchr("abcdefgh", str[left])) {
-      fromFile = file_from_char(str[left]);
-      left++;
-    }
-    if(strchr("12345678", str[left]))
-      fromRank = rank_from_char(str[left]);
-  }
-
-  // Look for a matching move:
-  Move m, move = MOVE_NONE;
-  int matches = 0;
-  
-  while((m = mp.get_next_move()) != MOVE_NONE) {
-    bool match = true;
-    if(pos.type_of_piece_on(move_from(m)) != pt)
-      match = false;
-    else if(move_to(m) != to)
-      match = false;
-    else if(move_promotion(m) != promotion)
-      match = false;
-    else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m)))
-      match = false;
-    else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m)))
-      match = false;
-    if(match) {
-      move = m;
-      matches++;
-    }
-  }
-  
-  if(matches == 1)
-    return move;
-  else
-    return MOVE_NONE;
-}
-
-
-/// line_to_san() takes a position and a line (an array of moves representing
-/// a sequence of legal moves from the position) as input, and returns a
-/// string containing the line in short algebraic notation.  If the boolean
-/// parameter 'breakLines' is true, line breaks are inserted, with a line
-/// length of 80 characters.  After a line break, 'startColumn' spaces are
-/// inserted at the beginning of the new line.
-
-const std::string line_to_san(const Position &pos, Move line[], int startColumn,
-                              bool breakLines) {
-  Position p = Position(pos);
-  UndoInfo u;
-  std::stringstream s;
-  std::string moveStr;
-  int length, maxLength;
-
-  length = 0;
-  maxLength = 80 - startColumn;
-
-  for(int i = 0; line[i] != MOVE_NONE; i++) {
-    moveStr = move_to_san(p, line[i]);
-    length += moveStr.length() + 1;
-    if(breakLines && length > maxLength) {
-      s << "\n";
-      for(int j = 0; j < startColumn; j++)
-        s << " ";
-      length = moveStr.length() + 1;
-    }
-    s << moveStr << " ";
-
-    if(line[i] == MOVE_NULL)
-      p.do_null_move(u);
-    else
-      p.do_move(line[i], u);
-  }
-
-  return s.str();
-}
-
-
-/// pretty_pv() creates a human-readable string from a position and a PV.
-/// It is used to write search information to the log file (which is created
-/// when the UCI parameter "Use Search Log" is "true").
-
-const std::string pretty_pv(const Position &pos, int time, int depth,
-                            uint64_t nodes, Value score, Move pv[]) {
-  std::stringstream s;
-
-  // Depth
-  s << std::setw(2) << std::setfill(' ') << depth << "  ";
-
-  // Score
-  s << std::setw(8) << score_string(score);
-
-  // Time
-  s << std::setw(8) << std::setfill(' ') << time_string(time) << " ";
-
-  // Nodes
-  if(nodes < 1000000ULL)
-    s << std::setw(8) << std::setfill(' ') << nodes << " ";
-  else if(nodes < 1000000000ULL)
-    s << std::setw(7) << std::setfill(' ') << nodes/1000ULL << 'k' << " ";
-  else
-    s << std::setw(7) << std::setfill(' ') << nodes/1000000ULL << 'M' << " ";
-
-  // PV
-  s << line_to_san(pos, pv, 30, true);
-
-  return s.str();
-}
-
-
-namespace {
-
-  Ambiguity move_ambiguity(Position &pos, Move m) {
-    Square from, to;
-    Piece pc;
-
-    from = move_from(m);
-    to = move_to(m);
-    pc = pos.piece_on(from);
-
-    // King moves are never ambiguous, because there is never two kings of
-    // the same color.
-    if(type_of_piece(pc) == KING)
-      return AMBIGUITY_NONE;
-
-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
-                               MOVE_NONE, OnePly);
-    Move mv, moveList[8];
-    int i, j, n;
-
-    n = 0;
-    while((mv = mp.get_next_move()) != MOVE_NONE)
-      if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
-         && pos.move_is_legal(mv))
-        moveList[n++] = mv;
-    if(n == 1)
-      return AMBIGUITY_NONE;
-
-    j = 0;
-    for(i = 0; i < n; i++)
-      if(square_file(move_from(moveList[i])) == square_file(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_FILE;
-
-    j = 0;
-    for(i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
-        j++;
-    if(j == 1)
-      return AMBIGUITY_RANK;
-
-    return AMBIGUITY_BOTH;
-  }
-
-
-  const std::string time_string(int milliseconds) {
-    std::stringstream s;
-
-    int hours = milliseconds / (1000 * 60 * 60);
-    int minutes = (milliseconds - hours*1000*60*60) / (60*1000);
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*60*1000) / 1000;
-
-    if(hours)
-      s << hours << ':';
-    s << std::setw(2) << std::setfill('0') << minutes << ':';
-    s << std::setw(2) << std::setfill('0') << seconds;
-    
-    return s.str();
-  }
-
-
-  const std::string score_string(Value v) {
-    std::stringstream s;
-
-    if(abs(v) >= VALUE_MATE - 200) {
-      if(v < 0)
-        s << "-#" << (VALUE_MATE + v) / 2;
-      else
-        s << "#" << (VALUE_MATE - v + 1) / 2;
-    }
-    else {
-      float floatScore = float(v) / float(PawnValueMidgame);
-      if(v >= 0)
-        s << '+';
-      s << std::setprecision(2) << std::fixed << floatScore;
-    }
-    return s.str();
-  }
-  
-}

src/san.h

@@ -1,46 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(SAN_H_INCLUDED)
-#define SAN_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <string>
-
-#include "move.h"
-#include "position.h"
-#include "value.h"
-
-
-////
-//// Prototypes
-////
-
-extern const std::string move_to_san(Position &pos, Move m);
-extern Move move_from_san(Position &pos, const std::string &str);
-extern const std::string line_to_san(const Position &pos, Move line[],
-                                     int startColumn, bool breakLines);
-extern const std::string pretty_pv(const Position &pos, int time, int depth,
-                                   uint64_t nodes, Value score, Move pv[]);
-
-
-#endif // !defined(SAN_H_INCLUDED)

src/scale.h

@@ -1,51 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(SCALE_H_INCLUDED)
-#define SCALE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "value.h"
-
-
-////
-//// Types
-////
-
-enum ScaleFactor {
-  SCALE_FACTOR_ZERO = 0,
-  SCALE_FACTOR_NORMAL = 64,
-  SCALE_FACTOR_MAX = 128,
-  SCALE_FACTOR_NONE = 255
-};
-
-
-////
-//// Inline functions
-////
-
-inline Value apply_scale_factor(Value v, ScaleFactor f) {
-  return Value((v * f) / int(SCALE_FACTOR_NORMAL));
-}
-
-
-#endif // !defined(SCALE_H_INCLUDED)

src/search.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,35 +17,16 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(SEARCH_H_INCLUDED)
 #define SEARCH_H_INCLUDED
 
-////
-//// Includes
-////
+#include <cstring>
 
+#include "move.h"
 #include "types.h"
-#include "depth.h"
-#include "history.h"
-#include "lock.h"
-#include "movegen.h"
-#include "position.h"
-#include "tt.h"
-#include "value.h"
 
-
-////
-//// Constants
-////
-
-const int PLY_MAX = 100;
-const int PLY_MAX_PLUS_2 = 102;
-
-
-////
-//// Types
-////
+class Position;
+struct SplitPoint;
 
 /// The SearchStack struct keeps track of the information we need to remember
 /// from nodes shallower and deeper in the tree during the search.  Each
@@ -52,39 +34,40 @@ const int PLY_MAX_PLUS_2 = 102;
 /// current ply.
 
 struct SearchStack {
-  Move pv[PLY_MAX];
+  int ply;
   Move currentMove;
-  Value currentMoveCaptureValue;
-  Move mateKiller, killer1, killer2;
-  Move threatMove;
+  Move mateKiller;
+  Move excludedMove;
+  Move bestMove;
+  Move killers[2];
   Depth reduction;
+  Value eval;
+  Value evalMargin;
+  bool skipNullMove;
+  SplitPoint* sp;
 };
 
 
-////
-//// Global variables
-////
+/// The SearchLimits struct stores information sent by GUI about available time
+/// to search the current move, maximum depth/time, if we are in analysis mode
+/// or if we have to ponder while is our opponent's side to move.
 
-extern TranspositionTable TT;
+struct SearchLimits {
 
-extern int ActiveThreads;
+  SearchLimits() { memset(this, 0, sizeof(SearchLimits)); }
 
-extern Lock SMPLock;
+  SearchLimits(int t, int i, int mtg, int mt, int md, int mn, bool inf, bool pon)
+              : time(t), increment(i), movesToGo(mtg), maxTime(mt), maxDepth(md),
+                maxNodes(mn), infinite(inf), ponder(pon) {}
 
-// Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;  
+  bool useTimeManagement() const { return !(maxTime | maxDepth | maxNodes | int(infinite)); }
 
+  int time, increment, movesToGo, maxTime, maxDepth, maxNodes;
+  bool infinite, ponder;
+};
 
-////
-//// Prototypes
-////
-
-extern void init_threads();
-extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int time,
-                  int increment, int movesToGo, int maxDepth, int maxNodes,
-                  int maxTime, Move searchMoves[]);
-extern int64_t nodes_searched();
-
+extern void init_search();
+extern int64_t perft(Position& pos, Depth depth);
+extern bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]);
 
 #endif // !defined(SEARCH_H_INCLUDED)

src/square.cpp

@@ -1,85 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstdio>
-#include <string>
-
-#include "square.h"
-
-
-////
-//// Functions
-////
-
-
-/// Translating files, ranks and squares to/from characters and strings:
-
-File file_from_char(char c) {
-  return File(c - 'a') + FILE_A;
-}
-
-
-char file_to_char(File f) {
-  return char(f - FILE_A) + 'a';
-}
-
-
-Rank rank_from_char(char c) {
-  return Rank(c - '1') + RANK_1;
-}
-
-
-char rank_to_char(Rank r) {
-  return char(r - RANK_1) + '1';
-}
-
-
-Square square_from_string(const std::string &str) {
-  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
-}
-
-
-const std::string square_to_string(Square s) {
-  std::string str;
-  str += file_to_char(square_file(s));
-  str += rank_to_char(square_rank(s));
-  return str;
-}
-
-
-/// file_is_ok(), rank_is_ok() and square_is_ok(), for debugging:
-
-bool file_is_ok(File f) {
-  return f >= FILE_A && f <= FILE_H;
-}
-
-
-bool rank_is_ok(Rank r) {
-  return r >= RANK_1 && r <= RANK_8;
-}
-
-
-bool square_is_ok(Square s) {
-  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
-}

src/square.h

@@ -1,177 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(SQUARE_H_INCLUDED)
-#define SQUARE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <string>
-
-#include "color.h"
-#include "misc.h"
-
-
-////
-//// Types
-////
-
-enum Square {
-  SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,
-  SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
-  SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,
-  SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4,
-  SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5,
-  SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6,
-  SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
-  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
-  SQ_NONE
-}; 
-
-enum File {
-  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NONE
-};
-
-enum Rank {
-  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NONE
-};
-
-enum SquareDelta {
-  DELTA_SSW = -021, DELTA_SS = -020, DELTA_SSE = -017, DELTA_SWW = -012,
-  DELTA_SW = -011, DELTA_S = -010, DELTA_SE = -07, DELTA_SEE = -06,
-  DELTA_W = -01, DELTA_ZERO = 0, DELTA_E = 01, DELTA_NWW = 06, DELTA_NW = 07,
-  DELTA_N = 010, DELTA_NE = 011, DELTA_NEE = 012, DELTA_NNW = 017,
-  DELTA_NN = 020, DELTA_NNE = 021
-};
-
-
-////
-//// Constants
-////
-
-const int FlipMask = 070;
-const int FlopMask = 07;
-
-
-//// 
-//// Inline functions
-////
-
-inline File operator+ (File x, int i) { return File(int(x) + i); }
-inline File operator+ (File x, File y) { return x + int(y); }
-inline void operator++ (File &x, int) { x = File(int(x) + 1); }
-inline void operator+= (File &x, int i) { x = File(int(x) + i); }
-inline File operator- (File x, int i) { return File(int(x) - i); }
-inline void operator-- (File &x, int) { x = File(int(x) - 1); }
-inline void operator-= (File &x, int i) { x = File(int(x) - i); }
-
-inline Rank operator+ (Rank x, int i) { return Rank(int(x) + i); }
-inline Rank operator+ (Rank x, Rank y) { return x + int(y); }
-inline void operator++ (Rank &x, int) { x = Rank(int(x) + 1); }
-inline void operator+= (Rank &x, int i) { x = Rank(int(x) + i); }
-inline Rank operator- (Rank x, int i) { return Rank(int(x) - i); }
-inline void operator-- (Rank &x, int) { x = Rank(int(x) - 1); }
-inline void operator-= (Rank &x, int i) { x = Rank(int(x) - i); }
-
-inline Square operator+ (Square x, int i) { return Square(int(x) + i); }
-inline void operator++ (Square &x, int) { x = Square(int(x) + 1); }
-inline void operator+= (Square &x, int i) { x = Square(int(x) + i); }
-inline Square operator- (Square x, int i) { return Square(int(x) - i); }
-inline void operator-- (Square &x, int) { x = Square(int(x) - 1); }
-inline void operator-= (Square &x, int i) { x = Square(int(x) - i); }
-inline Square operator+ (Square x, SquareDelta i) { return Square(int(x) + i); }
-inline void operator+= (Square &x, SquareDelta i) { x = Square(int(x) + i); }
-inline Square operator- (Square x, SquareDelta i) { return Square(int(x) - i); }
-inline void operator-= (Square &x, SquareDelta i) { x = Square(int(x) - i); }
-inline SquareDelta operator- (Square x, Square y) {
-  return SquareDelta(int(x) - int(y));
-}
-
-inline Square make_square(File f, Rank r) {
-  return Square(int(f) | (int(r) << 3));
-}
-
-inline File square_file(Square s) {
-  return File(int(s) & 7);
-}
-
-inline Rank square_rank(Square s) {
-  return Rank(int(s) >> 3);
-}
-
-inline Square flip_square(Square s) {
-  return Square(int(s) ^ FlipMask);
-}
-
-inline Square flop_square(Square s) {
-  return Square(int(s) ^ FlopMask);
-}
-
-inline Square relative_square(Color c, Square s) {
-  return Square(int(s) ^ (int(c) * FlipMask));
-}
-
-inline Rank pawn_rank(Color c, Square s) {
-  return square_rank(relative_square(c, s));
-}
-
-inline Color square_color(Square s) {
-  return Color((int(square_file(s)) + int(square_rank(s))) & 1);
-}
-
-inline int file_distance(File f1, File f2) {
-  return abs(int(f1) - int(f2));
-}
-
-inline int file_distance(Square s1, Square s2) {
-  return file_distance(square_file(s1), square_file(s2));
-}
-
-inline int rank_distance(Rank r1, Rank r2) {
-  return abs(int(r1) - int(r2));
-}
-
-inline int rank_distance(Square s1, Square s2) {
-  return rank_distance(square_rank(s1), square_rank(s2));
-}
-
-inline int square_distance(Square s1, Square s2) {
-  return Max(file_distance(s1, s2), rank_distance(s1, s2));
-}
-
-
-//// 
-//// Prototypes
-////
-
-extern File file_from_char(char c);
-extern char file_to_char(File f);
-extern Rank rank_from_char(char c);
-extern char rank_to_char(Rank r);
-extern Square square_from_string(const std::string &str);
-extern const std::string square_to_string(Square s);
-
-extern bool file_is_ok(File f);
-extern bool rank_is_ok(Rank r);
-extern bool square_is_ok(Square s);
-
-
-#endif // !defined(SQUARE_H_INCLUDED)

src/thread.cpp

@@ -0,0 +1,345 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  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
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <iostream>
+
+#include "thread.h"
+#include "ucioption.h"
+
+ThreadsManager Threads; // Global object definition
+
+namespace { extern "C" {
+
+ // start_routine() is the C function which is called when a new thread
+ // is launched. It simply calls idle_loop() with the supplied threadID.
+ // There are two versions of this function; one for POSIX threads and
+ // one for Windows threads.
+
+#if defined(_MSC_VER)
+
+  DWORD WINAPI start_routine(LPVOID threadID) {
+
+    Threads.idle_loop(*(int*)threadID, NULL);
+    return 0;
+  }
+
+#else
+
+  void* start_routine(void* threadID) {
+
+    Threads.idle_loop(*(int*)threadID, NULL);
+    return NULL;
+  }
+
+#endif
+
+} }
+
+
+// wake_up() wakes up the thread, normally at the beginning of the search or,
+// if "sleeping threads" is used, when there is some work to do.
+
+void Thread::wake_up() {
+
+  lock_grab(&sleepLock);
+  cond_signal(&sleepCond);
+  lock_release(&sleepLock);
+}
+
+
+// cutoff_occurred() checks whether a beta cutoff has occurred in
+// the thread's currently active split point, or in some ancestor of
+// the current split point.
+
+bool Thread::cutoff_occurred() const {
+
+  for (SplitPoint* sp = splitPoint; sp; sp = sp->parent)
+      if (sp->is_betaCutoff)
+          return true;
+  return false;
+}
+
+
+// is_available_to() checks whether the thread is available to help the thread with
+// threadID "master" at a split point. An obvious requirement is that thread must be
+// idle. With more than two threads, this is not by itself sufficient: If the thread
+// is the master of some active split point, it is only available as a slave to the
+// threads which are busy searching the split point at the top of "slave"'s split
+// point stack (the "helpful master concept" in YBWC terminology).
+
+bool Thread::is_available_to(int master) const {
+
+  if (state != AVAILABLE)
+      return false;
+
+  // Make a local copy to be sure doesn't become zero under our feet while
+  // testing next condition and so leading to an out of bound access.
+  int localActiveSplitPoints = activeSplitPoints;
+
+  // No active split points means that the thread is available as a slave for any
+  // other thread otherwise apply the "helpful master" concept if possible.
+  if (   !localActiveSplitPoints
+      || splitPoints[localActiveSplitPoints - 1].is_slave[master])
+      return true;
+
+  return false;
+}
+
+
+// read_uci_options() updates number of active threads and other internal
+// parameters according to the UCI options values. It is called before
+// to start a new search.
+
+void ThreadsManager::read_uci_options() {
+
+  maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value<int>();
+  minimumSplitDepth       = Options["Minimum Split Depth"].value<int>() * ONE_PLY;
+  useSleepingThreads      = Options["Use Sleeping Threads"].value<bool>();
+  activeThreads           = Options["Threads"].value<int>();
+}
+
+
+// init() is called during startup. Initializes locks and condition variables
+// and launches all threads sending them immediately to sleep.
+
+void ThreadsManager::init() {
+
+  int threadID[MAX_THREADS];
+
+  // This flag is needed to properly end the threads when program exits
+  allThreadsShouldExit = false;
+
+  // Threads will sent to sleep as soon as created, only main thread is kept alive
+  activeThreads = 1;
+  threads[0].state = Thread::SEARCHING;
+
+  // Allocate pawn and material hash tables for main thread
+  init_hash_tables();
+
+  lock_init(&mpLock);
+
+  // Initialize thread and split point locks
+  for (int i = 0; i < MAX_THREADS; i++)
+  {
+      lock_init(&threads[i].sleepLock);
+      cond_init(&threads[i].sleepCond);
+
+      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+          lock_init(&(threads[i].splitPoints[j].lock));
+  }
+
+  // Create and startup all the threads but the main that is already running
+  for (int i = 1; i < MAX_THREADS; i++)
+  {
+      threads[i].state = Thread::INITIALIZING;
+      threadID[i] = i;
+
+#if defined(_MSC_VER)
+      bool ok = (CreateThread(NULL, 0, start_routine, (LPVOID)&threadID[i], 0, NULL) != NULL);
+#else
+      pthread_t pthreadID;
+      bool ok = (pthread_create(&pthreadID, NULL, start_routine, (void*)&threadID[i]) == 0);
+      pthread_detach(pthreadID);
+#endif
+      if (!ok)
+      {
+          std::cout << "Failed to create thread number " << i << std::endl;
+          ::exit(EXIT_FAILURE);
+      }
+
+      // Wait until the thread has finished launching and is gone to sleep
+      while (threads[i].state == Thread::INITIALIZING) {}
+  }
+}
+
+
+// exit() is called to cleanly exit the threads when the program finishes
+
+void ThreadsManager::exit() {
+
+  // Force the woken up threads to exit idle_loop() and hence terminate
+  allThreadsShouldExit = true;
+
+  for (int i = 0; i < MAX_THREADS; i++)
+  {
+      // Wake up all the threads and waits for termination
+      if (i != 0)
+      {
+          threads[i].wake_up();
+          while (threads[i].state != Thread::TERMINATED) {}
+      }
+
+      // Now we can safely destroy the locks and wait conditions
+      lock_destroy(&threads[i].sleepLock);
+      cond_destroy(&threads[i].sleepCond);
+
+      for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
+          lock_destroy(&(threads[i].splitPoints[j].lock));
+  }
+
+  lock_destroy(&mpLock);
+}
+
+
+// init_hash_tables() dynamically allocates pawn and material hash tables
+// according to the number of active threads. This avoids preallocating
+// memory for all possible threads if only few are used as, for instance,
+// on mobile devices where memory is scarce and allocating for MAX_THREADS
+// threads could even result in a crash.
+
+void ThreadsManager::init_hash_tables() {
+
+  for (int i = 0; i < activeThreads; i++)
+  {
+      threads[i].pawnTable.init();
+      threads[i].materialTable.init();
+  }
+}
+
+
+// available_slave_exists() tries to find an idle thread which is available as
+// a slave for the thread with threadID "master".
+
+bool ThreadsManager::available_slave_exists(int master) const {
+
+  assert(master >= 0 && master < activeThreads);
+
+  for (int i = 0; i < activeThreads; i++)
+      if (i != master && threads[i].is_available_to(master))
+          return true;
+
+  return false;
+}
+
+
+// split() does the actual work of distributing the work at a node between
+// several available threads. If it does not succeed in splitting the
+// node (because no idle threads are available, or because we have no unused
+// split point objects), the function immediately returns. If splitting is
+// possible, a SplitPoint object is initialized with all the data that must be
+// copied to the helper threads and we tell our helper threads that they have
+// been assigned work. This will cause them to instantly leave their idle loops and
+// call search().When all threads have returned from search() then split() returns.
+
+template <bool Fake>
+void ThreadsManager::split(Position& pos, SearchStack* ss, Value* alpha, const Value beta,
+                           Value* bestValue, Depth depth, Move threatMove,
+                           int moveCount, MovePicker* mp, bool pvNode) {
+  assert(pos.is_ok());
+  assert(*bestValue >= -VALUE_INFINITE);
+  assert(*bestValue <= *alpha);
+  assert(*alpha < beta);
+  assert(beta <= VALUE_INFINITE);
+  assert(depth > DEPTH_ZERO);
+  assert(pos.thread() >= 0 && pos.thread() < activeThreads);
+  assert(activeThreads > 1);
+
+  int i, master = pos.thread();
+  Thread& masterThread = threads[master];
+
+  lock_grab(&mpLock);
+
+  // If no other thread is available to help us, or if we have too many
+  // active split points, don't split.
+  if (   !available_slave_exists(master)
+      || masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS)
+  {
+      lock_release(&mpLock);
+      return;
+  }
+
+  // Pick the next available split point object from the split point stack
+  SplitPoint& splitPoint = masterThread.splitPoints[masterThread.activeSplitPoints++];
+
+  // Initialize the split point object
+  splitPoint.parent = masterThread.splitPoint;
+  splitPoint.master = master;
+  splitPoint.is_betaCutoff = false;
+  splitPoint.depth = depth;
+  splitPoint.threatMove = threatMove;
+  splitPoint.alpha = *alpha;
+  splitPoint.beta = beta;
+  splitPoint.pvNode = pvNode;
+  splitPoint.bestValue = *bestValue;
+  splitPoint.mp = mp;
+  splitPoint.moveCount = moveCount;
+  splitPoint.pos = &pos;
+  splitPoint.nodes = 0;
+  splitPoint.ss = ss;
+  for (i = 0; i < activeThreads; i++)
+      splitPoint.is_slave[i] = false;
+
+  masterThread.splitPoint = &splitPoint;
+
+  // If we are here it means we are not available
+  assert(masterThread.state != Thread::AVAILABLE);
+
+  int workersCnt = 1; // At least the master is included
+
+  // Allocate available threads setting state to THREAD_BOOKED
+  for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++)
+      if (i != master && threads[i].is_available_to(master))
+      {
+          threads[i].state = Thread::BOOKED;
+          threads[i].splitPoint = &splitPoint;
+          splitPoint.is_slave[i] = true;
+          workersCnt++;
+      }
+
+  assert(Fake || workersCnt > 1);
+
+  // We can release the lock because slave threads are already booked and master is not available
+  lock_release(&mpLock);
+
+  // Tell the threads that they have work to do. This will make them leave
+  // their idle loop.
+  for (i = 0; i < activeThreads; i++)
+      if (i == master || splitPoint.is_slave[i])
+      {
+          assert(i == master || threads[i].state == Thread::BOOKED);
+
+          threads[i].state = Thread::WORKISWAITING; // This makes the slave to exit from idle_loop()
+
+          if (useSleepingThreads && i != master)
+              threads[i].wake_up();
+      }
+
+  // Everything is set up. The master thread enters the idle loop, from
+  // which it will instantly launch a search, because its state is
+  // THREAD_WORKISWAITING.  We send the split point as a second parameter to the
+  // idle loop, which means that the main thread will return from the idle
+  // loop when all threads have finished their work at this split point.
+  idle_loop(master, &splitPoint);
+
+  // We have returned from the idle loop, which means that all threads are
+  // finished. Update alpha and bestValue, and return.
+  lock_grab(&mpLock);
+
+  *alpha = splitPoint.alpha;
+  *bestValue = splitPoint.bestValue;
+  masterThread.activeSplitPoints--;
+  masterThread.splitPoint = splitPoint.parent;
+  pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes);
+
+  lock_release(&mpLock);
+}
+
+// Explicit template instantiations
+template void ThreadsManager::split<false>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);
+template void ThreadsManager::split<true>(Position&, SearchStack*, Value*, const Value, Value*, Depth, Move, int, MovePicker*, bool);

src/thread.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,63 +17,116 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(THREAD_H_INCLUDED)
 #define THREAD_H_INCLUDED
 
-
-////
-//// Includes
-////
+#include <cstring>
 
 #include "lock.h"
+#include "material.h"
 #include "movepick.h"
+#include "pawns.h"
 #include "position.h"
-#include "search.h"
 
-
-////
-//// Constants and variables
-////
-
-const int THREAD_MAX = 8;
-
-
-////
-//// Types
-////
+const int MAX_THREADS = 32;
+const int MAX_ACTIVE_SPLIT_POINTS = 8;
 
 struct SplitPoint {
-  SplitPoint *parent;
-  Position pos;
-  SearchStack sstack[THREAD_MAX][PLY_MAX];
-  SearchStack *parentSstack;
-  int ply;
+
+  // Const data after splitPoint has been setup
+  SplitPoint* parent;
+  const Position* pos;
   Depth depth;
-  volatile Value alpha, beta, bestValue;
   bool pvNode;
-  Bitboard dcCandidates;
-  int master, slaves[THREAD_MAX];
+  Value beta;
+  int ply;
+  int master;
+  Move threatMove;
+
+  // Const pointers to shared data
+  MovePicker* mp;
+  SearchStack* ss;
+
+  // Shared data
   Lock lock;
-  MovePicker *mp;
-  volatile int moves;
-  volatile int cpus;
-  bool finished;
+  volatile int64_t nodes;
+  volatile Value alpha;
+  volatile Value bestValue;
+  volatile int moveCount;
+  volatile bool is_betaCutoff;
+  volatile bool is_slave[MAX_THREADS];
 };
 
 
+/// Thread struct is used to keep together all the thread related stuff like locks,
+/// state and especially split points. We also use per-thread pawn and material hash
+/// tables so that once we get a pointer to an entry its life time is unlimited and
+/// we don't have to care about someone changing the entry under our feet.
+
 struct Thread {
-  SplitPoint *splitPoint;
-  int activeSplitPoints;
-  uint64_t nodes;
-  bool failHighPly1;
-  volatile bool stop;
-  volatile bool running;
-  volatile bool idle;
-  volatile bool workIsWaiting;
-  volatile bool printCurrentLine;
-  unsigned char pad[64];
+
+  enum ThreadState
+  {
+    INITIALIZING,  // Thread is initializing itself
+    SEARCHING,     // Thread is performing work
+    AVAILABLE,     // Thread is waiting for work
+    BOOKED,        // Other thread (master) has booked us as a slave
+    WORKISWAITING, // Master has ordered us to start
+    TERMINATED     // We are quitting and thread is terminated
+  };
+
+  void wake_up();
+  bool cutoff_occurred() const;
+  bool is_available_to(int master) const;
+
+  MaterialInfoTable materialTable;
+  PawnInfoTable pawnTable;
+  int maxPly;
+  Lock sleepLock;
+  WaitCondition sleepCond;
+  volatile ThreadState state;
+  SplitPoint* volatile splitPoint;
+  volatile int activeSplitPoints;
+  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
 };
 
 
+/// ThreadsManager class is used to handle all the threads related stuff like init,
+/// starting, parking and, the most important, launching a slave thread at a split
+/// point. All the access to shared thread data is done through this class.
+
+class ThreadsManager {
+  /* As long as the single ThreadsManager object is defined as a global we don't
+     need to explicitly initialize to zero its data members because variables with
+     static storage duration are automatically set to zero before enter main()
+  */
+public:
+  Thread& operator[](int threadID) { return threads[threadID]; }
+  void init();
+  void exit();
+  void init_hash_tables();
+
+  int min_split_depth() const { return minimumSplitDepth; }
+  int size() const { return activeThreads; }
+  void set_size(int cnt) { activeThreads = cnt; }
+
+  void read_uci_options();
+  bool available_slave_exists(int master) const;
+  void idle_loop(int threadID, SplitPoint* sp);
+
+  template <bool Fake>
+  void split(Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,
+             Depth depth, Move threatMove, int moveCount, MovePicker* mp, bool pvNode);
+private:
+  Lock mpLock;
+  Depth minimumSplitDepth;
+  int maxThreadsPerSplitPoint;
+  bool useSleepingThreads;
+  int activeThreads;
+  volatile bool allThreadsShouldExit;
+  Thread threads[MAX_THREADS];
+};
+
+extern ThreadsManager Threads;
+
 #endif // !defined(THREAD_H_INCLUDED)

src/timeman.cpp

@@ -0,0 +1,161 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  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
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <cmath>
+
+#include "misc.h"
+#include "search.h"
+#include "timeman.h"
+#include "ucioption.h"
+
+namespace {
+
+  /// Constants
+
+  const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
+  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
+  const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio
+
+
+  // MoveImportance[] is based on naive statistical analysis of "how many games are still undecided
+  // after n half-moves". Game is considered "undecided" as long as neither side has >275cp advantage.
+  // Data was extracted from CCRL game database with some simple filtering criteria.
+  const int MoveImportance[512] = {
+    7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780,
+    7780, 7780, 7780, 7780, 7778, 7778, 7776, 7776, 7776, 7773, 7770, 7768, 7766, 7763, 7757, 7751,
+    7743, 7735, 7724, 7713, 7696, 7689, 7670, 7656, 7627, 7605, 7571, 7549, 7522, 7493, 7462, 7425,
+    7385, 7350, 7308, 7272, 7230, 7180, 7139, 7094, 7055, 7010, 6959, 6902, 6841, 6778, 6705, 6651,
+    6569, 6508, 6435, 6378, 6323, 6253, 6152, 6085, 5995, 5931, 5859, 5794, 5717, 5646, 5544, 5462,
+    5364, 5282, 5172, 5078, 4988, 4901, 4831, 4764, 4688, 4609, 4536, 4443, 4365, 4293, 4225, 4155,
+    4085, 4005, 3927, 3844, 3765, 3693, 3634, 3560, 3479, 3404, 3331, 3268, 3207, 3146, 3077, 3011,
+    2947, 2894, 2828, 2776, 2727, 2676, 2626, 2589, 2538, 2490, 2442, 2394, 2345, 2302, 2243, 2192,
+    2156, 2115, 2078, 2043, 2004, 1967, 1922, 1893, 1845, 1809, 1772, 1736, 1702, 1674, 1640, 1605,
+    1566, 1536, 1509, 1479, 1452, 1423, 1388, 1362, 1332, 1304, 1289, 1266, 1250, 1228, 1206, 1180,
+    1160, 1134, 1118, 1100, 1080, 1068, 1051, 1034, 1012, 1001, 980, 960, 945, 934, 916, 900, 888,
+    878, 865, 852, 828, 807, 787, 770, 753, 744, 731, 722, 706, 700, 683, 676, 671, 664, 652, 641,
+    634, 627, 613, 604, 591, 582, 568, 560, 552, 540, 534, 529, 519, 509, 495, 484, 474, 467, 460,
+    450, 438, 427, 419, 410, 406, 399, 394, 387, 382, 377, 372, 366, 359, 353, 348, 343, 337, 333,
+    328, 321, 315, 309, 303, 298, 293, 287, 284, 281, 277, 273, 265, 261, 255, 251, 247, 241, 240,
+    235, 229, 218, 217, 213, 212, 208, 206, 197, 193, 191, 189, 185, 184, 180, 177, 172, 170, 170,
+    170, 166, 163, 159, 158, 156, 155, 151, 146, 141, 138, 136, 132, 130, 128, 125, 123, 122, 118,
+    118, 118, 117, 115, 114, 108, 107, 105, 105, 105, 102, 97, 97, 95, 94, 93, 91, 88, 86, 83, 80,
+    80, 79, 79, 79, 78, 76, 75, 72, 72, 71, 70, 68, 65, 63, 61, 61, 59, 59, 59, 58, 56, 55, 54, 54,
+    52, 49, 48, 48, 48, 48, 45, 45, 45, 44, 43, 41, 41, 41, 41, 40, 40, 38, 37, 36, 34, 34, 34, 33,
+    31, 29, 29, 29, 28, 28, 28, 28, 28, 28, 28, 27, 27, 27, 27, 27, 24, 24, 23, 23, 22, 21, 20, 20,
+    19, 19, 19, 19, 19, 18, 18, 18, 18, 17, 17, 17, 17, 17, 16, 16, 15, 15, 14, 14, 14, 12, 12, 11,
+    9, 9, 9, 9, 9, 9, 9, 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, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 2, 2, 2,
+    2, 1, 1, 1, 1, 1, 1, 1 };
+
+  int move_importance(int ply) { return MoveImportance[Min(ply, 511)]; }
+
+
+  /// Function Prototypes
+
+  enum TimeType { OptimumTime, MaxTime };
+
+  template<TimeType>
+  int remaining(int myTime, int movesToGo, int currentPly);
+}
+
+
+void TimeManager::pv_instability(int curChanges, int prevChanges) {
+
+    unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
+                         + prevChanges * (optimumSearchTime / 3);
+}
+
+
+void TimeManager::init(const SearchLimits& limits, int currentPly)
+{
+  /* We support four different kind of time controls:
+
+      increment == 0 && movesToGo == 0 means: x basetime  [sudden death!]
+      increment == 0 && movesToGo != 0 means: x moves in y minutes
+      increment >  0 && movesToGo == 0 means: x basetime + z increment
+      increment >  0 && movesToGo != 0 means: x moves in y minutes + z increment
+
+    Time management is adjusted by following UCI parameters:
+
+      emergencyMoveHorizon: Be prepared to always play at least this many moves
+      emergencyBaseTime   : Always attempt to keep at least this much time (in ms) at clock
+      emergencyMoveTime   : Plus attempt to keep at least this much time for each remaining emergency move
+      minThinkingTime     : No matter what, use at least this much thinking before doing the move
+  */
+
+  int hypMTG, hypMyTime, t1, t2;
+
+  // Read uci parameters
+  int emergencyMoveHorizon = Options["Emergency Move Horizon"].value<int>();
+  int emergencyBaseTime    = Options["Emergency Base Time"].value<int>();
+  int emergencyMoveTime    = Options["Emergency Move Time"].value<int>();
+  int minThinkingTime      = Options["Minimum Thinking Time"].value<int>();
+
+  // Initialize to maximum values but unstablePVExtraTime that is reset
+  unstablePVExtraTime = 0;
+  optimumSearchTime = maximumSearchTime = limits.time;
+
+  // We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
+  // minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values.
+  for (hypMTG = 1; hypMTG <= (limits.movesToGo ? Min(limits.movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
+  {
+      // Calculate thinking time for hypothetic "moves to go"-value
+      hypMyTime =  limits.time
+                 + limits.increment * (hypMTG - 1)
+                 - emergencyBaseTime
+                 - emergencyMoveTime * Min(hypMTG, emergencyMoveHorizon);
+
+      hypMyTime = Max(hypMyTime, 0);
+
+      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
+      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+
+      optimumSearchTime = Min(optimumSearchTime, t1);
+      maximumSearchTime = Min(maximumSearchTime, t2);
+  }
+
+  if (Options["Ponder"].value<bool>())
+      optimumSearchTime += optimumSearchTime / 4;
+
+  // Make sure that maxSearchTime is not over absoluteMaxSearchTime
+  optimumSearchTime = Min(optimumSearchTime, maximumSearchTime);
+}
+
+
+namespace {
+
+  template<TimeType T>
+  int remaining(int myTime, int movesToGo, int currentPly)
+  {
+    const float TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
+
+    int thisMoveImportance = move_importance(currentPly);
+    int otherMovesImportance = 0;
+
+    for (int i = 1; i < movesToGo; i++)
+        otherMovesImportance += move_importance(currentPly + 2 * i);
+
+    float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
+    float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
+
+    return int(floor(myTime * Min(ratio1, ratio2)));
+  }
+}

src/timeman.h

@@ -0,0 +1,39 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-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
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if !defined(TIMEMAN_H_INCLUDED)
+#define TIMEMAN_H_INCLUDED
+
+struct SearchLimits;
+
+class TimeManager {
+public:
+
+  void init(const SearchLimits& limits, int currentPly);
+  void pv_instability(int curChanges, int prevChanges);
+  int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
+  int maximum_time() const { return maximumSearchTime; }
+
+private:
+  int optimumSearchTime;
+  int maximumSearchTime;
+  int unstablePVExtraTime;
+};
+
+#endif // !defined(TIMEMAN_H_INCLUDED)

src/timeoday.cpp

@@ -1,28 +0,0 @@
-/*
-   (c) Copyright 1992 Eric Backus
-
-   This software may be used freely so long as this copyright notice is
-   left intact.  There is no warrantee on this software.
- */
-#include <windows.h>
-#include <time.h>
-#include "dos.h"
-
-
-int             gettimeofday(struct timeval * tp, struct timezone * tzp)
-{
-    SYSTEMTIME      systime;
-
-    if (tp) {
-        struct tm       tmrec;
-        time_t          theTime = time(NULL);
-
-
-        tmrec = *localtime(&theTime);
-        tp->tv_sec = mktime(&tmrec);
-        GetLocalTime(&systime); /* system time */
-
-        tp->tv_usec = systime.wMilliseconds * 1000;
-    }
-    return 0;
-}

src/tt.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,215 +17,128 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
-#include <cmath>
+#include <cstring>
+#include <iostream>
 
 #include "tt.h"
 
+TranspositionTable TT; // Our global transposition table
 
-////
-//// Functions
-////
+TranspositionTable::TranspositionTable() {
 
-/// Constructor
-
-TranspositionTable::TranspositionTable(unsigned mbSize) {
-  size = 0;
-  generation = 0;
-  writes = 0;
-  entries = 0;
-  this->set_size(mbSize);
+  size = generation = 0;
+  entries = NULL;
 }
 
-
-/// Destructor
-
 TranspositionTable::~TranspositionTable() {
+
   delete [] entries;
 }
 
 
-/// TranspositionTable::set_size sets the size of the transposition table,
+/// TranspositionTable::set_size() sets the size of the transposition table,
 /// measured in megabytes.
 
-void TranspositionTable::set_size(unsigned mbSize) {
-  unsigned newSize;
+void TranspositionTable::set_size(size_t mbSize) {
 
-  assert(mbSize >= 4 && mbSize <= 1024);
+  size_t newSize = 1024;
 
-  for(newSize = 1024; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20);
-      newSize *= 2);
-  newSize /= 2;
+  // Transposition table consists of clusters and each cluster consists
+  // of ClusterSize number of TTEntries. Each non-empty entry contains
+  // information of exactly one position and newSize is the number of
+  // clusters we are going to allocate.
+  while (2ULL * newSize * sizeof(TTCluster) <= (mbSize << 20))
+      newSize *= 2;
 
-  if(newSize != size) {
-    size = newSize;
-    delete [] entries;
-    entries = new TTEntry[size * 4];
-    if(entries == NULL) {
+  if (newSize == size)
+      return;
+
+  size = newSize;
+  delete [] entries;
+  entries = new (std::nothrow) TTCluster[size];
+  if (!entries)
+  {
       std::cerr << "Failed to allocate " << mbSize
-                << " MB for transposition table."
-                << std::endl;
+                << " MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
-    }
-    this->clear();
   }
+  clear();
 }
 
 
-/// TranspositionTable::clear overwrites the entire transposition table
-/// with zeroes.  It is called whenever the table is resized, or when the
+/// TranspositionTable::clear() overwrites the entire transposition table
+/// with zeroes. It is called whenever the table is resized, or when the
 /// user asks the program to clear the table (from the UCI interface).
-/// Perhaps we should also clear it when the "ucinewgame" command is recieved?
 
 void TranspositionTable::clear() {
-  memset(entries, 0, size * 4 * sizeof(TTEntry));
+
+  memset(entries, 0, size * sizeof(TTCluster));
 }
 
 
-/// TranspositionTable::store writes a new entry containing a position,
-/// a value, a value type, a search depth, and a best move to the
-/// transposition table.  The transposition table is organized in clusters
-/// of four TTEntry objects, and when a new entry is written, it replaces
-/// the least valuable of the four entries in a cluster.  A TTEntry t1 is
-/// considered to be more valuable than a TTEntry t2 if t1 is from the
-/// current search and t2 is from a previous search, or if the depth of t1
-/// is bigger than the depth of t2.
+/// TranspositionTable::store() writes a new entry containing position key and
+/// valuable information of current position. The lowest order bits of position
+/// key are used to decide on which cluster the position will be placed.
+/// When a new entry is written and there are no empty entries available in cluster,
+/// it replaces the least valuable of entries. A TTEntry t1 is considered to be
+/// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
+/// a previous search, or if the depth of t1 is bigger than the depth of t2.
 
-void TranspositionTable::store(const Position &pos, Value v, Depth d,
-                               Move m, ValueType type) {
+void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
+
+  int c1, c2, c3;
   TTEntry *tte, *replace;
+  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key inside the cluster
 
-  tte = replace = entries + int(pos.get_key() & (size - 1)) * 4;
-  for(int i = 0; i < 4; i++) {
-    if((tte+i)->key() == pos.get_key()) {
-      if(m == MOVE_NONE)
-        m = (tte+i)->move();
-      *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
-      return;
-    }
-    if(replace->generation() == generation) {
-      if((tte+i)->generation() != generation ||
-         (tte+i)->depth() < replace->depth())
-        replace = tte+i;
-    }
-    else if((tte+i)->generation() != generation &&
-            (tte+i)->depth() < replace->depth())
-      replace = tte+i;
+  tte = replace = first_entry(posKey);
+
+  for (int i = 0; i < ClusterSize; i++, tte++)
+  {
+      if (!tte->key() || tte->key() == posKey32) // Empty or overwrite old
+      {
+          // Preserve any existing ttMove
+          if (m == MOVE_NONE)
+              m = tte->move();
+
+          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
+          return;
+      }
+
+      // Implement replace strategy
+      c1 = (replace->generation() == generation ?  2 : 0);
+      c2 = (tte->generation() == generation || tte->type() == VALUE_TYPE_EXACT ? -2 : 0);
+      c3 = (tte->depth() < replace->depth() ?  1 : 0);
+
+      if (c1 + c2 + c3 > 0)
+          replace = tte;
   }
-  *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
-  writes++;
+  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
 }
 
 
-/// TranspositionTable::retrieve looks up the current position in the
-/// transposition table, and extracts the value, value type, depth and
-/// best move if the position is found.  The return value is true if
-/// the position is found, and false if it isn't.
+/// TranspositionTable::probe() looks up the current position in the
+/// transposition table. Returns a pointer to the TTEntry or NULL if
+/// position is not found.
 
-bool TranspositionTable::retrieve(const Position &pos, Value *value,
-                                  Depth *d, Move *move,
-                                  ValueType *type) const {
-  TTEntry *tte;
-  bool found = false;
+TTEntry* TranspositionTable::probe(const Key posKey) const {
 
-  tte = entries + int(pos.get_key() & (size - 1)) * 4;
-  for(int i = 0; i < 4 && !found ; i++)
-    if((tte+i)->key() == pos.get_key()) {
-      tte = tte + i;
-      found = true;
-    }
-  if(!found) {
-    *move = MOVE_NONE;
-    return false;
-  }
+  uint32_t posKey32 = posKey >> 32;
+  TTEntry* tte = first_entry(posKey);
 
-  *value = tte->value();
-  *type = tte->type();
-  *d = tte->depth();
-  *move = tte->move();
+  for (int i = 0; i < ClusterSize; i++, tte++)
+      if (tte->key() == posKey32)
+          return tte;
 
-  return true;
+  return NULL;
 }
 
 
 /// TranspositionTable::new_search() is called at the beginning of every new
-/// search.  It increments the "generation" variable, which is used to
+/// search. It increments the "generation" variable, which is used to
 /// distinguish transposition table entries from previous searches from
 /// entries from the current search.
 
 void TranspositionTable::new_search() {
   generation++;
-  writes = 0;
-}
-
-
-/// TranspositionTable::insert_pv() is called at the end of a search 
-/// iteration, and inserts the PV back into the PV.  This makes sure the
-/// old PV moves are searched first, even if the old TT entries have been
-/// overwritten.
-
-void TranspositionTable::insert_pv(const Position &pos, Move pv[]) {
-  UndoInfo u;
-  Position p(pos);
-
-  for(int i = 0; pv[i] != MOVE_NONE; i++) {
-    this->store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
-    p.do_move(pv[i], u);
-  }
-}
-
-
-/// TranspositionTable::full() returns the permill of all transposition table
-/// entries which have received at least one write during the current search.
-/// It is used to display the "info hashfull ..." information in UCI.
-
-int TranspositionTable::full() {
-  double N = double(size) * 4.0;
-  return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
-}
-
-
-/// Constructors
-
-TTEntry::TTEntry() {
-}
-
-TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) {
-  key_ = k;
-  data = (m & 0x7FFFF) | (t << 20) | (generation << 23);
-  value_ = v;
-  depth_ = int16_t(d);
-}
-
-
-/// Functions for extracting data from TTEntry objects.
-
-Key TTEntry::key() const {
-  return key_;
-}
-
-Depth TTEntry::depth() const {
-  return Depth(depth_);
-}
-
-Move TTEntry::move() const {
-  return Move(data & 0x7FFFF);
-}
-
-Value TTEntry::value() const {
-  return Value(value_);
-}
-
-ValueType TTEntry::type() const {
-  return ValueType((data >> 20) & 3);
-}
-
-int TTEntry::generation() const {
-  return (data >> 23);
 }

src/tt.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,77 +17,157 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(TT_H_INCLUDED)
 #define TT_H_INCLUDED
 
-////
-//// Includes
-////
+#include <iostream>
 
-#include "depth.h"
-#include "position.h"
-#include "value.h"
+#include "move.h"
+#include "types.h"
 
 
-////
-//// Types
-////
-
-/// The TTEntry class is the class of transposition table entries.
+/// The TTEntry is the class of transposition table entries
+///
+/// A TTEntry needs 128 bits to be stored
+///
+/// bit  0-31: key
+/// bit 32-63: data
+/// bit 64-79: value
+/// bit 80-95: depth
+/// bit 96-111: static value
+/// bit 112-127: margin of static value
+///
+/// the 32 bits of the data field are so defined
+///
+/// bit  0-15: move
+/// bit 16-20: not used
+/// bit 21-22: value type
+/// bit 23-31: generation
 
 class TTEntry {
 
 public:
-  TTEntry();
-  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
-  Key key() const;
-  Depth depth() const;
-  Move move() const;
-  Value value() const;
-  ValueType type() const;
-  int generation() const;
+  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
+
+    key32        = (uint32_t)k;
+    move16       = (uint16_t)m;
+    valueType    = (uint8_t)t;
+    generation8  = (uint8_t)g;
+    value16      = (int16_t)v;
+    depth16      = (int16_t)d;
+    staticValue  = (int16_t)statV;
+    staticMargin = (int16_t)statM;
+  }
+  void set_generation(int g) { generation8 = (uint8_t)g; }
+
+  uint32_t key() const              { return key32; }
+  Depth depth() const               { return (Depth)depth16; }
+  Move move() const                 { return (Move)move16; }
+  Value value() const               { return (Value)value16; }
+  ValueType type() const            { return (ValueType)valueType; }
+  int generation() const            { return (int)generation8; }
+  Value static_value() const        { return (Value)staticValue; }
+  Value static_value_margin() const { return (Value)staticMargin; }
 
 private:
-  Key key_;
-  uint32_t data;
-  int16_t value_;
-  int16_t depth_;
+  uint32_t key32;
+  uint16_t move16;
+  uint8_t valueType, generation8;
+  int16_t value16, depth16, staticValue, staticMargin;
 };
 
 
-/// The transposition table class.  This is basically just a huge array
-/// containing TTEntry objects, and a few methods for writing new entries
-/// and reading new ones.
+/// This is the number of TTEntry slots for each cluster
+const int ClusterSize = 4;
+
+
+/// TTCluster consists of ClusterSize number of TTEntries. Size of TTCluster
+/// must not be bigger than a cache line size. In case it is less, it should
+/// be padded to guarantee always aligned accesses.
+
+struct TTCluster {
+  TTEntry data[ClusterSize];
+};
+
+
+/// The transposition table class. This is basically just a huge array containing
+/// TTCluster objects, and a few methods for writing and reading entries.
 
 class TranspositionTable {
 
+  TranspositionTable(const TranspositionTable&);
+  TranspositionTable& operator=(const TranspositionTable&);
+
 public:
-  TranspositionTable(unsigned mbSize);
+  TranspositionTable();
   ~TranspositionTable();
-  void set_size(unsigned mbSize);
+  void set_size(size_t mbSize);
   void clear();
-  void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
-  bool retrieve(const Position &pos, Value *value, Depth *d, Move *move,
-                ValueType *type) const;
+  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+  TTEntry* probe(const Key posKey) const;
   void new_search();
-  void insert_pv(const Position &pos, Move pv[]);
-  int full();
+  TTEntry* first_entry(const Key posKey) const;
+  void refresh(const TTEntry* tte) const;
 
 private:
-  unsigned size;
-  int writes;
-  TTEntry* entries;
-  uint8_t generation;
+  size_t size;
+  TTCluster* entries;
+  uint8_t generation; // Size must be not bigger then TTEntry::generation8
 };
 
+extern TranspositionTable TT;
 
-////
-//// Constants and variables
-////
 
-// Default transposition table size, in megabytes:
-const int TTDefaultSize = 32;
+/// TranspositionTable::first_entry() returns a pointer to the first entry of
+/// a cluster given a position. The lowest order bits of the key are used to
+/// get the index of the cluster.
 
+inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
+
+  return entries[((uint32_t)posKey) & (size - 1)].data;
+}
+
+
+/// TranspositionTable::refresh() updates the 'generation' value of the TTEntry
+/// to avoid aging. Normally called after a TT hit.
+
+inline void TranspositionTable::refresh(const TTEntry* tte) const {
+
+  const_cast<TTEntry*>(tte)->set_generation(generation);
+}
+
+
+/// A simple fixed size hash table used to store pawns and material
+/// configurations. It is basically just an array of Entry objects.
+/// Without cluster concept or overwrite policy.
+
+template<class Entry, int HashSize>
+struct SimpleHash {
+
+  typedef SimpleHash<Entry, HashSize> Base;
+
+  void init() {
+
+    if (entries)
+        return;
+
+    entries = new (std::nothrow) Entry[HashSize];
+    if (!entries)
+    {
+        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
+                  << " bytes for hash table." << std::endl;
+        exit(EXIT_FAILURE);
+    }
+    memset(entries, 0, HashSize * sizeof(Entry));
+  }
+
+  virtual ~SimpleHash() { delete [] entries; }
+
+  Entry* probe(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
+  void prefetch(Key key) const { ::prefetch((char*)probe(key)); }
+
+protected:
+  Entry* entries;
+};
 
 #endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,31 +17,454 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(TYPES_H_INCLUDED)
 #define TYPES_H_INCLUDED
 
-#if !defined(_MSC_VER)
+#include <climits>
+#include <cstdlib>
 
-#include <inttypes.h>
+#if defined(_MSC_VER)
+
+// Disable some silly and noisy warning from MSVC compiler
+#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
+#pragma warning(disable: 4127) // Conditional expression is constant
+#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
+
+// MSVC does not support <inttypes.h>
+typedef   signed __int8    int8_t;
+typedef unsigned __int8   uint8_t;
+typedef   signed __int16  int16_t;
+typedef unsigned __int16 uint16_t;
+typedef   signed __int32  int32_t;
+typedef unsigned __int32 uint32_t;
+typedef   signed __int64  int64_t;
+typedef unsigned __int64 uint64_t;
 
 #else
 
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64;
-typedef unsigned __int64 uint64_t;
+#include <inttypes.h>
 
-typedef __int16 int16_t;
-typedef __int64 int64_t;
+#endif
 
-#endif // !defined(_MSC_VER)
+#define Min(x, y) (((x) < (y)) ? (x) : (y))
+#define Max(x, y) (((x) < (y)) ? (y) : (x))
+
+////
+//// Configuration
+////
+
+//// For Linux and OSX configuration is done automatically using Makefile.
+//// To get started type "make help".
+////
+//// For windows part of the configuration is detected automatically, but
+//// some switches need to be set manually:
+////
+//// -DNDEBUG       | Disable debugging mode. Use always.
+////
+//// -DNO_PREFETCH  | Disable use of prefetch asm-instruction. A must if you want the
+////                | executable to run on some very old machines.
+////
+//// -DUSE_POPCNT   | Add runtime support for use of popcnt asm-instruction.
+////                | Works only in 64-bit mode. For compiling requires hardware
+////                | with popcnt support. Around 4% speed-up.
+////
+//// -DOLD_LOCKS    | By default under Windows are used the fast Slim Reader/Writer (SRW)
+////                | Locks and Condition Variables: these are not supported by Windows XP
+////                | and older, to compile for those platforms you should enable OLD_LOCKS.
+
+// Automatic detection for 64-bit under Windows
+#if defined(_WIN64)
+#define IS_64BIT
+#endif
+
+// Automatic detection for use of bsfq asm-instruction under Windows
+#if defined(_WIN64)
+#define USE_BSFQ
+#endif
+
+// Intel header for _mm_popcnt_u64() intrinsic
+#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
+#include <nmmintrin.h>
+#endif
+
+// Cache line alignment specification
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#else
+#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#endif
+
+// 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
+
+// Define FORCE_INLINE macro to force inlining overriding compiler choice
+#if defined(_MSC_VER)
+#define FORCE_INLINE  __forceinline
+#elif defined(__GNUC__)
+#define FORCE_INLINE  inline __attribute__((always_inline))
+#else
+#define FORCE_INLINE  inline
+#endif
+
+/// cpu_has_popcnt() detects support for popcnt instruction at runtime
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+/// CpuHasPOPCNT is a global constant initialized at startup that
+/// is set to true if CPU on which application runs supports popcnt
+/// hardware instruction. Unless USE_POPCNT is not defined.
+#if defined(USE_POPCNT)
+const bool CpuHasPOPCNT = cpu_has_popcnt();
+#else
+const bool CpuHasPOPCNT = false;
+#endif
+
+
+/// CpuIs64Bit is a global constant initialized at compile time that
+/// is set to true if CPU on which application runs is a 64 bits.
+#if defined(IS_64BIT)
+const bool CpuIs64Bit = true;
+#else
+const bool CpuIs64Bit = false;
+#endif
+
+#include <string>
 
-// Hash keys:
 typedef uint64_t Key;
+typedef uint64_t Bitboard;
+
+const int PLY_MAX = 100;
+const int PLY_MAX_PLUS_2 = PLY_MAX + 2;
+
+enum ValueType {
+  VALUE_TYPE_NONE  = 0,
+  VALUE_TYPE_UPPER = 1,
+  VALUE_TYPE_LOWER = 2,
+  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+};
+
+enum Value {
+  VALUE_ZERO      = 0,
+  VALUE_DRAW      = 0,
+  VALUE_KNOWN_WIN = 15000,
+  VALUE_MATE      = 30000,
+  VALUE_INFINITE  = 30001,
+  VALUE_NONE      = 30002,
+
+  VALUE_MATE_IN_PLY_MAX  =  VALUE_MATE - PLY_MAX,
+  VALUE_MATED_IN_PLY_MAX = -VALUE_MATE + PLY_MAX,
+
+  VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN
+};
+
+enum PieceType {
+  PIECE_TYPE_NONE = 0,
+  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+};
+
+enum Piece {
+  PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
+  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
+};
+
+enum Color {
+  WHITE, BLACK, COLOR_NONE
+};
+
+enum Depth {
+
+  ONE_PLY = 2,
+
+  DEPTH_ZERO         =  0 * ONE_PLY,
+  DEPTH_QS_CHECKS    = -1 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS = -2 * ONE_PLY,
+
+  DEPTH_NONE = -127 * ONE_PLY
+};
+
+enum Square {
+  SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,
+  SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
+  SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,
+  SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4,
+  SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5,
+  SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6,
+  SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
+  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
+  SQ_NONE,
+
+  DELTA_N =  8,
+  DELTA_E =  1,
+  DELTA_S = -8,
+  DELTA_W = -1,
+
+  DELTA_NN = DELTA_N + DELTA_N,
+  DELTA_NE = DELTA_N + DELTA_E,
+  DELTA_SE = DELTA_S + DELTA_E,
+  DELTA_SS = DELTA_S + DELTA_S,
+  DELTA_SW = DELTA_S + DELTA_W,
+  DELTA_NW = DELTA_N + DELTA_W
+};
+
+enum File {
+  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H
+};
+
+enum Rank {
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8
+};
+
+enum SquareColor {
+  DARK, LIGHT
+};
+
+enum ScaleFactor {
+  SCALE_FACTOR_ZERO   = 0,
+  SCALE_FACTOR_NORMAL = 64,
+  SCALE_FACTOR_MAX    = 128,
+  SCALE_FACTOR_NONE   = 255
+};
+
+
+/// 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 {
+    SCORE_ZERO = 0,
+    SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+    SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
+};
+
+#define ENABLE_OPERATORS_ON(T) \
+inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \
+inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \
+inline T operator* (int i, const T d) {  return T(i * int(d)); } \
+inline T operator* (const T d, int i) {  return T(int(d) * i); } \
+inline T operator/ (const T d, int i) { return T(int(d) / i); } \
+inline T operator- (const T d) { return T(-int(d)); } \
+inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \
+inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \
+inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \
+inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \
+inline void operator*= (T& d, int i) { d = T(int(d) * i); } \
+inline void operator/= (T& d, int i) { d = T(int(d) / i); }
+
+ENABLE_OPERATORS_ON(Value)
+ENABLE_OPERATORS_ON(PieceType)
+ENABLE_OPERATORS_ON(Piece)
+ENABLE_OPERATORS_ON(Color)
+ENABLE_OPERATORS_ON(Depth)
+ENABLE_OPERATORS_ON(Square)
+ENABLE_OPERATORS_ON(File)
+ENABLE_OPERATORS_ON(Rank)
+
+#undef ENABLE_OPERATORS_ON
+
+// Extra operators for adding integers to a Value
+inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
+inline Value operator- (Value v, int i) { return Value(int(v) - i); }
+
+// 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); }
+
+// 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);
+
+// Remaining Score operators are standard
+inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); }
+inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); }
+inline Score operator* (int i, const Score d) {  return Score(i * int(d)); }
+inline Score operator* (const Score d, int i) {  return Score(int(d) * i); }
+inline Score operator- (const Score d) { return Score(-int(d)); }
+inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; }
+inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; }
+inline void operator*= (Score& d, int i) { d = Score(int(d) * i); }
+inline void operator/= (Score& d, int i) { d = Score(int(d) / i); }
+
+const Value PawnValueMidgame   = Value(0x0C6);
+const Value PawnValueEndgame   = Value(0x102);
+const Value KnightValueMidgame = Value(0x331);
+const Value KnightValueEndgame = Value(0x34E);
+const Value BishopValueMidgame = Value(0x344);
+const Value BishopValueEndgame = Value(0x359);
+const Value RookValueMidgame   = Value(0x4F6);
+const Value RookValueEndgame   = Value(0x4FE);
+const Value QueenValueMidgame  = Value(0x9D9);
+const Value QueenValueEndgame  = Value(0x9FE);
+
+inline Value value_mate_in(int ply) {
+  return VALUE_MATE - ply;
+}
+
+inline Value value_mated_in(int ply) {
+  return -VALUE_MATE + ply;
+}
+
+inline Piece make_piece(Color c, PieceType pt) {
+  return Piece((int(c) << 3) | int(pt));
+}
+
+inline PieceType type_of_piece(Piece p)  {
+  return PieceType(int(p) & 7);
+}
+
+inline Color color_of_piece(Piece p) {
+  return Color(int(p) >> 3);
+}
+
+inline Color opposite_color(Color c) {
+  return Color(int(c) ^ 1);
+}
+
+inline bool color_is_ok(Color c) {
+  return c == WHITE || c == BLACK;
+}
+
+inline bool piece_type_is_ok(PieceType pt) {
+  return pt >= PAWN && pt <= KING;
+}
+
+inline bool piece_is_ok(Piece p) {
+  return piece_type_is_ok(type_of_piece(p)) && color_is_ok(color_of_piece(p));
+}
+
+inline char piece_type_to_char(PieceType pt) {
+  static const char ch[] = " PNBRQK";
+  return ch[pt];
+}
+
+inline Square make_square(File f, Rank r) {
+  return Square((int(r) << 3) | int(f));
+}
+
+inline File square_file(Square s) {
+  return File(int(s) & 7);
+}
+
+inline Rank square_rank(Square s) {
+  return Rank(int(s) >> 3);
+}
+
+inline Square flip_square(Square s) {
+  return Square(int(s) ^ 56);
+}
+
+inline Square flop_square(Square s) {
+  return Square(int(s) ^ 7);
+}
+
+inline Square relative_square(Color c, Square s) {
+  return Square(int(s) ^ (int(c) * 56));
+}
+
+inline Rank relative_rank(Color c, Rank r) {
+  return Rank(int(r) ^ (int(c) * 7));
+}
+
+inline Rank relative_rank(Color c, Square s) {
+  return relative_rank(c, square_rank(s));
+}
+
+inline SquareColor square_color(Square s) {
+  return SquareColor(int(square_rank(s) + s) & 1);
+}
+
+inline bool opposite_color_squares(Square s1, Square s2) {
+  int s = int(s1) ^ int(s2);
+  return ((s >> 3) ^ s) & 1;
+}
+
+inline int file_distance(Square s1, Square s2) {
+  return abs(square_file(s1) - square_file(s2));
+}
+
+inline int rank_distance(Square s1, Square s2) {
+  return abs(square_rank(s1) - square_rank(s2));
+}
+
+inline int square_distance(Square s1, Square s2) {
+  return Max(file_distance(s1, s2), rank_distance(s1, s2));
+}
+
+inline File file_from_char(char c) {
+  return File(c - 'a') + FILE_A;
+}
+
+inline char file_to_char(File f) {
+  return char(f - FILE_A + int('a'));
+}
+
+inline Rank rank_from_char(char c) {
+  return Rank(c - '1') + RANK_1;
+}
+
+inline char rank_to_char(Rank r) {
+  return char(r - RANK_1 + int('1'));
+}
+
+inline const std::string square_to_string(Square s) {
+  char ch[] = { file_to_char(square_file(s)), rank_to_char(square_rank(s)), 0 };
+  return std::string(ch);
+}
+
+inline bool file_is_ok(File f) {
+  return f >= FILE_A && f <= FILE_H;
+}
+
+inline bool rank_is_ok(Rank r) {
+  return r >= RANK_1 && r <= RANK_8;
+}
+
+inline bool square_is_ok(Square s) {
+  return s >= SQ_A1 && s <= SQ_H8;
+}
+
+inline Square pawn_push(Color c) {
+  return c == WHITE ? DELTA_N : DELTA_S;
+}
 
 #endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,376 +17,231 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
+#include <cassert>
 #include <iostream>
+#include <sstream>
 #include <string>
 
-#include "book.h"
 #include "evaluate.h"
 #include "misc.h"
 #include "move.h"
-#include "movegen.h"
 #include "position.h"
-#include "san.h"
 #include "search.h"
-#include "uci.h"
 #include "ucioption.h"
 
-
-////
-//// Local definitions:
-////
+using namespace std;
 
 namespace {
 
-  // UCIInputParser is a class for parsing UCI input.  The class is
-  // very simple, and basically just consist of a constant input
-  // string and a current location in the string.  There are methods
-  // for checking if we are at the end of the line, for getting the
-  // next token (defined as any whitespace-delimited sequence of
-  // characters), and for getting the rest of the line as a single
-  // string.
+  // FEN string for the initial position
+  const string StartPositionFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-  class UCIInputParser {
+  // UCIParser is a class for parsing UCI input. The class
+  // is actually a string stream built on a given input string.
+  typedef istringstream UCIParser;
 
-  public:
-    UCIInputParser(const std::string &line);
-    std::string get_next_token();
-    std::string get_rest_of_line();
-    bool at_end_of_line();
-
-  private:
-    const std::string &inputLine;
-    int length, currentIndex;
-
-    void skip_whitespace();
-
-  };
-
-
-  // The root position.  This is set up when the user (or in practice, the GUI)
-  // sends the "position" UCI command.  The root position is sent to the think()
-  // function when the program receives the "go" command.
-  Position RootPosition;
-
-  // Local functions
-  void wait_for_command();
-  void handle_command(const std::string &command);
-  void set_option(UCIInputParser &uip);
-  void set_position(UCIInputParser &uip);
-  void go(UCIInputParser &uip);
+  void set_option(UCIParser& up);
+  void set_position(Position& pos, UCIParser& up);
+  bool go(Position& pos, UCIParser& up);
+  void perft(Position& pos, UCIParser& up);
 }
 
 
-////
-//// Functions
-////
+/// execute_uci_command() takes a string as input, uses a UCIParser
+/// object to parse this text string as a UCI command, and calls
+/// the appropriate functions. In addition to the UCI commands,
+/// the function also supports a few debug commands.
 
-/// uci_main_loop() is the only global function in this file.  It is
-/// called immediately after the program has finished initializing.
-/// The program remains in this loop until it receives the "quit" UCI
-/// command.
+bool execute_uci_command(const string& cmd) {
 
-void uci_main_loop() {
-  RootPosition.from_fen(StartPosition);
-  while(1) wait_for_command();
+  static Position pos(StartPositionFEN, false, 0); // The root position
+
+  UCIParser up(cmd);
+  string token;
+
+  up >> token; // operator>>() skips any whitespace
+
+  if (token == "quit")
+      return false;
+
+  if (token == "go")
+      return go(pos, up);
+
+  if (token == "ucinewgame")
+      pos.from_fen(StartPositionFEN, false);
+
+  else if (token == "isready")
+      cout << "readyok" << endl;
+
+  else if (token == "position")
+      set_position(pos, up);
+
+  else if (token == "setoption")
+      set_option(up);
+
+  else if (token == "perft")
+      perft(pos, up);
+
+  else if (token == "d")
+      pos.print();
+
+  else if (token == "flip")
+      pos.flip();
+
+  else if (token == "eval")
+  {
+      read_evaluation_uci_options(pos.side_to_move());
+      cout << trace_evaluate(pos) << endl;
+  }
+
+  else if (token == "key")
+      cout << "key: " << hex     << pos.get_key()
+           << "\nmaterial key: " << pos.get_material_key()
+           << "\npawn key: "     << pos.get_pawn_key() << endl;
+
+  else if (token == "uci")
+      cout << "id name "     << engine_name()
+           << "\nid author " << engine_authors()
+           << "\n"           << Options.print_all()
+           << "\nuciok"      << endl;
+  else
+      cout << "Unknown command: " << cmd << endl;
+
+  return true;
 }
 
 
-////
-//// Local functions
-////
-
 namespace {
 
-  ///
-  /// Implementation of the UCIInputParser class.
-  ///
+  // set_position() is called when engine receives the "position" UCI
+  // command. The function sets up the position described in the given
+  // fen string ("fen") or the starting position ("startpos") and then
+  // makes the moves given in the following move list ("moves").
 
-  // Constructor for the UCIInputParser class.  The constructor takes a 
-  // text string containing a single UCI command as input.
+  void set_position(Position& pos, UCIParser& up) {
 
-  UCIInputParser::UCIInputParser(const std::string &line) : inputLine(line) {
-    this->currentIndex = 0;
-    this->length = line.length();
+    string token, fen;
+
+    up >> token; // operator>>() skips any whitespace
+
+    if (token == "startpos")
+    {
+        pos.from_fen(StartPositionFEN, false);
+        up >> token; // Consume "moves" token if any
+    }
+    else if (token == "fen")
+    {
+        while (up >> token && token != "moves")
+            fen += token + " ";
+
+        pos.from_fen(fen, Options["UCI_Chess960"].value<bool>());
+    }
+    else return;
+
+    // Parse move list (if any)
+    while (up >> token)
+        pos.do_setup_move(move_from_uci(pos, token));
   }
 
 
-  // UCIInputParser::skip_whitspace() skips any number of whitespace
-  // characters from the current location in an input string.
+  // set_option() is called when engine receives the "setoption" UCI
+  // command. The function updates the corresponding UCI option ("name")
+  // to the given value ("value").
 
-  void UCIInputParser::skip_whitespace() {
-    while(isspace((int)(unsigned char)this->inputLine[this->currentIndex]))
-      this->currentIndex++;
+  void set_option(UCIParser& up) {
+
+    string token, name;
+    string value = "true"; // UCI buttons don't have a "value" field
+
+    up >> token; // Consume "name" token
+    up >> name;  // Read option name
+
+    // Handle names with included spaces
+    while (up >> token && token != "value")
+        name += " " + token;
+
+    up >> value; // Read option value
+
+    // Handle values with included spaces
+    while (up >> token)
+        value += " " + token;
+
+    if (Options.find(name) != Options.end())
+        Options[name].set_value(value);
+    else
+        cout << "No such option: " << name << endl;
   }
 
 
-  // UCIInputParser::get_next_token() gets the next token in an UCI
-  // command.  A 'token' in an UCI command is simply any
-  // whitespace-delimited sequence of characters.
+  // go() is called when engine receives the "go" UCI command. The
+  // function sets the thinking time and other parameters from the input
+  // string, and then calls think(). Returns false if a quit command
+  // is received while thinking, true otherwise.
 
-  std::string UCIInputParser::get_next_token() {
-    int i, j;
+  bool go(Position& pos, UCIParser& up) {
 
-    this->skip_whitespace();
-    for(i = j = this->currentIndex; 
-        j < this->length && !isspace(this->inputLine[j]); 
-        j++);
-    this->currentIndex = j;
-    this->skip_whitespace();
+    string token;
+    SearchLimits limits;
+    Move searchMoves[MAX_MOVES], *cur = searchMoves;
+    int time[] = { 0, 0 }, inc[] = { 0, 0 };
 
-    std::string str = this->inputLine.substr(i, j - i);
+    while (up >> token)
+    {
+        if (token == "infinite")
+            limits.infinite = true;
+        else if (token == "ponder")
+            limits.ponder = true;
+        else if (token == "wtime")
+            up >> time[WHITE];
+        else if (token == "btime")
+            up >> time[BLACK];
+        else if (token == "winc")
+            up >> inc[WHITE];
+        else if (token == "binc")
+            up >> inc[BLACK];
+        else if (token == "movestogo")
+            up >> limits.movesToGo;
+        else if (token == "depth")
+            up >> limits.maxDepth;
+        else if (token == "nodes")
+            up >> limits.maxNodes;
+        else if (token == "movetime")
+            up >> limits.maxTime;
+        else if (token == "searchmoves")
+            while (up >> token)
+                *cur++ = move_from_uci(pos, token);
+    }
 
-    return str;
+    *cur = MOVE_NONE;
+    limits.time = time[pos.side_to_move()];
+    limits.increment = inc[pos.side_to_move()];
+
+    assert(pos.is_ok());
+
+    return think(pos, limits, searchMoves);
   }
 
 
-  // UCIInputParser::get_rest_of_line() returns the rest of the input
-  // line (from the current location) as a single string.
+  // perft() is called when engine receives the "perft" command.
+  // The function calls perft() passing the required search depth
+  // then prints counted leaf nodes and elapsed time.
 
-  std::string UCIInputParser::get_rest_of_line() {
-    this->skip_whitespace();
-    return this->inputLine.substr(this->currentIndex, this->length);
+  void perft(Position& pos, UCIParser& up) {
+
+    int depth, time;
+    int64_t n;
+
+    if (!(up >> depth))
+        return;
+
+    time = get_system_time();
+
+    n = perft(pos, depth * ONE_PLY);
+
+    time = get_system_time() - time;
+
+    std::cout << "\nNodes " << n
+              << "\nTime (ms) " << time
+              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
   }
-
-
-  // UCIInputParser::at_end_of_line() tests whether we have reached the
-  // end of the input string, i.e. if any more input remains to be
-  // parsed.
-
-  bool UCIInputParser::at_end_of_line() {
-    return this->currentIndex == this->length;
-  }
-
-
-  /// 
-  /// Other functions
-  ///
-
-
-  // wait_for_command() waits for a command from the user, and passes
-  // this command to handle_command.  wait_for_command also intercepts
-  // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Glaurung exits gracefully if the GUI dies
-  // unexpectedly.
-
-  void wait_for_command() {
-    std::string command;
-    if(!std::getline(std::cin, command)) command = "quit";
-    handle_command(command);
-  }
-
-
-  // handle_command() takes a text string as input, uses a
-  // UCIInputParser object to parse this text string as a UCI command,
-  // and calls the appropriate functions.  In addition to the UCI
-  // commands, the function also supports a few debug commands.
-  
-  void handle_command(const std::string &command) {
-    UCIInputParser uip(command);
-    std::string s = uip.get_next_token();
-
-    if(s == "quit") {
-      OpeningBook.close();
-      stop_threads();
-      quit_eval();
-      exit(0);
-    }
-    else if(s == "uci") {
-      std::cout << "id name " << engine_name() << std::endl;
-      std::cout << "id author Tord Romstad" << std::endl;
-      print_uci_options();
-      std::cout << "uciok" << std::endl;
-    }
-    else if(s == "ucinewgame") {
-      TT.clear();
-      Position::init_piece_square_tables();
-      RootPosition.from_fen(StartPosition);
-    }
-    else if(s == "isready")
-      std::cout << "readyok" << std::endl;
-    else if(s == "position")
-      set_position(uip);
-    else if(s == "setoption")
-      set_option(uip);
-    else if(s == "go")
-      go(uip);
-
-    // The remaining commands are for debugging purposes only.
-    // Perhaps they should be removed later in order to reduce the
-    // size of the program binary.
-    else if(s == "d")
-      RootPosition.print();
-    else if(s == "flip") {
-      Position p(RootPosition);
-      RootPosition.flipped_copy(p);
-    }
-    else if(s == "eval") {
-      EvalInfo ei;
-      std::cout << "Incremental mg: " << RootPosition.mg_value()
-                << std::endl;
-      std::cout << "Incremental eg: " << RootPosition.eg_value()
-                << std::endl;
-      std::cout << "Full eval: "
-                << evaluate(RootPosition, ei, 0)
-                << std::endl;
-    }
-    else if(s == "key") {
-      std::cout << "key: " << RootPosition.get_key()
-                << " material key: " << RootPosition.get_material_key()
-                << " pawn key: " << RootPosition.get_pawn_key()
-                << std::endl;
-    }
-    else {
-      std::cout << "Unknown command: " << command << std::endl;
-      while(!uip.at_end_of_line()) {
-        std::cout << uip.get_next_token() << std::endl;
-      }
-    }
-  }
-
-
-  // set_position() is called when Glaurung receives the "position" UCI
-  // command.  The input parameter is a UCIInputParser.  It is assumed
-  // that this parser has consumed the first token of the UCI command
-  // ("position"), and is ready to read the second token ("startpos"
-  // or "fen", if the input is well-formed).
-
-  void set_position(UCIInputParser &uip) {
-    std::string token;
-
-    token = uip.get_next_token();
-    if(token == "startpos")
-      RootPosition.from_fen(StartPosition);
-    else if(token == "fen") {
-      std::string fen;
-      while(token != "moves" && !uip.at_end_of_line()) {
-        token = uip.get_next_token();
-        fen += token;
-        fen += ' ';
-      }
-      RootPosition.from_fen(fen);
-    }
-
-    if(!uip.at_end_of_line()) {
-      if(token != "moves")
-        token = uip.get_next_token();
-      if(token == "moves") {
-        Move move;
-        UndoInfo u;
-        while(!uip.at_end_of_line()) {
-          token = uip.get_next_token();
-          move = move_from_string(RootPosition, token);
-          RootPosition.do_move(move, u);
-          if(RootPosition.rule_50_counter() == 0)
-            RootPosition.reset_game_ply();
-        }
-      }
-    }
-  }
-
-
-  // set_option() is called when Glaurung receives the "setoption" UCI
-  // command.  The input parameter is a UCIInputParser.  It is assumed
-  // that this parser has consumed the first token of the UCI command
-  // ("setoption"), and is ready to read the second token ("name", if
-  // the input is well-formed).
-
-  void set_option(UCIInputParser &uip) {
-    std::string token;
-    if(!uip.at_end_of_line()) {
-      token = uip.get_next_token();
-      if(token == "name" && !uip.at_end_of_line()) {
-        std::string name = uip.get_next_token();
-        std::string nextToken;
-        while(!uip.at_end_of_line()
-              && (nextToken = uip.get_next_token()) != "value")
-          name += (" " + nextToken);
-        if(nextToken == "value")
-          set_option_value(name, uip.get_rest_of_line());
-        else
-          push_button(name);
-      }
-    }
-  }
-
-
-  // go() is called when Glaurung receives the "go" UCI command.  The
-  // input parameter is a UCIInputParser.  It is assumed that this
-  // parser has consumed the first token of the UCI command ("go"),
-  // and is ready to read the second token.  The function sets the
-  // thinking time and other parameters from the input string, and
-  // calls think() (defined in search.cpp) with the appropriate
-  // parameters.
-
-  void go(UCIInputParser &uip) {
-    std::string token;
-    int time[2] = {0, 0}, inc[2] = {0, 0}, movesToGo = 0, depth = 0, nodes = 0;
-    int moveTime = 0;
-    bool infinite = false, ponder = false;
-    Move searchMoves[500];
-
-    searchMoves[0] = MOVE_NONE;
-
-    while(!uip.at_end_of_line()) {
-      token = uip.get_next_token();
-
-      if(token == "infinite")
-        infinite = true;
-      else if(token == "ponder")
-        ponder = true;
-      else if(token == "wtime") {
-        if(!uip.at_end_of_line())
-          time[0] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "btime") {
-        if(!uip.at_end_of_line())
-          time[1] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "winc") {
-        if(!uip.at_end_of_line())
-          inc[0] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "binc") {
-        if(!uip.at_end_of_line())
-          inc[1] = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movestogo") {
-        if(!uip.at_end_of_line())
-          movesToGo = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "depth") {
-        if(!uip.at_end_of_line())
-          depth = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "nodes") {
-        if(!uip.at_end_of_line())
-          nodes = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movetime") {
-        if(!uip.at_end_of_line())
-          moveTime = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "searchmoves" && !uip.at_end_of_line()) {
-        int numOfMoves = 0;
-        while(!uip.at_end_of_line()) {
-          token = uip.get_next_token();
-          searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
-        }
-        searchMoves[numOfMoves] = MOVE_NONE;
-      }
-    }
-
-    if(moveTime)
-      infinite = true;  // HACK
-
-    think(RootPosition, infinite, ponder, time[RootPosition.side_to_move()],
-          inc[RootPosition.side_to_move()], movesToGo, depth, nodes, moveTime,
-          searchMoves);
-  }
-  
 }

src/uci.h

@@ -1,30 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(UCI_H_INCLUDED)
-#define UCI_H_INCLUDED
-
-////
-//// Prototypes
-////
-
-extern void uci_main_loop();
-
-
-#endif // !defined(UCI_H_INCLUDED)

src/ucioption.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,255 +17,154 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstdarg>
-#include <cstdio>
+#include <cctype>
+#include <iostream>
+#include <sstream>
 
 #include "misc.h"
 #include "thread.h"
 #include "ucioption.h"
 
+using std::string;
+using std::cout;
+using std::endl;
 
-////
-//// Variables
-////
-
-bool Chess960 = false;
+OptionsMap Options; // Global object
 
 
-////
-//// Local definitions
-////
+// Our case insensitive less() function as required by UCI protocol
+bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
 
-namespace {
+  int c1, c2;
+  size_t i = 0;
 
-  ///
-  /// Types
-  ///
+  while (i < s1.size() && i < s2.size())
+  {
+      c1 = tolower(s1[i]);
+      c2 = tolower(s2[i++]);
 
-  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON, OPTION_TYPE_NONE};
-
-  struct Option {
-    char name[50], defaultValue[300], currentValue[300];
-    OptionType type;
-    int minValue, maxValue;
-    char comboValues[8][64];
-  };
-    
-
-  ///
-  /// Variables
-  ///
-
-  Option Options[] = {
-    { "Use Search Log", "false", "false", CHECK, 0, 0, {""} },
-    { "Search Log Filename", "SearchLog.txt", "SearchLog.txt", STRING, 0, 0, {""} },
-    { "Book File", "book.bin", "book.bin", STRING, 0, 0, {""} },
-    { "Mobility (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Mobility (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Aggressiveness", "100", "100", SPIN, 0, 200, {""} },
-    { "Cowardice", "100", "100", SPIN, 0, 200, {""} },
-    { "King Safety Curve", "Quadratic", "Quadratic", COMBO, 0, 0,
-      { "Quadratic", "Linear" /*, "From File"*/ } },
-    { "King Safety Coefficient", "40", "40", SPIN, 1, 100 , {""} },
-    { "King Safety X Intercept", "0", "0", SPIN, 0, 20, {""} },
-    { "King Safety Max Slope", "30", "30", SPIN, 10, 100, {""} },
-    { "King Safety Max Value", "500", "500", SPIN, 100, 1000, {""} },
-    { "Queen Contact Check Bonus", "4", "4", SPIN, 0, 8, {""} },
-    { "Rook Contact Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Queen Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Rook Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Bishop Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Knight Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Discovered Check Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Mate Threat Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Check Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Check Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Full Depth Moves (PV nodes)", "14", "14", SPIN, 1, 100, {""} },
-    { "Full Depth Moves (non-PV nodes)", "3", "3", SPIN, 1, 100, {""} },
-    { "Threat Depth", "5", "5", SPIN, 0, 100, {""} },
-    { "Selective Plies", "7", "7", SPIN, 0, 10, {""} },
-    { "Futility Pruning (Main Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Pruning (Quiescence Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Margin 0", "50", "50", SPIN, 0, 1000, {""} },
-    { "Futility Margin 1", "100", "100", SPIN, 0, 1000, {""} },
-    { "Futility Margin 2", "300", "300", SPIN, 0, 1000, {""} },
-    { "Maximum Razoring Depth", "3", "3", SPIN, 0, 4, {""} },
-    { "Razoring Margin", "300", "300", SPIN, 150, 600, {""} },
-    { "Randomness", "0", "0", SPIN, 0, 10, {""} },
-    { "Minimum Split Depth", "4", "4", SPIN, 4, 7, {""} },
-    { "Maximum Number of Threads per Split Point", "5", "5", SPIN, 4, 8, {""} },
-    { "Threads", "1", "1", SPIN, 1, 8, {""} },
-    { "Hash", "32", "32", SPIN, 4, 4096, {""} },
-    { "Clear Hash", "false", "false", BUTTON, 0, 0, {""} },
-    { "Ponder", "true", "true", CHECK, 0, 0, {""} },
-    { "OwnBook", "true", "true", CHECK, 0, 0, {""} },
-    { "MultiPV", "1", "1", SPIN, 1, 500, {""} },
-    { "UCI_ShowCurrLine", "false", "false", CHECK, 0, 0, {""} },
-    { "UCI_Chess960", "false", "false", CHECK, 0, 0, {""} },
-    { "", "", "", OPTION_TYPE_NONE, 0, 0, {""}}
-  };
-    
-
-  ///
-  /// Functions
-  ///
-
-  Option *option_with_name(const char *optionName);
-
-}
-
-
-////
-//// Functions
-////
-
-/// init_uci_options() initializes the UCI options.  Currently, the only
-/// thing this function does is to initialize the default value of the
-/// "Threads" parameter to the number of available CPU cores.
-
-void init_uci_options() {
-  Option *o;
-
-  o = option_with_name("Threads");
-  assert(o != NULL);
-
-  // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
-  // According to Ken Dail's tests, Glaurung plays much better with 7 than
-  // 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.
-  sprintf(o->defaultValue, "%d", Min(cpu_count(), 7));
-  sprintf(o->currentValue, "%d", Min(cpu_count(), 7));
-
-  // Increase the minimum split depth when the number of CPUs is big.
-  // It would probably be better to let this depend on the number of threads
-  // instead.
-  o = option_with_name("Minimum Split Depth");
-  assert(o != NULL);
-  if(cpu_count() > 4) {
-    sprintf(o->defaultValue, "%d", 6);
-    sprintf(o->defaultValue, "%d", 6);
+      if (c1 != c2)
+          return c1 < c2;
   }
+  return s1.size() < s2.size();
 }
 
 
-/// print_uci_options() prints all the UCI options to the standard output,
-/// in the format defined by the UCI protocol.
+// stringify() converts a numeric value of type T to a std::string
+template<typename T>
+static string stringify(const T& v) {
 
-void print_uci_options() {
-  static const char optionTypeName[][16] = {
-    "spin", "combo", "check", "string", "button"
-  };
-  for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) {
-    printf("option name %s type %s", o->name, optionTypeName[o->type]);
-    if(o->type != BUTTON) {
-      printf(" default %s", o->defaultValue);
-      if(o->type == SPIN)
-        printf(" min %d max %d", o->minValue, o->maxValue);
-      else if(o->type == COMBO)
-        for(int i = 0; strlen(o->comboValues[i]) > 0; i++)
-          printf(" var %s", o->comboValues[i]);
-    }
-    printf("\n");
-  }
+  std::ostringstream ss;
+  ss << v;
+  return ss.str();
 }
 
 
-/// get_option_value_bool() returns the current value of a UCI parameter of
-/// type "check".
+/// OptionsMap c'tor initializes the UCI options to their hard coded default
+/// values and initializes the default value of "Threads" and "Minimum Split Depth"
+/// parameters according to the number of CPU cores.
 
-bool get_option_value_bool(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return o != NULL && strcmp(o->currentValue, "true") == 0;
+OptionsMap::OptionsMap() {
+
+  OptionsMap& o = *this;
+
+  o["Use Search Log"] = UCIOption(false);
+  o["Search Log Filename"] = UCIOption("SearchLog.txt");
+  o["Book File"] = UCIOption("book.bin");
+  o["Best Book Move"] = UCIOption(false);
+  o["Mobility (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Mobility (Endgame)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Endgame)"] = UCIOption(100, 0, 200);
+  o["Space"] = UCIOption(100, 0, 200);
+  o["Aggressiveness"] = UCIOption(100, 0, 200);
+  o["Cowardice"] = UCIOption(100, 0, 200);
+  o["Minimum Split Depth"] = UCIOption(4, 4, 7);
+  o["Maximum Number of Threads per Split Point"] = UCIOption(5, 4, 8);
+  o["Threads"] = UCIOption(1, 1, MAX_THREADS);
+  o["Use Sleeping Threads"] = UCIOption(false);
+  o["Hash"] = UCIOption(32, 4, 8192);
+  o["Clear Hash"] = UCIOption(false, "button");
+  o["Ponder"] = UCIOption(true);
+  o["OwnBook"] = UCIOption(true);
+  o["MultiPV"] = UCIOption(1, 1, 500);
+  o["Skill Level"] = UCIOption(20, 0, 20);
+  o["Emergency Move Horizon"] = UCIOption(40, 0, 50);
+  o["Emergency Base Time"] = UCIOption(200, 0, 30000);
+  o["Emergency Move Time"] = UCIOption(70, 0, 5000);
+  o["Minimum Thinking Time"] = UCIOption(20, 0, 5000);
+  o["UCI_Chess960"] = UCIOption(false);
+  o["UCI_AnalyseMode"] = UCIOption(false);
+
+  // Set some SMP parameters accordingly to the detected CPU count
+  UCIOption& thr = o["Threads"];
+  UCIOption& msd = o["Minimum Split Depth"];
+
+  thr.defaultValue = thr.currentValue = stringify(cpu_count());
+
+  if (cpu_count() >= 8)
+      msd.defaultValue = msd.currentValue = stringify(7);
 }
 
 
-/// get_option_value_int() returns the value of a UCI parameter as an integer.
-/// Normally, this function will be used for a parameter of type "spin", but
-/// it could also be used with a "combo" parameter, where all the available
-/// values are integers.
+/// OptionsMap::print_all() returns a string with all the UCI options in chronological
+/// insertion order (the idx field) and in the format defined by the UCI protocol.
 
-int get_option_value_int(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return atoi(o->currentValue);
+string OptionsMap::print_all() const {
+
+  std::stringstream s;
+
+  for (size_t i = 0; i <= size(); i++)
+      for (OptionsMap::const_iterator it = begin(); it != end(); ++it)
+          if (it->second.idx == i)
+          {
+              const UCIOption& o = it->second;
+              s << "\noption name " << it->first << " type " << o.type;
+
+              if (o.type != "button")
+                  s << " default " << o.defaultValue;
+
+              if (o.type == "spin")
+                  s << " min " << o.minValue << " max " << o.maxValue;
+
+              break;
+          }
+  return s.str();
 }
 
 
-/// get_option_value_string() returns the current value of a UCI parameter as
-/// a string.  It is used with parameters of type "combo" and "string".
+/// Option class c'tors
 
-const std::string get_option_value_string(const std::string &optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return o->currentValue;
-}
+UCIOption::UCIOption(const char* def) : type("string"), minValue(0), maxValue(0), idx(Options.size())
+{ defaultValue = currentValue = def; }
+
+UCIOption::UCIOption(bool def, string t) : type(t), minValue(0), maxValue(0), idx(Options.size())
+{ defaultValue = currentValue = (def ? "true" : "false"); }
+
+UCIOption::UCIOption(int def, int minv, int maxv) : type("spin"), minValue(minv), maxValue(maxv), idx(Options.size())
+{ defaultValue = currentValue = stringify(def); }
 
 
-/// button_was_pressed() tests whether a UCI parameter of type "button" has
-/// been selected since the last time the function was called.
+/// set_value() updates currentValue of the Option object. 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.
 
-bool button_was_pressed(const std::string &buttonName) {
-  if(get_option_value_bool(buttonName)) {
-    set_option_value(buttonName, "false");
-    return true;
-  }
-  else
-    return false;
-}
+void UCIOption::set_value(const string& v) {
 
+  assert(!type.empty());
 
-/// set_option_value() inserts a new value for a UCI parameter.  Note that
-/// the function does not check that the new value is legal for the given
-/// parameter:  This is assumed to be the responsibility of the GUI.
+  if (v.empty())
+      return;
 
-void set_option_value(const std::string &optionName,
-                      const std::string &newValue) {
-  Option *o = option_with_name(optionName.c_str());
+  if ((type == "check" || type == "button") != (v == "true" || v == "false"))
+      return;
 
-  if(o != NULL)
-    strcpy(o->currentValue, newValue.c_str());
-  else
-    std::cout << "No such option: " << optionName << std::endl;
-}
-
-
-/// push_button() is used to tell the engine that a UCI parameter of type
-/// "button" has been selected:
-
-void push_button(const std::string &buttonName) {
-  set_option_value(buttonName, "true");
-}
-
-
-namespace {
-
-  // option_with_name() tries to find a UCI option with a given
-  // name.  It returns a pointer to the UCI option or the null pointer,
-  // depending on whether an option with the given name exists.
-  
-  Option *option_with_name(const char *optionName) {
-    for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++)
-      if(strcmp(o->name, optionName) == 0)
-        return o;
-    return NULL;
+  if (type == "spin")
+  {
+      int val = atoi(v.c_str());
+      if (val < minValue || val > maxValue)
+          return;
   }
 
+  currentValue = v;
 }

src/ucioption.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -16,37 +17,69 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(UCIOPTION_H_INCLUDED)
 #define UCIOPTION_H_INCLUDED
 
-////
-//// Includes
-////
-
+#include <cassert>
+#include <cstdlib>
+#include <map>
 #include <string>
 
+class UCIOption {
+public:
+  UCIOption() {} // To be used in a std::map
+  UCIOption(const char* defaultValue);
+  UCIOption(bool defaultValue, std::string type = "check");
+  UCIOption(int defaultValue, int minValue, int maxValue);
 
-////
-//// Variables
-////
+  void set_value(const std::string& v);
+  template<typename T> T value() const;
 
-extern bool Chess960;
+private:
+  friend class OptionsMap;
+
+  std::string defaultValue, currentValue, type;
+  int minValue, maxValue;
+  size_t idx;
+};
 
 
-////
-//// Prototypes
-////
+/// Custom comparator because UCI options should not be case sensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
 
-extern void init_uci_options();
-extern void print_uci_options();
-extern bool get_option_value_bool(const std::string &optionName);
-extern int get_option_value_int(const std::string &optionName);
-extern const std::string get_option_value_string(const std::string &optionName);
-extern bool button_was_pressed(const std::string &buttonName);
-extern void set_option_value(const std::string &optionName, 
-                             const std::string &newValue);
-extern void push_button(const std::string &buttonName);
 
+/// Our options container is actually a map with a customized c'tor
+class OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
+public:
+  OptionsMap();
+  std::string print_all() const;
+};
+
+extern OptionsMap Options;
+
+
+/// Option::value() definition and specializations
+template<typename T>
+T UCIOption::value() const {
+
+  assert(type == "spin");
+  return T(atoi(currentValue.c_str()));
+}
+
+template<>
+inline std::string UCIOption::value<std::string>() const {
+
+  assert(type == "string");
+  return currentValue;
+}
+
+template<>
+inline bool UCIOption::value<bool>() const {
+
+  assert(type == "check" || type == "button");
+  return currentValue == "true";
+}
 
 #endif // !defined(UCIOPTION_H_INCLUDED)

src/value.cpp

@@ -1,95 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <sstream>
-#include <string>
-
-#include "value.h"
-
-
-////
-//// Functions
-////
-
-/// value_to_tt() adjusts a mate score from "plies to mate from the root" to
-/// "plies to mate from the current ply".  Non-mate scores are unchanged.
-/// The function is called before storing a value to the transposition table.
-
-Value value_to_tt(Value v, int ply) {
-  if(v >= value_mate_in(100))
-    return v + ply;
-  else if(v <= value_mated_in(100))
-    return v - ply;
-  else
-    return v;
-}
-
-
-/// value_from_tt() is the inverse of value_to_tt():  It adjusts a mate score
-/// from the transposition table to a mate score corrected for the current
-/// ply depth.
-
-Value value_from_tt(Value v, int ply) {
-  if(v >= value_mate_in(100))
-    return v - ply;
-  else if(v <= value_mated_in(100))
-    return v + ply;
-  else
-    return v;
-}
-
-
-/// value_to_centipawns() converts a value from Glaurung's somewhat unusual
-/// scale of pawn = 256 to the more conventional pawn = 100.
-
-int value_to_centipawns(Value v) {
-  return (int(v) * 100) / int(PawnValueMidgame);
-}
-
-
-/// value_from_centipawns() converts a centipawn value to Glaurung's internal
-/// evaluation scale.  It's used when reading the values of UCI options
-/// containing material values (e.g. futility pruning margins).
-
-Value value_from_centipawns(int cp) {
-  return Value((cp * 256) / 100);
-}
-
-
-/// value_to_string() converts a value to a string suitable for use with the
-/// UCI protocol.
-
-const std::string value_to_string(Value v) {
-  std::stringstream s;
-
-  if(abs(v) < VALUE_MATE - 200)
-    s << "cp " << value_to_centipawns(v);
-  else {
-    s << "mate ";
-    if(v > 0)
-      s << (VALUE_MATE - v + 1) / 2;
-    else
-      s << -(VALUE_MATE + v) / 2;
-  }
-  return s.str();
-}

src/value.h

@@ -1,164 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-  
-  Glaurung is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-  
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#if !defined(VALUE_H_INCLUDED)
-#define VALUE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "piece.h"
-
-
-////
-//// Types
-////
-
-enum ValueType {
-  VALUE_TYPE_NONE = 0,
-  VALUE_TYPE_UPPER = 1,  // Upper bound
-  VALUE_TYPE_LOWER = 2,  // Lower bound
-  VALUE_TYPE_EXACT = 3   // Exact score
-};
-
-
-enum Value {
-  VALUE_DRAW = 0,
-  VALUE_KNOWN_WIN = 15000,
-  VALUE_MATE = 30000,
-  VALUE_INFINITE = 30001,
-  VALUE_NONE = 30002
-};
-
-
-////
-//// Constants and variables
-////
-
-/// Piece values, middle game and endgame
-
-/// Important: If the material values are changed, one must also
-/// adjust the piece square tables, and the method game_phase() in the
-/// Position class!
-
-const Value PawnValueMidgame = Value(0xCC);
-const Value PawnValueEndgame = Value(0x100);
-const Value KnightValueMidgame = Value(0x340);
-const Value KnightValueEndgame = Value(0x340);
-const Value BishopValueMidgame = Value(0x340);
-const Value BishopValueEndgame = Value(0x340);
-const Value RookValueMidgame = Value(0x505);
-const Value RookValueEndgame = Value(0x505);
-const Value QueenValueMidgame = Value(0xA00);
-const Value QueenValueEndgame = Value(0xA00);
-
-const Value PieceValueMidgame[17] = {
-  Value(0),
-  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
-  RookValueMidgame, QueenValueMidgame,
-  Value(0), Value(0), Value(0),
-  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
-  RookValueMidgame, QueenValueMidgame,
-  Value(0), Value(0), Value(0)
-};
-
-const Value PieceValueEndgame[17] = {
-  Value(0),
-  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
-  RookValueEndgame, QueenValueEndgame,
-  Value(0), Value(0), Value(0),
-  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
-  RookValueEndgame, QueenValueEndgame,
-  Value(0), Value(0), Value(0)
-};
-
-/// Bonus for having the side to move
-
-const Value TempoValueMidgame = Value(50);
-const Value TempoValueEndgame = Value(20);
-
-
-////
-//// Inline functions
-////
-
-inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
-inline Value operator+ (Value v1, Value v2) { return Value(int(v1) + int(v2)); }
-inline void operator+= (Value &v1, Value v2) {
-  v1 = Value(int(v1) + int(v2));
-}
-inline Value operator- (Value v, int i) { return Value(int(v) - i); }
-inline Value operator- (Value v) { return Value(-int(v)); }
-inline Value operator- (Value v1, Value v2) { return Value(int(v1) - int(v2)); }
-inline void operator-= (Value &v1, Value v2) {
-  v1 = Value(int(v1) - int(v2));
-}
-inline Value operator* (Value v, int i) { return Value(int(v) * i); }
-inline void operator*= (Value &v, int i) { v = Value(int(v) * i); }
-inline Value operator* (int i, Value v) { return Value(int(v) * i); }
-inline Value operator/ (Value v, int i) { return Value(int(v) / i); }
-inline void operator/= (Value &v, int i) { v = Value(int(v) / i); }
-
-
-inline Value value_mate_in(int ply) {
-  return Value(VALUE_MATE - Value(ply));
-}
-               
-inline Value value_mated_in(int ply) {
-  return Value(-VALUE_MATE + Value(ply));
-}
-
-inline bool is_upper_bound(ValueType vt) {
-  return (int(vt) & int(VALUE_TYPE_UPPER)) != 0;
-}
-
-inline bool is_lower_bound(ValueType vt) {
-  return (int(vt) & int(VALUE_TYPE_LOWER)) != 0;
-}
-
-inline Value piece_value_midgame(PieceType pt) {
-  return PieceValueMidgame[pt];
-}
-
-inline Value piece_value_endgame(PieceType pt) {
-  return PieceValueEndgame[pt];
-}
-
-inline Value piece_value_midgame(Piece p) {
-  return PieceValueMidgame[p];
-}
-
-inline Value piece_value_endgame(Piece p) {
-  return PieceValueEndgame[p];
-}
-
-
-////
-//// Prototypes
-////
-
-extern Value value_to_tt(Value v, int ply);
-extern Value value_from_tt(Value v, int ply);
-extern int value_to_centipawns(Value v);
-extern Value value_from_centipawns(int cp);
-extern const std::string value_to_string(Value v);
-
-
-#endif // !defined(VALUE_H_INCLUDED)