Stockfish 7

Bench: 8355485

No functional change

.travis.yml

@@ -0,0 +1,49 @@
+language: cpp
+
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8']
+      env:
+        - COMPILER=g++-4.8
+        - COMP=gcc
+
+    - os: linux
+      compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.7']
+          packages: ['clang-3.7']
+      env:
+        - COMPILER=clang++-3.7
+        - COMP=clang
+
+    - os: osx
+      compiler: gcc
+      env:
+        - COMPILER=g++-4.8
+        - COMP=gcc
+
+    - os: osx
+      compiler: clang
+      env:
+        - COMPILER=clang++ V='Apple LLVM 6.0' # Apple LLVM version 6.0 (clang-600.0.54) (based on LLVM 3.5svn)
+        - COMP=clang
+
+branches:
+  only:
+   - master
+
+before_script:
+  - cd src
+
+script:
+  - make clean && make build ARCH=x86-64 && ./stockfish bench 2>&1 >/dev/null | grep 'Nodes searched' | tee bench1
+  - make clean && make build ARCH=x86-32 && ./stockfish bench 2>&1 >/dev/null | grep 'Nodes searched' | tee bench2
+  - echo "Checking for same bench numbers..."
+  - diff bench1 bench2 > result
+  - test ! -s result

AUTHORS

@@ -0,0 +1,98 @@
+# Generated with git shortlog -sn | cut -c8-', which sorts by commits (manually ordered the first four authors)
+
+Tord Romstad
+Marco Costalba
+Joona Kiiski
+Gary Linscott
+lucasart
+mstembera
+Lucas Braesch
+Stefan Geschwentner
+Reuven Peleg
+Chris Caino
+joergoster
+VoyagerOne
+Jean-Francois Romang
+homoSapiensSapiens
+Alain SAVARD
+Arjun Temurnikar
+Stéphane Nicolet
+Uri Blass
+jundery
+Ralph Stößer
+Ajith
+Leonid Pechenik
+Stefano80
+Tom Vijlbrief
+hxim
+snicolet
+Daylen Yang
+Henri Wiechers
+Jonathan Calovski
+mbootsector
+David Zar
+Eelco de Groot
+Jerry Donald
+Joerg Oster
+Jörg Oster
+Ryan Schmitt
+mcostalba
+Alexander Kure
+Dan Schmidt
+H. Felix Wittmann
+Joseph R. Prostko
+Justin Blanchard
+Linus Arver
+NicklasPersson
+Rodrigo Exterckötter Tjäder
+Ron Britvich
+Ronald de Man
+RyanTaker
+Vince Negri
+ceebo
+jhellis3
+ppigazzini
+shane31
+Andy Duplain
+Auguste Pop
+Balint Pfliegel
+Chris Cain
+DU-jdto
+Dariusz Orzechowski
+DiscanX
+Ernesto Gatti
+Gregor Cramer
+Guenther Demetz
+Hiraoka Takuya
+Hongzhi Cheng
+Joseph Hellis
+Kelly Wilson
+Ken T Takusagawa
+Kojirion
+Luca Brivio
+Matt Sullivan
+Matthew Lai
+Matthew Sullivan
+Michel Van den Bergh
+Mysseno
+Oskar Werkelin Ahlin
+Pablo Vazquez
+Pascal Romaret
+Ralph Stoesser
+Ralph Stößer
+Raminder Singh
+Richard Lloyd
+Ryan Takker
+Stephane Nicolet
+Thanar2
+absimaldata
+braich
+gguliash
+kinderchocolate
+loco-loco
+pellanda
+renouve
+sf-x
+thaspel
+unknown
+uriblass

Readme.md

@@ -0,0 +1,114 @@
+### Overview
+
+[![Build Status](https://travis-ci.org/official-stockfish/Stockfish.svg?branch=master)](https://travis-ci.org/official-stockfish/Stockfish)
+
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
+not a complete chess program and requires some UCI-compatible GUI
+(e.g. XBoard with PolyGlot, eboard, 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 it.
+
+This version of Stockfish supports up to 128 cores. The engine defaults
+to one search thread, so 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.
+
+This version of Stockfish has support for Syzygybases.
+
+
+### Files
+
+This distribution of Stockfish consists of the following files:
+
+  * Readme.md, the file you are currently reading.
+
+  * Copying.txt, a text file containing the GNU General Public License.
+
+  * src, a subdirectory containing the full source code, including a Makefile
+    that can be used to compile Stockfish on Unix-like systems.
+
+
+### Syzygybases
+
+**Configuration**
+
+Syzygybases are configured using the UCI options "SyzygyPath",
+"SyzygyProbeDepth", "Syzygy50MoveRule" and "SyzygyProbeLimit".
+
+The option "SyzygyPath" should be set to the directory or directories that
+contain the .rtbw and .rtbz files. Multiple directories should be
+separated by ";" on Windows and by ":" on Unix-based operating systems.
+**Do not use spaces around the ";" or ":".**
+
+Example: `C:\tablebases\wdl345;C:\tablebases\wdl6;D:\tablebases\dtz345;D:\tablebases\dtz6`
+
+It is recommended to store .rtbw files on an SSD. There is no loss in
+storing the .rtbz files on a regular HD.
+
+Increasing the "SyzygyProbeDepth" option lets the engine probe less
+aggressively. Set this option to a higher value if you experience too much
+slowdown (in terms of nps) due to TB probing.
+
+Set the "Syzygy50MoveRule" option to false if you want tablebase positions
+that are drawn by the 50-move rule to count as win or loss. This may be useful
+for correspondence games (because of tablebase adjudication).
+
+The "SyzygyProbeLimit" option should normally be left at its default value.
+
+**What to expect**
+If the engine is searching a position that is not in the tablebases (e.g.
+a position with 7 pieces), it will access the tablebases during the search.
+If the engine reports a very large score (typically 123.xx), this means
+that it has found a winning line into a tablebase position.
+
+If the engine is given a position to search that is in the tablebases, it
+will use the tablebases at the beginning of the search to preselect all
+good moves, i.e. all moves that preserve the win or preserve the draw while
+taking into account the 50-move rule.
+It will then perform a search only on those moves. **The engine will not move
+immediately**, unless there is only a single good move. **The engine likely
+will not report a mate score even if the position is known to be won.**
+
+It is therefore clear that behaviour is not identical to what one might
+be used to with Nalimov tablebases. There are technical reasons for this
+difference, the main technical reason being that Nalimov tablebases use the
+DTM metric (distance-to-mate), while Syzygybases use a variation of the
+DTZ metric (distance-to-zero, zero meaning any move that resets the 50-move
+counter). This special metric is one of the reasons that Syzygybases are
+more compact than Nalimov tablebases, while still storing all information
+needed for optimal play and in addition being able to take into account
+the 50-move rule.
+
+
+### Compiling it yourself
+
+On Unix-like systems, it should be possible to compile Stockfish
+directly from the source code with the included Makefile.
+
+Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT
+instruction, big-endian machines such as Power PC, and other platforms.
+
+In general it is recommended to run `make help` to see a list of make
+targets with corresponding descriptions. When not using the Makefile to
+compile (for instance with Microsoft MSVC) you need to manually
+set/unset some switches in the compiler command line; see file *types.h*
+for a quick reference.
+
+
+### Terms of use
+
+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 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.
+
+For full details, read the copy of the GPL found in the file named
+*Copying.txt*

Readme.txt

@@ -1,88 +0,0 @@
-1. Introduction
----------------
-
-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.
-
-This version of Stockfish supports up to 16 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. 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 Stockfish consists of the following files:
-
-  * Readme.txt, the file you are currently reading.
-
-  * Copying.txt, a text file containing the GNU General Public
-    License.
-
-  * src/, a subdirectory containing the full source code, including a
-    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.
-
-  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
-    adapter.
-
-
-3. Opening books
-----------------
-
-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
-Stockfish directly from the source code with the included Makefile.
-
-For big-endian machines like Power PC you need to enable the proper
-flag changing from -DNBIGENDIAN to -DBIGENDIAN in the Makefile.
-
-Stockfish has POPCNT instruction runtime detection and support. This can
-give an extra speed on Core i7 or similar systems. To enable this feature
-compile with 'make icc-profile-popcnt'
-
-On 64 bit Unix-like systems the 'bsfq' assembly instruction will be used
-for bit counting. Detection is automatic at compile time, but in case you
-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. Terms of use
----------------
-
-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 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.
-
-For full details, read the copy of the GPL found in the file named
-Copying.txt.
-

polyglot.ini

@@ -1,52 +0,0 @@
-
-[PolyGlot]
-
-EngineDir = .
-EngineCommand = ./stockfish
-
-Book = false
-BookFile = book.bin
-
-Log = false
-LogFile = stockfish.log
-
-Resign = true
-ResignScore = 600
-
-[Engine]
-
-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
-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
-Minimum Split Depth = 4
-Maximum Number of Threads per Split Point = 5
-Use Sleeping Threads = false
-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,8 +1,7 @@
 # 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
+# Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
-#
+# Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
-# This file is part of Stockfish.
 #
 # Stockfish is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -22,6 +21,9 @@
 ### Section 1. General Configuration
 ### ==========================================================================
 
+### Establish the operating system name
+UNAME = $(shell uname)
+
 ### Executable name
 EXE = stockfish
 
@@ -30,13 +32,12 @@ PREFIX = /usr/local
 BINDIR = $(PREFIX)/bin
 
 ### Built-in benchmark for pgo-builds
-PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+PGOBENCH = ./$(EXE) bench 16 1 1000 default time
 
 ### Object files
-OBJS = bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
+OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \
-	misc.o move.o movegen.o history.o movepick.o search.o position.o \
+	material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \
-	tt.o uci.o ucioption.o book.o bitbase.o san.o benchmark.o timeman.o
+	search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o
-
 
 ### ==========================================================================
 ### Section 2. High-level Configuration
@@ -45,148 +46,92 @@ OBJS = bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
 # flag                --- Comp switch --- Description
 # ----------------------------------------------------------------------------
 #
-# debug = no/yes      --- -DNDEBUG    --- Enable/Disable debug mode
+# debug = yes/no      --- -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 = yes/no   --- -DUSE_PREFETCH   --- Use prefetch x86 asm-instruction
-# prefetch = no/yes   --- -DUSE_PREFETCH  --- Use prefetch x86 asm-instruction
+# bsfq = yes/no       --- -DUSE_BSFQ       --- Use bsfq x86_64 asm-instruction (only
-# bsfq = no/yes       --- -DUSE_BSFQ  --- Use bsfq x86_64 asm-instruction
+#                                              with GCC and ICC 64-bit)
-#                                     --- (Works only with GCC and ICC 64-bit)
+# popcnt = yes/no     --- -DUSE_POPCNT     --- Use popcnt x86_64 asm-instruction
-# popcnt = no/yes     --- -DUSE_POPCNT --- Use popcnt x86_64 asm-instruction
+# sse = yes/no        --- -msse            --- Use Intel Streaming SIMD Extensions
+# pext = yes/no       --- -DUSE_PEXT       --- Use pext 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
+### 2.1. General and architecture defaults
-debug = no
 optimize = yes
+debug = no
+bits = 32
+prefetch = no
+bsfq = no
+popcnt = no
+sse = no
+pext = no
 
 ### 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),x86-32)
-ifeq ($(ARCH),osx-ppc-64)
+	arch = i386
-	arch = ppc64
+	prefetch = yes
-	os = osx
+	sse = yes
+endif
+
+ifeq ($(ARCH),general-64)
+	arch = any
 	bits = 64
-	bigendian = yes
-	prefetch = no
-	bsfq = no
-	popcnt = no
 endif
 
-ifeq ($(ARCH),osx-ppc-32)
+ifeq ($(ARCH),x86-64)
-	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
+	sse = yes
 endif
 
-ifeq ($(ARCH),osx-x86-32)
+ifeq ($(ARCH),x86-64-modern)
-	arch = i386
+	arch = x86_64
-	os = osx
+	bits = 64
-	bits = 32
-	bigendian = no
 	prefetch = yes
-	bsfq = no
+	bsfq = yes
-	popcnt = no
+	popcnt = yes
+	sse = yes
+endif
+
+ifeq ($(ARCH),x86-64-bmi2)
+	arch = x86_64
+	bits = 64
+	prefetch = yes
+	bsfq = yes
+	popcnt = yes
+	sse = yes
+	pext = yes
+endif
+
+ifeq ($(ARCH),armv7)
+	arch = armv7
+	prefetch = yes
+	bsfq = yes
+endif
+
+ifeq ($(ARCH),ppc-32)
+	arch = ppc
+endif
+
+ifeq ($(ARCH),ppc-64)
+	arch = ppc64
+	bits = 64
 endif
 
 
@@ -195,66 +140,103 @@ endif
 ### ==========================================================================
 
 ### 3.1 Selecting compiler (default = gcc)
+
+CXXFLAGS += -Wall -Wcast-qual -fno-exceptions -fno-rtti -std=c++11 $(EXTRACXXFLAGS)
+DEPENDFLAGS += -std=c++11
+LDFLAGS += $(EXTRALDFLAGS)
+
 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++
+	CXXFLAGS += -pedantic -Wextra -Wshadow
+	ifneq ($(UNAME),Darwin)
+	   LDFLAGS += -Wl,--no-as-needed
+	endif
+endif
+
+ifeq ($(COMP),mingw)
+	comp=mingw
+
+	ifeq ($(UNAME),Linux)
+		ifeq ($(bits),64)
+			ifeq ($(shell which x86_64-w64-mingw32-c++-posix),)
+				CXX=x86_64-w64-mingw32-c++
+			else
+				CXX=x86_64-w64-mingw32-c++-posix
+			endif
+		else
+			ifeq ($(shell which i686-w64-mingw32-c++-posix),)
+				CXX=i686-w64-mingw32-c++
+			else
+				CXX=i686-w64-mingw32-c++-posix
+			endif
+		endif
+	else
+		CXX=g++
+	endif
+
+	CXXFLAGS += -Wextra -Wshadow
+	LDFLAGS += -static
+endif
+
+ifeq ($(COMP),icc)
+	comp=icc
+	CXX=icpc
+	CXXFLAGS += -diag-disable 1476,10120 -Wcheck -Wabi -Wdeprecated -strict-ansi
+endif
+
+ifeq ($(COMP),clang)
+	comp=clang
+	CXX=clang++
+	CXXFLAGS += -pedantic -Wextra -Wshadow
+	ifeq ($(UNAME),Darwin)
+		CXXFLAGS += -std=c++0x -stdlib=libc++
+		DEPENDFLAGS += -std=c++0x -stdlib=libc++
+	endif
+endif
+
+ifeq ($(comp),icc)
+	profile_prepare = icc-profile-prepare
+	profile_make = icc-profile-make
+	profile_use = icc-profile-use
+	profile_clean = icc-profile-clean
+else
 	profile_prepare = gcc-profile-prepare
 	profile_make = gcc-profile-make
 	profile_use = gcc-profile-use
 	profile_clean = gcc-profile-clean
 endif
 
-ifeq ($(COMP),icc)
+ifeq ($(UNAME),Darwin)
-	comp=icc
+	CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.9
-	CXX=icpc
+	LDFLAGS += -arch $(arch) -mmacosx-version-min=10.9
-	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
+### Travis CI script uses COMPILER to overwrite CXX
-CXXFLAGS = -g -Wall -Wcast-qual -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+ifdef COMPILER
-
+	CXX=$(COMPILER)
-ifeq ($(comp),gcc)
-	CXXFLAGS += -ansi -pedantic -Wno-long-long -Wextra
 endif
 
-ifeq ($(comp),mingw)
+### On mingw use Windows threads, otherwise POSIX
-	CXXFLAGS += -Wno-long-long -Wextra
+ifneq ($(comp),mingw)
-endif
+	# On Android Bionic's C library comes with its own pthread implementation bundled in
-
+	ifneq ($(arch),armv7)
-ifeq ($(comp),icc)
+		# Haiku has pthreads in its libroot, so only link it in on other platforms
-	CXXFLAGS += -wd383,981,1418,1419,10187,10188,11505,11503 -Wcheck -Wabi -Wdeprecated -strict-ansi
+		ifneq ($(UNAME),Haiku)
-endif
+			LDFLAGS += -lpthread
-
+		endif
-ifeq ($(os),osx)
+	endif
-	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
+else
+	CXXFLAGS += -g
 endif
 
 ### 3.5 Optimization
@@ -263,7 +245,7 @@ ifeq ($(optimize),yes)
 	ifeq ($(comp),gcc)
 		CXXFLAGS += -O3
 
-		ifeq ($(os),osx)
+		ifeq ($(UNAME),Darwin)
 			ifeq ($(arch),i386)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
@@ -271,6 +253,10 @@ ifeq ($(optimize),yes)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
 		endif
+
+		ifeq ($(arch),armv7)
+			CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
+		endif
 	endif
 
 	ifeq ($(comp),mingw)
@@ -278,11 +264,28 @@ ifeq ($(optimize),yes)
 	endif
 
 	ifeq ($(comp),icc)
+		ifeq ($(UNAME),Darwin)
+			CXXFLAGS += -fast -mdynamic-no-pic
+		else
 			CXXFLAGS += -fast
+		endif
+	endif
 
-		ifeq ($(os),osx)
+	ifeq ($(comp),clang)
+		CXXFLAGS += -O3
+
+		ifeq ($(UNAME),Darwin)
+			ifeq ($(pext),no)
+				CXXFLAGS += -flto
+				LDFLAGS += $(CXXFLAGS)
+			endif
+			ifeq ($(arch),i386)
 				CXXFLAGS += -mdynamic-no-pic
 			endif
+			ifeq ($(arch),x86_64)
+				CXXFLAGS += -mdynamic-no-pic
+			endif
+		endif
 	endif
 endif
 
@@ -291,36 +294,73 @@ ifeq ($(bits),64)
 	CXXFLAGS += -DIS_64BIT
 endif
 
-### 3.7 Endianess
+### 3.7 prefetch
-ifeq ($(bigendian),yes)
-	CXXFLAGS += -DBIGENDIAN
-endif
-
-### 3.8 prefetch
 ifeq ($(prefetch),yes)
+	ifeq ($(sse),yes)
 		CXXFLAGS += -msse
 		DEPENDFLAGS += -msse
+	endif
 else
 	CXXFLAGS += -DNO_PREFETCH
 endif
 
-### 3.9 bsfq
+### 3.8 bsfq
 ifeq ($(bsfq),yes)
 	CXXFLAGS += -DUSE_BSFQ
 endif
 
-### 3.10 popcnt
+### 3.9 popcnt
 ifeq ($(popcnt),yes)
-	CXXFLAGS += -DUSE_POPCNT
+	ifeq ($(comp),icc)
+		CXXFLAGS += -msse3 -DUSE_POPCNT
+	else
+		CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT
+	endif
 endif
 
+### 3.10 pext
+ifeq ($(pext),yes)
+	CXXFLAGS += -DUSE_PEXT
+	ifeq ($(comp),$(filter $(comp),gcc clang mingw))
+		CXXFLAGS += -mbmi -mbmi2
+	endif
+endif
+
+### 3.11 Link Time Optimization, it works since gcc 4.5 but not on mingw under Windows.
+### This is a mix of compile and link time options because the lto link phase
+### needs access to the optimization flags.
+ifeq ($(comp),gcc)
+	ifeq ($(optimize),yes)
+	ifeq ($(debug),no)
+		CXXFLAGS += -flto
+		LDFLAGS += $(CXXFLAGS)
+	endif
+	endif
+endif
+
+ifeq ($(comp),mingw)
+	ifeq ($(UNAME),Linux)
+	ifeq ($(optimize),yes)
+	ifeq ($(debug),no)
+		CXXFLAGS += -flto
+		LDFLAGS += $(CXXFLAGS)
+	endif
+	endif
+	endif
+endif
+
+### 3.12 Android 5 can only run position independent executables. Note that this
+### breaks Android 4.0 and earlier.
+ifeq ($(arch),armv7)
+	CXXFLAGS += -fPIE
+	LDFLAGS += -fPIE -pie
+endif
+
+
 ### ==========================================================================
 ### Section 4. Public targets
 ### ==========================================================================
 
-default:
-	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) build
-
 help:
 	@echo ""
 	@echo "To compile stockfish, type: "
@@ -329,45 +369,39 @@ help:
 	@echo ""
 	@echo "Supported targets:"
 	@echo ""
-	@echo "build                > Build unoptimized version"
+	@echo "build                   > Standard build"
-	@echo "profile-build        > Build PGO-optimized version"
+	@echo "profile-build           > PGO build"
-	@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-64-modern           > x86 64-bit with popcnt support"
-	@echo "x86-32               > x86 32-bit excluding very old hardware without SSE-support"
+	@echo "x86-64-bmi2             > x86 64-bit with pext support"
-	@echo "x86-32-old           > x86 32-bit including also very old hardware"
+	@echo "x86-32                  > x86 32-bit with SSE support"
-	@echo "osx-ppc-64           > PPC-Mac OS X 64 bit"
+	@echo "x86-32-old              > x86 32-bit fall back for old hardware"
-	@echo "osx-ppc-32           > PPC-Mac OS X 32 bit"
+	@echo "ppc-64                  > PPC 64-bit"
-	@echo "osx-x86-64           > x86-Mac OS X 64 bit"
+	@echo "ppc-32                  > PPC 32-bit"
-	@echo "osx-x86-32           > x86-Mac OS X 32 bit"
+	@echo "armv7                   > ARMv7 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 "Supported compilers:"
 	@echo ""
 	@echo "gcc                     > Gnu compiler (default)"
-	@echo "icc                  > Intel compiler"
 	@echo "mingw                   > Gnu compiler with MinGW under Windows"
-	@echo ""
+	@echo "clang                   > LLVM Clang compiler"
-	@echo "Non-standard targets:"
+	@echo "icc                     > Intel compiler"
-	@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 build ARCH=x86-64    (This is for 64-bit systems)"
-	@echo "make profile-build ARCH=x86-32    (This is for 32-bit systems)"
+	@echo "make build ARCH=x86-32    (This is for 32-bit systems)"
 	@echo ""
 
+.PHONY: build profile-build
 build:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
@@ -379,47 +413,19 @@ profile-build:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_prepare)
 	@echo ""
 	@echo "Step 1/4. Building executable for benchmark ..."
-	@touch *.cpp *.h
+	@touch *.cpp *.h syzygy/*.cpp syzygy/*.h
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
 	@echo ""
 	@echo "Step 2/4. Running benchmark for pgo-build ..."
-	@$(PGOBENCH) > /dev/null
+	$(PGOBENCH) > /dev/null
 	@echo ""
 	@echo "Step 3/4. Building final executable ..."
-	@touch *.cpp
+	@touch *.cpp *.h syzygy/*.cpp syzygy/*.h
 	$(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)
 
@@ -429,10 +435,10 @@ install:
 	-strip $(BINDIR)/$(EXE)
 
 clean:
-	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda
+	$(RM) $(EXE) $(EXE).exe *.o .depend *~ core bench.txt *.gcda ./syzygy/*.o ./syzygy/*.gcda
 
-testrun:
+default:
-	@$(PGOBENCH)
+	help
 
 ### ==========================================================================
 ### Section 5. Private targets
@@ -446,12 +452,12 @@ config-sanity:
 	@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 "sse: '$(sse)'"
+	@echo "pext: '$(pext)'"
 	@echo ""
 	@echo "Flags:"
 	@echo "CXX: $(CXX)"
@@ -463,14 +469,14 @@ config-sanity:
 	@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 "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
-	@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"
+	@test "$(sse)" = "yes" || test "$(sse)" = "no"
+	@test "$(pext)" = "yes" || test "$(pext)" = "no"
+	@test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang"
 
 $(EXE): $(OBJS)
 	$(CXX) -o $@ $(OBJS) $(LDFLAGS)
@@ -486,11 +492,12 @@ gcc-profile-make:
 
 gcc-profile-use:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
-	EXTRACXXFLAGS='-fprofile-use' \
+	EXTRACXXFLAGS='-fprofile-use -fno-peel-loops -fno-tracer' \
+	EXTRALDFLAGS='-lgcov' \
 	all
 
 gcc-profile-clean:
-	@rm -rf *.gcda *.gcno bench.txt
+	@rm -rf *.gcda *.gcno syzygy/*.gcda syzygy/*.gcno bench.txt
 
 icc-profile-prepare:
 	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) icc-profile-clean
@@ -514,15 +521,3 @@ icc-profile-clean:
 
 -include .depend
 
-
-### ==========================================================================
-### Section 6. Non-standard targets
-### ==========================================================================
-
-hpux:
-	$(MAKE) \
-	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG -DNO_PREFETCH' \
-	CXXFLAGS="" \
-	LDFLAGS="" \
-	all
-

src/benchmark.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,27 +18,25 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
 #include <fstream>
+#include <iostream>
+#include <istream>
 #include <vector>
 
+#include "misc.h"
+#include "position.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
 
 using namespace std;
 
-////
+namespace {
-//// Variables
-////
 
-static const string BenchmarkPositions[] = {
+const vector<string> Defaults = {
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
-  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
+  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10",
-  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -",
+  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11",
   "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",
@@ -51,104 +50,126 @@ static const string BenchmarkPositions[] = {
   "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",
-  ""
+  "6k1/6p1/6Pp/ppp5/3pn2P/1P3K2/1PP2P2/3N4 b - - 0 1",
+  "3b4/5kp1/1p1p1p1p/pP1PpP1P/P1P1P3/3KN3/8/8 w - - 0 1",
+  "2K5/p7/7P/5pR1/8/5k2/r7/8 w - - 0 1",
+  "8/6pk/1p6/8/PP3p1p/5P2/4KP1q/3Q4 w - - 0 1",
+  "7k/3p2pp/4q3/8/4Q3/5Kp1/P6b/8 w - - 0 1",
+  "8/2p5/8/2kPKp1p/2p4P/2P5/3P4/8 w - - 0 1",
+  "8/1p3pp1/7p/5P1P/2k3P1/8/2K2P2/8 w - - 0 1",
+  "8/pp2r1k1/2p1p3/3pP2p/1P1P1P1P/P5KR/8/8 w - - 0 1",
+  "8/3p4/p1bk3p/Pp6/1Kp1PpPp/2P2P1P/2P5/5B2 b - - 0 1",
+  "5k2/7R/4P2p/5K2/p1r2P1p/8/8/8 b - - 0 1",
+  "6k1/6p1/P6p/r1N5/5p2/7P/1b3PP1/4R1K1 w - - 0 1",
+  "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1",
+  "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1",
+  "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1",
+
+  // 5-man positions
+  "8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1",     // Kc2 - mate
+  "8/8/8/5N2/8/p7/8/2NK3k w - - 0 1",      // Na2 - mate
+  "8/3k4/8/8/8/4B3/4KB2/2B5 w - - 0 1",    // draw
+
+  // 6-man positions
+  "8/8/1P6/5pr1/8/4R3/7k/2K5 w - - 0 1",   // Re5 - mate
+  "8/2p4P/8/kr6/6R1/8/8/1K6 w - - 0 1",    // Ka2 - mate
+  "8/8/3P3k/8/1p6/8/1P6/1K3n2 b - - 0 1",  // Nd2 - draw
+
+  // 7-man positions
+  "8/R7/2q5/8/6k1/8/1P5p/K6R w - - 0 124"  // Draw
 };
 
-
+} // namespace
-////
-//// Functions
-////
 
 /// benchmark() runs a simple benchmark by letting Stockfish analyze a set
-/// of positions for a given limit each.  There are five parameters; the
+/// 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
+/// be used, the limit value spent for each position (optional, default is
-/// is ply 12), an optional file name where to look for positions in fen
+/// depth 13), an optional file name where to look for positions in FEN
-/// format (default are the BenchmarkPositions defined above) and the type
+/// format (defaults are the positions defined above) and the type of the
-/// of the limit value: depth (default), time in secs or number of nodes.
+/// limit value: depth (default), time in millisecs or number of nodes.
-/// The analysis is written to a file named bench.txt.
 
-void benchmark(int argc, char* argv[]) {
+void benchmark(const Position& current, istream& is) {
 
-  vector<string> positions;
+  string token;
-  string ttSize, threads, valStr, posFile, valType;
+  vector<string> fens;
-  int val, secsPerPos, maxDepth, maxNodes;
+  Search::LimitsType limits;
 
-  ttSize  = argc > 2 ? argv[2] : "128";
+  // Assign default values to missing arguments
-  threads = argc > 3 ? argv[3] : "1";
+  string ttSize    = (is >> token) ? token : "16";
-  valStr  = argc > 4 ? argv[4] : "12";
+  string threads   = (is >> token) ? token : "1";
-  posFile = argc > 5 ? argv[5] : "default";
+  string limit     = (is >> token) ? token : "13";
-  valType = argc > 6 ? argv[6] : "depth";
+  string fenFile   = (is >> token) ? token : "default";
+  string limitType = (is >> token) ? token : "depth";
 
-  Options["Hash"].set_value(ttSize);
+  Options["Hash"]    = ttSize;
-  Options["Threads"].set_value(threads);
+  Options["Threads"] = threads;
-  Options["OwnBook"].set_value("false");
+  Search::clear();
-  Options["Use Search Log"].set_value("true");
-  Options["Search Log Filename"].set_value("bench.txt");
 
-  secsPerPos = maxDepth = maxNodes = 0;
+  if (limitType == "time")
-  val = atoi(valStr.c_str());
+      limits.movetime = stoi(limit); // movetime is in millisecs
+
+  else if (limitType == "nodes")
+      limits.nodes = stoi(limit);
+
+  else if (limitType == "mate")
+      limits.mate = stoi(limit);
 
-  if (valType == "depth" || valType == "perft")
-      maxDepth = val;
-  else if (valType == "time")
-      secsPerPos = val * 1000;
   else
-      maxNodes = val;
+      limits.depth = stoi(limit);
 
-  if (posFile != "default")
+  if (fenFile == "default")
+      fens = Defaults;
+
+  else if (fenFile == "current")
+      fens.push_back(current.fen());
+
+  else
   {
-      ifstream fenFile(posFile.c_str());
+      string fen;
-      if (!fenFile.is_open())
+      ifstream file(fenFile);
+
+      if (!file.is_open())
       {
-          cerr << "Unable to open positions file " << posFile << endl;
+          cerr << "Unable to open file " << fenFile << endl;
-          exit(EXIT_FAILURE);
+          return;
       }
-      string pos;
+
-      while (fenFile.good())
+      while (getline(file, fen))
-      {
+          if (!fen.empty())
-          getline(fenFile, pos);
+              fens.push_back(fen);
-          if (!pos.empty())
+
-              positions.push_back(pos);
+      file.close();
   }
-      fenFile.close();
-  } else
-      for (int i = 0; !BenchmarkPositions[i].empty(); i++)
-          positions.push_back(BenchmarkPositions[i]);
 
-  vector<string>::iterator it;
+  uint64_t nodes = 0;
-  int cnt = 1;
+  TimePoint elapsed = now();
-  int64_t totalNodes = 0;
-  int startTime = get_system_time();
 
-  for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
+  for (size_t i = 0; i < fens.size(); ++i)
   {
-      Move moves[1] = { MOVE_NONE };
+      Position pos(fens[i], Options["UCI_Chess960"], Threads.main());
-      int dummy[2] = { 0, 0 };
+
-      Position pos(*it, false, 0);
+      cerr << "\nPosition: " << i + 1 << '/' << fens.size() << endl;
-      cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
+
-      if (valType == "perft")
+      if (limitType == "perft")
+          nodes += Search::perft(pos, limits.depth * ONE_PLY);
+
+      else
       {
-          int64_t perftCnt = perft(pos, maxDepth * ONE_PLY);
+          Search::StateStackPtr st;
-          cerr << "\nPerft " << maxDepth << " result (nodes searched): " << perftCnt << endl << endl;
+          limits.startTime = now();
-          totalNodes += perftCnt;
+          Threads.start_thinking(pos, limits, st);
-      } else {
+          Threads.main()->wait_for_search_finished();
-          if (!think(pos, false, false, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+          nodes += Threads.nodes_searched();
-              break;
-          totalNodes += pos.nodes_searched();
       }
   }
 
-  cnt = get_system_time() - startTime;
+  elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
-  cerr << "==============================="
-       << "\nTotal time (ms) : " << cnt
-       << "\nNodes searched  : " << totalNodes
-       << "\nNodes/second    : " << (int)(totalNodes/(cnt/1000.0)) << endl << endl;
 
-  // Under MS Visual C++ debug window always unconditionally closes
+  dbg_print(); // Just before to exit
-  // when program exits, this is bad because we want to read results before.
+
-  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
+  cerr << "\n==========================="
-  cerr << "Press any key to exit" << endl;
+       << "\nTotal time (ms) : " << elapsed
-  cin >> ttSize;
+       << "\nNodes searched  : " << nodes
-  #endif
+       << "\nNodes/second    : " << 1000 * nodes / elapsed << endl;
 }

src/bitbase.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,303 +18,163 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <algorithm>
-////
-//// Includes
-////
-
 #include <cassert>
+#include <numeric>
+#include <vector>
 
 #include "bitboard.h"
-#include "square.h"
+#include "types.h"
-
-
-////
-//// Local definitions
-////
 
 namespace {
 
+  // There are 24 possible pawn squares: the first 4 files and ranks from 2 to 7
+  const unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608
+
+  // Each uint32_t stores results of 32 positions, one per bit
+  uint32_t KPKBitbase[MAX_INDEX / 32];
+
+  // A KPK bitbase index is an integer in [0, IndexMax] range
+  //
+  // Information is mapped in a way that minimizes the number of iterations:
+  //
+  // bit  0- 5: white king square (from SQ_A1 to SQ_H8)
+  // bit  6-11: black king square (from SQ_A1 to SQ_H8)
+  // bit    12: side to move (WHITE or BLACK)
+  // bit 13-14: white pawn file (from FILE_A to FILE_D)
+  // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
+  unsigned index(Color us, Square bksq, Square wksq, Square psq) {
+    return wksq | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15);
+  }
+
   enum Result {
-    RESULT_UNKNOWN,
+    INVALID = 0,
-    RESULT_INVALID,
+    UNKNOWN = 1,
-    RESULT_WIN,
+    DRAW    = 2,
-    RESULT_LOSS,
+    WIN     = 4
-    RESULT_DRAW
   };
 
+  Result& operator|=(Result& r, Result v) { return r = Result(r | v); }
+
   struct KPKPosition {
-    void from_index(int index);
+    KPKPosition() = default;
-    bool is_legal() const;
+    explicit KPKPosition(unsigned idx);
-    bool is_immediate_draw() const;
+    operator Result() const { return result; }
-    bool is_immediate_win() const;
+    Result classify(const std::vector<KPKPosition>& db)
-    Bitboard wk_attacks()   const { return StepAttackBB[WK][whiteKingSquare]; }
+    { return us == WHITE ? classify<WHITE>(db) : classify<BLACK>(db); }
-    Bitboard bk_attacks()   const { return StepAttackBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const { return StepAttackBB[WP][pawnSquare]; }
 
-    Square whiteKingSquare, blackKingSquare, pawnSquare;
+    template<Color Us> Result classify(const std::vector<KPKPosition>& db);
-    Color sideToMove;
+
+    Color us;
+    Square ksq[COLOR_NB], psq;
+    Result result;
   };
 
-  const int IndexMax = 2 * 24 * 64 * 64;
+} // namespace
 
-  Result classify_wtm(const KPKPosition& pos, const Result bb[]);
+
-  Result classify_btm(const KPKPosition& pos, const Result bb[]);
+bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color us) {
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm);
+
+  assert(file_of(wpsq) <= FILE_D);
+
+  unsigned idx = index(us, bksq, wksq, wpsq);
+  return KPKBitbase[idx / 32] & (1 << (idx & 0x1F));
 }
 
 
-////
+void Bitbases::init() {
-//// Functions
-////
 
-void generate_kpk_bitbase(uint8_t bitbase[]) {
+  std::vector<KPKPosition> db(MAX_INDEX);
+  unsigned idx, repeat = 1;
 
-  bool repeat;
+  // Initialize db with known win / draw positions
-  int i, j, b;
+  for (idx = 0; idx < MAX_INDEX; ++idx)
-  KPKPosition pos;
+      db[idx] = KPKPosition(idx);
-  Result bb[IndexMax];
 
-  // Initialize table
+  // Iterate through the positions until none of the unknown positions can be
-  for (i = 0; i < IndexMax; i++)
+  // changed to either wins or draws (15 cycles needed).
-  {
+  while (repeat)
-      pos.from_index(i);
+      for (repeat = idx = 0; idx < MAX_INDEX; ++idx)
-      bb[i] = !pos.is_legal()          ? RESULT_INVALID
+          repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN);
-             : pos.is_immediate_draw() ? RESULT_DRAW
-             : pos.is_immediate_win()  ? RESULT_WIN : RESULT_UNKNOWN;
-  }
 
-  // Iterate until all positions are classified (30 cycles needed)
+  // Map 32 results into one KPKBitbase[] entry
-  do {
+  for (idx = 0; idx < MAX_INDEX; ++idx)
-      repeat = false;
+      if (db[idx] == WIN)
-
+          KPKBitbase[idx / 32] |= 1 << (idx & 0x1F);
-      for (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);
-
-  // Compress result and map into supplied bitbase parameter
-  for (i = 0; i < 24576; i++)
-  {
-      b = 0;
-      for (j = 0; j < 8; j++)
-          if (bb[8*i+j] == RESULT_WIN || bb[8*i+j] == RESULT_LOSS)
-              b |= (1 << j);
-
-      bitbase[i] = (uint8_t)b;
-  }
 }
 
 
 namespace {
 
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
+  KPKPosition::KPKPosition(unsigned idx) {
 
-      int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
+    ksq[WHITE] = Square((idx >>  0) & 0x3F);
-      int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p;
+    ksq[BLACK] = Square((idx >>  6) & 0x3F);
+    us         = Color ((idx >> 12) & 0x01);
+    psq        = make_square(File((idx >> 13) & 0x3), RANK_7 - Rank((idx >> 15) & 0x7));
 
-      assert(r >= 0 && r < IndexMax);
+    // Check if two pieces are on the same square or if a king can be captured
+    if (   distance(ksq[WHITE], ksq[BLACK]) <= 1
+        || ksq[WHITE] == psq
+        || ksq[BLACK] == psq
+        || (us == WHITE && (StepAttacksBB[PAWN][psq] & ksq[BLACK])))
+        result = INVALID;
 
-      return r;
+    // Immediate win if a pawn can be promoted without getting captured
-  }
+    else if (   us == WHITE
+             && rank_of(psq) == RANK_7
+             && ksq[us] != psq + DELTA_N
+             && (    distance(ksq[~us], psq + DELTA_N) > 1
+                 || (StepAttacksBB[KING][ksq[us]] & (psq + DELTA_N))))
+        result = WIN;
 
-  void KPKPosition::from_index(int index) {
+    // Immediate draw if it is a stalemate or a king captures undefended pawn
+    else if (   us == BLACK
+             && (  !(StepAttacksBB[KING][ksq[us]] & ~(StepAttacksBB[KING][ksq[~us]] | StepAttacksBB[PAWN][psq]))
+                 || (StepAttacksBB[KING][ksq[us]] & psq & ~StepAttacksBB[KING][ksq[~us]])))
+        result = DRAW;
 
-    int s = (index / 8192) % 24;
+    // Position will be classified later
-
-    sideToMove = Color(index % 2);
-    blackKingSquare = Square((index / 2) % 64);
-    whiteKingSquare = Square((index / 128) % 64);
-    pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
-  }
-
-  bool KPKPosition::is_legal() const {
-
-    if (   whiteKingSquare == pawnSquare
-        || whiteKingSquare == blackKingSquare
-        || pawnSquare == blackKingSquare)
-        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(bk_attacks(), whiteKingSquare))
-        return false;
-
-    return true;
-  }
-
-  bool KPKPosition::is_immediate_draw() const {
-
-    if (sideToMove == BLACK)
-    {
-        Bitboard wka = wk_attacks();
-        Bitboard bka = bk_attacks();
-
-        // 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
-    {
+        result = UNKNOWN;
-        // Case 1: Stalemate
-        if (   whiteKingSquare == SQ_A8
-            && pawnSquare == SQ_A7
-            && (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
-            return true;
-    }
-    return false;
   }
 
-  bool KPKPosition::is_immediate_win() const {
+  template<Color Us>
+  Result KPKPosition::classify(const std::vector<KPKPosition>& db) {
 
-    // The position is an immediate win if it is white to move and the
+    // White to move: If one move leads to a position classified as WIN, the result
-    // white pawn can be promoted without getting captured.
+    // of the current position is WIN. If all moves lead to positions classified
-    return   sideToMove == WHITE
+    // as DRAW, the current position is classified as DRAW, otherwise the current
-          && square_rank(pawnSquare) == RANK_7
+    // position is classified as UNKNOWN.
-          && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
+    //
-              || bit_is_set(wk_attacks(), pawnSquare + DELTA_N));
+    // Black to move: If one move leads to a position classified as DRAW, the result
-  }
+    // of the current position is DRAW. If all moves lead to positions classified
+    // as WIN, the position is classified as WIN, otherwise the current position is
+    // classified as UNKNOWN.
 
-  Result classify_wtm(const KPKPosition& pos, const Result bb[]) {
+    const Color  Them = (Us == WHITE ? BLACK : WHITE);
+    const Result Good = (Us == WHITE ? WIN   : DRAW);
+    const Result Bad  = (Us == WHITE ? DRAW  : WIN);
 
-    // If one move leads to a position classified as RESULT_LOSS, the result
+    Result r = INVALID;
-    // of the current position is RESULT_WIN. If all moves lead to positions
+    Bitboard b = StepAttacksBB[KING][ksq[Us]];
-    // 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;
-    int idx;
-
-    // King moves
-    b = pos.wk_attacks();
     while (b)
+        r |= Us == WHITE ? db[index(Them, ksq[Them]  , pop_lsb(&b), psq)]
+                         : db[index(Them, pop_lsb(&b), ksq[Them]  , psq)];
+
+    if (Us == WHITE)
     {
-        s = pop_1st_bit(&b);
+        if (rank_of(psq) < RANK_7)      // Single push
-        idx = compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK);
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + DELTA_N)];
 
-        switch (bb[idx]) {
+        if (   rank_of(psq) == RANK_2   // Double push
-
+            && psq + DELTA_N != ksq[Us]
-        case RESULT_LOSS:
+            && psq + DELTA_N != ksq[Them])
-            return RESULT_WIN;
+            r |= db[index(Them, ksq[Them], ksq[Us], psq + DELTA_N + DELTA_N)];
-
-        case RESULT_UNKNOWN:
-            unknownFound = true;
-
-        case RESULT_DRAW:
-        case RESULT_INVALID:
-             break;
-
-         default:
-             assert(false);
-        }
     }
 
-    // Pawn moves
+    return result = r & Good  ? Good  : r & UNKNOWN ? UNKNOWN : Bad;
-    if (square_rank(pos.pawnSquare) < RANK_7)
-    {
-        s = pos.pawnSquare + DELTA_N;
-        idx = compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK);
-
-        switch (bb[idx]) {
-
-        case RESULT_LOSS:
-            return RESULT_WIN;
-
-        case RESULT_UNKNOWN:
-            unknownFound = true;
-
-        case RESULT_DRAW:
-        case RESULT_INVALID:
-            break;
-
-        default:
-            assert(false);
   }
 
-        // Double pawn push
+} // namespace
-        if (   square_rank(s) == RANK_3
-            && s != pos.whiteKingSquare
-            && s != pos.blackKingSquare)
-        {
-            s += DELTA_N;
-            idx = compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK);
-
-            switch (bb[idx]) {
-
-            case RESULT_LOSS:
-                return RESULT_WIN;
-
-            case RESULT_UNKNOWN:
-                unknownFound = true;
-
-            case RESULT_DRAW:
-            case RESULT_INVALID:
-                break;
-
-            default:
-                assert(false);
-            }
-        }
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
-  }
-
-
-  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
-    // classified as RESULT_WIN, the current position is classified as
-    // RESULT_LOSS. Otherwise, the current position is classified as
-    // RESULT_UNKNOWN.
-
-    bool unknownFound = false;
-    Bitboard b;
-    Square s;
-    int idx;
-
-    // King moves
-    b = pos.bk_attacks();
-    while (b)
-    {
-        s = pop_1st_bit(&b);
-        idx = compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE);
-
-        switch (bb[idx]) {
-
-        case RESULT_DRAW:
-            return RESULT_DRAW;
-
-        case RESULT_UNKNOWN:
-            unknownFound = true;
-
-        case RESULT_WIN:
-        case RESULT_INVALID:
-            break;
-
-        default:
-            assert(false);
-        }
-    }
-    return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS;
-  }
-
-}

src/bitboard.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,517 +18,301 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <algorithm>
-////
-//// Includes
-////
-
-#include <iostream>
 
 #include "bitboard.h"
 #include "bitcount.h"
+#include "misc.h"
 
+int SquareDistance[SQUARE_NB][SQUARE_NB];
 
-#if defined(IS_64BIT)
+Bitboard  RookMasks  [SQUARE_NB];
+Bitboard  RookMagics [SQUARE_NB];
+Bitboard* RookAttacks[SQUARE_NB];
+unsigned  RookShifts [SQUARE_NB];
 
-const uint64_t BMult[64] = {
+Bitboard  BishopMasks  [SQUARE_NB];
-  0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL,
+Bitboard  BishopMagics [SQUARE_NB];
-  0x48c4440084048090ULL, 0x2801104026490000ULL, 0x4100880442040800ULL,
+Bitboard* BishopAttacks[SQUARE_NB];
-  0x181011002e06040ULL, 0x9101004104200e00ULL, 0x1240848848310401ULL,
+unsigned  BishopShifts [SQUARE_NB];
-  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,
-  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
-};
 
-const uint64_t RMult[64] = {
+Bitboard SquareBB[SQUARE_NB];
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+Bitboard FileBB[FILE_NB];
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
+Bitboard RankBB[RANK_NB];
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
+Bitboard AdjacentFilesBB[FILE_NB];
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
+Bitboard InFrontBB[COLOR_NB][RANK_NB];
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
+Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
+Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
+Bitboard LineBB[SQUARE_NB][SQUARE_NB];
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
+Bitboard DistanceRingBB[SQUARE_NB][8];
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
+Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
+Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
+Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
+Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
-  0x410201ce5c030092ULL
-};
-
-const int BShift[64] = {
-  58, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 59, 59,
-  59, 59, 57, 57, 57, 57, 59, 59, 59, 59, 57, 55, 55, 57, 59, 59,
-  59, 59, 57, 55, 55, 57, 59, 59, 59, 59, 57, 57, 57, 57, 59, 59,
-  59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
-};
-
-const int RShift[64] = {
-  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
-};
-
-#else // if !defined(IS_64BIT)
-
-const uint64_t BMult[64] = {
-  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
-  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
-  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
-  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
-  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
-  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
-  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
-  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
-  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
-  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
-  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
-  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
-  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
-  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
-  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
-  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
-  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
-  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
-  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
-  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
-  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
-  0xdc01f6dca4bebbdcULL,
-};
-
-const uint64_t RMult[64] = {
-  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
-  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
-  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
-  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
-  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
-  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
-  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
-  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
-  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
-  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
-  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
-  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
-  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
-  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
-  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
-  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
-  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
-  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
-  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
-  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
-  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
-  0x5ac08a4735370479ULL,
-};
-
-const int BShift[64] = {
-  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
-  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
-  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
-};
-
-const int RShift[64] = {
-  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
-};
-
-#endif // defined(IS_64BIT)
-
-const Bitboard LightSquaresBB = 0x55AA55AA55AA55AAULL;
-const Bitboard DarkSquaresBB  = 0xAA55AA55AA55AA55ULL;
-
-const Bitboard SquaresByColorBB[2] = { DarkSquaresBB, LightSquaresBB };
-
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};
-
-const Bitboard RankBB[8] = {
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
-  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
-  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
-};
-
-const Bitboard InFrontBB[2][8] = {
-  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  { EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
-
-Bitboard RMask[64];
-int RAttackIndex[64];
-Bitboard RAttacks[0x19000];
-
-Bitboard BMask[64];
-int BAttackIndex[64];
-Bitboard BAttacks[0x1480];
-
-Bitboard SetMaskBB[65];
-Bitboard ClearMaskBB[65];
-
-Bitboard StepAttackBB[16][64];
-Bitboard BetweenBB[64][64];
-
-Bitboard SquaresInFrontMask[2][64];
-Bitboard PassedPawnMask[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();
+  // De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
-  void init_attacks();
+  const uint64_t DeBruijn64 = 0x3F79D71B4CB0A89ULL;
-  void init_between_bitboards();
+  const uint32_t DeBruijn32 = 0x783A9B23;
-  void init_pseudo_attacks();
-  Bitboard index_to_bitboard(int index, Bitboard mask);
-  Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
-                           int fmin, int fmax, int rmin, int rmax);
-  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
-                            const int shift[], const Bitboard mult[], int deltas[][2]);
-}
 
+  int MSBTable[256];            // To implement software msb()
+  Square BSFTable[SQUARE_NB];   // To implement software bitscan
+  Bitboard RookTable[0x19000];  // To store rook attacks
+  Bitboard BishopTable[0x1480]; // To store bishop attacks
 
-////
+  typedef unsigned (Fn)(Square, Bitboard);
-//// Functions
-////
 
-/// print_bitboard() prints a bitboard in an easily readable format to the
+  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
-/// standard output.  This is sometimes useful for debugging.
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index);
 
-void print_bitboard(Bitboard b) {
+  // bsf_index() returns the index into BSFTable[] to look up the bitscan. Uses
+  // Matt Taylor's folding for 32 bit case, extended to 64 bit by Kim Walisch.
 
-  for (Rank r = RANK_8; r >= RANK_1; r--)
+  unsigned bsf_index(Bitboard b) {
-  {
+    b ^= b - 1;
-      std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
+    return Is64Bit ? (b * DeBruijn64) >> 58
-      for (File f = FILE_A; f <= FILE_H; f++)
+                   : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn32) >> 26;
-          std::cout << "| " << (bit_is_set(b, make_square(f, r))? 'X' : ' ') << ' ';
-
-      std::cout << "|" << std::endl;
   }
-  std::cout << "+---+---+---+---+---+---+---+---+" << std::endl;
 }
 
+#ifndef USE_BSFQ
 
-/// init_bitboards() initializes various bitboard arrays.  It is called during
+/// Software fall-back of lsb() and msb() for CPU lacking hardware support
-/// program initialization.
 
-void init_bitboards() {
+Square lsb(Bitboard b) {
-
+  return BSFTable[bsf_index(b)];
-  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_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();
 }
 
+Square msb(Bitboard b) {
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+  unsigned b32;
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
+  int result = 0;
-/// nonzero bitboard.
 
-#if defined(IS_64BIT) && !defined(USE_BSFQ)
+  if (b > 0xFFFFFFFF)
-
-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
-};
-
-Square first_1(Bitboard b) {
-  return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
-}
-
-Square pop_1st_bit(Bitboard* b) {
-  Bitboard bb = *b;
-  *b &= (*b - 1);
-  return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
-}
-
-#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]);
+      b >>= 32;
-       u.dw.l &= (u.dw.l - 1);
+      result = 32;
-       *bb = u.b;
-       return ret;
   }
-   ret = Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
+
-   u.dw.h &= (u.dw.h - 1);
+  b32 = unsigned(b);
-   *bb = u.b;
+
-   return ret;
+  if (b32 > 0xFFFF)
+  {
+      b32 >>= 16;
+      result += 16;
+  }
+
+  if (b32 > 0xFF)
+  {
+      b32 >>= 8;
+      result += 8;
+  }
+
+  return Square(result + MSBTable[b32]);
 }
 
-#endif
+#endif // ifndef USE_BSFQ
+
+
+/// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
+/// to be printed to standard output. Useful for debugging.
+
+const std::string Bitboards::pretty(Bitboard b) {
+
+  std::string s = "+---+---+---+---+---+---+---+---+\n";
+
+  for (Rank r = RANK_8; r >= RANK_1; --r)
+  {
+      for (File f = FILE_A; f <= FILE_H; ++f)
+          s += b & make_square(f, r) ? "| X " : "|   ";
+
+      s += "|\n+---+---+---+---+---+---+---+---+\n";
+  }
+
+  return s;
+}
+
+
+/// Bitboards::init() initializes various bitboard tables. It is called at
+/// startup and relies on global objects to be already zero-initialized.
+
+void Bitboards::init() {
+
+  for (Square s = SQ_A1; s <= SQ_H8; ++s)
+  {
+      SquareBB[s] = 1ULL << s;
+      BSFTable[bsf_index(SquareBB[s])] = s;
+  }
+
+  for (Bitboard b = 2; b < 256; ++b)
+      MSBTable[b] = MSBTable[b - 1] + !more_than_one(b);
+
+  for (File f = FILE_A; f <= FILE_H; ++f)
+      FileBB[f] = f > FILE_A ? FileBB[f - 1] << 1 : FileABB;
+
+  for (Rank r = RANK_1; r <= RANK_8; ++r)
+      RankBB[r] = r > RANK_1 ? RankBB[r - 1] << 8 : Rank1BB;
+
+  for (File f = FILE_A; f <= FILE_H; ++f)
+      AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
+
+  for (Rank r = RANK_1; r < RANK_8; ++r)
+      InFrontBB[WHITE][r] = ~(InFrontBB[BLACK][r + 1] = InFrontBB[BLACK][r] | RankBB[r]);
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      {
+          ForwardBB[c][s]      = InFrontBB[c][rank_of(s)] & FileBB[file_of(s)];
+          PawnAttackSpan[c][s] = InFrontBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
+          PassedPawnMask[c][s] = ForwardBB[c][s] | PawnAttackSpan[c][s];
+      }
+
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+          if (s1 != s2)
+          {
+              SquareDistance[s1][s2] = std::max(distance<File>(s1, s2), distance<Rank>(s1, s2));
+              DistanceRingBB[s1][SquareDistance[s1][s2] - 1] |= s2;
+          }
+
+  int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 },
+                     {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } };
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      for (PieceType pt = PAWN; pt <= KING; ++pt)
+          for (Square s = SQ_A1; s <= SQ_H8; ++s)
+              for (int i = 0; steps[pt][i]; ++i)
+              {
+                  Square to = s + Square(c == WHITE ? steps[pt][i] : -steps[pt][i]);
+
+                  if (is_ok(to) && distance(s, to) < 3)
+                      StepAttacksBB[make_piece(c, pt)][s] |= to;
+              }
+
+  Square RookDeltas[] = { DELTA_N,  DELTA_E,  DELTA_S,  DELTA_W  };
+  Square BishopDeltas[] = { DELTA_NE, DELTA_SE, DELTA_SW, DELTA_NW };
+
+  init_magics(RookTable, RookAttacks, RookMagics, RookMasks, RookShifts, RookDeltas, magic_index<ROOK>);
+  init_magics(BishopTable, BishopAttacks, BishopMagics, BishopMasks, BishopShifts, BishopDeltas, magic_index<BISHOP>);
+
+  for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
+  {
+      PseudoAttacks[QUEEN][s1]  = PseudoAttacks[BISHOP][s1] = attacks_bb<BISHOP>(s1, 0);
+      PseudoAttacks[QUEEN][s1] |= PseudoAttacks[  ROOK][s1] = attacks_bb<  ROOK>(s1, 0);
+
+      for (Piece pc = W_BISHOP; pc <= W_ROOK; ++pc)
+          for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
+          {
+              if (!(PseudoAttacks[pc][s1] & s2))
+                  continue;
+
+              LineBB[s1][s2] = (attacks_bb(pc, s1, 0) & attacks_bb(pc, s2, 0)) | s1 | s2;
+              BetweenBB[s1][s2] = attacks_bb(pc, s1, SquareBB[s2]) & attacks_bb(pc, s2, SquareBB[s1]);
+          }
+  }
+}
 
 
 namespace {
 
-  // All functions below are used to precompute various bitboards during
+  Bitboard sliding_attack(Square deltas[], Square sq, Bitboard occupied) {
-  // program initialization.  Some of the functions may be difficult to
-  // understand, but they all seem to work correctly, and it should never
-  // be necessary to touch any of them.
 
-  void init_masks() {
+    Bitboard attack = 0;
 
-    SetMaskBB[SQ_NONE] = 0ULL;
+    for (int i = 0; i < 4; ++i)
-    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
+        for (Square s = sq + deltas[i];
-
+             is_ok(s) && distance(s, s - deltas[i]) == 1;
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
+             s += deltas[i])
         {
-        SetMaskBB[s] = (1ULL << s);
+            attack |= s;
-        ClearMaskBB[s] = ~SetMaskBB[s];
-    }
 
-    for (Color c = WHITE; c <= BLACK; c++)
+            if (occupied & s)
-        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_attacks() {
-
-    const int step[16][8] =  {
-      {0},
-      {7,9,0}, {17,15,10,6,-6,-10,-15,-17}, {9,7,-7,-9,0}, {8,1,-1,-8,0},
-      {9,7,-7,-9,8,1,-1,-8}, {9,7,-7,-9,8,1,-1,-8}, {0}, {0},
-      {-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}
-    };
-
-    for (int i = 0; i < 64; i++)
-        for (int j = 0; j <= int(BK); j++)
-        {
-            StepAttackBB[j][i] = EmptyBoardBB;
-            for (int k = 0; k < 8 && step[j][k] != 0; k++)
-            {
-                int l = i + step[j][k];
-                if (l >= 0 && l < 64 && abs((i & 7) - (l & 7)) < 3)
-                    StepAttackBB[j][i] |= (1ULL << l);
-           }
-        }
-  }
-
-  Bitboard sliding_attacks(int sq, Bitboard block, int dirs, int deltas[][2],
-                           int fmin=0, int fmax=7, int rmin=0, int rmax=7) {
-    Bitboard result = 0ULL;
-    int rk = sq / 8;
-    int fl = sq % 8;
-
-    for (int i = 0; i < dirs; i++)
-    {
-        int dx = deltas[i][0];
-        int dy = deltas[i][1];
-        int f = fl + dx;
-        int r = rk + dy;
-
-        while (   (dx == 0 || (f >= fmin && f <= fmax))
-               && (dy == 0 || (r >= rmin && r <= rmax)))
-        {
-            result |= (1ULL << (f + r*8));
-            if (block & (1ULL << (f + r*8)))
                 break;
-
-            f += dx;
-            r += dy;
-        }
-    }
-    return result;
         }
 
-  void init_between_bitboards() {
+    return attack;
+  }
 
-    Square s1, s2, s3;
-    SquareDelta d;
-    int f, r;
 
-    for (s1 = SQ_A1; s1 <= SQ_H8; s1++)
+  // init_magics() computes all rook and bishop attacks at startup. Magic
-        for (s2 = SQ_A1; s2 <= SQ_H8; s2++)
+  // bitboards are used to look up attacks of sliding pieces. As a reference see
+  // chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we
+  // use the so called "fancy" approach.
+
+  void init_magics(Bitboard table[], Bitboard* attacks[], Bitboard magics[],
+                   Bitboard masks[], unsigned shifts[], Square deltas[], Fn index) {
+
+    int seeds[][RANK_NB] = { { 8977, 44560, 54343, 38998,  5731, 95205, 104912, 17020 },
+                             {  728, 10316, 55013, 32803, 12281, 15100,  16645,   255 } };
+
+    Bitboard occupancy[4096], reference[4096], edges, b;
+    int age[4096] = {0}, current = 0, i, size;
+
+    // attacks[s] is a pointer to the beginning of the attacks table for square 's'
+    attacks[SQ_A1] = table;
+
+    for (Square s = SQ_A1; s <= SQ_H8; ++s)
     {
-            BetweenBB[s1][s2] = EmptyBoardBB;
+        // Board edges are not considered in the relevant occupancies
+        edges = ((Rank1BB | Rank8BB) & ~rank_bb(s)) | ((FileABB | FileHBB) & ~file_bb(s));
 
-            if (bit_is_set(QueenPseudoAttacks[s1], s2))
+        // Given a square 's', the mask is the bitboard of sliding attacks from
+        // 's' computed on an empty board. The index must be big enough to contain
+        // all the attacks for each possible subset of the mask and so is 2 power
+        // the number of 1s of the mask. Hence we deduce the size of the shift to
+        // apply to the 64 or 32 bits word to get the index.
+        masks[s]  = sliding_attack(deltas, s, 0) & ~edges;
+        shifts[s] = (Is64Bit ? 64 : 32) - popcount<Max15>(masks[s]);
+
+        // Use Carry-Rippler trick to enumerate all subsets of masks[s] and
+        // store the corresponding sliding attack bitboard in reference[].
+        b = size = 0;
+        do {
+            occupancy[size] = b;
+            reference[size] = sliding_attack(deltas, s, b);
+
+            if (HasPext)
+                attacks[s][pext(b, masks[s])] = reference[size];
+
+            size++;
+            b = (b - masks[s]) & masks[s];
+        } while (b);
+
+        // Set the offset for the table of the next square. We have individual
+        // table sizes for each square with "Fancy Magic Bitboards".
+        if (s < SQ_H8)
+            attacks[s + 1] = attacks[s] + size;
+
+        if (HasPext)
+            continue;
+
+        PRNG rng(seeds[Is64Bit][rank_of(s)]);
+
+        // Find a magic for square 's' picking up an (almost) random number
+        // until we find the one that passes the verification test.
+        do {
+            do
+                magics[s] = rng.sparse_rand<Bitboard>();
+            while (popcount<Max15>((magics[s] * masks[s]) >> 56) < 6);
+
+            // A good magic must map every possible occupancy to an index that
+            // looks up the correct sliding attack in the attacks[s] database.
+            // Note that we build up the database for square 's' as a side
+            // effect of verifying the magic.
+            for (++current, i = 0; i < size; ++i)
             {
-                f = file_distance(s1, s2);
+                unsigned idx = index(s, occupancy[i]);
-                r = rank_distance(s1, s2);
 
-                d = SquareDelta(s2 - s1) / Max(f, r);
+                if (age[idx] < current)
-
-                for (s3 = s1 + d; s3 != s2; s3 += d)
-                    set_bit(&(BetweenBB[s1][s2]), s3);
-            }
-      }
-  }
-
-  Bitboard index_to_bitboard(int index, Bitboard mask) {
-
-    Bitboard result = 0ULL;
-    int bits = count_1s<CNT32>(mask);
-
-    for (int i = 0; i < bits; i++)
                 {
-        int j = pop_1st_bit(&mask);
+                    age[idx] = current;
-        if (index & (1 << i))
+                    attacks[s][idx] = reference[i];
-            result |= (1ULL << j);
                 }
-    return result;
+                else if (attacks[s][idx] != reference[i])
+                    break;
             }
-
+        } while (i < size);
-  void init_sliding_attacks(Bitboard attacks[], int attackIndex[], Bitboard mask[],
-                            const int shift[], const Bitboard mult[], int deltas[][2]) {
-
-    for (int i = 0, index = 0; i < 64; i++)
-    {
-        attackIndex[i] = index;
-        mask[i] = sliding_attacks(i, 0, 4, deltas, 1, 6, 1, 6);
-
-#if defined(IS_64BIT)
-        int j = (1 << (64 - shift[i]));
-#else
-        int j = (1 << (32 - shift[i]));
-#endif
-
-        for (int k = 0; k < j; k++)
-        {
-#if defined(IS_64BIT)
-            Bitboard b = index_to_bitboard(k, mask[i]);
-            attacks[index + ((b * mult[i]) >> shift[i])] = sliding_attacks(i, b, 4, deltas);
-#else
-            Bitboard b = index_to_bitboard(k, mask[i]);
-            unsigned v = int(b) * int(mult[i]) ^ int(b >> 32) * int(mult[i] >> 32);
-            attacks[index + (v >> shift[i])] = sliding_attacks(i, b, 4, deltas);
-#endif
-        }
-        index += j;
     }
   }
-
-  void init_pseudo_attacks() {
-
-    for (Square s = SQ_A1; s <= SQ_H8; s++)
-    {
-        BishopPseudoAttacks[s] = bishop_attacks_bb(s, EmptyBoardBB);
-        RookPseudoAttacks[s]   = rook_attacks_bb(s, EmptyBoardBB);
-        QueenPseudoAttacks[s]  = queen_attacks_bb(s, EmptyBoardBB);
-    }
-  }
-
 }

src/bitboard.h

@@ -1,14 +1,14 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -18,24 +18,28 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef BITBOARD_H_INCLUDED
-#if !defined(BITBOARD_H_INCLUDED)
 #define BITBOARD_H_INCLUDED
 
-////
+#include <string>
-//// Includes
-////
 
-#include "piece.h"
-#include "square.h"
 #include "types.h"
 
+namespace Bitbases {
 
-////
+void init();
-//// Constants and variables
+bool probe(Square wksq, Square wpsq, Square bksq, Color us);
-////
 
-const Bitboard EmptyBoardBB = 0;
+}
+
+namespace Bitboards {
+
+void init();
+const std::string pretty(Bitboard b);
+
+}
+
+const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
 
 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = FileABB << 1;
@@ -55,83 +59,70 @@ const Bitboard Rank6BB = Rank1BB << (8 * 5);
 const Bitboard Rank7BB = Rank1BB << (8 * 6);
 const Bitboard Rank8BB = Rank1BB << (8 * 7);
 
-extern const Bitboard SquaresByColorBB[2];
+extern int SquareDistance[SQUARE_NB][SQUARE_NB];
-extern const Bitboard FileBB[8];
-extern const Bitboard NeighboringFilesBB[8];
-extern const Bitboard ThisAndNeighboringFilesBB[8];
-extern const Bitboard RankBB[8];
-extern const Bitboard RelativeRankBB[2][8];
-extern const Bitboard InFrontBB[2][8];
 
-extern Bitboard SetMaskBB[65];
+extern Bitboard  RookMasks  [SQUARE_NB];
-extern Bitboard ClearMaskBB[65];
+extern Bitboard  RookMagics [SQUARE_NB];
+extern Bitboard* RookAttacks[SQUARE_NB];
+extern unsigned  RookShifts [SQUARE_NB];
 
-extern Bitboard StepAttackBB[16][64];
+extern Bitboard  BishopMasks  [SQUARE_NB];
-extern Bitboard BetweenBB[64][64];
+extern Bitboard  BishopMagics [SQUARE_NB];
+extern Bitboard* BishopAttacks[SQUARE_NB];
+extern unsigned  BishopShifts [SQUARE_NB];
 
-extern Bitboard SquaresInFrontMask[2][64];
+extern Bitboard SquareBB[SQUARE_NB];
-extern Bitboard PassedPawnMask[2][64];
+extern Bitboard FileBB[FILE_NB];
-extern Bitboard AttackSpanMask[2][64];
+extern Bitboard RankBB[RANK_NB];
-
+extern Bitboard AdjacentFilesBB[FILE_NB];
-extern const uint64_t RMult[64];
+extern Bitboard InFrontBB[COLOR_NB][RANK_NB];
-extern const int RShift[64];
+extern Bitboard StepAttacksBB[PIECE_NB][SQUARE_NB];
-extern Bitboard RMask[64];
+extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
-extern int RAttackIndex[64];
+extern Bitboard LineBB[SQUARE_NB][SQUARE_NB];
-extern Bitboard RAttacks[0x19000];
+extern Bitboard DistanceRingBB[SQUARE_NB][8];
-
+extern Bitboard ForwardBB[COLOR_NB][SQUARE_NB];
-extern const uint64_t BMult[64];
+extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
-extern const int BShift[64];
+extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
-extern Bitboard BMask[64];
+extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
-extern int BAttackIndex[64];
-extern Bitboard BAttacks[0x1480];
-
-extern Bitboard BishopPseudoAttacks[64];
-extern Bitboard RookPseudoAttacks[64];
-extern Bitboard QueenPseudoAttacks[64];
-
-extern uint8_t BitCount8Bit[256];
 
 
-////
+/// Overloads of bitwise operators between a Bitboard and a Square for testing
-//// Inline functions
+/// whether a given bit is set in a bitboard, and for setting and clearing bits.
-////
 
-/// Functions for testing whether a given bit is set in a bitboard, and for
+inline Bitboard operator&(Bitboard b, Square s) {
-/// setting and clearing bits.
+  return b & SquareBB[s];
-
-inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & SetMaskBB[s];
 }
 
-inline void set_bit(Bitboard *b, Square s) {
+inline Bitboard operator|(Bitboard b, Square s) {
-  *b |= SetMaskBB[s];
+  return b | SquareBB[s];
 }
 
-inline void clear_bit(Bitboard *b, Square s) {
+inline Bitboard operator^(Bitboard b, Square s) {
-  *b &= ClearMaskBB[s];
+  return b ^ SquareBB[s];
+}
+
+inline Bitboard& operator|=(Bitboard& b, Square s) {
+  return b |= SquareBB[s];
+}
+
+inline Bitboard& operator^=(Bitboard& b, Square s) {
+  return b ^= SquareBB[s];
+}
+
+inline bool more_than_one(Bitboard b) {
+  return b & (b - 1);
 }
 
 
-/// Functions used to update a bitboard after a move. This is faster
+/// rank_bb() and file_bb() return a bitboard representing all the squares on
-/// then calling a sequence of clear_bit() + set_bit()
+/// the given file or rank.
-
-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[rank_of(s)];
 }
 
 inline Bitboard file_bb(File f) {
@@ -139,205 +130,203 @@ inline Bitboard file_bb(File f) {
 }
 
 inline Bitboard file_bb(Square s) {
-  return file_bb(square_file(s));
+  return FileBB[file_of(s)];
 }
 
 
-/// neighboring_files_bb takes a file or a square as input, and returns a
+/// shift_bb() moves a bitboard one step along direction Delta. Mainly for pawns
-/// bitboard representing all squares on the neighboring files.
 
-inline Bitboard neighboring_files_bb(File f) {
+template<Square Delta>
-  return NeighboringFilesBB[f];
+inline Bitboard shift_bb(Bitboard b) {
-}
+  return  Delta == DELTA_N  ?  b             << 8 : Delta == DELTA_S  ?  b             >> 8
-
+        : Delta == DELTA_NE ? (b & ~FileHBB) << 9 : Delta == DELTA_SE ? (b & ~FileHBB) >> 7
-inline Bitboard neighboring_files_bb(Square s) {
+        : Delta == DELTA_NW ? (b & ~FileABB) << 7 : Delta == DELTA_SW ? (b & ~FileABB) >> 9
-  return NeighboringFilesBB[square_file(s)];
+        : 0;
 }
 
 
-/// this_and_neighboring_files_bb takes a file or a square as input, and
+/// adjacent_files_bb() returns a bitboard representing all the squares on the
-/// returns a bitboard representing all squares on the given and neighboring
+/// adjacent files of the given one.
-/// files.
 
-inline Bitboard this_and_neighboring_files_bb(File f) {
+inline Bitboard adjacent_files_bb(File f) {
-  return ThisAndNeighboringFilesBB[f];
+  return AdjacentFilesBB[f];
-}
-
-inline Bitboard this_and_neighboring_files_bb(Square s) {
-  return ThisAndNeighboringFilesBB[square_file(s)];
 }
 
 
-/// relative_rank_bb() takes a color and a rank as input, and returns a bitboard
+/// between_bb() returns a bitboard representing all the squares between the two
-/// representing all squares on the given rank from the given color's point of
+/// given ones. For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with
-/// view. For instance, relative_rank_bb(WHITE, 7) gives all squares on the
+/// the bits for square d5 and e6 set. If s1 and s2 are not on the same rank, file
-/// 7th rank, while relative_rank_bb(BLACK, 7) gives all squares on the 2nd
+/// or diagonal, 0 is returned.
-/// rank.
 
-inline Bitboard relative_rank_bb(Color c, Rank r) {
+inline Bitboard between_bb(Square s1, Square s2) {
-  return RelativeRankBB[c][r];
+  return BetweenBB[s1][s2];
 }
 
 
-/// in_front_bb() takes a color and a rank or square as input, and returns a
+/// in_front_bb() returns a bitboard representing all the squares on all the ranks
-/// bitboard representing all the squares on all ranks in front of the rank
+/// in front of the given one, from the point of view of the given color. For
-/// (or square), from the given color's point of view.  For instance,
+/// instance, in_front_bb(BLACK, RANK_3) will return the squares on ranks 1 and 2.
-/// in_front_bb(WHITE, RANK_5) will give all squares on ranks 6, 7 and 8, while
-/// in_front_bb(BLACK, SQ_D3) will give all squares on ranks 1 and 2.
 
 inline Bitboard in_front_bb(Color c, Rank r) {
   return InFrontBB[c][r];
 }
 
-inline Bitboard in_front_bb(Color c, Square s) {
+
-  return InFrontBB[c][square_rank(s)];
+/// forward_bb() returns a bitboard representing all the squares along the line
+/// in front of the given one, from the point of view of the given color:
+///        ForwardBB[c][s] = in_front_bb(c, s) & file_bb(s)
+
+inline Bitboard forward_bb(Color c, Square s) {
+  return ForwardBB[c][s];
 }
 
 
-/// behind_bb() takes a color and a rank or square as input, and returns a
+/// pawn_attack_span() returns a bitboard representing all the squares that can be
-/// bitboard representing all the squares on all ranks behind of the rank
+/// attacked by a pawn of the given color when it moves along its file, starting
-/// (or square), from the given color's point of view.
+/// from the given square:
+///       PawnAttackSpan[c][s] = in_front_bb(c, s) & adjacent_files_bb(s);
 
-inline Bitboard behind_bb(Color c, Rank r) {
+inline Bitboard pawn_attack_span(Color c, Square s) {
-  return InFrontBB[opposite_color(c)][r];
+  return PawnAttackSpan[c][s];
-}
-
-inline Bitboard behind_bb(Color c, Square s) {
-  return InFrontBB[opposite_color(c)][square_rank(s)];
 }
 
 
-/// Functions for computing sliding attack bitboards. rook_attacks_bb(),
+/// passed_pawn_mask() returns a bitboard mask which can be used to test if a
-/// bishop_attacks_bb() and queen_attacks_bb() all take a square and a
+/// pawn of the given color and on the given square is a passed pawn:
-/// bitboard of occupied squares as input, and return a bitboard representing
+///       PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_bb(c, s)
-/// all squares attacked by a rook, bishop or queen on the given square.
-
-#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])];
-}
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
-}
-
-#else // if !defined(IS_64BIT)
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  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);
-}
-
-
-/// squares_between returns a bitboard representing all squares between
-/// two squares.  For instance, squares_between(SQ_C4, SQ_F7) returns a
-/// bitboard with the bits for square d5 and e6 set.  If s1 and s2 are not
-/// on the same line, file or diagonal, EmptyBoardBB is returned.
-
-inline Bitboard squares_between(Square s1, Square s2) {
-  return BetweenBB[s1][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. 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 SquaresInFrontMask[c][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 SquaresInFrontMask[opposite_color(c)][s];
-}
-
-
-/// passed_pawn_mask takes a color and a square as input, and returns a
-/// bitboard mask which can be used to test if a pawn of the given color on
-/// the given square is a passed pawn. 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];
 }
 
 
-/// attack_span_mask takes a color and a square as input, and returns a bitboard
+/// aligned() returns true if the squares s1, s2 and s3 are aligned either on a
-/// representing all squares that can be attacked by a pawn of the given color
+/// straight or on a diagonal line.
-/// 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 attack_span_mask(Color c, Square s) {
+inline bool aligned(Square s1, Square s2, Square s3) {
-  return AttackSpanMask[c][s];
+  return LineBB[s1][s2] & s3;
 }
 
 
-/// squares_aligned returns true if the squares s1, s2 and s3 are aligned
+/// distance() functions return the distance between x and y, defined as the
-/// either on a straight or on a diagonal line.
+/// number of steps for a king in x to reach y. Works with squares, ranks, files.
 
-inline bool squares_aligned(Square s1, Square s2, Square s3) {
+template<typename T> inline int distance(T x, T y) { return x < y ? y - x : x - y; }
-  return  (BetweenBB[s1][s2] | BetweenBB[s1][s3] | BetweenBB[s2][s3])
+template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; }
-        & ((1ULL << s1) | (1ULL << s2) | (1ULL << s3));
+
+template<typename T1, typename T2> inline int distance(T2 x, T2 y);
+template<> inline int distance<File>(Square x, Square y) { return distance(file_of(x), file_of(y)); }
+template<> inline int distance<Rank>(Square x, Square y) { return distance(rank_of(x), rank_of(y)); }
+
+
+/// attacks_bb() returns a bitboard representing all the squares attacked by a
+/// piece of type Pt (bishop or rook) placed on 's'. The helper magic_index()
+/// looks up the index using the 'magic bitboards' approach.
+template<PieceType Pt>
+inline unsigned magic_index(Square s, Bitboard occupied) {
+
+  Bitboard* const Masks  = Pt == ROOK ? RookMasks  : BishopMasks;
+  Bitboard* const Magics = Pt == ROOK ? RookMagics : BishopMagics;
+  unsigned* const Shifts = Pt == ROOK ? RookShifts : BishopShifts;
+
+  if (HasPext)
+      return unsigned(pext(occupied, Masks[s]));
+
+  if (Is64Bit)
+      return unsigned(((occupied & Masks[s]) * Magics[s]) >> Shifts[s]);
+
+  unsigned lo = unsigned(occupied) & unsigned(Masks[s]);
+  unsigned hi = unsigned(occupied >> 32) & unsigned(Masks[s] >> 32);
+  return (lo * unsigned(Magics[s]) ^ hi * unsigned(Magics[s] >> 32)) >> Shifts[s];
+}
+
+template<PieceType Pt>
+inline Bitboard attacks_bb(Square s, Bitboard occupied) {
+  return (Pt == ROOK ? RookAttacks : BishopAttacks)[s][magic_index<Pt>(s, occupied)];
+}
+
+inline Bitboard attacks_bb(Piece pc, Square s, Bitboard occupied) {
+
+  switch (type_of(pc))
+  {
+  case BISHOP: return attacks_bb<BISHOP>(s, occupied);
+  case ROOK  : return attacks_bb<ROOK>(s, occupied);
+  case QUEEN : return attacks_bb<BISHOP>(s, occupied) | attacks_bb<ROOK>(s, occupied);
+  default    : return StepAttacksBB[pc][s];
+  }
 }
 
 
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// lsb() and msb() return the least/most significant bit in a non-zero bitboard
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
 
-#if defined(USE_BSFQ) // Assembly code by Heinz van Saanen
+#ifdef USE_BSFQ
 
-inline Square first_1(Bitboard b) {
+#  if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-  Bitboard dummy;
+
-  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
+inline Square lsb(Bitboard b) {
-  return (Square)(dummy);
+  unsigned long idx;
+  _BitScanForward64(&idx, b);
+  return (Square) idx;
 }
 
-inline Square pop_1st_bit(Bitboard* b) {
+inline Square msb(Bitboard b) {
-  const Square s = first_1(*b);
+  unsigned long idx;
-  *b &= ~(1ULL<<s);
+  _BitScanReverse64(&idx, b);
-  return s;
+  return (Square) idx;
 }
 
-#else // if !defined(USE_BSFQ)
+#  elif defined(__arm__)
 
-extern Square first_1(Bitboard b);
+inline int lsb32(uint32_t v) {
-extern Square pop_1st_bit(Bitboard* b);
+  __asm__("rbit %0, %1" : "=r"(v) : "r"(v));
+  return __builtin_clz(v);
+}
+
+inline Square msb(Bitboard b) {
+  return (Square) (63 - __builtin_clzll(b));
+}
+
+inline Square lsb(Bitboard b) {
+  return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32)));
+}
+
+#  else // Assumed gcc or compatible compiler
+
+inline Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen
+  Bitboard idx;
+  __asm__("bsfq %1, %0": "=r"(idx): "rm"(b) );
+  return (Square) idx;
+}
+
+inline Square msb(Bitboard b) {
+  Bitboard idx;
+  __asm__("bsrq %1, %0": "=r"(idx): "rm"(b) );
+  return (Square) idx;
+}
+
+#  endif
+
+#else // ifdef(USE_BSFQ)
+
+Square lsb(Bitboard b);
+Square msb(Bitboard b);
 
 #endif
 
 
-////
+/// pop_lsb() finds and clears the least significant bit in a non-zero bitboard
-//// Prototypes
-////
 
-extern void print_bitboard(Bitboard b);
+inline Square pop_lsb(Bitboard* b) {
-extern void init_bitboards();
+  const Square s = lsb(*b);
+  *b &= *b - 1;
+  return s;
+}
 
 
-#endif // !defined(BITBOARD_H_INCLUDED)
+/// frontmost_sq() and backmost_sq() return the square corresponding to the
+/// most/least advanced bit relative to the given color.
+
+inline Square frontmost_sq(Color c, Bitboard b) { return c == WHITE ? msb(b) : lsb(b); }
+inline Square  backmost_sq(Color c, Bitboard b) { return c == WHITE ? lsb(b) : msb(b); }
+
+#endif // #ifndef BITBOARD_H_INCLUDED

src/bitcount.h

@@ -1,14 +1,14 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -18,108 +18,88 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef BITCOUNT_H_INCLUDED
-#if !defined(BITCOUNT_H_INCLUDED)
 #define BITCOUNT_H_INCLUDED
 
+#include <cassert>
+
 #include "types.h"
 
 enum BitCountType {
-    CNT64,
+  CNT_64,
-    CNT64_MAX15,
+  CNT_64_MAX15,
-    CNT32,
+  CNT_32,
-    CNT32_MAX15,
+  CNT_32_MAX15,
-    CNT_POPCNT
+  CNT_HW_POPCNT
 };
 
-/// count_1s() counts the number of nonzero bits in a bitboard.
+/// Determine at compile time the best popcount<> specialization according to
-/// We have different optimized versions according if platform
+/// whether the platform is 32 or 64 bit, the maximum number of non-zero
-/// is 32 or 64 bits, and to the maximum number of nonzero bits.
+/// bits to count and if the hardware popcnt instruction is available.
-/// We also support hardware popcnt instruction. See Readme.txt
+const BitCountType Full  = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64       : CNT_32;
-/// on how to pgo compile with popcnt support.
+const BitCountType Max15 = HasPopCnt ? CNT_HW_POPCNT : Is64Bit ? CNT_64_MAX15 : CNT_32_MAX15;
-template<BitCountType> inline int count_1s(Bitboard);
+
+
+/// popcount() counts the number of non-zero bits in a bitboard
+template<BitCountType> inline int popcount(Bitboard);
 
 template<>
-inline int count_1s<CNT64>(Bitboard b) {
+inline int popcount<CNT_64>(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
+  b -=  (b >> 1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  b  = ((b >> 4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
+  return (b * 0x0101010101010101ULL) >> 56;
-  return int(b >> 56);
 }
 
 template<>
-inline int count_1s<CNT64_MAX15>(Bitboard b) {
+inline int popcount<CNT_64_MAX15>(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
+  b -=  (b >> 1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b  = ((b >> 2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
+  return (b * 0x1111111111111111ULL) >> 60;
-  return int(b >> 60);
 }
 
 template<>
-inline int count_1s<CNT32>(Bitboard b) {
+inline int popcount<CNT_32>(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  = ((v >> 4) + v + (w >> 4) + w) & 0x0F0F0F0F;
-  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  return (v * 0x01010101) >> 24;
-  v *= 0x01010101; // mul is fast on amd procs
-  return int(v >> 24);
 }
 
 template<>
-inline int count_1s<CNT32_MAX15>(Bitboard b) {
+inline int popcount<CNT_32_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
+  return ((v + w) * 0x11111111) >> 28;
-  v *= 0x11111111;
-  return int(v >> 28);
 }
 
 template<>
-inline int count_1s<CNT_POPCNT>(Bitboard b) {
+inline int popcount<CNT_HW_POPCNT>(Bitboard b) {
-#if !defined(USE_POPCNT)
+
-  return int(b != 0); // Avoid 'b not used' warning
+#ifndef USE_POPCNT
+
+  assert(false);
+  return b != 0; // Avoid 'b not used' warning
+
+#elif defined(_MSC_VER) && defined(__INTEL_COMPILER)
+
+  return _mm_popcnt_u64(b);
+
 #elif defined(_MSC_VER)
-  return __popcnt64(b);
+
-#elif defined(__GNUC__)
+  return (int)__popcnt64(b);
-  unsigned long ret;
+
-  __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b));
+#else // Assumed gcc or compatible compiler
-  return ret;
+
+  return __builtin_popcountll(b);
+
 #endif
 }
 
-
+#endif // #ifndef BITCOUNT_H_INCLUDED
-/// 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
-
-#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,587 +0,0 @@
-/*
-  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/>.
-*/
-
-
-/*
-  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
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-
-#include "book.h"
-#include "movegen.h"
-
-using namespace std;
-
-////
-//// Local definitions
-////
-
-namespace {
-
-  // Book entry size in bytes
-  const int EntrySize = 16;
-
-  // Random numbers from PolyGlot, used to compute book hash keys
-  const uint64_t Random64[781] = {
-    0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
-    0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL,
-    0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL,
-    0x1A083822CEAFE02DULL, 0x9605D5F0E25EC3B0ULL, 0xD021FF5CD13A2ED5ULL,
-    0x40BDF15D4A672E32ULL, 0x011355146FD56395ULL, 0x5DB4832046F3D9E5ULL,
-    0x239F8B2D7FF719CCULL, 0x05D1A1AE85B49AA1ULL, 0x679F848F6E8FC971ULL,
-    0x7449BBFF801FED0BULL, 0x7D11CDB1C3B7ADF0ULL, 0x82C7709E781EB7CCULL,
-    0xF3218F1C9510786CULL, 0x331478F3AF51BBE6ULL, 0x4BB38DE5E7219443ULL,
-    0xAA649C6EBCFD50FCULL, 0x8DBD98A352AFD40BULL, 0x87D2074B81D79217ULL,
-    0x19F3C751D3E92AE1ULL, 0xB4AB30F062B19ABFULL, 0x7B0500AC42047AC4ULL,
-    0xC9452CA81A09D85DULL, 0x24AA6C514DA27500ULL, 0x4C9F34427501B447ULL,
-    0x14A68FD73C910841ULL, 0xA71B9B83461CBD93ULL, 0x03488B95B0F1850FULL,
-    0x637B2B34FF93C040ULL, 0x09D1BC9A3DD90A94ULL, 0x3575668334A1DD3BULL,
-    0x735E2B97A4C45A23ULL, 0x18727070F1BD400BULL, 0x1FCBACD259BF02E7ULL,
-    0xD310A7C2CE9B6555ULL, 0xBF983FE0FE5D8244ULL, 0x9F74D14F7454A824ULL,
-    0x51EBDC4AB9BA3035ULL, 0x5C82C505DB9AB0FAULL, 0xFCF7FE8A3430B241ULL,
-    0x3253A729B9BA3DDEULL, 0x8C74C368081B3075ULL, 0xB9BC6C87167C33E7ULL,
-    0x7EF48F2B83024E20ULL, 0x11D505D4C351BD7FULL, 0x6568FCA92C76A243ULL,
-    0x4DE0B0F40F32A7B8ULL, 0x96D693460CC37E5DULL, 0x42E240CB63689F2FULL,
-    0x6D2BDCDAE2919661ULL, 0x42880B0236E4D951ULL, 0x5F0F4A5898171BB6ULL,
-    0x39F890F579F92F88ULL, 0x93C5B5F47356388BULL, 0x63DC359D8D231B78ULL,
-    0xEC16CA8AEA98AD76ULL, 0x5355F900C2A82DC7ULL, 0x07FB9F855A997142ULL,
-    0x5093417AA8A7ED5EULL, 0x7BCBC38DA25A7F3CULL, 0x19FC8A768CF4B6D4ULL,
-    0x637A7780DECFC0D9ULL, 0x8249A47AEE0E41F7ULL, 0x79AD695501E7D1E8ULL,
-    0x14ACBAF4777D5776ULL, 0xF145B6BECCDEA195ULL, 0xDABF2AC8201752FCULL,
-    0x24C3C94DF9C8D3F6ULL, 0xBB6E2924F03912EAULL, 0x0CE26C0B95C980D9ULL,
-    0xA49CD132BFBF7CC4ULL, 0xE99D662AF4243939ULL, 0x27E6AD7891165C3FULL,
-    0x8535F040B9744FF1ULL, 0x54B3F4FA5F40D873ULL, 0x72B12C32127FED2BULL,
-    0xEE954D3C7B411F47ULL, 0x9A85AC909A24EAA1ULL, 0x70AC4CD9F04F21F5ULL,
-    0xF9B89D3E99A075C2ULL, 0x87B3E2B2B5C907B1ULL, 0xA366E5B8C54F48B8ULL,
-    0xAE4A9346CC3F7CF2ULL, 0x1920C04D47267BBDULL, 0x87BF02C6B49E2AE9ULL,
-    0x092237AC237F3859ULL, 0xFF07F64EF8ED14D0ULL, 0x8DE8DCA9F03CC54EULL,
-    0x9C1633264DB49C89ULL, 0xB3F22C3D0B0B38EDULL, 0x390E5FB44D01144BULL,
-    0x5BFEA5B4712768E9ULL, 0x1E1032911FA78984ULL, 0x9A74ACB964E78CB3ULL,
-    0x4F80F7A035DAFB04ULL, 0x6304D09A0B3738C4ULL, 0x2171E64683023A08ULL,
-    0x5B9B63EB9CEFF80CULL, 0x506AACF489889342ULL, 0x1881AFC9A3A701D6ULL,
-    0x6503080440750644ULL, 0xDFD395339CDBF4A7ULL, 0xEF927DBCF00C20F2ULL,
-    0x7B32F7D1E03680ECULL, 0xB9FD7620E7316243ULL, 0x05A7E8A57DB91B77ULL,
-    0xB5889C6E15630A75ULL, 0x4A750A09CE9573F7ULL, 0xCF464CEC899A2F8AULL,
-    0xF538639CE705B824ULL, 0x3C79A0FF5580EF7FULL, 0xEDE6C87F8477609DULL,
-    0x799E81F05BC93F31ULL, 0x86536B8CF3428A8CULL, 0x97D7374C60087B73ULL,
-    0xA246637CFF328532ULL, 0x043FCAE60CC0EBA0ULL, 0x920E449535DD359EULL,
-    0x70EB093B15B290CCULL, 0x73A1921916591CBDULL, 0x56436C9FE1A1AA8DULL,
-    0xEFAC4B70633B8F81ULL, 0xBB215798D45DF7AFULL, 0x45F20042F24F1768ULL,
-    0x930F80F4E8EB7462ULL, 0xFF6712FFCFD75EA1ULL, 0xAE623FD67468AA70ULL,
-    0xDD2C5BC84BC8D8FCULL, 0x7EED120D54CF2DD9ULL, 0x22FE545401165F1CULL,
-    0xC91800E98FB99929ULL, 0x808BD68E6AC10365ULL, 0xDEC468145B7605F6ULL,
-    0x1BEDE3A3AEF53302ULL, 0x43539603D6C55602ULL, 0xAA969B5C691CCB7AULL,
-    0xA87832D392EFEE56ULL, 0x65942C7B3C7E11AEULL, 0xDED2D633CAD004F6ULL,
-    0x21F08570F420E565ULL, 0xB415938D7DA94E3CULL, 0x91B859E59ECB6350ULL,
-    0x10CFF333E0ED804AULL, 0x28AED140BE0BB7DDULL, 0xC5CC1D89724FA456ULL,
-    0x5648F680F11A2741ULL, 0x2D255069F0B7DAB3ULL, 0x9BC5A38EF729ABD4ULL,
-    0xEF2F054308F6A2BCULL, 0xAF2042F5CC5C2858ULL, 0x480412BAB7F5BE2AULL,
-    0xAEF3AF4A563DFE43ULL, 0x19AFE59AE451497FULL, 0x52593803DFF1E840ULL,
-    0xF4F076E65F2CE6F0ULL, 0x11379625747D5AF3ULL, 0xBCE5D2248682C115ULL,
-    0x9DA4243DE836994FULL, 0x066F70B33FE09017ULL, 0x4DC4DE189B671A1CULL,
-    0x51039AB7712457C3ULL, 0xC07A3F80C31FB4B4ULL, 0xB46EE9C5E64A6E7CULL,
-    0xB3819A42ABE61C87ULL, 0x21A007933A522A20ULL, 0x2DF16F761598AA4FULL,
-    0x763C4A1371B368FDULL, 0xF793C46702E086A0ULL, 0xD7288E012AEB8D31ULL,
-    0xDE336A2A4BC1C44BULL, 0x0BF692B38D079F23ULL, 0x2C604A7A177326B3ULL,
-    0x4850E73E03EB6064ULL, 0xCFC447F1E53C8E1BULL, 0xB05CA3F564268D99ULL,
-    0x9AE182C8BC9474E8ULL, 0xA4FC4BD4FC5558CAULL, 0xE755178D58FC4E76ULL,
-    0x69B97DB1A4C03DFEULL, 0xF9B5B7C4ACC67C96ULL, 0xFC6A82D64B8655FBULL,
-    0x9C684CB6C4D24417ULL, 0x8EC97D2917456ED0ULL, 0x6703DF9D2924E97EULL,
-    0xC547F57E42A7444EULL, 0x78E37644E7CAD29EULL, 0xFE9A44E9362F05FAULL,
-    0x08BD35CC38336615ULL, 0x9315E5EB3A129ACEULL, 0x94061B871E04DF75ULL,
-    0xDF1D9F9D784BA010ULL, 0x3BBA57B68871B59DULL, 0xD2B7ADEEDED1F73FULL,
-    0xF7A255D83BC373F8ULL, 0xD7F4F2448C0CEB81ULL, 0xD95BE88CD210FFA7ULL,
-    0x336F52F8FF4728E7ULL, 0xA74049DAC312AC71ULL, 0xA2F61BB6E437FDB5ULL,
-    0x4F2A5CB07F6A35B3ULL, 0x87D380BDA5BF7859ULL, 0x16B9F7E06C453A21ULL,
-    0x7BA2484C8A0FD54EULL, 0xF3A678CAD9A2E38CULL, 0x39B0BF7DDE437BA2ULL,
-    0xFCAF55C1BF8A4424ULL, 0x18FCF680573FA594ULL, 0x4C0563B89F495AC3ULL,
-    0x40E087931A00930DULL, 0x8CFFA9412EB642C1ULL, 0x68CA39053261169FULL,
-    0x7A1EE967D27579E2ULL, 0x9D1D60E5076F5B6FULL, 0x3810E399B6F65BA2ULL,
-    0x32095B6D4AB5F9B1ULL, 0x35CAB62109DD038AULL, 0xA90B24499FCFAFB1ULL,
-    0x77A225A07CC2C6BDULL, 0x513E5E634C70E331ULL, 0x4361C0CA3F692F12ULL,
-    0xD941ACA44B20A45BULL, 0x528F7C8602C5807BULL, 0x52AB92BEB9613989ULL,
-    0x9D1DFA2EFC557F73ULL, 0x722FF175F572C348ULL, 0x1D1260A51107FE97ULL,
-    0x7A249A57EC0C9BA2ULL, 0x04208FE9E8F7F2D6ULL, 0x5A110C6058B920A0ULL,
-    0x0CD9A497658A5698ULL, 0x56FD23C8F9715A4CULL, 0x284C847B9D887AAEULL,
-    0x04FEABFBBDB619CBULL, 0x742E1E651C60BA83ULL, 0x9A9632E65904AD3CULL,
-    0x881B82A13B51B9E2ULL, 0x506E6744CD974924ULL, 0xB0183DB56FFC6A79ULL,
-    0x0ED9B915C66ED37EULL, 0x5E11E86D5873D484ULL, 0xF678647E3519AC6EULL,
-    0x1B85D488D0F20CC5ULL, 0xDAB9FE6525D89021ULL, 0x0D151D86ADB73615ULL,
-    0xA865A54EDCC0F019ULL, 0x93C42566AEF98FFBULL, 0x99E7AFEABE000731ULL,
-    0x48CBFF086DDF285AULL, 0x7F9B6AF1EBF78BAFULL, 0x58627E1A149BBA21ULL,
-    0x2CD16E2ABD791E33ULL, 0xD363EFF5F0977996ULL, 0x0CE2A38C344A6EEDULL,
-    0x1A804AADB9CFA741ULL, 0x907F30421D78C5DEULL, 0x501F65EDB3034D07ULL,
-    0x37624AE5A48FA6E9ULL, 0x957BAF61700CFF4EULL, 0x3A6C27934E31188AULL,
-    0xD49503536ABCA345ULL, 0x088E049589C432E0ULL, 0xF943AEE7FEBF21B8ULL,
-    0x6C3B8E3E336139D3ULL, 0x364F6FFA464EE52EULL, 0xD60F6DCEDC314222ULL,
-    0x56963B0DCA418FC0ULL, 0x16F50EDF91E513AFULL, 0xEF1955914B609F93ULL,
-    0x565601C0364E3228ULL, 0xECB53939887E8175ULL, 0xBAC7A9A18531294BULL,
-    0xB344C470397BBA52ULL, 0x65D34954DAF3CEBDULL, 0xB4B81B3FA97511E2ULL,
-    0xB422061193D6F6A7ULL, 0x071582401C38434DULL, 0x7A13F18BBEDC4FF5ULL,
-    0xBC4097B116C524D2ULL, 0x59B97885E2F2EA28ULL, 0x99170A5DC3115544ULL,
-    0x6F423357E7C6A9F9ULL, 0x325928EE6E6F8794ULL, 0xD0E4366228B03343ULL,
-    0x565C31F7DE89EA27ULL, 0x30F5611484119414ULL, 0xD873DB391292ED4FULL,
-    0x7BD94E1D8E17DEBCULL, 0xC7D9F16864A76E94ULL, 0x947AE053EE56E63CULL,
-    0xC8C93882F9475F5FULL, 0x3A9BF55BA91F81CAULL, 0xD9A11FBB3D9808E4ULL,
-    0x0FD22063EDC29FCAULL, 0xB3F256D8ACA0B0B9ULL, 0xB03031A8B4516E84ULL,
-    0x35DD37D5871448AFULL, 0xE9F6082B05542E4EULL, 0xEBFAFA33D7254B59ULL,
-    0x9255ABB50D532280ULL, 0xB9AB4CE57F2D34F3ULL, 0x693501D628297551ULL,
-    0xC62C58F97DD949BFULL, 0xCD454F8F19C5126AULL, 0xBBE83F4ECC2BDECBULL,
-    0xDC842B7E2819E230ULL, 0xBA89142E007503B8ULL, 0xA3BC941D0A5061CBULL,
-    0xE9F6760E32CD8021ULL, 0x09C7E552BC76492FULL, 0x852F54934DA55CC9ULL,
-    0x8107FCCF064FCF56ULL, 0x098954D51FFF6580ULL, 0x23B70EDB1955C4BFULL,
-    0xC330DE426430F69DULL, 0x4715ED43E8A45C0AULL, 0xA8D7E4DAB780A08DULL,
-    0x0572B974F03CE0BBULL, 0xB57D2E985E1419C7ULL, 0xE8D9ECBE2CF3D73FULL,
-    0x2FE4B17170E59750ULL, 0x11317BA87905E790ULL, 0x7FBF21EC8A1F45ECULL,
-    0x1725CABFCB045B00ULL, 0x964E915CD5E2B207ULL, 0x3E2B8BCBF016D66DULL,
-    0xBE7444E39328A0ACULL, 0xF85B2B4FBCDE44B7ULL, 0x49353FEA39BA63B1ULL,
-    0x1DD01AAFCD53486AULL, 0x1FCA8A92FD719F85ULL, 0xFC7C95D827357AFAULL,
-    0x18A6A990C8B35EBDULL, 0xCCCB7005C6B9C28DULL, 0x3BDBB92C43B17F26ULL,
-    0xAA70B5B4F89695A2ULL, 0xE94C39A54A98307FULL, 0xB7A0B174CFF6F36EULL,
-    0xD4DBA84729AF48ADULL, 0x2E18BC1AD9704A68ULL, 0x2DE0966DAF2F8B1CULL,
-    0xB9C11D5B1E43A07EULL, 0x64972D68DEE33360ULL, 0x94628D38D0C20584ULL,
-    0xDBC0D2B6AB90A559ULL, 0xD2733C4335C6A72FULL, 0x7E75D99D94A70F4DULL,
-    0x6CED1983376FA72BULL, 0x97FCAACBF030BC24ULL, 0x7B77497B32503B12ULL,
-    0x8547EDDFB81CCB94ULL, 0x79999CDFF70902CBULL, 0xCFFE1939438E9B24ULL,
-    0x829626E3892D95D7ULL, 0x92FAE24291F2B3F1ULL, 0x63E22C147B9C3403ULL,
-    0xC678B6D860284A1CULL, 0x5873888850659AE7ULL, 0x0981DCD296A8736DULL,
-    0x9F65789A6509A440ULL, 0x9FF38FED72E9052FULL, 0xE479EE5B9930578CULL,
-    0xE7F28ECD2D49EECDULL, 0x56C074A581EA17FEULL, 0x5544F7D774B14AEFULL,
-    0x7B3F0195FC6F290FULL, 0x12153635B2C0CF57ULL, 0x7F5126DBBA5E0CA7ULL,
-    0x7A76956C3EAFB413ULL, 0x3D5774A11D31AB39ULL, 0x8A1B083821F40CB4ULL,
-    0x7B4A38E32537DF62ULL, 0x950113646D1D6E03ULL, 0x4DA8979A0041E8A9ULL,
-    0x3BC36E078F7515D7ULL, 0x5D0A12F27AD310D1ULL, 0x7F9D1A2E1EBE1327ULL,
-    0xDA3A361B1C5157B1ULL, 0xDCDD7D20903D0C25ULL, 0x36833336D068F707ULL,
-    0xCE68341F79893389ULL, 0xAB9090168DD05F34ULL, 0x43954B3252DC25E5ULL,
-    0xB438C2B67F98E5E9ULL, 0x10DCD78E3851A492ULL, 0xDBC27AB5447822BFULL,
-    0x9B3CDB65F82CA382ULL, 0xB67B7896167B4C84ULL, 0xBFCED1B0048EAC50ULL,
-    0xA9119B60369FFEBDULL, 0x1FFF7AC80904BF45ULL, 0xAC12FB171817EEE7ULL,
-    0xAF08DA9177DDA93DULL, 0x1B0CAB936E65C744ULL, 0xB559EB1D04E5E932ULL,
-    0xC37B45B3F8D6F2BAULL, 0xC3A9DC228CAAC9E9ULL, 0xF3B8B6675A6507FFULL,
-    0x9FC477DE4ED681DAULL, 0x67378D8ECCEF96CBULL, 0x6DD856D94D259236ULL,
-    0xA319CE15B0B4DB31ULL, 0x073973751F12DD5EULL, 0x8A8E849EB32781A5ULL,
-    0xE1925C71285279F5ULL, 0x74C04BF1790C0EFEULL, 0x4DDA48153C94938AULL,
-    0x9D266D6A1CC0542CULL, 0x7440FB816508C4FEULL, 0x13328503DF48229FULL,
-    0xD6BF7BAEE43CAC40ULL, 0x4838D65F6EF6748FULL, 0x1E152328F3318DEAULL,
-    0x8F8419A348F296BFULL, 0x72C8834A5957B511ULL, 0xD7A023A73260B45CULL,
-    0x94EBC8ABCFB56DAEULL, 0x9FC10D0F989993E0ULL, 0xDE68A2355B93CAE6ULL,
-    0xA44CFE79AE538BBEULL, 0x9D1D84FCCE371425ULL, 0x51D2B1AB2DDFB636ULL,
-    0x2FD7E4B9E72CD38CULL, 0x65CA5B96B7552210ULL, 0xDD69A0D8AB3B546DULL,
-    0x604D51B25FBF70E2ULL, 0x73AA8A564FB7AC9EULL, 0x1A8C1E992B941148ULL,
-    0xAAC40A2703D9BEA0ULL, 0x764DBEAE7FA4F3A6ULL, 0x1E99B96E70A9BE8BULL,
-    0x2C5E9DEB57EF4743ULL, 0x3A938FEE32D29981ULL, 0x26E6DB8FFDF5ADFEULL,
-    0x469356C504EC9F9DULL, 0xC8763C5B08D1908CULL, 0x3F6C6AF859D80055ULL,
-    0x7F7CC39420A3A545ULL, 0x9BFB227EBDF4C5CEULL, 0x89039D79D6FC5C5CULL,
-    0x8FE88B57305E2AB6ULL, 0xA09E8C8C35AB96DEULL, 0xFA7E393983325753ULL,
-    0xD6B6D0ECC617C699ULL, 0xDFEA21EA9E7557E3ULL, 0xB67C1FA481680AF8ULL,
-    0xCA1E3785A9E724E5ULL, 0x1CFC8BED0D681639ULL, 0xD18D8549D140CAEAULL,
-    0x4ED0FE7E9DC91335ULL, 0xE4DBF0634473F5D2ULL, 0x1761F93A44D5AEFEULL,
-    0x53898E4C3910DA55ULL, 0x734DE8181F6EC39AULL, 0x2680B122BAA28D97ULL,
-    0x298AF231C85BAFABULL, 0x7983EED3740847D5ULL, 0x66C1A2A1A60CD889ULL,
-    0x9E17E49642A3E4C1ULL, 0xEDB454E7BADC0805ULL, 0x50B704CAB602C329ULL,
-    0x4CC317FB9CDDD023ULL, 0x66B4835D9EAFEA22ULL, 0x219B97E26FFC81BDULL,
-    0x261E4E4C0A333A9DULL, 0x1FE2CCA76517DB90ULL, 0xD7504DFA8816EDBBULL,
-    0xB9571FA04DC089C8ULL, 0x1DDC0325259B27DEULL, 0xCF3F4688801EB9AAULL,
-    0xF4F5D05C10CAB243ULL, 0x38B6525C21A42B0EULL, 0x36F60E2BA4FA6800ULL,
-    0xEB3593803173E0CEULL, 0x9C4CD6257C5A3603ULL, 0xAF0C317D32ADAA8AULL,
-    0x258E5A80C7204C4BULL, 0x8B889D624D44885DULL, 0xF4D14597E660F855ULL,
-    0xD4347F66EC8941C3ULL, 0xE699ED85B0DFB40DULL, 0x2472F6207C2D0484ULL,
-    0xC2A1E7B5B459AEB5ULL, 0xAB4F6451CC1D45ECULL, 0x63767572AE3D6174ULL,
-    0xA59E0BD101731A28ULL, 0x116D0016CB948F09ULL, 0x2CF9C8CA052F6E9FULL,
-    0x0B090A7560A968E3ULL, 0xABEEDDB2DDE06FF1ULL, 0x58EFC10B06A2068DULL,
-    0xC6E57A78FBD986E0ULL, 0x2EAB8CA63CE802D7ULL, 0x14A195640116F336ULL,
-    0x7C0828DD624EC390ULL, 0xD74BBE77E6116AC7ULL, 0x804456AF10F5FB53ULL,
-    0xEBE9EA2ADF4321C7ULL, 0x03219A39EE587A30ULL, 0x49787FEF17AF9924ULL,
-    0xA1E9300CD8520548ULL, 0x5B45E522E4B1B4EFULL, 0xB49C3B3995091A36ULL,
-    0xD4490AD526F14431ULL, 0x12A8F216AF9418C2ULL, 0x001F837CC7350524ULL,
-    0x1877B51E57A764D5ULL, 0xA2853B80F17F58EEULL, 0x993E1DE72D36D310ULL,
-    0xB3598080CE64A656ULL, 0x252F59CF0D9F04BBULL, 0xD23C8E176D113600ULL,
-    0x1BDA0492E7E4586EULL, 0x21E0BD5026C619BFULL, 0x3B097ADAF088F94EULL,
-    0x8D14DEDB30BE846EULL, 0xF95CFFA23AF5F6F4ULL, 0x3871700761B3F743ULL,
-    0xCA672B91E9E4FA16ULL, 0x64C8E531BFF53B55ULL, 0x241260ED4AD1E87DULL,
-    0x106C09B972D2E822ULL, 0x7FBA195410E5CA30ULL, 0x7884D9BC6CB569D8ULL,
-    0x0647DFEDCD894A29ULL, 0x63573FF03E224774ULL, 0x4FC8E9560F91B123ULL,
-    0x1DB956E450275779ULL, 0xB8D91274B9E9D4FBULL, 0xA2EBEE47E2FBFCE1ULL,
-    0xD9F1F30CCD97FB09ULL, 0xEFED53D75FD64E6BULL, 0x2E6D02C36017F67FULL,
-    0xA9AA4D20DB084E9BULL, 0xB64BE8D8B25396C1ULL, 0x70CB6AF7C2D5BCF0ULL,
-    0x98F076A4F7A2322EULL, 0xBF84470805E69B5FULL, 0x94C3251F06F90CF3ULL,
-    0x3E003E616A6591E9ULL, 0xB925A6CD0421AFF3ULL, 0x61BDD1307C66E300ULL,
-    0xBF8D5108E27E0D48ULL, 0x240AB57A8B888B20ULL, 0xFC87614BAF287E07ULL,
-    0xEF02CDD06FFDB432ULL, 0xA1082C0466DF6C0AULL, 0x8215E577001332C8ULL,
-    0xD39BB9C3A48DB6CFULL, 0x2738259634305C14ULL, 0x61CF4F94C97DF93DULL,
-    0x1B6BACA2AE4E125BULL, 0x758F450C88572E0BULL, 0x959F587D507A8359ULL,
-    0xB063E962E045F54DULL, 0x60E8ED72C0DFF5D1ULL, 0x7B64978555326F9FULL,
-    0xFD080D236DA814BAULL, 0x8C90FD9B083F4558ULL, 0x106F72FE81E2C590ULL,
-    0x7976033A39F7D952ULL, 0xA4EC0132764CA04BULL, 0x733EA705FAE4FA77ULL,
-    0xB4D8F77BC3E56167ULL, 0x9E21F4F903B33FD9ULL, 0x9D765E419FB69F6DULL,
-    0xD30C088BA61EA5EFULL, 0x5D94337FBFAF7F5BULL, 0x1A4E4822EB4D7A59ULL,
-    0x6FFE73E81B637FB3ULL, 0xDDF957BC36D8B9CAULL, 0x64D0E29EEA8838B3ULL,
-    0x08DD9BDFD96B9F63ULL, 0x087E79E5A57D1D13ULL, 0xE328E230E3E2B3FBULL,
-    0x1C2559E30F0946BEULL, 0x720BF5F26F4D2EAAULL, 0xB0774D261CC609DBULL,
-    0x443F64EC5A371195ULL, 0x4112CF68649A260EULL, 0xD813F2FAB7F5C5CAULL,
-    0x660D3257380841EEULL, 0x59AC2C7873F910A3ULL, 0xE846963877671A17ULL,
-    0x93B633ABFA3469F8ULL, 0xC0C0F5A60EF4CDCFULL, 0xCAF21ECD4377B28CULL,
-    0x57277707199B8175ULL, 0x506C11B9D90E8B1DULL, 0xD83CC2687A19255FULL,
-    0x4A29C6465A314CD1ULL, 0xED2DF21216235097ULL, 0xB5635C95FF7296E2ULL,
-    0x22AF003AB672E811ULL, 0x52E762596BF68235ULL, 0x9AEBA33AC6ECC6B0ULL,
-    0x944F6DE09134DFB6ULL, 0x6C47BEC883A7DE39ULL, 0x6AD047C430A12104ULL,
-    0xA5B1CFDBA0AB4067ULL, 0x7C45D833AFF07862ULL, 0x5092EF950A16DA0BULL,
-    0x9338E69C052B8E7BULL, 0x455A4B4CFE30E3F5ULL, 0x6B02E63195AD0CF8ULL,
-    0x6B17B224BAD6BF27ULL, 0xD1E0CCD25BB9C169ULL, 0xDE0C89A556B9AE70ULL,
-    0x50065E535A213CF6ULL, 0x9C1169FA2777B874ULL, 0x78EDEFD694AF1EEDULL,
-    0x6DC93D9526A50E68ULL, 0xEE97F453F06791EDULL, 0x32AB0EDB696703D3ULL,
-    0x3A6853C7E70757A7ULL, 0x31865CED6120F37DULL, 0x67FEF95D92607890ULL,
-    0x1F2B1D1F15F6DC9CULL, 0xB69E38A8965C6B65ULL, 0xAA9119FF184CCCF4ULL,
-    0xF43C732873F24C13ULL, 0xFB4A3D794A9A80D2ULL, 0x3550C2321FD6109CULL,
-    0x371F77E76BB8417EULL, 0x6BFA9AAE5EC05779ULL, 0xCD04F3FF001A4778ULL,
-    0xE3273522064480CAULL, 0x9F91508BFFCFC14AULL, 0x049A7F41061A9E60ULL,
-    0xFCB6BE43A9F2FE9BULL, 0x08DE8A1C7797DA9BULL, 0x8F9887E6078735A1ULL,
-    0xB5B4071DBFC73A66ULL, 0x230E343DFBA08D33ULL, 0x43ED7F5A0FAE657DULL,
-    0x3A88A0FBBCB05C63ULL, 0x21874B8B4D2DBC4FULL, 0x1BDEA12E35F6A8C9ULL,
-    0x53C065C6C8E63528ULL, 0xE34A1D250E7A8D6BULL, 0xD6B04D3B7651DD7EULL,
-    0x5E90277E7CB39E2DULL, 0x2C046F22062DC67DULL, 0xB10BB459132D0A26ULL,
-    0x3FA9DDFB67E2F199ULL, 0x0E09B88E1914F7AFULL, 0x10E8B35AF3EEAB37ULL,
-    0x9EEDECA8E272B933ULL, 0xD4C718BC4AE8AE5FULL, 0x81536D601170FC20ULL,
-    0x91B534F885818A06ULL, 0xEC8177F83F900978ULL, 0x190E714FADA5156EULL,
-    0xB592BF39B0364963ULL, 0x89C350C893AE7DC1ULL, 0xAC042E70F8B383F2ULL,
-    0xB49B52E587A1EE60ULL, 0xFB152FE3FF26DA89ULL, 0x3E666E6F69AE2C15ULL,
-    0x3B544EBE544C19F9ULL, 0xE805A1E290CF2456ULL, 0x24B33C9D7ED25117ULL,
-    0xE74733427B72F0C1ULL, 0x0A804D18B7097475ULL, 0x57E3306D881EDB4FULL,
-    0x4AE7D6A36EB5DBCBULL, 0x2D8D5432157064C8ULL, 0xD1E649DE1E7F268BULL,
-    0x8A328A1CEDFE552CULL, 0x07A3AEC79624C7DAULL, 0x84547DDC3E203C94ULL,
-    0x990A98FD5071D263ULL, 0x1A4FF12616EEFC89ULL, 0xF6F7FD1431714200ULL,
-    0x30C05B1BA332F41CULL, 0x8D2636B81555A786ULL, 0x46C9FEB55D120902ULL,
-    0xCCEC0A73B49C9921ULL, 0x4E9D2827355FC492ULL, 0x19EBB029435DCB0FULL,
-    0x4659D2B743848A2CULL, 0x963EF2C96B33BE31ULL, 0x74F85198B05A2E7DULL,
-    0x5A0F544DD2B1FB18ULL, 0x03727073C2E134B1ULL, 0xC7F6AA2DE59AEA61ULL,
-    0x352787BAA0D7C22FULL, 0x9853EAB63B5E0B35ULL, 0xABBDCDD7ED5C0860ULL,
-    0xCF05DAF5AC8D77B0ULL, 0x49CAD48CEBF4A71EULL, 0x7A4C10EC2158C4A6ULL,
-    0xD9E92AA246BF719EULL, 0x13AE978D09FE5557ULL, 0x730499AF921549FFULL,
-    0x4E4B705B92903BA4ULL, 0xFF577222C14F0A3AULL, 0x55B6344CF97AAFAEULL,
-    0xB862225B055B6960ULL, 0xCAC09AFBDDD2CDB4ULL, 0xDAF8E9829FE96B5FULL,
-    0xB5FDFC5D3132C498ULL, 0x310CB380DB6F7503ULL, 0xE87FBB46217A360EULL,
-    0x2102AE466EBB1148ULL, 0xF8549E1A3AA5E00DULL, 0x07A69AFDCC42261AULL,
-    0xC4C118BFE78FEAAEULL, 0xF9F4892ED96BD438ULL, 0x1AF3DBE25D8F45DAULL,
-    0xF5B4B0B0D2DEEEB4ULL, 0x962ACEEFA82E1C84ULL, 0x046E3ECAAF453CE9ULL,
-    0xF05D129681949A4CULL, 0x964781CE734B3C84ULL, 0x9C2ED44081CE5FBDULL,
-    0x522E23F3925E319EULL, 0x177E00F9FC32F791ULL, 0x2BC60A63A6F3B3F2ULL,
-    0x222BBFAE61725606ULL, 0x486289DDCC3D6780ULL, 0x7DC7785B8EFDFC80ULL,
-    0x8AF38731C02BA980ULL, 0x1FAB64EA29A2DDF7ULL, 0xE4D9429322CD065AULL,
-    0x9DA058C67844F20CULL, 0x24C0E332B70019B0ULL, 0x233003B5A6CFE6ADULL,
-    0xD586BD01C5C217F6ULL, 0x5E5637885F29BC2BULL, 0x7EBA726D8C94094BULL,
-    0x0A56A5F0BFE39272ULL, 0xD79476A84EE20D06ULL, 0x9E4C1269BAA4BF37ULL,
-    0x17EFEE45B0DEE640ULL, 0x1D95B0A5FCF90BC6ULL, 0x93CBE0B699C2585DULL,
-    0x65FA4F227A2B6D79ULL, 0xD5F9E858292504D5ULL, 0xC2B5A03F71471A6FULL,
-    0x59300222B4561E00ULL, 0xCE2F8642CA0712DCULL, 0x7CA9723FBB2E8988ULL,
-    0x2785338347F2BA08ULL, 0xC61BB3A141E50E8CULL, 0x150F361DAB9DEC26ULL,
-    0x9F6A419D382595F4ULL, 0x64A53DC924FE7AC9ULL, 0x142DE49FFF7A7C3DULL,
-    0x0C335248857FA9E7ULL, 0x0A9C32D5EAE45305ULL, 0xE6C42178C4BBB92EULL,
-    0x71F1CE2490D20B07ULL, 0xF1BCC3D275AFE51AULL, 0xE728E8C83C334074ULL,
-    0x96FBF83A12884624ULL, 0x81A1549FD6573DA5ULL, 0x5FA7867CAF35E149ULL,
-    0x56986E2EF3ED091BULL, 0x917F1DD5F8886C61ULL, 0xD20D8C88C8FFE65FULL,
-    0x31D71DCE64B2C310ULL, 0xF165B587DF898190ULL, 0xA57E6339DD2CF3A0ULL,
-    0x1EF6E6DBB1961EC9ULL, 0x70CC73D90BC26E24ULL, 0xE21A6B35DF0C3AD7ULL,
-    0x003A93D8B2806962ULL, 0x1C99DED33CB890A1ULL, 0xCF3145DE0ADD4289ULL,
-    0xD0E4427A5514FB72ULL, 0x77C621CC9FB3A483ULL, 0x67A34DAC4356550BULL,
-    0xF8D626AAAF278509ULL
-  };
-
-  // Indices to the Random64[] array
-  const int PieceIdx     = 0;
-  const int CastleIdx    = 768;
-  const int EnPassantIdx = 772;
-  const int TurnIdx      = 780;
-
-  // Local functions
-  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);
-}
-
-
-////
-//// Functions
-////
-
-// 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>();
-}
-
-
-/// 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 (is_open())
-      ifstream::close();
-}
-
-
-/// Book::open() opens a book file with a given file name
-
-void Book::open(const string& fName) {
-
-  // Close old file before opening the new
-  close();
-
-  fileName = fName;
-  ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary);
-
-  // Silently return when asked to open a non-exsistent file
-  if (!is_open())
-      return;
-
-  // Get the book size in number of entries
-  seekg(0, ios::end);
-  bookSize = long(tellg()) / EntrySize;
-  seekg(0, ios::beg);
-
-  if (!good())
-  {
-      cerr << "Failed to open book file " << fileName << endl;
-      exit(EXIT_FAILURE);
-  }
-}
-
-
-/// Book::file_name() returns the file name of the currently active book,
-/// or the empty string if no book is open.
-
-const string Book::file_name() { // Not const to compile on HP-UX 11.X
-
-  return is_open() ? fileName : "";
-}
-
-
-/// Book::get_move() gets a book move for a given position. Returns
-/// MOVE_NONE if no book move is found.
-
-Move Book::get_move(const Position& pos, bool findBestMove) {
-
-  if (!is_open() || bookSize == 0)
-      return MOVE_NONE;
-
-  BookEntry entry;
-  int bookMove = MOVE_NONE;
-  unsigned scoresSum = 0, bestScore = 0;
-  uint64_t key = book_key(pos);
-
-  // Choose a book move among the possible moves for the given position
-  for (int idx = find_key(key); idx < bookSize; idx++)
-  {
-      read_entry(entry, idx);
-      if (entry.key != key)
-          break;
-
-      unsigned score = entry.count;
-
-      // If findBestMove is true choose highest rated book move
-      if (findBestMove)
-      {
-          if (score > bestScore)
-          {
-              bestScore = score;
-              bookMove = entry.move;
-          }
-          continue;
-      }
-
-      // Choose book move according to its score. If a move has a very
-      // high score it has more probability to be choosen then a one with
-      // lower score. Note that first entry is always chosen.
-      scoresSum += score;
-      if (RKiss.rand<unsigned>() % scoresSum < score)
-          bookMove = entry.move;
-  }
-  if (!bookMove)
-      return MOVE_NONE;
-
-  // Verify the book move is legal
-  MoveStack mlist[MOVES_MAX];
-  MoveStack* last = generate_moves(pos, mlist);
-  for (MoveStack* cur = mlist; cur != last; cur++)
-      if ((int(cur->move) & 07777) == bookMove)
-          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
-/// found in the book file, bookSize is returned.
-
-int Book::find_key(uint64_t key) {
-
-  int left, right, mid;
-  BookEntry entry;
-
-  // Binary search (finds the leftmost entry)
-  left = 0;
-  right = bookSize - 1;
-
-  assert(left <= right);
-
-  while (left < right)
-  {
-      mid = (left + right) / 2;
-
-      assert(mid >= left && mid < right);
-
-      read_entry(entry, mid);
-
-      if (key <= entry.key)
-          right = mid;
-      else
-          left = mid + 1;
-  }
-
-  assert(left == right);
-
-  read_entry(entry, left);
-  return entry.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.
-
-void Book::read_entry(BookEntry& entry, int idx) {
-
-  assert(idx >= 0 && idx < bookSize);
-  assert(is_open());
-
-  seekg(idx * EntrySize, ios_base::beg);
-
-  *this >> entry;
-
-  if (!good())
-  {
-      cerr << "Failed to read book entry at index " << idx << endl;
-      exit(EXIT_FAILURE);
-  }
-}
-
-
-/// Book::read_integer() reads size chars from the file stream
-/// and converts them in an integer number.
-
-uint64_t Book::read_integer(int size) {
-
-  char buf[8];
-  uint64_t n = 0;
-
-  read(buf, size);
-
-  // Numbers are stored on disk as a binary byte stream
-  for (int i = 0; i < size; i++)
-      n = (n << 8) + (unsigned char)buf[i];
-
-  return n;
-}
-
-
-////
-//// Local definitions
-////
-
-namespace {
-
-  uint64_t book_key(const Position& pos) {
-
-    uint64_t result = 0;
-    Bitboard b = pos.occupied_squares();
-
-    while (b)
-    {
-        Square s = pop_1st_bit(&b);
-        result ^= book_piece_key(pos.piece_on(s), s);
-    }
-
-    result ^= book_castle_key(pos);
-    result ^= book_ep_key(pos);
-    result ^= book_color_key(pos);
-    return result;
-  }
-
-
-  uint64_t book_piece_key(Piece p, Square s) {
-
-    // Convert pieces to the range 0..11
-    static const int PieceTo12[] = { 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 };
-
-    return Random64[PieceIdx + (PieceTo12[int(p)]^1) * 64 + int(s)];
-  }
-
-
-  uint64_t book_castle_key(const Position& pos) {
-
-    uint64_t result = 0;
-
-    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];
-
-    return result;
-  }
-
-
-  uint64_t book_ep_key(const Position& pos) {
-
-    return pos.ep_square() == SQ_NONE ? 0 : Random64[EnPassantIdx + square_file(pos.ep_square())];
-  }
-
-
-  uint64_t book_color_key(const Position& pos) {
-
-    return pos.side_to_move() == WHITE ? Random64[TurnIdx] : 0;
-  }
-}

src/book.h

@@ -1,81 +0,0 @@
-/*
-  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/>.
-*/
-
-
-/*
-  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
-////
-
-struct BookEntry {
-  uint64_t key;
-  uint16_t move;
-  uint16_t count;
-  uint16_t n;
-  uint16_t sum;
-};
-
-class Book : private std::ifstream {
-  Book(const Book&); // just decleared..
-  Book& operator=(const Book&); // ..to avoid a warning
-public:
-  Book();
-  ~Book();
-  void open(const std::string& fName);
-  void close();
-  const std::string file_name();
-  Move get_move(const Position& pos, bool findBestMove);
-
-private:
-  Book& operator>>(uint64_t& n) { n = read_integer(8); return *this; }
-  Book& operator>>(uint16_t& n) { n = (uint16_t)read_integer(2); return *this; }
-  void operator>>(BookEntry& e) { *this >> e.key >> e.move >> e.count >> e.n >> e.sum; }
-
-  uint64_t read_integer(int size);
-  void read_entry(BookEntry& e, int n);
-  int find_key(uint64_t key);
-
-  std::string fileName;
-  int bookSize;
-  RKISS RKiss;
-};
-
-#endif // !defined(BOOK_H_INCLUDED)

src/color.h

@@ -1,56 +0,0 @@
-/*
-  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(COLOR_H_INCLUDED)
-#define COLOR_H_INCLUDED
-
-#include "types.h"
-
-////
-//// Types
-////
-
-enum Color {
-  WHITE,
-  BLACK,
-  COLOR_NONE
-};
-
-enum SquareColor {
-  DARK,
-  LIGHT
-};
-
-ENABLE_OPERATORS_ON(Color)
-
-
-////
-//// Inline functions
-////
-
-inline Color opposite_color(Color c) {
-  return Color(int(c) ^ 1);
-}
-
-inline bool color_is_ok(Color c) {
-  return c == WHITE || c == BLACK;
-}
-
-#endif // !defined(COLOR_H_INCLUDED)

src/depth.h

@@ -1,43 +0,0 @@
-/*
-  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(DEPTH_H_INCLUDED)
-#define DEPTH_H_INCLUDED
-
-#include "types.h"
-
-////
-//// Types
-////
-
-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
-};
-
-ENABLE_OPERATORS_ON(Depth)
-
-#endif // !defined(DEPTH_H_INCLUDED)

src/endgame.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,88 +18,108 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef ENDGAME_H_INCLUDED
-#if !defined(ENDGAME_H_INCLUDED)
 #define ENDGAME_H_INCLUDED
 
-////
+#include <map>
-//// Includes
+#include <memory>
-////
+#include <string>
+#include <type_traits>
+#include <utility>
 
 #include "position.h"
-#include "value.h"
+#include "types.h"
 
 
-////
+/// EndgameType lists all supported endgames
-//// Types
-////
 
 enum EndgameType {
 
   // Evaluation functions
+
+  KNNK,  // KNN vs K
   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
+  KQKP,  // KQ vs KP
   KQKR,  // KQ vs KR
-    KBBKN, // KBB vs KN
+
-    KNNK,  // KNN vs K
-    KmmKm, // K and two minors vs K and one or two minors
 
   // Scaling functions
-    KBPsK,   // KB+pawns vs K
+  SCALING_FUNCTIONS,
-    KQKRPs,  // KQ vs KR+pawns
+
+  KBPsK,   // KB and pawns vs K
+  KQKRPs,  // KQ vs KR and pawns
   KRPKR,   // KRP vs KR
+  KRPKB,   // KRP vs KB
   KRPPKRP, // KRPP vs KRP
-    KPsK,    // King and pawns vs king
+  KPsK,    // K and pawns vs K
   KBPKB,   // KBP vs KB
   KBPPKB,  // KBPP vs KB
   KBPKN,   // KBP vs KN
   KNPK,    // KNP vs K
+  KNPKB,   // KNP vs KB
   KPKP     // KP vs KP
 };
 
-/// Template abstract base class for all special endgame functions
+
+/// Endgame functions can be of two types depending on whether they return a
+/// Value or a ScaleFactor.
+template<EndgameType E> using
+eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
+
+
+/// Base and derived templates for endgame evaluation and scaling functions
 
 template<typename T>
-class EndgameFunctionBase {
+struct EndgameBase {
+
+  virtual ~EndgameBase() = default;
+  virtual Color strong_side() const = 0;
+  virtual T operator()(const Position&) const = 0;
+};
+
+
+template<EndgameType E, typename T = eg_type<E>>
+struct Endgame : public EndgameBase<T> {
+
+  explicit Endgame(Color c) : strongSide(c), weakSide(~c) {}
+  Color strong_side() const { return strongSide; }
+  T operator()(const Position&) const;
+
+private:
+  Color strongSide, weakSide;
+};
+
+
+/// The Endgames class stores the pointers to endgame evaluation and scaling
+/// base objects in two std::map. We use polymorphism to invoke the actual
+/// endgame function by calling its virtual operator().
+
+class Endgames {
+
+  template<typename T> using Map = std::map<Key, std::unique_ptr<EndgameBase<T>>>;
+
+  template<EndgameType E, typename T = eg_type<E>>
+  void add(const std::string& code);
+
+  template<typename T>
+  Map<T>& map() {
+    return std::get<std::is_same<T, ScaleFactor>::value>(maps);
+  }
+
+  std::pair<Map<Value>, Map<ScaleFactor>> maps;
+
 public:
-  EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
+  Endgames();
-  virtual ~EndgameFunctionBase() {}
-  virtual T apply(const Position&) const = 0;
-  Color color() const { return strongerSide; }
 
-protected:
+  template<typename T>
-  Color strongerSide, weakerSide;
+  EndgameBase<T>* probe(Key key) {
+    return map<T>().count(key) ? map<T>()[key].get() : nullptr;
+  }
 };
 
-typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
+#endif // #ifndef ENDGAME_H_INCLUDED
-typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
-
-
-/// Templates subclass for various concrete endgames
-
-template<EndgameType>
-struct EvaluationFunction : public EndgameEvaluationFunctionBase {
-  typedef EndgameEvaluationFunctionBase Base;
-  explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
-  Value apply(const Position&) const;
-};
-
-template<EndgameType>
-struct ScalingFunction : public EndgameScalingFunctionBase {
-  typedef EndgameScalingFunctionBase Base;
-  explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
-  ScaleFactor apply(const Position&) const;
-};
-
-
-////
-//// Prototypes
-////
-
-extern void init_bitbases();
-
-#endif // !defined(ENDGAME_H_INCLUDED)

src/evaluate.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,18 +18,24 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef EVALUATE_H_INCLUDED
-#if !defined(EVALUATE_H_INCLUDED)
 #define EVALUATE_H_INCLUDED
 
-#include "color.h"
+#include <string>
-#include "value.h"
+
+#include "types.h"
 
 class Position;
 
-extern Value evaluate(const Position& pos, Value& margin);
+namespace Eval {
-extern void init_eval(int threads);
-extern void quit_eval();
-extern void read_evaluation_uci_options(Color sideToMove);
 
-#endif // !defined(EVALUATE_H_INCLUDED)
+const Value Tempo = Value(20); // Must be visible to search
+
+void init();
+std::string trace(const Position& pos);
+
+template<bool DoTrace = false>
+Value evaluate(const Position& pos);
+}
+
+#endif // #ifndef EVALUATE_H_INCLUDED

src/history.cpp

@@ -1,98 +0,0 @@
-/*
-  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/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstring>
-
-#include "history.h"
-
-
-////
-//// Functions
-////
-
-
-/// Constructor
-
-History::History() { clear(); }
-
-
-/// History::clear() clears the history tables
-
-void History::clear() {
-  memset(history, 0, 16 * 64 * sizeof(int));
-  memset(maxStaticValueDelta, 0, 16 * 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 destination square, and
-/// the search depth.
-
-void History::success(Piece p, Square to, Depth d) {
-
-  assert(piece_is_ok(p));
-  assert(square_is_ok(to));
-
-  history[p][to] += int(d) * int(d);
-
-  // Prevent history overflow
-  if (history[p][to] >= HistoryMax)
-      for (int i = 0; i < 16; i++)
-          for (int j = 0; j < 64; j++)
-              history[i][j] /= 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, Square to, Depth d) {
-
-  assert(piece_is_ok(p));
-  assert(square_is_ok(to));
-
-  history[p][to] -= int(d) * int(d);
-
-  // Prevent history underflow
-  if (history[p][to] <= -HistoryMax)
-      for (int i = 0; i < 16; i++)
-          for (int j = 0; j < 64; j++)
-              history[i][j] /= 2;
-}
-
-
-/// History::set_gain() and History::gain() store and retrieve the
-/// gain of a move given the delta of the static position evaluations
-/// before and after the move.
-
-void History::set_gain(Piece p, Square to, Value delta) {
-
-  if (delta >= maxStaticValueDelta[p][to])
-      maxStaticValueDelta[p][to] = delta;
-  else
-      maxStaticValueDelta[p][to]--;
-}

src/history.h

@@ -1,89 +0,0 @@
-/*
-  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(HISTORY_H_INCLUDED)
-#define HISTORY_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "depth.h"
-#include "move.h"
-#include "piece.h"
-#include "value.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. 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, Square to, Depth d);
-  void failure(Piece p, Square to, Depth d);
-  int value(Piece p, Square to) const;
-  void set_gain(Piece p, Square to, Value delta);
-  Value gain(Piece p, Square to) const;
-
-private:
-  int history[16][64];  // [piece][square]
-  int maxStaticValueDelta[16][64];  // [piece][from_square][to_square]
-};
-
-
-////
-//// Constants and variables
-////
-
-/// 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.
-
-const int HistoryMax = 50000 * ONE_PLY;
-
-
-////
-//// Inline functions
-////
-
-inline int History::value(Piece p, Square to) const {
-  return history[p][to];
-}
-
-inline Value History::gain(Piece p, Square to) const {
-  return Value(maxStaticValueDelta[p][to]);
-}
-
-#endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,81 +0,0 @@
-/*
-  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(LOCK_H_INCLUDED)
-#define LOCK_H_INCLUDED
-
-
-#if !defined(_MSC_VER)
-
-#  include <pthread.h>
-
-typedef pthread_mutex_t Lock;
-typedef pthread_cond_t WaitCondition;
-
-#  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
-
-// 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;
-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,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,94 +18,35 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-// To profile with callgrind uncomment following line
-//#define USE_CALLGRIND
-
-
-////
-//// Includes
-////
-
 #include <iostream>
-#include <string>
 
 #include "bitboard.h"
-#include "bitcount.h"
-#include "endgame.h"
 #include "evaluate.h"
-#include "material.h"
-#include "misc.h"
 #include "position.h"
 #include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "tt.h"
-
+#include "uci.h"
-#ifdef USE_CALLGRIND
+#include "syzygy/tbprobe.h"
-#include <valgrind/callgrind.h>
-#endif
-
-using namespace std;
-
-extern bool execute_uci_command(const string& cmd);
-extern void benchmark(int argc, char* argv[]);
-
-////
-//// Functions
-////
 
 int main(int argc, char* argv[]) {
 
-  // Disable IO buffering
+  std::cout << engine_info() << std::endl;
-  cout.rdbuf()->pubsetbuf(NULL, 0);
-  cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  // Startup initializations
+  UCI::init(Options);
-  init_bitboards();
+  PSQT::init();
-  init_uci_options();
+  Bitboards::init();
-  Position::init_zobrist();
+  Position::init();
-  Position::init_piece_square_tables();
+  Bitbases::init();
-  init_eval(1);
+  Search::init();
-  init_bitbases();
+  Eval::init();
-  init_search();
+  Pawns::init();
-  init_threads();
+  Threads.init();
+  Tablebases::init(Options["SyzygyPath"]);
+  TT.resize(Options["Hash"]);
 
-#ifdef USE_CALLGRIND
+  UCI::loop(argc, argv);
-  CALLGRIND_START_INSTRUMENTATION;
-#endif
 
-  if (argc <= 1)
+  Threads.exit();
-  {
-      // Print copyright notice
-      cout << engine_name()
-           << " by Tord Romstad, Marco Costalba, Joona Kiiski" << 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, by
-      // translating EOF to the "quit" command. This ensures that we
-      // exit gracefully if the GUI dies unexpectedly.
-      string cmd;
-
-      do {
-          // Wait for a command from stdin
-          if (!getline(cin, cmd))
-              cmd = "quit";
-
-      } while (execute_uci_command(cmd));
-  }
-  else // Process command line arguments
-  {
-      if (string(argv[1]) != "bench" || argc > 7)
-          cout << "Usage: stockfish bench [hash size = 128] [threads = 1] "
-               << "[limit = 12] [fen positions file = default] "
-               << "[depth, time, perft or node limited = depth]" << endl;
-      else
-          benchmark(argc, argv);
-  }
-
-  exit_threads();
-  quit_eval();
   return 0;
 }

src/material.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,419 +18,211 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <algorithm> // For std::min
-////
-//// Includes
-////
-
 #include <cassert>
-#include <cstring>
+#include <cstring>   // For std::memset
-#include <map>
 
 #include "material.h"
+#include "thread.h"
 
 using namespace std;
 
-
-////
-//// Local definitions
-////
-
 namespace {
 
-  // Values modified by Joona Kiiski
+  // Polynomial material imbalance parameters
-  const Value MidgameLimit = Value(15581);
-  const Value EndgameLimit = Value(3998);
 
-  // Polynomial material balance parameters
+  //                      pair  pawn knight bishop rook queen
-  const Value RedundantQueenPenalty = Value(320);
+  const int Linear[6] = { 1667, -168, -1027, -166,  238, -138 };
-  const Value RedundantRookPenalty  = Value(554);
 
-  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
+  const int QuadraticOurs[][PIECE_TYPE_NB] = {
+    //            OUR PIECES
+    // pair pawn knight bishop rook queen
+    {   0                               }, // Bishop pair
+    {  40,    2                         }, // Pawn
+    {  32,  255,  -3                    }, // Knight      OUR PIECES
+    {   0,  104,   4,    0              }, // Bishop
+    { -26,   -2,  47,   105,  -149      }, // Rook
+    {-185,   24, 122,   137,  -134,   0 }  // Queen
+  };
 
-  const int QuadraticCoefficientsSameColor[][8] = {
+  const int QuadraticTheirs[][PIECE_TYPE_NB] = {
-  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
+    //           THEIR PIECES
-  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
+    // pair pawn knight bishop rook queen
+    {   0                               }, // Bishop pair
+    {  36,    0                         }, // Pawn
+    {   9,   63,   0                    }, // Knight      OUR PIECES
+    {  59,   65,  42,     0             }, // Bishop
+    {  46,   39,  24,   -24,    0       }, // Rook
+    { 101,  100, -37,   141,  268,    0 }  // Queen
+  };
 
-  const int QuadraticCoefficientsOppositeColor[][8] = {
+  // Endgame evaluation and scaling functions are accessed directly and not through
-  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
+  // the function maps because they correspond to more than one material hash key.
-  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+  Endgame<KXK>    EvaluateKXK[] = { Endgame<KXK>(WHITE),    Endgame<KXK>(BLACK) };
 
-  typedef EndgameEvaluationFunctionBase EF;
+  Endgame<KBPsK>  ScaleKBPsK[]  = { Endgame<KBPsK>(WHITE),  Endgame<KBPsK>(BLACK) };
-  typedef EndgameScalingFunctionBase SF;
+  Endgame<KQKRPs> ScaleKQKRPs[] = { Endgame<KQKRPs>(WHITE), Endgame<KQKRPs>(BLACK) };
-  typedef map<Key, EF*> EFMap;
+  Endgame<KPsK>   ScaleKPsK[]   = { Endgame<KPsK>(WHITE),   Endgame<KPsK>(BLACK) };
-  typedef map<Key, SF*> SFMap;
+  Endgame<KPKP>   ScaleKPKP[]   = { Endgame<KPKP>(WHITE),   Endgame<KPKP>(BLACK) };
 
-  // Endgame evaluation and scaling functions accessed direcly and not through
+  // Helper used to detect a given material distribution
-  // the function maps because correspond to more then one material hash key.
+  bool is_KXK(const Position& pos, Color us) {
-  EvaluationFunction<KmmKm> EvaluateKmmKm[] = { EvaluationFunction<KmmKm>(WHITE), EvaluationFunction<KmmKm>(BLACK) };
+    return  !more_than_one(pos.pieces(~us))
-  EvaluationFunction<KXK>   EvaluateKXK[]   = { EvaluationFunction<KXK>(WHITE),   EvaluationFunction<KXK>(BLACK) };
+          && pos.non_pawn_material(us) >= RookValueMg;
-  ScalingFunction<KBPsK>    ScaleKBPsK[]    = { ScalingFunction<KBPsK>(WHITE),    ScalingFunction<KBPsK>(BLACK) };
+  }
-  ScalingFunction<KQKRPs>   ScaleKQKRPs[]   = { ScalingFunction<KQKRPs>(WHITE),   ScalingFunction<KQKRPs>(BLACK) };
+
-  ScalingFunction<KPsK>     ScaleKPsK[]     = { ScalingFunction<KPsK>(WHITE),     ScalingFunction<KPsK>(BLACK) };
+  bool is_KBPsKs(const Position& pos, Color us) {
-  ScalingFunction<KPKP>     ScaleKPKP[]     = { ScalingFunction<KPKP>(WHITE),     ScalingFunction<KPKP>(BLACK) };
+    return   pos.non_pawn_material(us) == BishopValueMg
+          && pos.count<BISHOP>(us) == 1
+          && pos.count<PAWN  >(us) >= 1;
+  }
+
+  bool is_KQKRPs(const Position& pos, Color us) {
+    return  !pos.count<PAWN>(us)
+          && pos.non_pawn_material(us) == QueenValueMg
+          && pos.count<QUEEN>(us)  == 1
+          && pos.count<ROOK>(~us) == 1
+          && pos.count<PAWN>(~us) >= 1;
+  }
+
+  /// imbalance() calculates the imbalance by comparing the piece count of each
+  /// piece type for both colors.
+  template<Color Us>
+  int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
 
-  // 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;
-  }
 
-  template<Color Us> bool is_KBPsK(const Position& pos) {
+    int bonus = 0;
-    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) {
+    // Second-degree polynomial material imbalance by Tord Romstad
-    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1)
-    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;
-  }
-}
-
-
-////
-//// Classes
-////
-
-/// EndgameFunctions class stores endgame evaluation and scaling functions
-/// in two std::map. Because STL library is not guaranteed to be thread
-/// safe even for read access, the maps, although with identical content,
-/// are replicated for each thread. This is faster then using locks.
-
-class EndgameFunctions {
-public:
-  EndgameFunctions();
-  ~EndgameFunctions();
-  template<class T> T* get(Key key) const;
-
-private:
-  template<class T> void add(const string& keyCode);
-
-  static Key buildKey(const string& keyCode);
-  static const string swapColors(const string& keyCode);
-
-  // Here we store two maps, for evaluate and scaling functions...
-  pair<EFMap, SFMap> maps;
-
-  // ...and here is the accessing template function
-  template<typename T> const map<Key, T*>& get() const;
-};
-
-// Explicit specializations of a member function shall be declared in
-// the namespace of which the class template is a member.
-template<> const EFMap& EndgameFunctions::get<EF>() const { return maps.first; }
-template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; }
-
-
-////
-//// Functions
-////
-
-/// MaterialInfoTable c'tor and d'tor, called once by each thread
-
-MaterialInfoTable::MaterialInfoTable() {
-
-  entries = new MaterialInfo[MaterialTableSize];
-  funcs = new EndgameFunctions();
-
-  if (!entries || !funcs)
     {
-      cerr << "Failed to allocate " << MaterialTableSize * sizeof(MaterialInfo)
+        if (!pieceCount[Us][pt1])
-           << " bytes for material hash table." << endl;
+            continue;
-      exit(EXIT_FAILURE);
-  }
-  memset(entries, 0, MaterialTableSize * sizeof(MaterialInfo));
-}
 
-MaterialInfoTable::~MaterialInfoTable() {
+        int v = Linear[pt1];
 
-  delete funcs;
+        for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2)
-  delete [] entries;
+            v +=  QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2]
-}
+                + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2];
 
-
+        bonus += pieceCount[Us][pt1] * v;
-/// MaterialInfoTable::game_phase() calculates the phase given the current
-/// position. Because the phase is strictly a function of the material, it
-/// is stored in MaterialInfo.
-
-Phase MaterialInfoTable::game_phase(const Position& pos) {
-
-  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
-
-  if (npm >= MidgameLimit)
-      return PHASE_MIDGAME;
-
-  if (npm <= EndgameLimit)
-      return PHASE_ENDGAME;
-
-  return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
-}
-
-/// MaterialInfoTable::get_material_info() takes a position object as input,
-/// computes or looks up a MaterialInfo object, and returns a pointer to it.
-/// If the material configuration is not already present in the table, it
-/// 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) {
-
-  Key key = pos.get_material_key();
-  unsigned index = unsigned(key & (MaterialTableSize - 1));
-  MaterialInfo* mi = entries + index;
-
-  // 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;
-
-  // Clear the MaterialInfo object, and set its key
-  memset(mi, 0, sizeof(MaterialInfo));
-  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
-  mi->key = key;
-
-  // Store game phase
-  mi->gamePhase = MaterialInfoTable::game_phase(pos);
-
-  // Let's look if we have a specialized evaluation function for this
-  // particular material configuration. First we look for a fixed
-  // configuration one, then a generic one if previous search failed.
-  if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
-      return mi;
-
-  if (is_KXK<WHITE>(pos) || is_KXK<BLACK>(pos))
-  {
-      mi->evaluationFunction = is_KXK<WHITE>(pos) ? &EvaluateKXK[WHITE] : &EvaluateKXK[BLACK];
-      return mi;
     }
 
-  if (   pos.pieces(PAWN)  == EmptyBoardBB
+    return bonus;
-      && pos.pieces(ROOK)  == EmptyBoardBB
-      && pos.pieces(QUEEN) == EmptyBoardBB)
-  {
-      // 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
+} // namespace
-  // material configuration. Is there a suitable scaling function?
-  //
-  // We face problems when there are several conflicting applicable
-  // scaling functions and we need to decide which one to use.
-  SF* sf;
 
-  if ((sf = funcs->get<SF>(key)) != NULL)
+namespace Material {
+
+/// Material::probe() looks up the current position's material configuration in
+/// the material hash table. It returns a pointer to the Entry if the position
+/// is found. Otherwise a new Entry is computed and stored there, so we don't
+/// have to recompute all when the same material configuration occurs again.
+
+Entry* probe(const Position& pos) {
+
+  Key key = pos.material_key();
+  Entry* e = pos.this_thread()->materialTable[key];
+
+  if (e->key == key)
+      return e;
+
+  std::memset(e, 0, sizeof(Entry));
+  e->key = key;
+  e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
+  e->gamePhase = pos.game_phase();
+
+  // Let's look if we have a specialized evaluation function for this particular
+  // material configuration. Firstly we look for a fixed configuration one, then
+  // for a generic one if the previous search failed.
+  if ((e->evaluationFunction = pos.this_thread()->endgames.probe<Value>(key)) != nullptr)
+      return e;
+
+  for (Color c = WHITE; c <= BLACK; ++c)
+      if (is_KXK(pos, c))
       {
-      mi->scalingFunction[sf->color()] = sf;
+          e->evaluationFunction = &EvaluateKXK[c];
-      return mi;
+          return e;
       }
 
-  // Generic scaling functions that refer to more then one material
+  // OK, we didn't find any special evaluation function for the current material
-  // distribution. Should be probed after the specialized ones.
+  // configuration. Is there a suitable specialized scaling function?
-  // Note that these ones don't return after setting the function.
+  EndgameBase<ScaleFactor>* sf;
-  if (is_KBPsK<WHITE>(pos))
-      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
 
-  if (is_KBPsK<BLACK>(pos))
+  if ((sf = pos.this_thread()->endgames.probe<ScaleFactor>(key)) != nullptr)
-      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
-
-  if (is_KQKRPs<WHITE>(pos))
-      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
-
-  else if (is_KQKRPs<BLACK>(pos))
-      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
-
-  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == VALUE_ZERO)
   {
-      if (pos.piece_count(BLACK, PAWN) == 0)
+      e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned
-      {
+      return e;
-          assert(pos.piece_count(WHITE, PAWN) >= 2);
-          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
   }
-      else if (pos.piece_count(WHITE, PAWN) == 0)
+
+  // We didn't find any specialized scaling function, so fall back on generic
+  // ones that refer to more than one material distribution. Note that in this
+  // case we don't return after setting the function.
+  for (Color c = WHITE; c <= BLACK; ++c)
   {
-          assert(pos.piece_count(BLACK, PAWN) >= 2);
+    if (is_KBPsKs(pos, c))
-          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+        e->scalingFunction[c] = &ScaleKBPsK[c];
+
+    else if (is_KQKRPs(pos, c))
+        e->scalingFunction[c] = &ScaleKQKRPs[c];
   }
-      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+
+  Value npm_w = pos.non_pawn_material(WHITE);
+  Value npm_b = pos.non_pawn_material(BLACK);
+
+  if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board
+  {
+      if (!pos.count<PAWN>(BLACK))
+      {
+          assert(pos.count<PAWN>(WHITE) >= 2);
+
+          e->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
+      }
+      else if (!pos.count<PAWN>(WHITE))
+      {
+          assert(pos.count<PAWN>(BLACK) >= 2);
+
+          e->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
+      }
+      else if (pos.count<PAWN>(WHITE) == 1 && pos.count<PAWN>(BLACK) == 1)
       {
           // This is a special case because we set scaling functions
           // for both colors instead of only one.
-          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          e->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
-          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
+          e->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
   }
 
-  // Compute the space weight
+  // Zero or just one pawn makes it difficult to win, even with a small material
-  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
+  // advantage. This catches some trivial draws like KK, KBK and KNK and gives a
-      2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
+  // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN).
-  {
+  if (!pos.count<PAWN>(WHITE) && npm_w - npm_b <= BishopValueMg)
-      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT)
+      e->factor[WHITE] = uint8_t(npm_w <  RookValueMg   ? SCALE_FACTOR_DRAW :
-                           + pos.piece_count(BLACK, KNIGHT)
+                                 npm_b <= BishopValueMg ? 4 : 14);
-                           + pos.piece_count(WHITE, BISHOP)
-                           + pos.piece_count(BLACK, BISHOP);
 
-      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  if (!pos.count<PAWN>(BLACK) && npm_b - npm_w <= BishopValueMg)
-  }
+      e->factor[BLACK] = uint8_t(npm_b <  RookValueMg   ? SCALE_FACTOR_DRAW :
+                                 npm_w <= BishopValueMg ? 4 : 14);
 
-  // Evaluate the material balance
+  if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)
-  const int pieceCount[2][8] = {
+      e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;
-  { 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) } };
 
-  Color c, them;
+  if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg)
-  int sign, pt1, pt2, pc;
+      e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN;
-  int v, vv, matValue = 0;
 
-  for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
+  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
-  {
+  // for the bishop pair "extended piece", which allows us to be more flexible
-    // No pawns makes it difficult to win, even with a material advantage
+  // in defining bishop pair bonuses.
-    if (   pos.piece_count(c, PAWN) == 0
+  const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = {
-        && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
+  { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
-    {
+    pos.count<BISHOP>(WHITE)    , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
-        if (   pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c))
+  { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
-            || pos.non_pawn_material(c) < RookValueMidgame)
+    pos.count<BISHOP>(BLACK)    , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
-            mi->factor[c] = 0;
-        else
-        {
-            switch (pos.piece_count(c, BISHOP)) {
-            case 2:
-                mi->factor[c] = 32;
-                break;
-            case 1:
-                mi->factor[c] = 12;
-                break;
-            case 0:
-                mi->factor[c] = 6;
-                break;
-            }
-        }
-    }
 
-    // Redundancy of major pieces, formula based on Kaufman's paper
+  e->value = int16_t((imbalance<WHITE>(PieceCount) - imbalance<BLACK>(PieceCount)) / 16);
-    // "The Evaluation of Material Imbalances in Chess"
+  return e;
-    // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    if (pieceCount[c][ROOK] >= 1)
-        matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty);
-
-    them = opposite_color(c);
-    v = 0;
-
-    // Second-degree polynomial material imbalance by Tord Romstad
-    //
-    // We use 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.
-    for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
-    {
-        pc = pieceCount[c][pt1];
-        if (!pc)
-            continue;
-
-        vv = LinearCoefficients[pt1];
-
-        for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
-            vv +=  pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2]
-                 + pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
-
-        v += pc * vv;
-    }
-    matValue += sign * v;
-  }
-  mi->value = (int16_t)(matValue / 16);
-  return mi;
 }
 
-
+} // namespace Material
-/// EndgameFunctions member definitions
-
-EndgameFunctions::EndgameFunctions() {
-
-  add<EvaluationFunction<KNNK>  >("KNNK");
-  add<EvaluationFunction<KPK>   >("KPK");
-  add<EvaluationFunction<KBNK>  >("KBNK");
-  add<EvaluationFunction<KRKP>  >("KRKP");
-  add<EvaluationFunction<KRKB>  >("KRKB");
-  add<EvaluationFunction<KRKN>  >("KRKN");
-  add<EvaluationFunction<KQKR>  >("KQKR");
-  add<EvaluationFunction<KBBKN> >("KBBKN");
-
-  add<ScalingFunction<KNPK>    >("KNPK");
-  add<ScalingFunction<KRPKR>   >("KRPKR");
-  add<ScalingFunction<KBPKB>   >("KBPKB");
-  add<ScalingFunction<KBPPKB>  >("KBPPKB");
-  add<ScalingFunction<KBPKN>   >("KBPKN");
-  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
-}
-
-EndgameFunctions::~EndgameFunctions() {
-
-    for (EFMap::const_iterator it = maps.first.begin(); it != maps.first.end(); ++it)
-        delete it->second;
-
-    for (SFMap::const_iterator it = maps.second.begin(); it != maps.second.end(); ++it)
-        delete it->second;
-}
-
-Key EndgameFunctions::buildKey(const string& keyCode) {
-
-    assert(keyCode.length() > 0 && keyCode.length() < 8);
-    assert(keyCode[0] == 'K');
-
-    string fen;
-    bool upcase = false;
-
-    // Build up a fen string with the given pieces, note that
-    // the fen string could be of an illegal position.
-    for (size_t i = 0; i < keyCode.length(); i++)
-    {
-        if (keyCode[i] == 'K')
-            upcase = !upcase;
-
-        fen += char(upcase ? toupper(keyCode[i]) : tolower(keyCode[i]));
-    }
-    fen += char(8 - keyCode.length() + '0');
-    fen += "/8/8/8/8/8/8/8 w - -";
-    return Position(fen, false, 0).get_material_key();
-}
-
-const string EndgameFunctions::swapColors(const string& keyCode) {
-
-    // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
-    size_t idx = keyCode.find('K', 1);
-    return keyCode.substr(idx) + keyCode.substr(0, idx);
-}
-
-template<class T>
-void EndgameFunctions::add(const string& keyCode) {
-
-  typedef typename T::Base F;
-  typedef map<Key, F*> M;
-
-  const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
-  const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
-}
-
-template<class T>
-T* EndgameFunctions::get(Key key) const {
-
-  typename map<Key, T*>::const_iterator it = get<T>().find(key);
-  return it != get<T>().end() ? it->second : NULL;
-}

src/material.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,146 +18,56 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef MATERIAL_H_INCLUDED
-#if !defined(MATERIAL_H_INCLUDED)
 #define MATERIAL_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "endgame.h"
+#include "misc.h"
 #include "position.h"
+#include "types.h"
 
+namespace Material {
 
-////
+/// Material::Entry contains various information about a material configuration.
-//// Types
+/// It contains a material imbalance 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.
-const int MaterialTableSize = 1024;
-
-/// MaterialInfo is a class which contains various information about a
-/// 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.
 ///
-/// The scale factors are used to scale the evaluation score up or down.
+/// The scale factors are used to scale the evaluation score up or down. For
-/// For instance, in KRB vs KR endgames, the score is scaled down by a factor
+/// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4,
-/// of 4, which will result in scores of absolute value less than one pawn.
+/// which will result in scores of absolute value less than one pawn.
 
-class MaterialInfo {
+struct Entry {
 
-  friend class MaterialInfoTable;
+  Score imbalance() const { return make_score(value, value); }
+  Phase game_phase() const { return gamePhase; }
+  bool specialized_eval_exists() const { return evaluationFunction != nullptr; }
+  Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); }
 
-public:
+  // scale_factor takes a position and a color as input and returns a scale factor
-  Score material_value() const;
+  // for the given color. We have to provide the position in addition to the color
-  ScaleFactor scale_factor(const Position& pos, Color c) const;
+  // because the scale factor may also be a function which should be applied to
-  int space_weight() const;
+  // the position. For instance, in KBP vs K endgames, the scaling function looks
-  Phase game_phase() const;
+  // for rook pawns and wrong-colored bishops.
-  bool specialized_eval_exists() const;
+  ScaleFactor scale_factor(const Position& pos, Color c) const {
-  Value evaluate(const Position& pos) const;
+    return   !scalingFunction[c]
+          || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE ? ScaleFactor(factor[c])
+                                                             : (*scalingFunction[c])(pos);
+  }
 
-private:
   Key key;
   int16_t value;
-  uint8_t factor[2];
+  uint8_t factor[COLOR_NB];
-  EndgameEvaluationFunctionBase* evaluationFunction;
+  EndgameBase<Value>* evaluationFunction;
-  EndgameScalingFunctionBase* scalingFunction[2];
+  EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each
-  int spaceWeight;
+                                                       // side (e.g. KPKP, KBPsKs)
   Phase gamePhase;
 };
 
-/// The MaterialInfoTable class represents a pawn hash table. It is basically
+typedef HashTable<Entry, 8192> Table;
-/// just an array of MaterialInfo objects and a few methods for accessing these
-/// objects. The most important method is get_material_info, which looks up a
-/// position in the table and returns a pointer to a MaterialInfo object.
-class EndgameFunctions;
 
-class MaterialInfoTable {
+Entry* probe(const Position& pos);
 
-  MaterialInfoTable(const MaterialInfoTable&);
+} // namespace Material
-  MaterialInfoTable& operator=(const MaterialInfoTable&);
 
-public:
+#endif // #ifndef MATERIAL_H_INCLUDED
-  MaterialInfoTable();
-  ~MaterialInfoTable();
-  MaterialInfo* get_material_info(const Position& pos);
-
-  static Phase game_phase(const Position& pos);
-
-private:
-  MaterialInfo* entries;
-  EndgameFunctions* funcs;
-};
-
-
-////
-//// Inline functions
-////
-
-
-/// MaterialInfo::material_value simply returns the material balance
-/// evaluation that is independent from game phase.
-
-inline Score MaterialInfo::material_value() const {
-
-  return make_score(value, value);
-}
-
-/// 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
-/// position in addition to the color, because the scale factor need not
-/// 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]);
-}
-
-
-/// MaterialInfo::space_weight() simply returns the weight for the space
-/// evaluation for this material configuration.
-
-inline int MaterialInfo::space_weight() const {
-
-  return spaceWeight;
-}
-
-/// MaterialInfo::game_phase() returns the game phase according
-/// to this material configuration.
-
-inline Phase MaterialInfo::game_phase() const {
-
-  return gamePhase;
-}
-
-
-/// MaterialInfo::specialized_eval_exists decides whether there is a
-/// specialized evaluation function for the current material configuration,
-/// or if the normal evaluation function should be used.
-
-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
-/// specialized_eval_exists() returns 'true'.
-
-inline Value MaterialInfo::evaluate(const Position& pos) const {
-
-  return evaluationFunction->apply(pos);
-}
-
-#endif // !defined(MATERIAL_H_INCLUDED)

src/misc.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,274 +18,170 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <fstream>
-////
-//// Includes
-////
-
-#if !defined(_MSC_VER)
-
-#  include <sys/time.h>
-#  include <sys/types.h>
-#  include <unistd.h>
-#  if defined(__hpux)
-#     include <sys/pstat.h>
-#  endif
-
-#else
-
-#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 this is left empty, the current date (in the format
+namespace {
-/// YYMMDD) is used as a version number.
 
-static const string EngineVersion = "2.0.1";
+/// Version number. If Version is left empty, then compile date in the format
-static const string AppName = "Stockfish";
+/// DD-MM-YY and show in engine_info.
-static const string AppTag  = "";
+const string Version = "7";
 
+/// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
+/// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
+/// can toggle the logging of std::cout and std:cin at runtime whilst preserving
+/// usual I/O functionality, all without changing a single line of code!
+/// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
 
-////
+struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
-//// Variables
-////
 
-static uint64_t dbg_cnt0 = 0;
+  Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
-static uint64_t dbg_cnt1 = 0;
 
-bool dbg_show_mean = false;
+  int sync() { return logBuf->pubsync(), buf->pubsync(); }
-bool dbg_show_hit_rate = false;
+  int overflow(int c) { return log(buf->sputc((char)c), "<< "); }
+  int underflow() { return buf->sgetc(); }
+  int uflow() { return log(buf->sbumpc(), ">> "); }
 
+  streambuf *buf, *logBuf;
 
-////
+  int log(int c, const char* prefix) {
-//// Functions
-////
 
-void dbg_hit_on(bool b) {
+    static int last = '\n'; // Single log file
 
-    assert(!dbg_show_mean);
+    if (last == '\n')
-    dbg_show_hit_rate = true;
+        logBuf->sputn(prefix, 3);
-    dbg_cnt0++;
-    if (b)
-        dbg_cnt1++;
-}
 
-void dbg_hit_on_c(bool c, bool b) {
+    return last = logBuf->sputc((char)c);
+  }
+};
 
-    if (c)
+class Logger {
-        dbg_hit_on(b);
-}
 
-void dbg_before() {
+  Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
+ ~Logger() { start(false); }
 
-    assert(!dbg_show_mean);
+  ofstream file;
-    dbg_show_hit_rate = true;
+  Tie in, out;
-    dbg_cnt0++;
-}
 
-void dbg_after() {
+public:
+  static void start(bool b) {
 
-    assert(!dbg_show_mean);
+    static Logger l;
-    dbg_show_hit_rate = true;
-    dbg_cnt1++;
-}
 
-void dbg_mean_of(int v) {
+    if (b && !l.file.is_open())
+    {
+        l.file.open("io_log.txt", ifstream::out);
+        cin.rdbuf(&l.in);
+        cout.rdbuf(&l.out);
+    }
+    else if (!b && l.file.is_open())
+    {
+        cout.rdbuf(l.out.buf);
+        cin.rdbuf(l.in.buf);
+        l.file.close();
+    }
+  }
+};
 
-    assert(!dbg_show_hit_rate);
+} // namespace
-    dbg_show_mean = true;
-    dbg_cnt0++;
-    dbg_cnt1 += v;
-}
 
-void dbg_print_hit_rate() {
+/// engine_info() returns the full name of the current Stockfish version. This
+/// will be either "Stockfish <Tag> DD-MM-YY" (where DD-MM-YY is the date when
+/// the program was compiled) or "Stockfish <Version>", depending on whether
+/// Version is empty.
 
-  cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+const string engine_info(bool to_uci) {
-       << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
-}
-
-void dbg_print_mean() {
-
-  cout << "Total " << dbg_cnt0 << " Mean "
-       << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
-}
-
-
-/// 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 (defined in misc.h) 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;
+  stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008"
 
+  ss << "Stockfish " << Version << setfill('0');
+
+  if (Version.empty())
+  {
       date >> month >> day >> year;
+      ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2);
+  }
 
-  s << setfill('0') << AppName + " " + AppTag + " "
+  ss << (Is64Bit ? " 64" : "")
-    << year.substr(2, 2) << setw(2)
+     << (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : ""))
-    << (1 + months.find(month) / 4) << setw(2)
+     << (to_uci  ? "\nid author ": " by ")
-    << day << cpu64;
+     << "T. Romstad, M. Costalba, J. Kiiski, G. Linscott";
 
-  return s.str();
+  return ss.str();
 }
 
 
-/// get_system_time() returns the current system time, measured in
+/// Debug functions used mainly to collect run-time statistics
-/// milliseconds.
+static int64_t hits[2], means[2];
 
-int get_system_time() {
+void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
+void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
+void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
+
+void dbg_print() {
+
+  if (hits[0])
+      cerr << "Total " << hits[0] << " Hits " << hits[1]
+           << " hit rate (%) " << 100 * hits[1] / hits[0] << endl;
+
+  if (means[0])
+      cerr << "Total " << means[0] << " Mean "
+           << (double)means[1] / means[0] << endl;
+}
+
+
+/// Used to serialize access to std::cout to avoid multiple threads writing at
+/// the same time.
+
+std::ostream& operator<<(std::ostream& os, SyncCout sc) {
+
+  static Mutex m;
+
+  if (sc == IO_LOCK)
+      m.lock();
+
+  if (sc == IO_UNLOCK)
+      m.unlock();
+
+  return os;
+}
+
+
+/// Trampoline helper to avoid moving Logger to misc.h
+void start_logger(bool b) { Logger::start(b); }
+
+
+/// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
+/// function that doesn't stall the CPU waiting for data to be loaded from memory,
+/// which can be quite slow.
+#ifdef NO_PREFETCH
+
+void prefetch(void*) {}
 
-#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
-}
 
+void prefetch(void* addr) {
 
-/// cpu_count() tries to detect the number of CPU cores.
+#  if defined(__INTEL_COMPILER)
-
+   // This hack prevents prefetches from being optimized away by
-#if !defined(_MSC_VER)
+   // Intel compiler. Both MSVC and gcc seem not be affected by this.
-
+   __asm__ ("");
-#  if defined(_SC_NPROCESSORS_ONLN)
-int cpu_count() {
-  return Min(sysconf(_SC_NPROCESSORS_ONLN), MAX_THREADS);
-}
-#  elif defined(__hpux)
-int cpu_count() {
-  struct pst_dynamic psd;
-  if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) == -1)
-      return 1;
-
-  return Min(psd.psd_proc_cnt, MAX_THREADS);
-}
-#  else
-int cpu_count() {
-  return 1;
-}
 #  endif
 
-#else
+#  if defined(__INTEL_COMPILER) || defined(_MSC_VER)
-
+  _mm_prefetch((char*)addr, _MM_HINT_T0);
-int cpu_count() {
+#  else
-  SYSTEM_INFO s;
+  __builtin_prefetch(addr);
-  GetSystemInfo(&s);
+#  endif
-  return Min(s.dwNumberOfProcessors, MAX_THREADS);
 }
 
 #endif
-
-
-/// Check for console input. Original code from Beowulf and Olithink
-
-#ifndef _WIN32
-
-int data_available()
-{
-  fd_set readfds;
-  struct timeval  timeout;
-
-  FD_ZERO(&readfds);
-  FD_SET(fileno(stdin), &readfds);
-  timeout.tv_sec = 0; // Set to timeout immediately
-  timeout.tv_usec = 0;
-  select(16, &readfds, 0, 0, &timeout);
-
-  return (FD_ISSET(fileno(stdin), &readfds));
-}
-
-#else
-
-int data_available()
-{
-    static HANDLE inh = NULL;
-    static bool usePipe;
-    INPUT_RECORD rec[256];
-    DWORD dw, recCnt;
-
-    if (!inh)
-    {
-        inh = GetStdHandle(STD_INPUT_HANDLE);
-        usePipe = !GetConsoleMode(inh, &dw);
-        if (!usePipe)
-        {
-            SetConsoleMode(inh, dw & ~(ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT));
-            FlushConsoleInputBuffer(inh);
-        }
-    }
-
-    // If we're running under XBoard then we can't use PeekConsoleInput() as
-    // the input commands are sent to us directly over the internal pipe.
-    if (usePipe)
-        return PeekNamedPipe(inh, NULL, 0, NULL, &dw, NULL) ? dw : 1;
-
-    // Count the number of unread input records, including keyboard,
-    // mouse, and window-resizing input records.
-    GetNumberOfConsoleInputEvents(inh, &dw);
-
-    // Read data from console without removing it from the buffer
-    if (dw <= 0 || !PeekConsoleInput(inh, rec, Min(dw, 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 RAM, that can be very slow.
-#if defined(NO_PREFETCH)
-void prefetch(char*) {}
-#else
-
-void prefetch(char* addr) {
-
-#if defined(__INTEL_COMPILER) || defined(__ICL)
-   // This hack prevents prefetches to be optimized away by
-   // Intel compiler. Both MSVC and gcc seems not affected.
-   __asm__ ("");
-#endif
-
-  _mm_prefetch(addr, _MM_HINT_T2);
-  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
-}
-
-#endif
-

src/misc.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,53 +18,83 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef MISC_H_INCLUDED
-#if !defined(MISC_H_INCLUDED)
 #define MISC_H_INCLUDED
 
-
+#include <cassert>
-////
+#include <chrono>
-//// Includes
+#include <ostream>
-////
-
-#include <fstream>
 #include <string>
+#include <vector>
 
 #include "types.h"
 
-////
+const std::string engine_info(bool to_uci = false);
-//// Macros
+void prefetch(void* addr);
-////
+void start_logger(bool b);
 
-#define Min(x, y) (((x) < (y))? (x) : (y))
+void dbg_hit_on(bool b);
-#define Max(x, y) (((x) < (y))? (y) : (x))
+void dbg_hit_on(bool c, bool b);
+void dbg_mean_of(int v);
+void dbg_print();
+
+typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
+
+inline TimePoint now() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>
+        (std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+template<class Entry, int Size>
+struct HashTable {
+  Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
+
+private:
+  std::vector<Entry> table = std::vector<Entry>(Size);
+};
 
 
-////
+enum SyncCout { IO_LOCK, IO_UNLOCK };
-//// Prototypes
+std::ostream& operator<<(std::ostream&, SyncCout);
-////
 
-extern const std::string engine_name();
+#define sync_cout std::cout << IO_LOCK
-extern int get_system_time();
+#define sync_endl std::endl << IO_UNLOCK
-extern int cpu_count();
-extern int data_available();
-extern void prefetch(char* addr);
-extern void prefetchPawn(Key, int);
 
 
-////
+/// xorshift64star Pseudo-Random Number Generator
-//// Debug
+/// This class is based on original code written and dedicated
-////
+/// to the public domain by Sebastiano Vigna (2014).
+/// It has the following characteristics:
+///
+///  -  Outputs 64-bit numbers
+///  -  Passes Dieharder and SmallCrush test batteries
+///  -  Does not require warm-up, no zeroland to escape
+///  -  Internal state is a single 64-bit integer
+///  -  Period is 2^64 - 1
+///  -  Speed: 1.60 ns/call (Core i7 @3.40GHz)
+///
+/// For further analysis see
+///   <http://vigna.di.unimi.it/ftp/papers/xorshift.pdf>
 
-extern bool dbg_show_mean;
+class PRNG {
-extern bool dbg_show_hit_rate;
 
-extern void dbg_hit_on(bool b);
+  uint64_t s;
-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)
+  uint64_t rand64() {
+
+    s ^= s >> 12, s ^= s << 25, s ^= s >> 27;
+    return s * 2685821657736338717LL;
+  }
+
+public:
+  PRNG(uint64_t seed) : s(seed) { assert(seed); }
+
+  template<typename T> T rand() { return T(rand64()); }
+
+  /// Special generator used to fast init magic numbers.
+  /// Output values only have 1/8th of their bits set on average.
+  template<typename T> T sparse_rand()
+  { return T(rand64() & rand64() & rand64()); }
+};
+
+#endif // #ifndef MISC_H_INCLUDED

src/move.cpp

@@ -1,152 +0,0 @@
-/*
-  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/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cctype>
-
-#include "move.h"
-#include "piece.h"
-#include "position.h"
-
-
-////
-//// Functions
-////
-
-/// move_from_uci() 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_uci(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 = make_square(file_from_char(str[0]), rank_from_char(str[1]));
-  to   = make_square(file_from_char(str[2]), rank_from_char(str[3]));
-
-  // 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 (str.length() > 4 && piece == piece_of_color_and_type(us, PAWN))
-  {
-      switch (tolower(str[4])) {
-      case 'n':
-          return make_promotion_move(from, to, KNIGHT);
-      case 'b':
-          return make_promotion_move(from, to, BISHOP);
-      case 'r':
-          return make_promotion_move(from, to, ROOK);
-      case 'q':
-          return make_promotion_move(from, to, QUEEN);
-      }
-  }
-
-  // En passant move? We assume that a pawn move is an en passant move
-  // if the destination square is epSquare.
-  if (to == pos.ep_square() && piece == piece_of_color_and_type(us, PAWN))
-      return make_ep_move(from, to);
-
-  // 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 (piece == piece_of_color_and_type(us, KING))
-  {
-      if (pos.piece_on(to) == piece_of_color_and_type(us, ROOK))
-          return make_castle_move(from, to);
-
-      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 = from;
-
-          do s += delta;
-          while (   pos.piece_on(s) != piece_of_color_and_type(us, ROOK)
-                 && relative_rank(us, s) == RANK_1);
-
-          return relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE;
-      }
-  }
-
-  return make_move(from, to);
-}
-
-
-/// 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_uci(Move move, bool chess960) {
-
-  std::string str;
-  Square from = move_from(move);
-  Square to = move_to(move);
-
-  if (move == MOVE_NONE)
-      str = "(none)";
-  else if (move == MOVE_NULL)
-      str = "0000";
-  else
-  {
-      if (move_is_short_castle(move) && !chess960)
-          return (from == SQ_E1 ? "e1g1" : "e8g8");
-
-      if (move_is_long_castle(move) && !chess960)
-          return (from == SQ_E1 ? "e1c1" : "e8c8");
-
-      str = square_to_string(from) + square_to_string(to);
-      if (move_is_promotion(move))
-          str += char(tolower(piece_type_to_char(move_promotion_piece(move))));
-  }
-  return str;
-}
-
-
-/// Overload the << operator, to make it easier to print moves.
-
-std::ostream& operator << (std::ostream& os, Move m) {
-
-  bool chess960 = (os.iword(0) != 0); // See set960()
-  return os << move_to_uci(m, chess960);
-}
-
-
-/// move_is_ok(), for debugging.
-
-bool move_is_ok(Move m) {
-
-  return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
-}

src/move.h

@@ -1,211 +0,0 @@
-/*
-  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(MOVE_H_INCLUDED)
-#define MOVE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <iostream>
-
-#include "misc.h"
-#include "piece.h"
-#include "square.h"
-
-// Maximum number of allowed moves per position
-const int MOVES_MAX = 256;
-
-////
-//// Types
-////
-
-class Position;
-
-/// A move needs 17 bits to be stored
-///
-/// bit  0- 5: destination square (from 0 to 63)
-/// bit  6-11: origin square (from 0 to 63)
-/// bit 12-14: promotion piece type
-/// bit    15: en passant flag
-/// bit    16: castle flag
-///
-/// 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
-};
-
-
-struct MoveStack {
-  Move move;
-  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) & 0x3F);
-}
-
-inline Square move_to(Move m) {
-  return Square(m & 0x3F);
-}
-
-inline PieceType move_promotion_piece(Move m) {
-  return PieceType((int(m) >> 12) & 7);
-}
-
-inline int move_is_special(Move m) {
-  return m & (0x1F << 12);
-}
-
-inline int move_is_promotion(Move m) {
-  return m & (7 << 12);
-}
-
-inline int move_is_ep(Move m) {
-  return m & (1 << 15);
-}
-
-inline int move_is_castle(Move m) {
-  return m & (1 << 16);
-}
-
-inline bool move_is_short_castle(Move m) {
-  return move_is_castle(m) && (move_to(m) > move_from(m));
-}
-
-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 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_ep_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (1 << 15));
-}
-
-
-////
-//// Prototypes
-////
-
-extern std::ostream& operator<<(std::ostream& os, Move m);
-extern Move move_from_uci(const Position& pos, const std::string &str);
-extern const std::string move_to_uci(Move m, bool chess960);
-extern bool move_is_ok(Move m);
-
-
-#endif // !defined(MOVE_H_INCLUDED)

src/movegen.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,29 +18,53 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef MOVEGEN_H_INCLUDED
-#if !defined(MOVEGEN_H_INCLUDED)
 #define MOVEGEN_H_INCLUDED
 
-////
+#include "types.h"
-//// Includes
-////
 
-#include "position.h"
+class Position;
 
+enum GenType {
+  CAPTURES,
+  QUIETS,
+  QUIET_CHECKS,
+  EVASIONS,
+  NON_EVASIONS,
+  LEGAL
+};
 
-////
+struct ExtMove {
-//// Prototypes
+  Move move;
-////
+  Value value;
 
-extern MoveStack* generate_captures(const Position& pos, MoveStack* mlist);
+  operator Move() const { return move; }
-extern MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist);
+  void operator=(Move m) { move = m; }
-extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist);
+};
-extern MoveStack* generate_evasions(const Position& pos, MoveStack* mlist);
-extern MoveStack* generate_non_evasions(const Position& pos, MoveStack* mlist);
-extern MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLegal = false);
-extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
-extern bool move_is_legal(const Position& pos, const Move m);
 
+inline bool operator<(const ExtMove& f, const ExtMove& s) {
+  return f.value < s.value;
+}
 
-#endif // !defined(MOVEGEN_H_INCLUDED)
+template<GenType>
+ExtMove* generate(const Position& pos, ExtMove* moveList);
+
+/// The MoveList struct is a simple wrapper around generate(). It sometimes comes
+/// in handy to use this class instead of the low level generate() function.
+template<GenType T>
+struct MoveList {
+
+  explicit MoveList(const Position& pos) : last(generate<T>(pos, moveList)) {}
+  const ExtMove* begin() const { return moveList; }
+  const ExtMove* end() const { return last; }
+  size_t size() const { return last - moveList; }
+  bool contains(Move move) const {
+    for (const auto& m : *this) if (m == move) return true;
+    return false;
+  }
+
+private:
+  ExtMove moveList[MAX_MOVES], *last;
+};
+
+#endif // #ifndef MOVEGEN_H_INCLUDED

src/movepick.cpp

@@ -1,14 +1,14 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -18,340 +18,301 @@
   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 "thread.h"
-#include "value.h"
-
-
-////
-//// Local definitions
-////
 
 namespace {
 
-  enum MovegenPhase {
+  enum Stages {
-    PH_TT_MOVES,       // Transposition table move and mate killer
+    MAIN_SEARCH, GOOD_CAPTURES, KILLERS, GOOD_QUIETS, BAD_QUIETS, BAD_CAPTURES,
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
+    EVASION, ALL_EVASIONS,
-    PH_KILLERS,        // Killer moves from the current ply
+    QSEARCH_WITH_CHECKS, QCAPTURES_1, CHECKS,
-    PH_NONCAPTURES,    // Non-captures and underpromotions
+    QSEARCH_WITHOUT_CHECKS, QCAPTURES_2,
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
+    PROBCUT, PROBCUT_CAPTURES,
-    PH_EVASIONS,       // Check evasions
+    RECAPTURE, RECAPTURES,
-    PH_QCAPTURES,      // Captures in quiescence search
+    STOP
-    PH_QCHECKS,        // Non-capture checks in quiescence search
-    PH_STOP
   };
 
-  CACHE_LINE_ALIGNMENT
+  // Our insertion sort, which is guaranteed to be stable, as it should be
-  const uint8_t MainSearchPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP};
+  void insertion_sort(ExtMove* begin, ExtMove* end)
-  const uint8_t EvasionsPhaseTable[] = { PH_TT_MOVES, PH_EVASIONS, PH_STOP};
+  {
-  const uint8_t QsearchWithChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP};
+    ExtMove tmp, *p, *q;
-  const uint8_t QsearchWithoutChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP};
+
+    for (p = begin + 1; p < end; ++p)
+    {
+        tmp = *p;
+        for (q = p; q != begin && *(q-1) < tmp; --q)
+            *q = *(q-1);
+        *q = tmp;
+    }
+  }
+
+  // pick_best() finds the best move in the range (begin, end) and moves it to
+  // the front. It's faster than sorting all the moves in advance when there
+  // are few moves e.g. the possible captures.
+  Move pick_best(ExtMove* begin, ExtMove* end)
+  {
+      std::swap(*begin, *std::max_element(begin, end));
+      return *begin;
+  }
+
+} // namespace
+
+
+/// Constructors of the MovePicker class. As arguments we pass 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 how important good move
+/// ordering is at the current node.
+
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h,
+                       const CounterMovesStats& cmh, Move cm, Search::Stack* s)
+           : pos(p), history(h), counterMovesHistory(&cmh), ss(s), countermove(cm), depth(d) {
+
+  assert(d > DEPTH_ZERO);
+
+  stage = pos.checkers() ? EVASION : MAIN_SEARCH;
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
+  endMoves += (ttMove != MOVE_NONE);
 }
 
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
+                       const HistoryStats& h, Square s)
+           : pos(p), history(h), counterMovesHistory(nullptr) {
 
-////
+  assert(d <= DEPTH_ZERO);
-//// Functions
-////
 
+  if (pos.checkers())
+      stage = EVASION;
 
-/// Constructor for the MovePicker class. Apart from the position for which
+  else if (d > DEPTH_QS_NO_CHECKS)
-/// it is asked to pick legal moves, MovePicker also wants some information
+      stage = QSEARCH_WITH_CHECKS;
-/// 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(const Position& p, Move ttm, Depth d, const History& h,
+  else if (d > DEPTH_QS_RECAPTURES)
-                       SearchStack* ss, Value beta) : pos(p), H(h) {
+      stage = QSEARCH_WITHOUT_CHECKS;
-  int searchTT = ttm;
-  ttMoves[0].move = ttm;
-  badCaptureThreshold = 0;
-  badCaptures = moves + MOVES_MAX;
 
-  pinned = p.pinned_pieces(pos.side_to_move());
-
-  if (ss && !p.is_check())
-  {
-      ttMoves[1].move = (ss->mateKiller == ttm) ? MOVE_NONE : ss->mateKiller;
-      searchTT |= ttMoves[1].move;
-      killers[0].move = ss->killers[0];
-      killers[1].move = ss->killers[1];
-  } else
-      ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
-
-  if (p.is_check())
-      phasePtr = EvasionsPhaseTable;
-  else if (d > DEPTH_ZERO)
-  {
-      // 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;
-
-      phasePtr = MainSearchPhaseTable;
-  }
-  else if (d >= DEPTH_QS_CHECKS)
-      phasePtr = QsearchWithChecksPhaseTable;
   else
   {
-      phasePtr = QsearchWithoutChecksPhaseTable;
+      stage = RECAPTURE;
-
+      recaptureSquare = s;
-      // Skip TT move if is not a capture or a promotion, this avoids
+      ttm = MOVE_NONE;
-      // 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;
+  ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
-  go_next_phase();
+  endMoves += (ttMove != MOVE_NONE);
+}
+
+MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, Value th)
+           : pos(p), history(h), counterMovesHistory(nullptr), threshold(th) {
+
+  assert(!pos.checkers());
+
+  stage = PROBCUT;
+
+  // In ProbCut we generate captures with SEE higher than the given threshold
+  ttMove =   ttm
+          && pos.pseudo_legal(ttm)
+          && pos.capture(ttm)
+          && pos.see(ttm) > threshold ? ttm : MOVE_NONE;
+
+  endMoves += (ttMove != MOVE_NONE);
 }
 
 
-/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
+/// score() assigns a numerical value to each move in a move list. The moves with
-/// of moves when there are no more moves to try for the current phase.
+/// highest values will be picked first.
+template<>
+void MovePicker::score<CAPTURES>() {
+  // Winning and equal captures in the main search are ordered by MVV, preferring
+  // captures near our home rank. Surprisingly, this appears to perform slightly
+  // better than SEE based move ordering: exchanging big pieces before capturing
+  // a hanging piece probably helps to reduce the subtree size.
+  // In main search we want to push captures with negative SEE values to the
+  // badCaptures[] array, but instead of doing it now we delay until the move
+  // has been picked up, saving some SEE calls in case we get a cutoff.
+  for (auto& m : *this)
+      m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
+               - Value(200 * relative_rank(pos.side_to_move(), to_sq(m)));
+}
 
-void MovePicker::go_next_phase() {
+template<>
+void MovePicker::score<QUIETS>() {
 
-  curMove = moves;
+  for (auto& m : *this)
-  phase = *(++phasePtr);
+      m.value =  history[pos.moved_piece(m)][to_sq(m)]
-  switch (phase) {
+               + (*counterMovesHistory)[pos.moved_piece(m)][to_sq(m)];
+}
 
-  case PH_TT_MOVES:
+template<>
-      curMove = ttMoves;
+void MovePicker::score<EVASIONS>() {
-      lastMove = curMove + 2;
+  // Try winning and equal captures captures ordered by MVV/LVA, then non-captures
-      return;
+  // ordered by history value, then bad-captures and quiet moves with a negative
+  // SEE ordered by SEE value.
+  Value see;
 
-  case PH_GOOD_CAPTURES:
+  for (auto& m : *this)
-      lastMove = generate_captures(pos, moves);
+      if ((see = pos.see_sign(m)) < VALUE_ZERO)
-      score_captures();
+          m.value = see - HistoryStats::Max; // At the bottom
-      return;
 
-  case PH_KILLERS:
+      else if (pos.capture(m))
-      curMove = killers;
+          m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-      lastMove = curMove + 2;
+                   - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max;
-      return;
+      else
+          m.value = history[pos.moved_piece(m)][to_sq(m)];
+}
 
-  case PH_NONCAPTURES:
-      lastMove = generate_noncaptures(pos, moves);
-      score_noncaptures();
-      sort_moves(moves, lastMove, &lastGoodNonCapture);
-      return;
 
-  case PH_BAD_CAPTURES:
+/// generate_next_stage() generates, scores and sorts the next bunch of moves,
-      // Bad captures SEE value is already calculated so just pick
+/// when there are no more moves to try for the current stage.
-      // them in order to get SEE move ordering.
-      curMove = badCaptures;
-      lastMove = moves + MOVES_MAX;
-      return;
 
-  case PH_EVASIONS:
+void MovePicker::generate_next_stage() {
-      assert(pos.is_check());
-      lastMove = generate_evasions(pos, moves);
-      score_evasions();
-      return;
 
-  case PH_QCAPTURES:
+  assert(stage != STOP);
-      lastMove = generate_captures(pos, moves);
-      score_captures();
-      return;
 
-  case PH_QCHECKS:
+  cur = moves;
-      lastMove = generate_non_capture_checks(pos, moves);
-      return;
 
-  case PH_STOP:
+  switch (++stage) {
-      lastMove = curMove + 1; // Avoids another go_next_phase() call
+
-      return;
+  case GOOD_CAPTURES: case QCAPTURES_1: case QCAPTURES_2:
+  case PROBCUT_CAPTURES: case RECAPTURES:
+      endMoves = generate<CAPTURES>(pos, moves);
+      score<CAPTURES>();
+      break;
+
+  case KILLERS:
+      killers[0] = ss->killers[0];
+      killers[1] = ss->killers[1];
+      killers[2] = countermove;
+      cur = killers;
+      endMoves = cur + 2 + (countermove != killers[0] && countermove != killers[1]);
+      break;
+
+  case GOOD_QUIETS:
+      endQuiets = endMoves = generate<QUIETS>(pos, moves);
+      score<QUIETS>();
+      endMoves = std::partition(cur, endMoves, [](const ExtMove& m) { return m.value > VALUE_ZERO; });
+      insertion_sort(cur, endMoves);
+      break;
+
+  case BAD_QUIETS:
+      cur = endMoves;
+      endMoves = endQuiets;
+      if (depth >= 3 * ONE_PLY)
+          insertion_sort(cur, endMoves);
+      break;
+
+  case BAD_CAPTURES:
+      // Just pick them in reverse order to get correct ordering
+      cur = moves + MAX_MOVES - 1;
+      endMoves = endBadCaptures;
+      break;
+
+  case ALL_EVASIONS:
+      endMoves = generate<EVASIONS>(pos, moves);
+      if (endMoves - moves > 1)
+          score<EVASIONS>();
+      break;
+
+  case CHECKS:
+      endMoves = generate<QUIET_CHECKS>(pos, moves);
+      break;
+
+  case EVASION: case QSEARCH_WITH_CHECKS: case QSEARCH_WITHOUT_CHECKS:
+  case PROBCUT: case RECAPTURE: case STOP:
+      stage = STOP;
+      break;
 
   default:
       assert(false);
-      return;
   }
 }
 
 
-/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
+/// next_move() is the most important method of the MovePicker class. It returns
-/// MovePicker::score_evasions() assign a numerical move ordering score
+/// a new pseudo legal move every time it is called, until there are no more moves
-/// to each move in a move list.  The moves with highest scores will be
+/// left. It picks the move with the biggest value from a list of generated moves
-/// picked first by get_next_move().
+/// taking care not to return the ttMove if it has already been searched.
 
-void MovePicker::score_captures() {
+Move MovePicker::next_move() {
-  // Winning and equal captures in the main search are ordered by MVV/LVA.
-  // Suprisingly, this appears to perform slightly better than SEE based
-  // move ordering. The reason is probably that in a position with a winning
-  // capture, capturing a more valuable (but sufficiently defended) piece
-  // first usually doesn't hurt. The opponent will have to recapture, and
-  // the hanging piece will still be hanging (except in the unusual cases
-  // where it is possible to recapture with the hanging piece). Exchanging
-  // big pieces before capturing a hanging piece probably helps to reduce
-  // the subtree size.
-  // In main search we want to push captures with negative SEE values to
-  // badCaptures[] array, but instead of doing it now we delay till when
-  // the move has been picked up in pick_move_from_list(), this way we save
-  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
-  Move m;
-
-  // Use MVV/LVA ordering
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
-  {
-      m = cur->move;
-      if (move_is_promotion(m))
-          cur->score = QueenValueMidgame;
-      else
-          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
-                      - pos.type_of_piece_on(move_from(m));
-  }
-}
-
-void MovePicker::score_noncaptures() {
-  // First score by history, when no history is available then use
-  // piece/square tables values. This seems to be better then a
-  // random choice when we don't have an history for any move.
-  Move m;
-  Piece piece;
-  Square from, to;
-
-  for (MoveStack* cur = moves; cur != lastMove; cur++)
-  {
-      m = cur->move;
-      from = move_from(m);
-      to = move_to(m);
-      piece = pos.piece_on(from);
-      cur->score = H.value(piece, to) + H.gain(piece, to);
-  }
-}
-
-void MovePicker::score_evasions() {
-  // Try good captures ordered by MVV/LVA, then non-captures if
-  // destination square is not under attack, ordered by history
-  // value, and at the end bad-captures and non-captures with a
-  // negative SEE. This last group is ordered by the SEE score.
-  Move m;
-  int seeScore;
-
-  // 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 - HistoryMax; // Be sure are at the bottom
-      else if (pos.move_is_capture(m))
-          cur->score =  pos.midgame_value_of_piece_on(move_to(m))
-                      - pos.type_of_piece_on(move_from(m)) + HistoryMax;
-      else
-          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
-  }
-}
-
-/// MovePicker::get_next_move() is the most important method of the MovePicker
-/// class. It returns a new legal move every time it is called, until there
-/// are no more moves left.
-/// 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() {
 
   Move move;
 
   while (true)
   {
-      while (curMove != lastMove)
+      while (cur == endMoves && stage != STOP)
-      {
+          generate_next_stage();
-          switch (phase) {
 
-          case PH_TT_MOVES:
+      switch (stage) {
-              move = (curMove++)->move;
-              if (   move != MOVE_NONE
-                  && move_is_legal(pos, move, pinned))
-                  return move;
-              break;
 
-          case PH_GOOD_CAPTURES:
+      case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS:
-              move = pick_best(curMove++, lastMove).move;
+      case QSEARCH_WITHOUT_CHECKS: case PROBCUT:
-              if (   move != ttMoves[0].move
+          ++cur;
-                  && move != ttMoves[1].move
+          return ttMove;
-                  && pos.pl_move_is_legal(move, pinned))
+
+      case GOOD_CAPTURES:
+          move = pick_best(cur++, endMoves);
+          if (move != ttMove)
           {
-                  // Check for a non negative SEE now
+              if (pos.see_sign(move) >= VALUE_ZERO)
-                  int seeValue = pos.see_sign(move);
-                  if (seeValue >= badCaptureThreshold)
                   return move;
 
-                  // Losing capture, move it to the tail of the array, note
+              // Losing capture, move it to the tail of the array
-                  // that move has now been already checked for legality.
+              *endBadCaptures-- = move;
-                  (--badCaptures)->move = move;
-                  badCaptures->score = seeValue;
           }
           break;
 
-          case PH_KILLERS:
+      case KILLERS:
-              move = (curMove++)->move;
+          move = *cur++;
           if (    move != MOVE_NONE
-                  && move_is_legal(pos, move, pinned)
+              &&  move != ttMove
-                  && move != ttMoves[0].move
+              &&  pos.pseudo_legal(move)
-                  && move != ttMoves[1].move
+              && !pos.capture(move))
-                  && !pos.move_is_capture(move))
               return move;
           break;
 
-          case PH_NONCAPTURES:
+      case GOOD_QUIETS: case BAD_QUIETS:
-
+          move = *cur++;
-              // Sort negative scored moves only when we get there
+          if (   move != ttMove
-              if (curMove == lastGoodNonCapture)
+              && move != killers[0]
-                  insertion_sort<MoveStack>(lastGoodNonCapture, lastMove);
+              && move != killers[1]
-
+              && move != killers[2])
-              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:
+      case BAD_CAPTURES:
-              move = pick_best(curMove++, lastMove).move;
+          return *cur--;
-              return move;
 
-          case PH_EVASIONS:
+      case ALL_EVASIONS: case QCAPTURES_1: case QCAPTURES_2:
-          case PH_QCAPTURES:
+          move = pick_best(cur++, endMoves);
-              move = pick_best(curMove++, lastMove).move;
+          if (move != ttMove)
-              if (   move != ttMoves[0].move
-                  && pos.pl_move_is_legal(move, pinned))
               return move;
           break;
 
-          case PH_QCHECKS:
+      case PROBCUT_CAPTURES:
-              move = (curMove++)->move;
+           move = pick_best(cur++, endMoves);
-              if (   move != ttMoves[0].move
+           if (move != ttMove && pos.see(move) > threshold)
-                  && pos.pl_move_is_legal(move, pinned))
                return move;
            break;
 
-          case PH_STOP:
+      case RECAPTURES:
+          move = pick_best(cur++, endMoves);
+          if (to_sq(move) == recaptureSquare)
+              return move;
+          break;
+
+      case CHECKS:
+          move = *cur++;
+          if (move != ttMove)
+              return move;
+          break;
+
+      case STOP:
           return MOVE_NONE;
 
       default:
           assert(false);
-              break;
       }
   }
-      go_next_phase();
-  }
 }
-

src/movepick.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,71 +18,96 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef MOVEPICK_H_INCLUDED
-#if !defined MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED
 
-////
+#include <algorithm> // For std::max
-//// Includes
+#include <cstring>   // For std::memset
-////
 
-#include "depth.h"
+#include "movegen.h"
-#include "history.h"
 #include "position.h"
+#include "search.h"
+#include "types.h"
 
 
-////
+/// The Stats struct stores moves statistics. According to the template parameter
-//// Types
+/// the class can store History and Countermoves. History records how often
-////
+/// different moves have been successful or unsuccessful during the current search
+/// and is used for reduction and move ordering decisions.
+/// Countermoves store the move that refute a previous one. Entries are stored
+/// using only the moving piece and destination square, hence two moves with
+/// different origin but same destination and piece will be considered identical.
+template<typename T, bool CM = false>
+struct Stats {
 
-struct SearchStack;
+  static const Value Max = Value(1 << 28);
 
-/// MovePicker is a class which is used to pick one legal move at a time from
+  const T* operator[](Piece pc) const { return table[pc]; }
-/// the current position. It is initialized with a Position object and a few
+  T* operator[](Piece pc) { return table[pc]; }
-/// moves we have reason to believe are good. The most important method is
+  void clear() { std::memset(table, 0, sizeof(table)); }
-/// MovePicker::pick_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.
 
-class MovePicker {
+  void update(Piece pc, Square to, Move m) {
 
-  MovePicker& operator=(const MovePicker&); // silence a warning under MSVC
+    if (m != table[pc][to])
+        table[pc][to] = m;
+  }
 
-public:
+  void update(Piece pc, Square to, Value v) {
-  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL, Value beta = -VALUE_INFINITE);
+
-  Move get_next_move();
+    if (abs(int(v)) >= 324)
-  int number_of_evasions() const;
+        return;
+
+    table[pc][to] -= table[pc][to] * abs(int(v)) / (CM ? 512 : 324);
+    table[pc][to] += int(v) * (CM ? 64 : 32);
+  }
 
 private:
-  void score_captures();
+  T table[PIECE_NB][SQUARE_NB];
-  void score_noncaptures();
-  void score_evasions();
-  void go_next_phase();
-
-  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[MOVES_MAX];
 };
 
+typedef Stats<Move> MovesStats;
+typedef Stats<Value, false> HistoryStats;
+typedef Stats<Value,  true> CounterMovesStats;
+typedef Stats<CounterMovesStats> CounterMovesHistoryStats;
 
-////
-//// Inline functions
-////
 
-/// MovePicker::number_of_evasions() simply returns the number of moves in
+/// MovePicker class is used to pick one pseudo legal move at a time from the
-/// evasions phase. It is intended to be used in positions where the side to
+/// current position. The most important method is next_move(), which returns a
-/// move is in check, for detecting checkmates or situations where there is
+/// new pseudo legal move each time it is called, until there are no moves left,
-/// only a single reply to check.
+/// when MOVE_NONE is returned. In order to improve the efficiency of the alpha
-/// WARNING: It works as long as PH_EVASIONS is the _only_ phase for evasions.
+/// beta algorithm, MovePicker attempts to return the moves which are most likely
+/// to get a cut-off first.
 
-inline int MovePicker::number_of_evasions() const {
+class MovePicker {
-  return int(lastMove - moves);
+public:
-}
+  MovePicker(const MovePicker&) = delete;
+  MovePicker& operator=(const MovePicker&) = delete;
 
-#endif // !defined(MOVEPICK_H_INCLUDED)
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, Square);
+  MovePicker(const Position&, Move, const HistoryStats&, Value);
+  MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesStats&, Move, Search::Stack*);
+
+  Move next_move();
+
+private:
+  template<GenType> void score();
+  void generate_next_stage();
+  ExtMove* begin() { return moves; }
+  ExtMove* end() { return endMoves; }
+
+  const Position& pos;
+  const HistoryStats& history;
+  const CounterMovesStats* counterMovesHistory;
+  Search::Stack* ss;
+  Move countermove;
+  Depth depth;
+  Move ttMove;
+  ExtMove killers[3];
+  Square recaptureSquare;
+  Value threshold;
+  int stage;
+  ExtMove *endQuiets, *endBadCaptures = moves + MAX_MOVES - 1;
+  ExtMove moves[MAX_MOVES], *cur = moves, *endMoves = moves;
+};
+
+#endif // #ifndef MOVEPICK_H_INCLUDED

src/pawns.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,222 +18,302 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <algorithm>
-////
-//// Includes
-////
-
 #include <cassert>
-#include <cstring>
 
+#include "bitboard.h"
 #include "bitcount.h"
 #include "pawns.h"
 #include "position.h"
-
+#include "thread.h"
-
-////
-//// Local definitions
-////
 
 namespace {
 
-  /// Constants and variables
+  #define V Value
-
   #define S(mg, eg) make_score(mg, eg)
 
-  // 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] = {
+  const Score Isolated[2][FILE_NB] = {
     { 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) }};
+      S(40, 35), S(40, 35), S(36, 35), S(25, 30) } };
 
-  // Backward pawn penalty by opposed flag and file
+  // Backward pawn penalty by opposed flag
-  const Score BackwardPawnPenalty[2][8] = {
+  const Score Backward[2] = { S(67, 42), S(49, 24) };
-  { 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
+  // Unsupported pawn penalty, for pawns which are neither isolated or backward
-  const Score ChainBonus[8] = {
+  const Score Unsupported = S(20, 10);
-    S(11,-1), S(13,-1), S(13,-1), S(14,-1),
-    S(14,-1), S(13,-1), S(13,-1), S(11,-1)
-  };
 
-  // Candidate passed pawn bonus by rank
+  // Connected pawn bonus by opposed, phalanx, twice supported and rank
-  const Score CandidateBonus[8] = {
+  Score Connected[2][2][2][RANK_NB];
-    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
+  
-    S(34,68), S(83,166), S(0, 0), S( 0, 0)
+  // Doubled pawn penalty by file
-  };
+  const Score Doubled[FILE_NB] = {
+    S(13, 43), S(20, 48), S(23, 48), S(23, 48),
+    S(23, 48), S(23, 48), S(20, 48), S(13, 43) };
+
+  // Lever bonus by rank
+  const Score Lever[RANK_NB] = {
+    S( 0,  0), S( 0,  0), S(0, 0), S(0, 0),
+    S(20, 20), S(40, 40), S(0, 0), S(0, 0) };
+
+  // Center bind bonus, when two pawns controls the same central square
+  const Score CenterBind = S(16, 0);
+
+  // Weakness of our pawn shelter in front of the king by [distance from edge][rank]
+  const Value ShelterWeakness[][RANK_NB] = {
+    { V( 97), V(21), V(26), V(51), V(87), V( 89), V( 99) },
+    { V(120), V( 0), V(28), V(76), V(88), V(103), V(104) },
+    { V(101), V( 7), V(54), V(78), V(77), V( 92), V(101) },
+    { V( 80), V(11), V(44), V(68), V(87), V( 90), V(119) } };
+
+  // Danger of enemy pawns moving toward our king by [type][distance from edge][rank]
+  const Value StormDanger[][4][RANK_NB] = {
+    { { V( 0),  V(  67), V( 134), V(38), V(32) },
+      { V( 0),  V(  57), V( 139), V(37), V(22) },
+      { V( 0),  V(  43), V( 115), V(43), V(27) },
+      { V( 0),  V(  68), V( 124), V(57), V(32) } },
+    { { V(20),  V(  43), V( 100), V(56), V(20) },
+      { V(23),  V(  20), V(  98), V(40), V(15) },
+      { V(23),  V(  39), V( 103), V(36), V(18) },
+      { V(28),  V(  19), V( 108), V(42), V(26) } },
+    { { V( 0),  V(   0), V(  75), V(14), V( 2) },
+      { V( 0),  V(   0), V( 150), V(30), V( 4) },
+      { V( 0),  V(   0), V( 160), V(22), V( 5) },
+      { V( 0),  V(   0), V( 166), V(24), V(13) } },
+    { { V( 0),  V(-283), V(-281), V(57), V(31) },
+      { V( 0),  V(  58), V( 141), V(39), V(18) },
+      { V( 0),  V(  65), V( 142), V(48), V(32) },
+      { V( 0),  V(  60), V( 126), V(51), V(19) } } };
+
+  // Max bonus for king safety. Corresponds to start position with all the pawns
+  // in front of the king and no enemy pawn on the horizon.
+  const Value MaxSafetyBonus = V(258);
 
   #undef S
-}
+  #undef V
 
+  template<Color Us>
+  Score evaluate(const Position& pos, Pawns::Entry* e) {
 
-////
+    const Color  Them  = (Us == WHITE ? BLACK    : WHITE);
-//// Functions
+    const Square Up    = (Us == WHITE ? DELTA_N  : DELTA_S);
-////
+    const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW);
+    const Square Left  = (Us == WHITE ? DELTA_NW : DELTA_SE);
 
-/// PawnInfoTable c'tor and d'tor instantiated one each thread
+    const Bitboard CenterBindMask =
+      Us == WHITE ? (FileDBB | FileEBB) & (Rank5BB | Rank6BB | Rank7BB)
+                  : (FileDBB | FileEBB) & (Rank4BB | Rank3BB | Rank2BB);
 
-PawnInfoTable::PawnInfoTable() {
+    Bitboard b, neighbours, doubled, supported, phalanx;
-
-  entries = new PawnInfo[PawnTableSize];
-
-  if (!entries)
-  {
-      std::cerr << "Failed to allocate " << (PawnTableSize * sizeof(PawnInfo))
-                << " bytes for pawn hash table." << std::endl;
-      exit(EXIT_FAILURE);
-  }
-  memset(entries, 0, PawnTableSize * sizeof(PawnInfo));
-}
-
-
-PawnInfoTable::~PawnInfoTable() {
-
-  delete [] entries;
-}
-
-
-/// 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.
-
-PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
-
-  assert(pos.is_ok());
-
-  Key key = pos.get_pawn_key();
-  unsigned index = unsigned(key & (PawnTableSize - 1));
-  PawnInfo* pi = entries + index;
-
-  // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return
-  // the information we found the last time instead of recomputing it.
-  if (pi->key == key)
-      return pi;
-
-  // Clear the PawnInfo object, and set the key
-  memset(pi, 0, sizeof(PawnInfo));
-  pi->halfOpenFiles[WHITE] = pi->halfOpenFiles[BLACK] = 0xFF;
-  pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
-  pi->key = key;
-
-  // 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);
-
-  // Evaluate pawns for both colors
-  pi->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, pi)
-             - evaluate_pawns<BLACK>(pos, bPawns, wPawns, pi);
-  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 {
-  Bitboard b;
     Square s;
-  File f;
+    bool passed, isolated, opposed, backward, lever, connected;
-  Rank r;
+    Score score = SCORE_ZERO;
-  bool passed, isolated, doubled, opposed, chain, backward, candidate;
+    const Square* pl = pos.squares<PAWN>(Us);
-  Score value = SCORE_ZERO;
+    const Bitboard* pawnAttacksBB = StepAttacksBB[make_piece(Us, PAWN)];
-  const BitCountType Max15 = CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
+
-  const Square* ptr = pos.piece_list_begin(Us, PAWN);
+    Bitboard ourPawns   = pos.pieces(Us  , PAWN);
+    Bitboard theirPawns = pos.pieces(Them, PAWN);
+
+    e->passedPawns[Us] = e->pawnAttacksSpan[Us] = 0;
+    e->kingSquares[Us] = SQ_NONE;
+    e->semiopenFiles[Us] = 0xFF;
+    e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
+    e->pawnsOnSquares[Us][BLACK] = popcount<Max15>(ourPawns & DarkSquares);
+    e->pawnsOnSquares[Us][WHITE] = pos.count<PAWN>(Us) - e->pawnsOnSquares[Us][BLACK];
 
     // Loop through all pawns of the current color and score each pawn
-  while ((s = *ptr++) != SQ_NONE)
+    while ((s = *pl++) != SQ_NONE)
     {
-      assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
+        assert(pos.piece_on(s) == make_piece(Us, PAWN));
 
-      f = square_file(s);
+        File f = file_of(s);
-      r = square_rank(s);
 
-      // This file cannot be half open
+        e->semiopenFiles[Us] &= ~(1 << f);
-      pi->halfOpenFiles[Us] &= ~(1 << f);
+        e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s);
 
-      // Our rank plus previous one. Used for chain detection.
+        // Flag the pawn
-      b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
+        neighbours  =   ourPawns   & adjacent_files_bb(f);
-
+        doubled     =   ourPawns   & forward_bb(Us, s);
-      // Passed, isolated, doubled or member of a pawn
+        opposed     =   theirPawns & forward_bb(Us, s);
-      // chain (but not the backward one) ?
         passed      = !(theirPawns & passed_pawn_mask(Us, s));
-      doubled  =   ourPawns   & squares_in_front_of(Us, s);
+        lever       =   theirPawns & pawnAttacksBB[s];
-      opposed  =   theirPawns & squares_in_front_of(Us, s);
+        phalanx     =   neighbours & rank_bb(s);
-      isolated = !(ourPawns   & neighboring_files_bb(f));
+        supported   =   neighbours & rank_bb(s - Up);
-      chain    =   ourPawns   & neighboring_files_bb(f) & b;
+        connected   =   supported | phalanx;
+        isolated    =  !neighbours;
 
-      // Test for backward pawn
+        // Test for backward pawn.
-      //
+        // If the pawn is passed, isolated, lever or connected it cannot be
+        // backward. If there are friendly pawns behind on adjacent files
+        // or if it is sufficiently advanced, it cannot be backward either.
+        if (   (passed | isolated | lever | connected)
+            || (ourPawns & pawn_attack_span(Them, s))
+            || (relative_rank(Us, s) >= RANK_5))
             backward = false;
-
+        else
-      // If the pawn is passed, isolated, or member of a pawn chain
-      // it cannot be backward. If can capture an enemy pawn or if
-      // there are friendly pawns behind on neighboring files it cannot
-      // be backward either.
-      if (   !(passed | isolated | chain)
-          && !(ourPawns & attack_span_mask(opposite_color(Us), s))
-          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
         {
-          // We now know that there are no friendly pawns beside or behind this
+            // We now know there are no friendly pawns beside or behind this
-          // pawn on neighboring files. We now check whether the pawn is
+            // pawn on adjacent files. We now check whether the pawn is
-          // backward by looking in the forward direction on the neighboring
+            // backward by looking in the forward direction on the adjacent
-          // files, and seeing whether we meet a friendly or an enemy pawn first.
+            // files, and picking the closest pawn there.
-          b = pos.attacks_from<PAWN>(s, Us);
+            b = pawn_attack_span(Us, s) & (ourPawns | theirPawns);
+            b = pawn_attack_span(Us, s) & rank_bb(backmost_sq(Us, b));
 
-          // Note that we are sure to find something because pawn is not passed
+            // If we have an enemy pawn in the same or next rank, the pawn is
-          // nor isolated, so loop is potentially infinite, but it isn't.
+            // backward because it cannot advance without being captured.
-          while (!(b & (ourPawns | theirPawns)))
+            backward = (b | shift_bb<Up>(b)) & 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(passed | opposed | (attack_span_mask(Us, s) & theirPawns));
+        assert(opposed | passed | (pawn_attack_span(Us, s) & theirPawns));
 
-      // Test for candidate passed pawn
+        // Passed pawns will be properly scored in evaluation because we need
-      candidate =   !(opposed | passed)
+        // full attack info to evaluate them. Only the frontmost passed
-                 && (b = attack_span_mask(opposite_color(Us), s + pawn_push(Us)) & ourPawns) != EmptyBoardBB
+        // pawn on each file is considered a true passed pawn.
-                 &&  count_1s<Max15>(b) >= count_1s<Max15>(attack_span_mask(Us, s) & theirPawns);
-
-      // Mark the pawn as passed. Pawn 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);
+            e->passedPawns[Us] |= s;
 
         // Score this pawn
         if (isolated)
-          value -= IsolatedPawnPenalty[opposed][f];
+            score -= Isolated[opposed][f];
+
+        else if (backward)
+            score -= Backward[opposed];
+
+        else if (!supported)
+            score -= Unsupported;
+
+        if (connected)
+            score += Connected[opposed][!!phalanx][more_than_one(supported)][relative_rank(Us, s)];
 
         if (doubled)
-          value -= DoubledPawnPenalty[opposed][f];
+            score -= Doubled[f] / distance<Rank>(s, frontmost_sq(Us, doubled));
 
-      if (backward)
+        if (lever)
-          value -= BackwardPawnPenalty[opposed][f];
+            score += Lever[relative_rank(Us, s)];
-
+    }
-      if (chain)
+
-          value += ChainBonus[f];
+    b = e->semiopenFiles[Us] ^ 0xFF;
-
+    e->pawnSpan[Us] = b ? int(msb(b) - lsb(b)) : 0;
-      if (candidate)
+
-          value += CandidateBonus[relative_rank(Us, s)];
+    b = shift_bb<Right>(ourPawns) & shift_bb<Left>(ourPawns) & CenterBindMask;
+    score += CenterBind * popcount<Max15>(b);
+
+    return score;
+  }
+
+} // namespace
+
+namespace Pawns {
+
+/// Pawns::init() initializes some tables needed by evaluation. Instead of using
+/// hard-coded tables, when makes sense, we prefer to calculate them with a formula
+/// to reduce independent parameters and to allow easier tuning and better insight.
+
+void init()
+{
+  static const int Seed[RANK_NB] = { 0, 6, 15, 10, 57, 75, 135, 258 };
+
+  for (int opposed = 0; opposed <= 1; ++opposed)
+      for (int phalanx = 0; phalanx <= 1; ++phalanx)
+          for (int apex = 0; apex <= 1; ++apex)
+              for (Rank r = RANK_2; r < RANK_8; ++r)
+  {
+      int v = (Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0)) >> opposed;
+      v += (apex ? v / 2 : 0);
+      Connected[opposed][phalanx][apex][r] = make_score(3 * v / 2, v);
   }
-  return value;
 }
+
+
+/// Pawns::probe() looks up the current position's pawns configuration in
+/// the pawns hash table. It returns a pointer to the Entry if the position
+/// is found. Otherwise a new Entry is computed and stored there, so we don't
+/// have to recompute all when the same pawns configuration occurs again.
+
+Entry* probe(const Position& pos) {
+
+  Key key = pos.pawn_key();
+  Entry* e = pos.this_thread()->pawnsTable[key];
+
+  if (e->key == key)
+      return e;
+
+  e->key = key;
+  e->score = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e);
+  e->asymmetry = popcount<Max15>(e->semiopenFiles[WHITE] ^ e->semiopenFiles[BLACK]);
+  return e;
+}
+
+
+/// Entry::shelter_storm() calculates shelter and storm penalties for the file
+/// the king is on, as well as the two adjacent files.
+
+template<Color Us>
+Value Entry::shelter_storm(const Position& pos, Square ksq) {
+
+  const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+  enum { NoFriendlyPawn, Unblocked, BlockedByPawn, BlockedByKing };
+
+  Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq));
+  Bitboard ourPawns = b & pos.pieces(Us);
+  Bitboard theirPawns = b & pos.pieces(Them);
+  Value safety = MaxSafetyBonus;
+  File center = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
+
+  for (File f = center - File(1); f <= center + File(1); ++f)
+  {
+      b = ourPawns & file_bb(f);
+      Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1;
+
+      b  = theirPawns & file_bb(f);
+      Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1;
+
+      safety -=  ShelterWeakness[std::min(f, FILE_H - f)][rkUs]
+               + StormDanger
+                 [f == file_of(ksq) && rkThem == relative_rank(Us, ksq) + 1 ? BlockedByKing  :
+                  rkUs   == RANK_1                                          ? NoFriendlyPawn :
+                  rkThem == rkUs + 1                                        ? BlockedByPawn  : Unblocked]
+                 [std::min(f, FILE_H - f)][rkThem];
+  }
+
+  return safety;
+}
+
+
+/// Entry::do_king_safety() calculates a bonus for king safety. It is called only
+/// when king square changes, which is about 20% of total king_safety() calls.
+
+template<Color Us>
+Score Entry::do_king_safety(const Position& pos, Square ksq) {
+
+  kingSquares[Us] = ksq;
+  castlingRights[Us] = pos.can_castle(Us);
+  int minKingPawnDistance = 0;
+
+  Bitboard pawns = pos.pieces(Us, PAWN);
+  if (pawns)
+      while (!(DistanceRingBB[ksq][minKingPawnDistance++] & pawns)) {}
+
+  if (relative_rank(Us, ksq) > RANK_4)
+      return make_score(0, -16 * minKingPawnDistance);
+
+  Value bonus = shelter_storm<Us>(pos, ksq);
+
+  // If we can castle use the bonus after the castling if it is bigger
+  if (pos.can_castle(MakeCastling<Us, KING_SIDE>::right))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_G1)));
+
+  if (pos.can_castle(MakeCastling<Us, QUEEN_SIDE>::right))
+      bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
+
+  return make_score(bonus, -16 * minKingPawnDistance);
+}
+
+// Explicit template instantiation
+template Score Entry::do_king_safety<WHITE>(const Position& pos, Square ksq);
+template Score Entry::do_king_safety<BLACK>(const Position& pos, Square ksq);
+
+} // namespace Pawns

src/pawns.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,147 +18,71 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef PAWNS_H_INCLUDED
-#if !defined(PAWNS_H_INCLUDED)
 #define PAWNS_H_INCLUDED
 
-////
+#include "misc.h"
-//// Includes
-////
-
-#include "bitboard.h"
 #include "position.h"
-#include "value.h"
+#include "types.h"
 
-////
+namespace Pawns {
-//// Types
-////
 
-const int PawnTableSize = 16384;
+/// Pawns::Entry contains various information about a pawn structure. A lookup
+/// to the pawn hash table (performed by calling the probe function) returns a
+/// pointer to an Entry object.
 
-/// PawnInfo is a class which contains various information about a pawn
+struct Entry {
-/// 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.
-class PawnInfo {
 
-  friend class PawnInfoTable;
+  Score pawns_score() const { return score; }
+  Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
+  Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
+  Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; }
+  int pawn_span(Color c) const { return pawnSpan[c]; }
+  int pawn_asymmetry() const { return asymmetry; }
 
-public:
+  int semiopen_file(Color c, File f) const {
-  Score pawns_value() const;
+    return semiopenFiles[c] & (1 << f);
-  Bitboard pawn_attacks(Color c) const;
+  }
-  Bitboard passed_pawns(Color c) const;
+
-  int file_is_half_open(Color c, File f) const;
+  int semiopen_side(Color c, File f, bool leftSide) const {
-  int has_open_file_to_left(Color c, File f) const;
+    return semiopenFiles[c] & (leftSide ? (1 << f) - 1 : ~((1 << (f + 1)) - 1));
-  int has_open_file_to_right(Color c, File f) const;
+  }
+
+  int pawns_on_same_color_squares(Color c, Square s) const {
+    return pawnsOnSquares[c][!!(DarkSquares & s)];
+  }
 
   template<Color Us>
-  Score king_shelter(const Position& pos, Square ksq);
+  Score king_safety(const Position& pos, Square ksq)  {
+    return  kingSquares[Us] == ksq && castlingRights[Us] == pos.can_castle(Us)
+          ? kingSafety[Us] : (kingSafety[Us] = do_king_safety<Us>(pos, ksq));
+  }
 
-private:
   template<Color Us>
-  Score updateShelter(const Position& pos, Square ksq);
+  Score do_king_safety(const Position& pos, Square ksq);
+
+  template<Color Us>
+  Value shelter_storm(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns[2];
+  Score score;
-  Bitboard pawnAttacks[2];
+  Bitboard passedPawns[COLOR_NB];
-  Square kingSquares[2];
+  Bitboard pawnAttacks[COLOR_NB];
-  Score value;
+  Bitboard pawnAttacksSpan[COLOR_NB];
-  int halfOpenFiles[2];
+  Square kingSquares[COLOR_NB];
-  Score kingShelters[2];
+  Score kingSafety[COLOR_NB];
+  int castlingRights[COLOR_NB];
+  int semiopenFiles[COLOR_NB];
+  int pawnSpan[COLOR_NB];
+  int pawnsOnSquares[COLOR_NB][COLOR_NB]; // [color][light/dark squares]
+  int asymmetry;
 };
 
-/// The PawnInfoTable class represents a pawn hash table.  It is basically
+typedef HashTable<Entry, 16384> Table;
-/// 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 {
+void init();
+Entry* probe(const Position& pos);
 
-  enum SideType { KingSide, QueenSide };
+} // namespace Pawns
 
-  PawnInfoTable(const PawnInfoTable&);
+#endif // #ifndef PAWNS_H_INCLUDED
-  PawnInfoTable& operator=(const PawnInfoTable&);
-
-public:
-  PawnInfoTable();
-  ~PawnInfoTable();
-  PawnInfo* get_pawn_info(const Position& pos) const;
-  void prefetch(Key key) const;
-
-private:
-  template<Color Us>
-  Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi) const;
-
-  PawnInfo* entries;
-};
-
-
-////
-//// Inline functions
-////
-
-inline void PawnInfoTable::prefetch(Key key) const {
-
-    unsigned index = unsigned(key & (PawnTableSize - 1));
-    PawnInfo* pi = entries + index;
-    ::prefetch((char*) pi);
-}
-
-inline Score PawnInfo::pawns_value() const {
-  return value;
-}
-
-inline Bitboard PawnInfo::pawn_attacks(Color c) const {
-  return pawnAttacks[c];
-}
-
-inline Bitboard PawnInfo::passed_pawns(Color c) const {
-  return passedPawns[c];
-}
-
-inline int PawnInfo::file_is_half_open(Color c, File f) const {
-  return (halfOpenFiles[c] & (1 << int(f)));
-}
-
-inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
-  return halfOpenFiles[c] & ((1 << int(f)) - 1);
-}
-
-inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
-  return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
-}
-
-/// 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 = square_rank(ksq) * 8;
-      for (int i = 1; i < 4; i++)
-      {
-          r += Shift;
-          shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
-      }
-  }
-  kingSquares[Us] = ksq;
-  kingShelters[Us] = make_score(shelter, 0);
-  return kingShelters[Us];
-}
-
-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/piece.h

@@ -1,111 +0,0 @@
-/*
-  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(PIECE_H_INCLUDED)
-#define PIECE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <string>
-
-#include "color.h"
-#include "square.h"
-#include "value.h"
-
-
-////
-//// Types
-////
-
-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
-};
-
-ENABLE_OPERATORS_ON(PieceType)
-ENABLE_OPERATORS_ON(Piece)
-
-
-////
-//// Constants
-////
-
-/// Important: If the material values are changed, one must also
-/// adjust the piece square tables, and the method game_phase() in the
-/// Position class!
-///
-/// Values modified by Joona Kiiski
-
-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 functions
-////
-
-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 SquareDelta pawn_push(Color c) {
-    return (c == WHITE ? DELTA_N : DELTA_S);
-}
-
-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) {
-  return std::string(" PNBRQK")[pt];
-}
-
-inline PieceType piece_type_from_char(char c) {
-  return PieceType(std::string(" PNBRQK").find(c));
-}
-
-#endif // !defined(PIECE_H_INCLUDED)

src/position.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,572 +18,420 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef POSITION_H_INCLUDED
-#if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED
 
-////
+#include <cassert>
-//// Includes
+#include <cstddef>  // For offsetof()
-////
+#include <string>
 
 #include "bitboard.h"
-#include "color.h"
+#include "types.h"
-#include "move.h"
-#include "piece.h"
-#include "square.h"
-#include "value.h"
 
+class Position;
+class Thread;
 
-////
+namespace PSQT {
-//// Constants
-////
 
-/// Maximum number of plies per game (220 should be enough, because the
+  extern Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
-/// maximum search depth is 100, and during position setup we reset the
-/// move counter for every non-reversible move).
-const int MaxGameLength = 220;
 
+  void init();
+}
 
-////
+/// CheckInfo struct is initialized at constructor time and keeps info used to
-//// Types
+/// detect if a move gives check.
-////
-
-/// struct checkInfo is initialized at c'tor time and keeps
-/// info used to detect if a move gives check.
 
 struct CheckInfo {
 
   explicit CheckInfo(const Position&);
 
   Bitboard dcCandidates;
-    Bitboard checkSq[8];
+  Bitboard pinned;
+  Bitboard checkSquares[PIECE_TYPE_NB];
   Square   ksq;
 };
 
-/// Castle rights, encoded as bit fields
 
-enum CastleRights {
+/// StateInfo struct stores information needed to restore a Position object to
-  CASTLES_NONE = 0,
+/// its previous state when we retract a move. Whenever a move is made on the
-  WHITE_OO     = 1,
+/// board (by calling Position::do_move), a StateInfo object must be passed.
-  BLACK_OO     = 2,
-  WHITE_OOO    = 4,
-  BLACK_OOO    = 8,
-  ALL_CASTLES  = 15
-};
-
-/// Game phase
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-/// 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 StateInfo {
-  Key pawnKey, materialKey;
-  int castleRights, rule50, gamePly, pliesFromNull;
-  Square epSquare;
-  Score value;
-  Value npMaterial[2];
 
-  PieceType capturedType;
+  // Copied when making a move
+  Key    pawnKey;
+  Key    materialKey;
+  Value  nonPawnMaterial[COLOR_NB];
+  int    castlingRights;
+  int    rule50;
+  int    pliesFromNull;
+  Score  psq;
+  Square epSquare;
+
+  // Not copied when making a move
   Key        key;
   Bitboard   checkersBB;
+  PieceType  capturedType;
   StateInfo* previous;
 };
 
 
-/// The position data structure. A position consists of the following data:
+/// Position class stores information regarding the board representation as
-///
+/// pieces, side to move, hash keys, castling info, etc. Important methods are
-///    * For each piece type, a bitboard representing the squares occupied
+/// do_move() and undo_move(), used by the search to update node info when
-///      by pieces of that type.
+/// traversing the search tree.
-///    * 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
-///      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.
-///    * 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
-///      repetition draws.
-///    * A counter for detecting 50 move rule draws.
 
 class Position {
 
-  friend class MaterialInfo;
-  friend class EndgameFunctions;
-
-  Position(); // No default or copy c'tor allowed
-  Position(const Position& pos);
-
 public:
-  enum GamePhase {
+  static void init();
-      MidGame,
-      EndGame
-  };
 
-  // Constructors
+  Position() = default; // To define the global object RootPos
-  Position(const Position& pos, int threadID);
+  Position(const Position&) = delete;
-  Position(const std::string& fen, bool isChess960, int threadID);
+  Position(const Position& pos, Thread* th) { *this = pos; thisThread = th; }
+  Position(const std::string& f, bool c960, Thread* th) { set(f, c960, th); }
+  Position& operator=(const Position&); // To assign RootPos from UCI
 
-  // Text input/output
+  // FEN string input/output
-  void from_fen(const std::string& fen, bool isChess960);
+  void set(const std::string& fenStr, bool isChess960, Thread* th);
-  const std::string to_fen() const;
+  const std::string fen() const;
-  void print(Move m = MOVE_NONE) const;
 
-  // Copying
+  // Position representation
-  void flipped_copy(const Position& pos);
+  Bitboard pieces() const;
-
-  // The piece on a given square
-  Piece piece_on(Square s) const;
-  PieceType type_of_piece_on(Square s) const;
-  Color color_of_piece_on(Square s) const;
-  bool square_is_empty(Square s) const;
-  bool square_is_occupied(Square s) const;
-  Value midgame_value_of_piece_on(Square s) const;
-  Value endgame_value_of_piece_on(Square s) const;
-
-  // Side to move
-  Color side_to_move() const;
-
-  // Bitboard representation of the position
-  Bitboard empty_squares() const;
-  Bitboard occupied_squares() const;
-  Bitboard pieces_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;
+  Bitboard pieces(Color c) const;
-
+  Bitboard pieces(Color c, PieceType pt) const;
-  // Number of pieces of each color and type
+  Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
-  int piece_count(Color c, PieceType pt) const;
+  Piece piece_on(Square s) const;
-
-  // The en passant square
   Square ep_square() const;
+  bool empty(Square s) const;
+  template<PieceType Pt> int count(Color c) const;
+  template<PieceType Pt> const Square* squares(Color c) const;
+  template<PieceType Pt> Square square(Color c) const;
 
-  // Current king position for each color
+  // Castling
-  Square king_square(Color c) const;
+  int can_castle(Color c) const;
+  int can_castle(CastlingRight cr) const;
+  bool castling_impeded(CastlingRight cr) const;
+  Square castling_rook_square(CastlingRight cr) const;
 
-  // Castling rights
+  // Checking
-  bool can_castle_kingside(Color c) const;
+  Bitboard checkers() const;
-  bool can_castle_queenside(Color c) const;
+  Bitboard discovered_check_candidates() const;
-  bool can_castle(Color c) const;
-  Square initial_kr_square(Color c) const;
-  Square initial_qr_square(Color c) const;
-
-  // Bitboards for pinned pieces and discovered check candidates
-  Bitboard discovered_check_candidates(Color c) const;
   Bitboard pinned_pieces(Color c) const;
 
-  // Checking pieces and under check information
+  // Attacks to/from a given square
-  Bitboard checkers() const;
-  bool is_check() const;
-
-  // Piece lists
-  Square piece_list(Color c, PieceType pt, int index) const;
-  const Square* piece_list_begin(Color c, PieceType pt) const;
-
-  // Information about attacks to or from a given square
   Bitboard attackers_to(Square s) const;
-  Bitboard attacks_from(Piece p, Square s) const;
+  Bitboard attackers_to(Square s, Bitboard occupied) const;
-  static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
+  Bitboard attacks_from(Piece pc, Square s) const;
   template<PieceType> Bitboard attacks_from(Square s) const;
   template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool pl_move_is_legal(Move m, Bitboard pinned) const;
+  bool legal(Move m, Bitboard pinned) const;
-  bool pl_move_is_evasion(Move m, Bitboard pinned) const;
+  bool pseudo_legal(const Move m) const;
-  bool move_is_check(Move m) const;
+  bool capture(Move m) const;
-  bool move_is_check(Move m, const CheckInfo& ci) const;
+  bool capture_or_promotion(Move m) const;
-  bool move_is_capture(Move m) const;
+  bool gives_check(Move m, const CheckInfo& ci) const;
-  bool move_is_capture_or_promotion(Move m) const;
+  bool advanced_pawn_push(Move m) const;
-  bool move_is_passed_pawn_push(Move m) const;
+  Piece moved_piece(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
+  // Piece specific
-  bool pawn_is_passed(Color c, Square s) const;
+  bool pawn_passed(Color c, Square s) const;
-
+  bool opposite_bishops() const;
-  // Weak squares
-  bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void detach();
+  void do_move(Move m, StateInfo& st, bool givesCheck);
-  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;
+  Value see(Move m) const;
-  int see(Move m) const;
+  Value see_sign(Move m) const;
-  int see_sign(Move m) const;
 
   // Accessing hash keys
-  Key get_key() const;
+  Key key() const;
-  Key get_exclusion_key() const;
+  Key key_after(Move m) const;
-  Key get_pawn_key() const;
+  Key exclusion_key() const;
-  Key get_material_key() const;
+  Key material_key() const;
-
+  Key pawn_key() const;
-  // Incremental evaluation
-  Score value() const;
-  Value non_pawn_material(Color c) const;
-  static Score pst_delta(Piece piece, Square from, Square to);
-
-  // Game termination checks
-  bool is_mate() const;
-  bool is_draw() const;
-
-  // Check if side to move could be mated in one
-  bool has_mate_threat();
-
-  // Number of plies since the last non-reversible move
-  int rule_50_counter() const;
-
-  int startpos_ply_counter() const;
 
   // Other properties of the position
-  bool opposite_colored_bishops() const;
+  Color side_to_move() const;
-  bool has_pawn_on_7th(Color c) const;
+  Phase game_phase() const;
+  int game_ply() const;
   bool is_chess960() const;
-
+  Thread* this_thread() const;
-  // Current thread ID searching on the position
+  uint64_t nodes_searched() const;
-  int thread() const;
+  void set_nodes_searched(uint64_t n);
-
+  bool is_draw() const;
-  // Reset the gamePly variable to 0
+  int rule50_count() const;
-  void reset_game_ply();
+  Score psq_score() const;
-  void inc_startpos_ply_counter();
+  Value non_pawn_material(Color c) const;
-  int64_t nodes_searched() const;
-  void set_nodes_searched(int64_t n);
 
   // Position consistency check, for debugging
-  bool is_ok(int* failedStep = NULL) const;
+  bool pos_is_ok(int* failedStep = nullptr) const;
-
+  void flip();
-  // Static member functions
-  static void init_zobrist();
-  static void init_piece_square_tables();
 
 private:
-
+  // Initialization helpers (used while setting up a position)
-  // Initialization helper functions (used while setting up a position)
   void clear();
-  void put_piece(Piece p, Square s);
+  void set_castling_right(Color c, Square rfrom);
-  void do_allow_oo(Color c);
+  void set_state(StateInfo* si) const;
-  void do_allow_ooo(Color c);
-  bool set_castling_rights(char token);
 
-  // Helper functions for doing and undoing moves
+  // Other helpers
-  void do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep);
+  Bitboard check_blockers(Color c, Color kingColor) const;
-  void do_castle_move(Move m);
+  void put_piece(Color c, PieceType pt, Square s);
-  void undo_castle_move(Move m);
+  void remove_piece(Color c, PieceType pt, Square s);
-  void find_checkers();
+  void move_piece(Color c, PieceType pt, Square from, Square to);
+  template<bool Do>
+  void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
 
-  template<bool FindPinned>
+  // Data members
-  Bitboard hidden_checkers(Color c) const;
+  Piece board[SQUARE_NB];
-
+  Bitboard byTypeBB[PIECE_TYPE_NB];
-  // Computing hash keys from scratch (for initialization and debugging)
+  Bitboard byColorBB[COLOR_NB];
-  Key compute_key() const;
+  int pieceCount[COLOR_NB][PIECE_TYPE_NB];
-  Key compute_pawn_key() const;
+  Square pieceList[COLOR_NB][PIECE_TYPE_NB][16];
-  Key compute_material_key() const;
+  int index[SQUARE_NB];
-
+  int castlingRightsMask[SQUARE_NB];
-  // Computing incremental evaluation scores and material counts
+  Square castlingRookSquare[CASTLING_RIGHT_NB];
-  static Score pst(Color c, PieceType pt, Square s);
+  Bitboard castlingPath[CASTLING_RIGHT_NB];
-  Score compute_value() const;
-  Value compute_non_pawn_material(Color c) const;
-
-  // 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]; // [square]
-
-  // Other info
-  Color sideToMove;
-  Key history[MaxGameLength];
-  int castleRightsMask[64];
   StateInfo startState;
-  File initialKFile, initialKRFile, initialQRFile;
+  uint64_t nodes;
-  bool isChess960;
+  int gamePly;
-  int startPosPlyCounter;
+  Color sideToMove;
-  int threadID;
+  Thread* thisThread;
-  int64_t nodes;
   StateInfo* st;
-
+  bool chess960;
-  // Static variables
-  static Key zobrist[2][8][64];
-  static Key zobEp[64];
-  static Key zobCastle[16];
-  static Key zobSideToMove;
-  static Score PieceSquareTable[16][64];
-  static Key zobExclusion;
-  static const Value seeValues[8];
-  static const Value PieceValueMidgame[17];
-  static const Value PieceValueEndgame[17];
 };
 
+extern std::ostream& operator<<(std::ostream& os, const Position& pos);
 
-////
+inline Color Position::side_to_move() const {
-//// Inline functions
+  return sideToMove;
-////
-
-inline int64_t Position::nodes_searched() const {
-  return nodes;
 }
 
-inline void Position::set_nodes_searched(int64_t n) {
+inline bool Position::empty(Square s) const {
-  nodes = n;
+  return board[s] == NO_PIECE;
 }
 
 inline Piece Position::piece_on(Square s) const {
   return board[s];
 }
 
-inline Color Position::color_of_piece_on(Square s) const {
+inline Piece Position::moved_piece(Move m) const {
-  return color_of_piece(piece_on(s));
+  return board[from_sq(m)];
 }
 
-inline PieceType Position::type_of_piece_on(Square s) const {
+inline Bitboard Position::pieces() const {
-  return type_of_piece(piece_on(s));
+  return byTypeBB[ALL_PIECES];
-}
-
-inline bool Position::square_is_empty(Square s) const {
-  return piece_on(s) == PIECE_NONE;
-}
-
-inline bool Position::square_is_occupied(Square s) const {
-  return !square_is_empty(s);
-}
-
-inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return PieceValueMidgame[piece_on(s)];
-}
-
-inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return PieceValueEndgame[piece_on(s)];
-}
-
-inline Color Position::side_to_move() const {
-  return sideToMove;
-}
-
-inline Bitboard Position::occupied_squares() const {
-  return byTypeBB[0];
-}
-
-inline Bitboard Position::empty_squares() const {
-  return ~occupied_squares();
-}
-
-inline Bitboard Position::pieces_of_color(Color c) const {
-  return byColorBB[c];
 }
 
 inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces(PieceType pt, Color c) const {
-  return byTypeBB[pt] & byColorBB[c];
-}
-
 inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
   return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
+inline Bitboard Position::pieces(Color c) const {
-  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
+  return byColorBB[c];
 }
 
-inline int Position::piece_count(Color c, PieceType pt) const {
+inline Bitboard Position::pieces(Color c, PieceType pt) const {
-  return pieceCount[c][pt];
+  return byColorBB[c] & byTypeBB[pt];
 }
 
-inline Square Position::piece_list(Color c, PieceType pt, int idx) const {
+inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
-  return pieceList[c][pt][idx];
+  return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
 }
 
-inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
+template<PieceType Pt> inline int Position::count(Color c) const {
-  return pieceList[c][pt];
+  return pieceCount[c][Pt];
+}
+
+template<PieceType Pt> inline const Square* Position::squares(Color c) const {
+  return pieceList[c][Pt];
+}
+
+template<PieceType Pt> inline Square Position::square(Color c) const {
+  assert(pieceCount[c][Pt] == 1);
+  return pieceList[c][Pt][0];
 }
 
 inline Square Position::ep_square() const {
   return st->epSquare;
 }
 
-inline Square Position::king_square(Color c) const {
+inline int Position::can_castle(CastlingRight cr) const {
-  return pieceList[c][KING][0];
+  return st->castlingRights & cr;
 }
 
-inline bool Position::can_castle_kingside(Color side) const {
+inline int Position::can_castle(Color c) const {
-  return st->castleRights & (1+int(side));
+  return st->castlingRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
 }
 
-inline bool Position::can_castle_queenside(Color side) const {
+inline bool Position::castling_impeded(CastlingRight cr) const {
-  return st->castleRights & (4+4*int(side));
+  return byTypeBB[ALL_PIECES] & castlingPath[cr];
 }
 
-inline bool Position::can_castle(Color side) const {
+inline Square Position::castling_rook_square(CastlingRight cr) const {
-  return can_castle_kingside(side) || can_castle_queenside(side);
+  return castlingRookSquare[cr];
 }
 
-inline Square Position::initial_kr_square(Color c) const {
+template<PieceType Pt>
-  return relative_square(c, make_square(initialKRFile, RANK_1));
+inline Bitboard Position::attacks_from(Square s) const {
-}
+  return  Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_PIECES])
-
+        : Pt == QUEEN  ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
-inline Square Position::initial_qr_square(Color c) const {
+        : StepAttacksBB[Pt][s];
-  return relative_square(c, make_square(initialQRFile, RANK_1));
 }
 
 template<>
 inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
-  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
+  return StepAttacksBB[make_piece(c, PAWN)][s];
 }
 
-template<PieceType Piece> // Knight and King and white pawns
+inline Bitboard Position::attacks_from(Piece pc, Square s) const {
-inline Bitboard Position::attacks_from(Square s) const {
+  return attacks_bb(pc, s, byTypeBB[ALL_PIECES]);
-  return StepAttackBB[Piece][s];
 }
 
-template<>
+inline Bitboard Position::attackers_to(Square s) const {
-inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
+  return attackers_to(s, byTypeBB[ALL_PIECES]);
-  return bishop_attacks_bb(s, occupied_squares());
-}
-
-template<>
-inline Bitboard Position::attacks_from<ROOK>(Square s) const {
-  return rook_attacks_bb(s, occupied_squares());
-}
-
-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 st->checkersBB;
 }
 
-inline bool Position::is_check() const {
+inline Bitboard Position::discovered_check_candidates() const {
-  return st->checkersBB != EmptyBoardBB;
+  return check_blockers(sideToMove, ~sideToMove);
 }
 
-inline bool Position::pawn_is_passed(Color c, Square s) const {
+inline Bitboard Position::pinned_pieces(Color c) const {
-  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
+  return check_blockers(c, c);
 }
 
-inline bool Position::square_is_weak(Square s, Color c) const {
+inline bool Position::pawn_passed(Color c, Square s) const {
-  return !(pieces(PAWN, opposite_color(c)) & attack_span_mask(c, s));
+  return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
 }
 
-inline Key Position::get_key() const {
+inline bool Position::advanced_pawn_push(Move m) const {
+  return   type_of(moved_piece(m)) == PAWN
+        && relative_rank(sideToMove, from_sq(m)) > RANK_4;
+}
+
+inline Key Position::key() const {
   return st->key;
 }
 
-inline Key Position::get_exclusion_key() const {
+inline Key Position::pawn_key() const {
-  return st->key ^ zobExclusion;
-}
-
-inline Key Position::get_pawn_key() const {
   return st->pawnKey;
 }
 
-inline Key Position::get_material_key() const {
+inline Key Position::material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::pst(Color c, PieceType pt, Square s) {
+inline Score Position::psq_score() const {
-  return PieceSquareTable[piece_of_color_and_type(c, pt)][s];
+  return st->psq;
-}
-
-inline Score Position::pst_delta(Piece piece, Square from, Square to) {
-  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
-}
-
-inline Score Position::value() const {
-  return st->value;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
-  return st->npMaterial[c];
+  return st->nonPawnMaterial[c];
 }
 
-inline bool Position::move_is_passed_pawn_push(Move m) const {
+inline int Position::game_ply() const {
-
+  return gamePly;
-  Color c = side_to_move();
-  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
-        && pawn_is_passed(c, move_to(m));
 }
 
-inline int Position::rule_50_counter() const {
+inline int Position::rule50_count() const {
   return st->rule50;
 }
 
-inline int Position::startpos_ply_counter() const {
+inline uint64_t Position::nodes_searched() const {
-  return startPosPlyCounter;
+  return nodes;
 }
 
-inline bool Position::opposite_colored_bishops() const {
+inline void Position::set_nodes_searched(uint64_t n) {
-
+  nodes = n;
-  return   piece_count(WHITE, BISHOP) == 1
-        && piece_count(BLACK, BISHOP) == 1
-        && !same_color_squares(piece_list(WHITE, BISHOP, 0), piece_list(BLACK, BISHOP, 0));
 }
 
-inline bool Position::has_pawn_on_7th(Color c) const {
+inline bool Position::opposite_bishops() const {
-  return pieces(PAWN, c) & relative_rank_bb(c, RANK_7);
+  return   pieceCount[WHITE][BISHOP] == 1
+        && pieceCount[BLACK][BISHOP] == 1
+        && opposite_colors(square<BISHOP>(WHITE), square<BISHOP>(BLACK));
 }
 
 inline bool Position::is_chess960() const {
-  return isChess960;
+  return chess960;
 }
 
-inline bool Position::move_is_capture(Move m) const {
+inline bool Position::capture_or_promotion(Move m) const {
 
-  // Move must not be MOVE_NONE !
+  assert(is_ok(m));
-  return (m & (3 << 15)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+  return type_of(m) != NORMAL ? type_of(m) != CASTLING : !empty(to_sq(m));
 }
 
-inline bool Position::move_is_capture_or_promotion(Move m) const {
+inline bool Position::capture(Move m) const {
 
-  // Move must not be MOVE_NONE !
+  // Castling is encoded as "king captures the rook"
-  return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
+  assert(is_ok(m));
+  return (!empty(to_sq(m)) && type_of(m) != CASTLING) || type_of(m) == ENPASSANT;
 }
 
 inline PieceType Position::captured_piece_type() const {
   return st->capturedType;
 }
 
-inline int Position::thread() const {
+inline Thread* Position::this_thread() const {
-  return threadID;
+  return thisThread;
 }
 
-inline void Position::do_allow_oo(Color c) {
+inline void Position::put_piece(Color c, PieceType pt, Square s) {
-  st->castleRights |= (1 + int(c));
+
+  board[s] = make_piece(c, pt);
+  byTypeBB[ALL_PIECES] |= s;
+  byTypeBB[pt] |= s;
+  byColorBB[c] |= s;
+  index[s] = pieceCount[c][pt]++;
+  pieceList[c][pt][index[s]] = s;
+  pieceCount[c][ALL_PIECES]++;
 }
 
-inline void Position::do_allow_ooo(Color c) {
+inline void Position::remove_piece(Color c, PieceType pt, Square s) {
-  st->castleRights |= (4 + 4*int(c));
+
+  // WARNING: This is not a reversible operation. If we remove a piece in
+  // do_move() and then replace it in undo_move() we will put it at the end of
+  // the list and not in its original place, it means index[] and pieceList[]
+  // are not guaranteed to be invariant to a do_move() + undo_move() sequence.
+  byTypeBB[ALL_PIECES] ^= s;
+  byTypeBB[pt] ^= s;
+  byColorBB[c] ^= s;
+  /* board[s] = NO_PIECE;  Not needed, overwritten by the capturing one */
+  Square lastSquare = pieceList[c][pt][--pieceCount[c][pt]];
+  index[lastSquare] = index[s];
+  pieceList[c][pt][index[lastSquare]] = lastSquare;
+  pieceList[c][pt][pieceCount[c][pt]] = SQ_NONE;
+  pieceCount[c][ALL_PIECES]--;
 }
 
-#endif // !defined(POSITION_H_INCLUDED)
+inline void Position::move_piece(Color c, PieceType pt, Square from, Square to) {
+
+  // index[from] is not updated and becomes stale. This works as long as index[]
+  // is accessed just by known occupied squares.
+  Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
+  byTypeBB[ALL_PIECES] ^= from_to_bb;
+  byTypeBB[pt] ^= from_to_bb;
+  byColorBB[c] ^= from_to_bb;
+  board[from] = NO_PIECE;
+  board[to] = make_piece(c, pt);
+  index[to] = index[from];
+  pieceList[c][pt][index[to]] = to;
+}
+
+#endif // #ifndef POSITION_H_INCLUDED

src/psqt.cpp

@@ -0,0 +1,119 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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 "types.h"
+
+namespace PSQT {
+
+#define S(mg, eg) make_score(mg, eg)
+
+// Bonus[PieceType][Square / 2] contains Piece-Square scores. For each piece
+// type on a given square a (middlegame, endgame) score pair is assigned. Table
+// is defined for files A..D and white side: it is symmetric for black side and
+// second half of the files.
+const Score Bonus[][RANK_NB][int(FILE_NB) / 2] = {
+  { },
+  { // Pawn
+   { S(  0, 0), S(  0, 0), S(  0, 0), S( 0, 0) },
+   { S(-19, 5), S(  1,-4), S(  7, 8), S( 3,-2) },
+   { S(-26,-6), S( -7,-5), S( 19, 5), S(24, 4) },
+   { S(-25, 1), S(-14, 3), S( 16,-8), S(31,-3) },
+   { S(-14, 6), S(  0, 9), S( -1, 7), S(17,-6) },
+   { S(-14, 6), S(-13,-5), S(-10, 2), S(-6, 4) },
+   { S(-12, 1), S( 15,-9), S( -8, 1), S(-4,18) },
+   { S(  0, 0), S(  0, 0), S(  0, 0), S( 0, 0) }
+  },
+  { // Knight
+   { S(-143, -97), S(-96,-82), S(-80,-46), S(-73,-14) },
+   { S( -83, -69), S(-43,-55), S(-21,-17), S(-10,  9) },
+   { S( -71, -50), S(-22,-39), S(  0, -8), S(  9, 28) },
+   { S( -25, -41), S( 18,-25), S( 43,  7), S( 47, 38) },
+   { S( -26, -46), S( 16,-25), S( 38,  2), S( 50, 41) },
+   { S( -11, -55), S( 37,-38), S( 56, -8), S( 71, 27) },
+   { S( -62, -64), S(-17,-50), S(  5,-24), S( 14, 13) },
+   { S(-195,-110), S(-66,-90), S(-42,-50), S(-29,-13) }
+  },
+  { // Bishop
+   { S(-54,-68), S(-23,-40), S(-35,-46), S(-44,-28) },
+   { S(-30,-43), S( 10,-17), S(  2,-23), S( -9, -5) },
+   { S(-19,-32), S( 17, -9), S( 11,-13), S(  1,  8) },
+   { S(-21,-36), S( 18,-13), S( 11,-15), S(  0,  7) },
+   { S(-21,-36), S( 14,-14), S(  6,-17), S( -1,  3) },
+   { S(-27,-35), S(  6,-13), S(  2,-10), S( -8,  1) },
+   { S(-33,-44), S(  7,-21), S( -4,-22), S(-12, -4) },
+   { S(-45,-65), S(-21,-42), S(-29,-46), S(-39,-27) }
+  },
+  { // Rook
+   { S(-25, 0), S(-16, 0), S(-16, 0), S(-9, 0) },
+   { S(-21, 0), S( -8, 0), S( -3, 0), S( 0, 0) },
+   { S(-21, 0), S( -9, 0), S( -4, 0), S( 2, 0) },
+   { S(-22, 0), S( -6, 0), S( -1, 0), S( 2, 0) },
+   { S(-22, 0), S( -7, 0), S(  0, 0), S( 1, 0) },
+   { S(-21, 0), S( -7, 0), S(  0, 0), S( 2, 0) },
+   { S(-12, 0), S(  4, 0), S(  8, 0), S(12, 0) },
+   { S(-23, 0), S(-15, 0), S(-11, 0), S(-5, 0) }
+  },
+  { // Queen
+   { S( 0,-70), S(-3,-57), S(-4,-41), S(-1,-29) },
+   { S(-4,-58), S( 6,-30), S( 9,-21), S( 8, -4) },
+   { S(-2,-39), S( 6,-17), S( 9, -7), S( 9,  5) },
+   { S(-1,-29), S( 8, -5), S(10,  9), S( 7, 17) },
+   { S(-3,-27), S( 9, -5), S( 8, 10), S( 7, 23) },
+   { S(-2,-40), S( 6,-16), S( 8,-11), S(10,  3) },
+   { S(-2,-54), S( 7,-30), S( 7,-21), S( 6, -7) },
+   { S(-1,-75), S(-4,-54), S(-1,-44), S( 0,-30) }
+  },
+  { // King
+   { S(291, 28), S(344, 76), S(294,103), S(219,112) },
+   { S(289, 70), S(329,119), S(263,170), S(205,159) },
+   { S(226,109), S(271,164), S(202,195), S(136,191) },
+   { S(204,131), S(212,194), S(175,194), S(137,204) },
+   { S(177,132), S(205,187), S(143,224), S( 94,227) },
+   { S(147,118), S(188,178), S(113,199), S( 70,197) },
+   { S(116, 72), S(158,121), S( 93,142), S( 48,161) },
+   { S( 94, 30), S(120, 76), S( 78,101), S( 31,111) }
+  }
+};
+
+#undef S
+
+Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+
+// init() initializes piece square tables: the white halves of the tables are
+// copied from Bonus[] adding the piece value, then the black halves of the
+// tables are initialized by flipping and changing the sign of the white scores.
+void init() {
+
+  for (PieceType pt = PAWN; pt <= KING; ++pt)
+  {
+      PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt];
+      PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt];
+
+      Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]);
+
+      for (Square s = SQ_A1; s <= SQ_H8; ++s)
+      {
+          int edgeDistance = file_of(s) < FILE_E ? file_of(s) : FILE_H - file_of(s);
+          psq[BLACK][pt][~s] = -(psq[WHITE][pt][s] = v + Bonus[pt][rank_of(s)][edgeDistance]);
+      }
+  }
+}
+
+} // namespace PSQT

src/psqtab.h

@@ -1,190 +0,0 @@
-/*
-  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(PSQTAB_H_INCLUDED)
-#define PSQTAB_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include "value.h"
-
-namespace {
-
-////
-//// Constants modified by Joona Kiiski
-////
-
-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
-   // 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
-   //  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
-   // 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
-   // 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
-   // 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
-   //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
-  }
-};
-
-const int EgPST[][64] = {
-  { },
-  {// 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
-   // 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
-   // 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
-   // 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
-   // 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
-   //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

@@ -1,84 +0,0 @@
-/*
-  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.
-
- ** A small "keep it simple and stupid" RNG with some fancy merits:
- **
- ** 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
- **
- ** (c) Heinz van Saanen
-
-*/
-
-#if !defined(RKISS_H_INCLUDED)
-#define RKISS_H_INCLUDED
-
-
-////
-//// Includes
-////
-
-#include "types.h"
-
-
-////
-//// Types
-////
-
-class RKISS {
-
-  // Keep variables always together
-  struct S { uint64_t a, b, c, d; } s;
-
-  // Return 64 bit unsigned integer in between [0,2^64-1]
-  uint64_t rand64() {
-
-      const uint64_t
-        e = s.a - ((s.b <<  7) | (s.b >> 57));
-      s.a = s.b ^ ((s.c << 13) | (s.c >> 51));
-      s.b = s.c + ((s.d << 37) | (s.d >> 27));
-      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,439 +0,0 @@
-/*
-  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/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <cstring>
-#include <iomanip>
-#include <string>
-#include <sstream>
-
-#include "movegen.h"
-#include "san.h"
-
-using std::string;
-
-////
-//// Local definitions
-////
-
-namespace {
-
-  enum Ambiguity {
-    AMBIGUITY_NONE, AMBIGUITY_FILE, AMBIGUITY_RANK, AMBIGUITY_BOTH
-  };
-
-  Ambiguity move_ambiguity(const Position& pos, Move m);
-  const string time_string(int milliseconds);
-  const 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 string move_to_san(Position& pos, Move m) {
-
-  assert(pos.is_ok());
-  assert(move_is_ok(m));
-
-  string san;
-  Square from = move_from(m);
-  Square to = move_to(m);
-  PieceType pt = type_of_piece(pos.piece_on(from));
-
-  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);
-
-          switch (move_ambiguity(pos, m)) {
-          case AMBIGUITY_NONE:
-            break;
-          case AMBIGUITY_FILE:
-            san += file_to_char(square_file(from));
-            break;
-          case AMBIGUITY_RANK:
-            san += rank_to_char(square_rank(from));
-            break;
-          case AMBIGUITY_BOTH:
-            san += square_to_string(from);
-            break;
-          default:
-            assert(false);
-          }
-      }
-
-      if (pos.move_is_capture(m))
-      {
-          if (pt == PAWN)
-              san += file_to_char(square_file(from));
-
-          san += 'x';
-      }
-      san += square_to_string(to);
-
-      if (move_is_promotion(m))
-      {
-          san += '=';
-          san += piece_type_to_char(move_promotion_piece(m));
-      }
-  }
-
-  // The move gives check ? We don't use pos.move_is_check() here
-  // because we need to test for mate after the move is done.
-  StateInfo st;
-  pos.do_move(m, st);
-  if (pos.is_check())
-      san += pos.is_mate() ? "#" : "+";
-  pos.undo_move(m);
-
-  return san;
-}
-
-
-/// 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(const Position& pos, const string& movestr) {
-
-  assert(pos.is_ok());
-
-  enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
-  static const string pieceLetters = "KQRBN";
-
-  MoveStack mlist[MOVES_MAX], *last;
-  PieceType pt = PIECE_TYPE_NONE, promotion = PIECE_TYPE_NONE;
-  File fromFile = FILE_NONE, toFile = FILE_NONE;
-  Rank fromRank = RANK_NONE, toRank = RANK_NONE;
-  Move move = MOVE_NONE;
-  Square from, to;
-  int matches, state = START;
-
-  // Generate all legal moves for the given position
-  last = generate_moves(pos, mlist);
-
-  // Castling moves
-  if (movestr == "O-O-O" || movestr == "O-O-O+")
-  {
-     for (MoveStack* cur = mlist; cur != last; cur++)
-          if (move_is_long_castle(cur->move))
-              return cur->move;
-
-      return MOVE_NONE;
-  }
-  else if (movestr == "O-O" || movestr == "O-O+")
-  {
-      for (MoveStack* cur = mlist; cur != last; cur++)
-           if (move_is_short_castle(cur->move))
-               return cur->move;
-
-    return MOVE_NONE;
-  }
-
-  // Normal moves. We use a simple FSM to parse the san string
-  for (size_t i = 0; i < movestr.length(); i++)
-  {
-      char type, c = movestr[i];
-
-      if (pieceLetters.find(c) != string::npos)
-          type = 'P';
-      else if (c >= 'a' && c <= 'h')
-          type = 'F';
-      else if (c >= '1' && c <= '8')
-          type = 'R';
-      else
-          type = c;
-
-      switch (type) {
-      case 'P':
-          if (state == START)
-          {
-              pt = piece_type_from_char(c);
-              state = TO_FILE;
-          }
-          else if (state == PROMOTION)
-          {
-              promotion = piece_type_from_char(c);
-              state = (i < movestr.length() - 1 ? CHECK : END);
-          }
-          else
-              return MOVE_NONE;
-          break;
-      case 'F':
-          if (state == START)
-          {
-              pt = PAWN;
-              fromFile = toFile = file_from_char(c);
-              state = TO_RANK;
-          }
-          else if (state == TO_FILE)
-          {
-              toFile = file_from_char(c);
-              state = TO_RANK;
-          }
-          else if (state == TO_RANK && toFile != FILE_NONE)
-          {
-              // Previous file was for disambiguation
-              fromFile = toFile;
-              toFile = file_from_char(c);
-          }
-          else
-              return MOVE_NONE;
-          break;
-      case 'R':
-          if (state == TO_RANK)
-          {
-              toRank = rank_from_char(c);
-              state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
-          }
-          else if (state == TO_FILE && fromRank == RANK_NONE)
-          {
-              // It's a disambiguation rank instead of a file
-              fromRank = rank_from_char(c);
-          }
-          else
-              return MOVE_NONE;
-          break;
-      case 'x':
-      case 'X':
-          if (state == TO_RANK)
-          {
-              // Previous file was for disambiguation, or it's a pawn capture
-              fromFile = toFile;
-              state = TO_FILE;
-          }
-          else if (state != TO_FILE)
-              return MOVE_NONE;
-          break;
-      case '=':
-          if (state == PROMOTION_OR_CHECK)
-              state = PROMOTION;
-          else
-              return MOVE_NONE;
-          break;
-      case '+':
-      case '#':
-          if (state == PROMOTION_OR_CHECK || state == CHECK)
-              state = END;
-          else
-              return MOVE_NONE;
-          break;
-      default:
-          return MOVE_NONE;
-          break;
-      }
-  }
-
-  if (state != END)
-      return MOVE_NONE;
-
-  // Look for an unambiguous matching move
-  to = make_square(toFile, toRank);
-  matches = 0;
-
-  for (MoveStack* cur = mlist; cur != last; cur++)
-  {
-      from = move_from(cur->move);
-
-      if (   pos.type_of_piece_on(from) == pt
-          && move_to(cur->move) == to
-          && move_promotion_piece(cur->move) == promotion
-          && (fromFile == FILE_NONE || fromFile == square_file(from))
-          && (fromRank == RANK_NONE || fromRank == square_rank(from)))
-      {
-          move = cur->move;
-          matches++;
-      }
-  }
-  return matches == 1 ? move : 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 string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
-
-  StateInfo st;
-  std::stringstream s;
-  string moveStr;
-  size_t length = 0;
-  size_t maxLength = 80 - startColumn;
-  Position p(pos, pos.thread());
-
-  for (Move* m = line; *m != MOVE_NONE; m++)
-  {
-      moveStr = move_to_san(p, *m);
-      length += moveStr.length() + 1;
-      if (breakLines && length > maxLength)
-      {
-          s << "\n" << std::setw(startColumn) << " ";
-          length = moveStr.length() + 1;
-      }
-      s << moveStr << ' ';
-
-      if (*m == MOVE_NULL)
-          p.do_null_move(st);
-      else
-          p.do_move(*m, st);
-  }
-  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 string pretty_pv(const Position& pos, int time, int depth,
-                       Value score, ValueType type, Move pv[]) {
-
-  const int64_t K = 1000;
-  const int64_t M = 1000000;
-
-  std::stringstream s;
-
-  // Depth
-  s << std::setw(2) << depth << "  ";
-
-  // Score
-  s << (type == VALUE_TYPE_LOWER ? ">" : type == VALUE_TYPE_UPPER ? "<" : " ")
-    << std::setw(7) << score_string(score);
-
-  // Time
-  s << std::setw(8) << time_string(time) << " ";
-
-  // Nodes
-  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 ";
-
-  // PV
-  s << line_to_san(pos, pv, 30, true);
-
-  return s.str();
-}
-
-
-namespace {
-
-  Ambiguity move_ambiguity(const Position& pos, Move m) {
-
-    MoveStack mlist[MOVES_MAX], *last;
-    Move candidates[8];
-    Square from = move_from(m);
-    Square to = move_to(m);
-    Piece pc = pos.piece_on(from);
-    int matches = 0, f = 0, r = 0;
-
-    // If there is only one piece 'pc' then move cannot be ambiguous
-    if (pos.piece_count(pos.side_to_move(), type_of_piece(pc)) == 1)
-        return AMBIGUITY_NONE;
-
-    // Collect all legal moves of piece 'pc' with destination 'to'
-    last = generate_moves(pos, mlist);
-    for (MoveStack* cur = mlist; cur != last; cur++)
-        if (move_to(cur->move) == to && pos.piece_on(move_from(cur->move)) == pc)
-            candidates[matches++] = cur->move;
-
-    if (matches == 1)
-        return AMBIGUITY_NONE;
-
-    for (int i = 0; i < matches; i++)
-    {
-        if (square_file(move_from(candidates[i])) == square_file(from))
-            f++;
-
-        if (square_rank(move_from(candidates[i])) == square_rank(from))
-            r++;
-    }
-
-    return f == 1 ? AMBIGUITY_FILE : r == 1 ? AMBIGUITY_RANK : AMBIGUITY_BOTH;
-  }
-
-
-  const string time_string(int millisecs) {
-
-    const int MSecMinute = 1000 * 60;
-    const int MSecHour   = 1000 * 60 * 60;
-
-    std::stringstream s;
-    s << std::setfill('0');
-
-    int hours = millisecs / MSecHour;
-    int minutes = (millisecs - hours * MSecHour) / MSecMinute;
-    int seconds = (millisecs - hours * MSecHour - minutes * MSecMinute) / 1000;
-
-    if (hours)
-        s << hours << ':';
-
-    s << 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
-    {
-        float floatScore = float(v) / float(PawnValueMidgame);
-        if (v >= 0)
-            s << '+';
-
-        s << std::setprecision(2) << std::fixed << floatScore;
-    }
-    return s.str();
-  }
-}

src/san.h

@@ -1,44 +0,0 @@
-/*
-  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(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(const Position& pos, const std::string& str);
-extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
-extern const std::string pretty_pv(const Position& pos, int time, int depth, Value score, ValueType type, Move pv[]);
-
-#endif // !defined(SAN_H_INCLUDED)

src/search.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,61 +18,93 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef SEARCH_H_INCLUDED
-#if !defined(SEARCH_H_INCLUDED)
 #define SEARCH_H_INCLUDED
 
-////
+#include <atomic>
-//// Includes
+#include <memory>  // For std::unique_ptr
-////
+#include <stack>
+#include <vector>
 
-#include "depth.h"
+#include "misc.h"
-#include "move.h"
+#include "position.h"
-#include "value.h"
+#include "types.h"
 
+namespace Search {
 
-////
+/// Stack struct keeps track of the information we need to remember from nodes
-//// Constants
+/// shallower and deeper in the tree during the search. Each search thread has
-////
+/// its own array of Stack objects, indexed by the current ply.
 
-const int PLY_MAX = 100;
+struct Stack {
-const int PLY_MAX_PLUS_2 = PLY_MAX + 2;
+  Move* pv;
-
+  int ply;
-
-////
-//// Types
-////
-
-/// The SearchStack struct keeps track of the information we need to remember
-/// from nodes shallower and deeper in the tree during the search.  Each
-/// search thread has its own array of SearchStack objects, indexed by the
-/// current ply.
-struct EvalInfo;
-struct SplitPoint;
-
-struct SearchStack {
   Move currentMove;
-  Move mateKiller;
   Move excludedMove;
-  Move bestMove;
   Move killers[2];
-  Depth reduction;
+  Value staticEval;
-  Value eval;
+  bool skipEarlyPruning;
-  Value evalMargin;
+  int moveCount;
-  bool skipNullMove;
-  SplitPoint* sp;
 };
 
+/// RootMove struct is used for moves at the root of the tree. For each root move
+/// we store a score and a PV (really a refutation in the case of moves which
+/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
 
-////
+struct RootMove {
-//// Prototypes
-////
 
-extern void init_search();
+  explicit RootMove(Move m) : pv(1, m) {}
-extern void init_threads();
-extern void exit_threads();
-extern int perft(Position& pos, Depth depth);
-extern bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[],
-                  int movesToGo, int maxDepth, int maxNodes, int maxTime, Move searchMoves[]);
 
-#endif // !defined(SEARCH_H_INCLUDED)
+  bool operator<(const RootMove& m) const { return m.score < score; } // Descending sort
+  bool operator==(const Move& m) const { return pv[0] == m; }
+  void insert_pv_in_tt(Position& pos);
+  bool extract_ponder_from_tt(Position& pos);
+
+  Value score = -VALUE_INFINITE;
+  Value previousScore = -VALUE_INFINITE;
+  std::vector<Move> pv;
+};
+
+typedef std::vector<RootMove> RootMoveVector;
+
+/// LimitsType 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 it's our opponent's turn to move.
+
+struct LimitsType {
+
+  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
+    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movestogo =
+    depth = movetime = mate = infinite = ponder = 0;
+  }
+
+  bool use_time_management() const {
+    return !(mate | movetime | depth | nodes | infinite);
+  }
+
+  std::vector<Move> searchmoves;
+  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder;
+  int64_t nodes;
+  TimePoint startTime;
+};
+
+/// The SignalsType struct stores atomic flags updated during the search
+/// typically in an async fashion e.g. to stop the search by the GUI.
+
+struct SignalsType {
+  std::atomic_bool stop, stopOnPonderhit;
+};
+
+typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
+
+extern SignalsType Signals;
+extern LimitsType Limits;
+extern StateStackPtr SetupStates;
+
+void init();
+void clear();
+template<bool Root = true> uint64_t perft(Position& pos, Depth depth);
+
+} // namespace Search
+
+#endif // #ifndef SEARCH_H_INCLUDED

src/square.h

@@ -1,183 +0,0 @@
-/*
-  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(SQUARE_H_INCLUDED)
-#define SQUARE_H_INCLUDED
-
-////
-//// Includes
-////
-
-#include <cstdlib> // for abs()
-#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_N = 8, DELTA_E = 1, DELTA_S = -8, DELTA_W = -1, DELTA_NONE = 0,
-
-  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
-};
-
-ENABLE_OPERATORS_ON(Square)
-ENABLE_OPERATORS_ON(File)
-ENABLE_OPERATORS_ON(Rank)
-ENABLE_OPERATORS_ON(SquareDelta)
-
-
-////
-//// Constants
-////
-
-const int FlipMask = 56;
-const int FlopMask =  7;
-
-////
-//// Inline functions
-////
-
-inline Square operator+ (Square x, SquareDelta i) { return x + Square(i); }
-inline void operator+= (Square& x, SquareDelta i) { x = x + Square(i); }
-inline Square operator- (Square x, SquareDelta i) { return x - Square(i); }
-inline void operator-= (Square& x, SquareDelta i) { x = x - Square(i); }
-
-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 relative_rank(Color c, Square s) {
-  return square_rank(relative_square(c, s));
-}
-
-inline SquareColor square_color(Square s) {
-  return SquareColor((int(square_file(s)) + int(square_rank(s))) & 1);
-}
-
-inline bool same_color_squares(Square s1, Square s2) {
-  int s = int(s1) ^ int(s2);
-  return (((s >> 3) ^ s) & 1) == 0;
-}
-
-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));
-}
-
-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) {
-  return  std::string(1, file_to_char(square_file(s)))
-        + std::string(1, rank_to_char(square_rank(s)));
-}
-
-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 file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
-}
-
-#endif // !defined(SQUARE_H_INCLUDED)

src/syzygy/tbcore.h

@@ -0,0 +1,169 @@
+/*
+  Copyright (c) 2011-2013 Ronald de Man
+*/
+
+#ifndef TBCORE_H
+#define TBCORE_H
+
+#ifndef _WIN32
+#include <pthread.h>
+#define SEP_CHAR ':'
+#define FD int
+#define FD_ERR -1
+#else
+#include <windows.h>
+#define SEP_CHAR ';'
+#define FD HANDLE
+#define FD_ERR INVALID_HANDLE_VALUE
+#endif
+
+#ifndef _WIN32
+#define LOCK_T pthread_mutex_t
+#define LOCK_INIT(x) pthread_mutex_init(&(x), NULL)
+#define LOCK(x) pthread_mutex_lock(&(x))
+#define UNLOCK(x) pthread_mutex_unlock(&(x))
+#else
+#define LOCK_T HANDLE
+#define LOCK_INIT(x) do { x = CreateMutex(NULL, FALSE, NULL); } while (0)
+#define LOCK(x) WaitForSingleObject(x, INFINITE)
+#define UNLOCK(x) ReleaseMutex(x)
+#endif
+
+#ifndef _MSC_VER
+#define BSWAP32(v) __builtin_bswap32(v)
+#define BSWAP64(v) __builtin_bswap64(v)
+#else
+#define BSWAP32(v) _byteswap_ulong(v)
+#define BSWAP64(v) _byteswap_uint64(v)
+#endif
+
+#define WDLSUFFIX ".rtbw"
+#define DTZSUFFIX ".rtbz"
+#define WDLDIR "RTBWDIR"
+#define DTZDIR "RTBZDIR"
+#define TBPIECES 6
+
+typedef unsigned long long uint64;
+typedef unsigned int uint32;
+typedef unsigned char ubyte;
+typedef unsigned short ushort;
+
+const ubyte WDL_MAGIC[4] = { 0x71, 0xe8, 0x23, 0x5d };
+const ubyte DTZ_MAGIC[4] = { 0xd7, 0x66, 0x0c, 0xa5 };
+
+#define TBHASHBITS 10
+
+struct TBHashEntry;
+
+typedef uint64 base_t;
+
+struct PairsData {
+  char *indextable;
+  ushort *sizetable;
+  ubyte *data;
+  ushort *offset;
+  ubyte *symlen;
+  ubyte *sympat;
+  int blocksize;
+  int idxbits;
+  int min_len;
+  base_t base[1]; // C++ complains about base[]...
+};
+
+struct TBEntry {
+  char *data;
+  uint64 key;
+  uint64 mapping;
+  ubyte ready;
+  ubyte num;
+  ubyte symmetric;
+  ubyte has_pawns;
+}
+#ifndef _WIN32
+__attribute__((__may_alias__))
+#endif
+;
+
+struct TBEntry_piece {
+  char *data;
+  uint64 key;
+  uint64 mapping;
+  ubyte ready;
+  ubyte num;
+  ubyte symmetric;
+  ubyte has_pawns;
+  ubyte enc_type;
+  struct PairsData *precomp[2];
+  int factor[2][TBPIECES];
+  ubyte pieces[2][TBPIECES];
+  ubyte norm[2][TBPIECES];
+};
+
+struct TBEntry_pawn {
+  char *data;
+  uint64 key;
+  uint64 mapping;
+  ubyte ready;
+  ubyte num;
+  ubyte symmetric;
+  ubyte has_pawns;
+  ubyte pawns[2];
+  struct {
+    struct PairsData *precomp[2];
+    int factor[2][TBPIECES];
+    ubyte pieces[2][TBPIECES];
+    ubyte norm[2][TBPIECES];
+  } file[4];
+};
+
+struct DTZEntry_piece {
+  char *data;
+  uint64 key;
+  uint64 mapping;
+  ubyte ready;
+  ubyte num;
+  ubyte symmetric;
+  ubyte has_pawns;
+  ubyte enc_type;
+  struct PairsData *precomp;
+  int factor[TBPIECES];
+  ubyte pieces[TBPIECES];
+  ubyte norm[TBPIECES];
+  ubyte flags; // accurate, mapped, side
+  ushort map_idx[4];
+  ubyte *map;
+};
+
+struct DTZEntry_pawn {
+  char *data;
+  uint64 key;
+  uint64 mapping;
+  ubyte ready;
+  ubyte num;
+  ubyte symmetric;
+  ubyte has_pawns;
+  ubyte pawns[2];
+  struct {
+    struct PairsData *precomp;
+    int factor[TBPIECES];
+    ubyte pieces[TBPIECES];
+    ubyte norm[TBPIECES];
+  } file[4];
+  ubyte flags[4];
+  ushort map_idx[4][4];
+  ubyte *map;
+};
+
+struct TBHashEntry {
+  uint64 key;
+  struct TBEntry *ptr;
+};
+
+struct DTZTableEntry {
+  uint64 key1;
+  uint64 key2;
+  struct TBEntry *entry;
+};
+
+#endif
+

src/syzygy/tbprobe.cpp

@@ -0,0 +1,833 @@
+/*
+  Copyright (c) 2013 Ronald de Man
+  This file may be redistributed and/or modified without restrictions.
+
+  tbprobe.cpp contains the Stockfish-specific routines of the
+  tablebase probing code. It should be relatively easy to adapt
+  this code to other chess engines.
+*/
+
+#define NOMINMAX
+
+#include <algorithm>
+
+#include "../position.h"
+#include "../movegen.h"
+#include "../bitboard.h"
+#include "../search.h"
+#include "../bitcount.h"
+
+#include "tbprobe.h"
+#include "tbcore.h"
+
+#include "tbcore.cpp"
+
+namespace Zobrist {
+  extern Key psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB];
+}
+
+int Tablebases::MaxCardinality = 0;
+
+// Given a position with 6 or fewer pieces, produce a text string
+// of the form KQPvKRP, where "KQP" represents the white pieces if
+// mirror == 0 and the black pieces if mirror == 1.
+static void prt_str(Position& pos, char *str, int mirror)
+{
+  Color color;
+  PieceType pt;
+  int i;
+
+  color = !mirror ? WHITE : BLACK;
+  for (pt = KING; pt >= PAWN; --pt)
+    for (i = popcount<Max15>(pos.pieces(color, pt)); i > 0; i--)
+      *str++ = pchr[6 - pt];
+  *str++ = 'v';
+  color = ~color;
+  for (pt = KING; pt >= PAWN; --pt)
+    for (i = popcount<Max15>(pos.pieces(color, pt)); i > 0; i--)
+      *str++ = pchr[6 - pt];
+  *str++ = 0;
+}
+
+// Given a position, produce a 64-bit material signature key.
+// If the engine supports such a key, it should equal the engine's key.
+static uint64 calc_key(Position& pos, int mirror)
+{
+  Color color;
+  PieceType pt;
+  int i;
+  uint64 key = 0;
+
+  color = !mirror ? WHITE : BLACK;
+  for (pt = PAWN; pt <= KING; ++pt)
+    for (i = popcount<Max15>(pos.pieces(color, pt)); i > 0; i--)
+      key ^= Zobrist::psq[WHITE][pt][i - 1];
+  color = ~color;
+  for (pt = PAWN; pt <= KING; ++pt)
+    for (i = popcount<Max15>(pos.pieces(color, pt)); i > 0; i--)
+      key ^= Zobrist::psq[BLACK][pt][i - 1];
+
+  return key;
+}
+
+// Produce a 64-bit material key corresponding to the material combination
+// defined by pcs[16], where pcs[1], ..., pcs[6] is the number of white
+// pawns, ..., kings and pcs[9], ..., pcs[14] is the number of black
+// pawns, ..., kings.
+static uint64 calc_key_from_pcs(int *pcs, int mirror)
+{
+  int color;
+  PieceType pt;
+  int i;
+  uint64 key = 0;
+
+  color = !mirror ? 0 : 8;
+  for (pt = PAWN; pt <= KING; ++pt)
+    for (i = 0; i < pcs[color + pt]; i++)
+      key ^= Zobrist::psq[WHITE][pt][i];
+  color ^= 8;
+  for (pt = PAWN; pt <= KING; ++pt)
+    for (i = 0; i < pcs[color + pt]; i++)
+      key ^= Zobrist::psq[BLACK][pt][i];
+
+  return key;
+}
+
+bool is_little_endian() {
+  union {
+    int i;
+    char c[sizeof(int)];
+  } x;
+  x.i = 1;
+  return x.c[0] == 1;
+}
+
+static ubyte decompress_pairs(struct PairsData *d, uint64 idx)
+{
+  static const bool isLittleEndian = is_little_endian();
+  return isLittleEndian ? decompress_pairs<true >(d, idx)
+                        : decompress_pairs<false>(d, idx);
+}
+
+// probe_wdl_table and probe_dtz_table require similar adaptations.
+static int probe_wdl_table(Position& pos, int *success)
+{
+  struct TBEntry *ptr;
+  struct TBHashEntry *ptr2;
+  uint64 idx;
+  uint64 key;
+  int i;
+  ubyte res;
+  int p[TBPIECES];
+
+  // Obtain the position's material signature key.
+  key = pos.material_key();
+
+  // Test for KvK.
+  if (key == (Zobrist::psq[WHITE][KING][0] ^ Zobrist::psq[BLACK][KING][0]))
+    return 0;
+
+  ptr2 = TB_hash[key >> (64 - TBHASHBITS)];
+  for (i = 0; i < HSHMAX; i++)
+    if (ptr2[i].key == key) break;
+  if (i == HSHMAX) {
+    *success = 0;
+    return 0;
+  }
+
+  ptr = ptr2[i].ptr;
+  if (!ptr->ready) {
+    LOCK(TB_mutex);
+    if (!ptr->ready) {
+      char str[16];
+      prt_str(pos, str, ptr->key != key);
+      if (!init_table_wdl(ptr, str)) {
+        ptr2[i].key = 0ULL;
+        *success = 0;
+        UNLOCK(TB_mutex);
+        return 0;
+      }
+      // Memory barrier to ensure ptr->ready = 1 is not reordered.
+#ifdef _MSC_VER
+      _ReadWriteBarrier();
+#else
+      __asm__ __volatile__ ("" ::: "memory");
+#endif
+      ptr->ready = 1;
+    }
+    UNLOCK(TB_mutex);
+  }
+
+  int bside, mirror, cmirror;
+  if (!ptr->symmetric) {
+    if (key != ptr->key) {
+      cmirror = 8;
+      mirror = 0x38;
+      bside = (pos.side_to_move() == WHITE);
+    } else {
+      cmirror = mirror = 0;
+      bside = !(pos.side_to_move() == WHITE);
+    }
+  } else {
+    cmirror = pos.side_to_move() == WHITE ? 0 : 8;
+    mirror = pos.side_to_move() == WHITE ? 0 : 0x38;
+    bside = 0;
+  }
+
+  // p[i] is to contain the square 0-63 (A1-H8) for a piece of type
+  // pc[i] ^ cmirror, where 1 = white pawn, ..., 14 = black king.
+  // Pieces of the same type are guaranteed to be consecutive.
+  if (!ptr->has_pawns) {
+    struct TBEntry_piece *entry = (struct TBEntry_piece *)ptr;
+    ubyte *pc = entry->pieces[bside];
+    for (i = 0; i < entry->num;) {
+      Bitboard bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
+                                      (PieceType)(pc[i] & 0x07));
+      do {
+        p[i++] = pop_lsb(&bb);
+      } while (bb);
+    }
+    idx = encode_piece(entry, entry->norm[bside], p, entry->factor[bside]);
+    res = decompress_pairs(entry->precomp[bside], idx);
+  } else {
+    struct TBEntry_pawn *entry = (struct TBEntry_pawn *)ptr;
+    int k = entry->file[0].pieces[0][0] ^ cmirror;
+    Bitboard bb = pos.pieces((Color)(k >> 3), (PieceType)(k & 0x07));
+    i = 0;
+    do {
+      p[i++] = pop_lsb(&bb) ^ mirror;
+    } while (bb);
+    int f = pawn_file(entry, p);
+    ubyte *pc = entry->file[f].pieces[bside];
+    for (; i < entry->num;) {
+      bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
+                                    (PieceType)(pc[i] & 0x07));
+      do {
+        p[i++] = pop_lsb(&bb) ^ mirror;
+      } while (bb);
+    }
+    idx = encode_pawn(entry, entry->file[f].norm[bside], p, entry->file[f].factor[bside]);
+    res = decompress_pairs(entry->file[f].precomp[bside], idx);
+  }
+
+  return ((int)res) - 2;
+}
+
+static int probe_dtz_table(Position& pos, int wdl, int *success)
+{
+  struct TBEntry *ptr;
+  uint64 idx;
+  int i, res;
+  int p[TBPIECES];
+
+  // Obtain the position's material signature key.
+  uint64 key = pos.material_key();
+
+  if (DTZ_table[0].key1 != key && DTZ_table[0].key2 != key) {
+    for (i = 1; i < DTZ_ENTRIES; i++)
+      if (DTZ_table[i].key1 == key) break;
+    if (i < DTZ_ENTRIES) {
+      struct DTZTableEntry table_entry = DTZ_table[i];
+      for (; i > 0; i--)
+        DTZ_table[i] = DTZ_table[i - 1];
+      DTZ_table[0] = table_entry;
+    } else {
+      struct TBHashEntry *ptr2 = TB_hash[key >> (64 - TBHASHBITS)];
+      for (i = 0; i < HSHMAX; i++)
+        if (ptr2[i].key == key) break;
+      if (i == HSHMAX) {
+        *success = 0;
+        return 0;
+      }
+      ptr = ptr2[i].ptr;
+      char str[16];
+      int mirror = (ptr->key != key);
+      prt_str(pos, str, mirror);
+      if (DTZ_table[DTZ_ENTRIES - 1].entry)
+        free_dtz_entry(DTZ_table[DTZ_ENTRIES-1].entry);
+      for (i = DTZ_ENTRIES - 1; i > 0; i--)
+        DTZ_table[i] = DTZ_table[i - 1];
+      load_dtz_table(str, calc_key(pos, mirror), calc_key(pos, !mirror));
+    }
+  }
+
+  ptr = DTZ_table[0].entry;
+  if (!ptr) {
+    *success = 0;
+    return 0;
+  }
+
+  int bside, mirror, cmirror;
+  if (!ptr->symmetric) {
+    if (key != ptr->key) {
+      cmirror = 8;
+      mirror = 0x38;
+      bside = (pos.side_to_move() == WHITE);
+    } else {
+      cmirror = mirror = 0;
+      bside = !(pos.side_to_move() == WHITE);
+    }
+  } else {
+    cmirror = pos.side_to_move() == WHITE ? 0 : 8;
+    mirror = pos.side_to_move() == WHITE ? 0 : 0x38;
+    bside = 0;
+  }
+
+  if (!ptr->has_pawns) {
+    struct DTZEntry_piece *entry = (struct DTZEntry_piece *)ptr;
+    if ((entry->flags & 1) != bside && !entry->symmetric) {
+      *success = -1;
+      return 0;
+    }
+    ubyte *pc = entry->pieces;
+    for (i = 0; i < entry->num;) {
+      Bitboard bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
+                                    (PieceType)(pc[i] & 0x07));
+      do {
+        p[i++] = pop_lsb(&bb);
+      } while (bb);
+    }
+    idx = encode_piece((struct TBEntry_piece *)entry, entry->norm, p, entry->factor);
+    res = decompress_pairs(entry->precomp, idx);
+
+    if (entry->flags & 2)
+      res = entry->map[entry->map_idx[wdl_to_map[wdl + 2]] + res];
+
+    if (!(entry->flags & pa_flags[wdl + 2]) || (wdl & 1))
+      res *= 2;
+  } else {
+    struct DTZEntry_pawn *entry = (struct DTZEntry_pawn *)ptr;
+    int k = entry->file[0].pieces[0] ^ cmirror;
+    Bitboard bb = pos.pieces((Color)(k >> 3), (PieceType)(k & 0x07));
+    i = 0;
+    do {
+      p[i++] = pop_lsb(&bb) ^ mirror;
+    } while (bb);
+    int f = pawn_file((struct TBEntry_pawn *)entry, p);
+    if ((entry->flags[f] & 1) != bside) {
+      *success = -1;
+      return 0;
+    }
+    ubyte *pc = entry->file[f].pieces;
+    for (; i < entry->num;) {
+      bb = pos.pieces((Color)((pc[i] ^ cmirror) >> 3),
+                            (PieceType)(pc[i] & 0x07));
+      do {
+        p[i++] = pop_lsb(&bb) ^ mirror;
+      } while (bb);
+    }
+    idx = encode_pawn((struct TBEntry_pawn *)entry, entry->file[f].norm, p, entry->file[f].factor);
+    res = decompress_pairs(entry->file[f].precomp, idx);
+
+    if (entry->flags[f] & 2)
+      res = entry->map[entry->map_idx[f][wdl_to_map[wdl + 2]] + res];
+
+    if (!(entry->flags[f] & pa_flags[wdl + 2]) || (wdl & 1))
+      res *= 2;
+  }
+
+  return res;
+}
+
+// Add underpromotion captures to list of captures.
+static ExtMove *add_underprom_caps(Position& pos, ExtMove *stack, ExtMove *end)
+{
+  ExtMove *moves, *extra = end;
+
+  for (moves = stack; moves < end; moves++) {
+    Move move = moves->move;
+    if (type_of(move) == PROMOTION && !pos.empty(to_sq(move))) {
+      (*extra++).move = (Move)(move - (1 << 12));
+      (*extra++).move = (Move)(move - (2 << 12));
+      (*extra++).move = (Move)(move - (3 << 12));
+    }
+  }
+
+  return extra;
+}
+
+static int probe_ab(Position& pos, int alpha, int beta, int *success)
+{
+  int v;
+  ExtMove stack[64];
+  ExtMove *moves, *end;
+  StateInfo st;
+
+  // Generate (at least) all legal non-ep captures including (under)promotions.
+  // It is OK to generate more, as long as they are filtered out below.
+  if (!pos.checkers()) {
+    end = generate<CAPTURES>(pos, stack);
+    // Since underpromotion captures are not included, we need to add them.
+    end = add_underprom_caps(pos, stack, end);
+  } else
+    end = generate<EVASIONS>(pos, stack);
+
+  CheckInfo ci(pos);
+
+  for (moves = stack; moves < end; moves++) {
+    Move capture = moves->move;
+    if (!pos.capture(capture) || type_of(capture) == ENPASSANT
+                        || !pos.legal(capture, ci.pinned))
+      continue;
+    pos.do_move(capture, st, pos.gives_check(capture, ci));
+    v = -probe_ab(pos, -beta, -alpha, success);
+    pos.undo_move(capture);
+    if (*success == 0) return 0;
+    if (v > alpha) {
+      if (v >= beta) {
+        *success = 2;
+        return v;
+      }
+      alpha = v;
+    }
+  }
+
+  v = probe_wdl_table(pos, success);
+  if (*success == 0) return 0;
+  if (alpha >= v) {
+    *success = 1 + (alpha > 0);
+    return alpha;
+  } else {
+    *success = 1;
+    return v;
+  }
+}
+
+// Probe the WDL table for a particular position.
+// If *success != 0, the probe was successful.
+// The return value is from the point of view of the side to move:
+// -2 : loss
+// -1 : loss, but draw under 50-move rule
+//  0 : draw
+//  1 : win, but draw under 50-move rule
+//  2 : win
+int Tablebases::probe_wdl(Position& pos, int *success)
+{
+  int v;
+
+  *success = 1;
+  v = probe_ab(pos, -2, 2, success);
+
+  // If en passant is not possible, we are done.
+  if (pos.ep_square() == SQ_NONE)
+    return v;
+  if (!(*success)) return 0;
+
+  // Now handle en passant.
+  int v1 = -3;
+  // Generate (at least) all legal en passant captures.
+  ExtMove stack[192];
+  ExtMove *moves, *end;
+  StateInfo st;
+
+  if (!pos.checkers())
+    end = generate<CAPTURES>(pos, stack);
+  else
+    end = generate<EVASIONS>(pos, stack);
+
+  CheckInfo ci(pos);
+
+  for (moves = stack; moves < end; moves++) {
+    Move capture = moves->move;
+    if (type_of(capture) != ENPASSANT
+          || !pos.legal(capture, ci.pinned))
+      continue;
+    pos.do_move(capture, st, pos.gives_check(capture, ci));
+    int v0 = -probe_ab(pos, -2, 2, success);
+    pos.undo_move(capture);
+    if (*success == 0) return 0;
+    if (v0 > v1) v1 = v0;
+  }
+  if (v1 > -3) {
+    if (v1 >= v) v = v1;
+    else if (v == 0) {
+      // Check whether there is at least one legal non-ep move.
+      for (moves = stack; moves < end; moves++) {
+        Move capture = moves->move;
+        if (type_of(capture) == ENPASSANT) continue;
+        if (pos.legal(capture, ci.pinned)) break;
+      }
+      if (moves == end && !pos.checkers()) {
+        end = generate<QUIETS>(pos, end);
+        for (; moves < end; moves++) {
+          Move move = moves->move;
+          if (pos.legal(move, ci.pinned))
+            break;
+        }
+      }
+      // If not, then we are forced to play the losing ep capture.
+      if (moves == end)
+        v = v1;
+    }
+  }
+
+  return v;
+}
+
+// This routine treats a position with en passant captures as one without.
+static int probe_dtz_no_ep(Position& pos, int *success)
+{
+  int wdl, dtz;
+
+  wdl = probe_ab(pos, -2, 2, success);
+  if (*success == 0) return 0;
+
+  if (wdl == 0) return 0;
+
+  if (*success == 2)
+    return wdl == 2 ? 1 : 101;
+
+  ExtMove stack[192];
+  ExtMove *moves, *end = NULL;
+  StateInfo st;
+  CheckInfo ci(pos);
+
+  if (wdl > 0) {
+    // Generate at least all legal non-capturing pawn moves
+    // including non-capturing promotions.
+    if (!pos.checkers())
+      end = generate<NON_EVASIONS>(pos, stack);
+    else
+      end = generate<EVASIONS>(pos, stack);
+
+    for (moves = stack; moves < end; moves++) {
+      Move move = moves->move;
+      if (type_of(pos.moved_piece(move)) != PAWN || pos.capture(move)
+                || !pos.legal(move, ci.pinned))
+        continue;
+      pos.do_move(move, st, pos.gives_check(move, ci));
+      int v = -probe_ab(pos, -2, -wdl + 1, success);
+      pos.undo_move(move);
+      if (*success == 0) return 0;
+      if (v == wdl)
+        return v == 2 ? 1 : 101;
+    }
+  }
+
+  dtz = 1 + probe_dtz_table(pos, wdl, success);
+  if (*success >= 0) {
+    if (wdl & 1) dtz += 100;
+    return wdl >= 0 ? dtz : -dtz;
+  }
+
+  if (wdl > 0) {
+    int best = 0xffff;
+    for (moves = stack; moves < end; moves++) {
+      Move move = moves->move;
+      if (pos.capture(move) || type_of(pos.moved_piece(move)) == PAWN
+                || !pos.legal(move, ci.pinned))
+        continue;
+      pos.do_move(move, st, pos.gives_check(move, ci));
+      int v = -Tablebases::probe_dtz(pos, success);
+      pos.undo_move(move);
+      if (*success == 0) return 0;
+      if (v > 0 && v + 1 < best)
+        best = v + 1;
+    }
+    return best;
+  } else {
+    int best = -1;
+    if (!pos.checkers())
+      end = generate<NON_EVASIONS>(pos, stack);
+    else
+      end = generate<EVASIONS>(pos, stack);
+    for (moves = stack; moves < end; moves++) {
+      int v;
+      Move move = moves->move;
+      if (!pos.legal(move, ci.pinned))
+        continue;
+      pos.do_move(move, st, pos.gives_check(move, ci));
+      if (st.rule50 == 0) {
+        if (wdl == -2) v = -1;
+        else {
+          v = probe_ab(pos, 1, 2, success);
+          v = (v == 2) ? 0 : -101;
+        }
+      } else {
+        v = -Tablebases::probe_dtz(pos, success) - 1;
+      }
+      pos.undo_move(move);
+      if (*success == 0) return 0;
+      if (v < best)
+        best = v;
+    }
+    return best;
+  }
+}
+
+static int wdl_to_dtz[] = {
+  -1, -101, 0, 101, 1
+};
+
+// Probe the DTZ table for a particular position.
+// If *success != 0, the probe was successful.
+// The return value is from the point of view of the side to move:
+//         n < -100 : loss, but draw under 50-move rule
+// -100 <= n < -1   : loss in n ply (assuming 50-move counter == 0)
+//         0        : draw
+//     1 < n <= 100 : win in n ply (assuming 50-move counter == 0)
+//   100 < n        : win, but draw under 50-move rule
+//
+// The return value n can be off by 1: a return value -n can mean a loss
+// in n+1 ply and a return value +n can mean a win in n+1 ply. This
+// cannot happen for tables with positions exactly on the "edge" of
+// the 50-move rule.
+//
+// This implies that if dtz > 0 is returned, the position is certainly
+// a win if dtz + 50-move-counter <= 99. Care must be taken that the engine
+// picks moves that preserve dtz + 50-move-counter <= 99.
+//
+// If n = 100 immediately after a capture or pawn move, then the position
+// is also certainly a win, and during the whole phase until the next
+// capture or pawn move, the inequality to be preserved is
+// dtz + 50-movecounter <= 100.
+//
+// In short, if a move is available resulting in dtz + 50-move-counter <= 99,
+// then do not accept moves leading to dtz + 50-move-counter == 100.
+//
+int Tablebases::probe_dtz(Position& pos, int *success)
+{
+  *success = 1;
+  int v = probe_dtz_no_ep(pos, success);
+
+  if (pos.ep_square() == SQ_NONE)
+    return v;
+  if (*success == 0) return 0;
+
+  // Now handle en passant.
+  int v1 = -3;
+
+  ExtMove stack[192];
+  ExtMove *moves, *end;
+  StateInfo st;
+
+  if (!pos.checkers())
+    end = generate<CAPTURES>(pos, stack);
+  else
+    end = generate<EVASIONS>(pos, stack);
+  CheckInfo ci(pos);
+
+  for (moves = stack; moves < end; moves++) {
+    Move capture = moves->move;
+    if (type_of(capture) != ENPASSANT
+                || !pos.legal(capture, ci.pinned))
+      continue;
+    pos.do_move(capture, st, pos.gives_check(capture, ci));
+    int v0 = -probe_ab(pos, -2, 2, success);
+    pos.undo_move(capture);
+    if (*success == 0) return 0;
+    if (v0 > v1) v1 = v0;
+  }
+  if (v1 > -3) {
+    v1 = wdl_to_dtz[v1 + 2];
+    if (v < -100) {
+      if (v1 >= 0)
+        v = v1;
+    } else if (v < 0) {
+      if (v1 >= 0 || v1 < -100)
+        v = v1;
+    } else if (v > 100) {
+      if (v1 > 0)
+        v = v1;
+    } else if (v > 0) {
+      if (v1 == 1)
+        v = v1;
+    } else if (v1 >= 0) {
+      v = v1;
+    } else {
+      for (moves = stack; moves < end; moves++) {
+        Move move = moves->move;
+        if (type_of(move) == ENPASSANT) continue;
+        if (pos.legal(move, ci.pinned)) break;
+      }
+      if (moves == end && !pos.checkers()) {
+        end = generate<QUIETS>(pos, end);
+        for (; moves < end; moves++) {
+          Move move = moves->move;
+          if (pos.legal(move, ci.pinned))
+            break;
+        }
+      }
+      if (moves == end)
+        v = v1;
+    }
+  }
+
+  return v;
+}
+
+// Check whether there has been at least one repetition of positions
+// since the last capture or pawn move.
+static int has_repeated(StateInfo *st)
+{
+  while (1) {
+    int i = 4, e = std::min(st->rule50, st->pliesFromNull);
+    if (e < i)
+      return 0;
+    StateInfo *stp = st->previous->previous;
+    do {
+      stp = stp->previous->previous;
+      if (stp->key == st->key)
+        return 1;
+      i += 2;
+    } while (i <= e);
+    st = st->previous;
+  }
+}
+
+static Value wdl_to_Value[5] = {
+  -VALUE_MATE + MAX_PLY + 1,
+  VALUE_DRAW - 2,
+  VALUE_DRAW,
+  VALUE_DRAW + 2,
+  VALUE_MATE - MAX_PLY - 1
+};
+
+// Use the DTZ tables to filter out moves that don't preserve the win or draw.
+// If the position is lost, but DTZ is fairly high, only keep moves that
+// maximise DTZ.
+//
+// A return value false indicates that not all probes were successful and that
+// no moves were filtered out.
+bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score)
+{
+  int success;
+
+  int dtz = probe_dtz(pos, &success);
+  if (!success) return false;
+
+  StateInfo st;
+  CheckInfo ci(pos);
+
+  // Probe each move.
+  for (size_t i = 0; i < rootMoves.size(); i++) {
+    Move move = rootMoves[i].pv[0];
+    pos.do_move(move, st, pos.gives_check(move, ci));
+    int v = 0;
+    if (pos.checkers() && dtz > 0) {
+      ExtMove s[192];
+      if (generate<LEGAL>(pos, s) == s)
+        v = 1;
+    }
+    if (!v) {
+      if (st.rule50 != 0) {
+        v = -Tablebases::probe_dtz(pos, &success);
+        if (v > 0) v++;
+        else if (v < 0) v--;
+      } else {
+        v = -Tablebases::probe_wdl(pos, &success);
+        v = wdl_to_dtz[v + 2];
+      }
+    }
+    pos.undo_move(move);
+    if (!success) return false;
+    rootMoves[i].score = (Value)v;
+  }
+
+  // Obtain 50-move counter for the root position.
+  // In Stockfish there seems to be no clean way, so we do it like this:
+  int cnt50 = st.previous->rule50;
+
+  // Use 50-move counter to determine whether the root position is
+  // won, lost or drawn.
+  int wdl = 0;
+  if (dtz > 0)
+    wdl = (dtz + cnt50 <= 100) ? 2 : 1;
+  else if (dtz < 0)
+    wdl = (-dtz + cnt50 <= 100) ? -2 : -1;
+
+  // Determine the score to report to the user.
+  score = wdl_to_Value[wdl + 2];
+  // If the position is winning or losing, but too few moves left, adjust the
+  // score to show how close it is to winning or losing.
+  // NOTE: int(PawnValueEg) is used as scaling factor in score_to_uci().
+  if (wdl == 1 && dtz <= 100)
+    score = (Value)(((200 - dtz - cnt50) * int(PawnValueEg)) / 200);
+  else if (wdl == -1 && dtz >= -100)
+    score = -(Value)(((200 + dtz - cnt50) * int(PawnValueEg)) / 200);
+
+  // Now be a bit smart about filtering out moves.
+  size_t j = 0;
+  if (dtz > 0) { // winning (or 50-move rule draw)
+    int best = 0xffff;
+    for (size_t i = 0; i < rootMoves.size(); i++) {
+      int v = rootMoves[i].score;
+      if (v > 0 && v < best)
+        best = v;
+    }
+    int max = best;
+    // If the current phase has not seen repetitions, then try all moves
+    // that stay safely within the 50-move budget, if there are any.
+    if (!has_repeated(st.previous) && best + cnt50 <= 99)
+      max = 99 - cnt50;
+    for (size_t i = 0; i < rootMoves.size(); i++) {
+      int v = rootMoves[i].score;
+      if (v > 0 && v <= max)
+        rootMoves[j++] = rootMoves[i];
+    }
+  } else if (dtz < 0) { // losing (or 50-move rule draw)
+    int best = 0;
+    for (size_t i = 0; i < rootMoves.size(); i++) {
+      int v = rootMoves[i].score;
+      if (v < best)
+        best = v;
+    }
+    // Try all moves, unless we approach or have a 50-move rule draw.
+    if (-best * 2 + cnt50 < 100)
+      return true;
+    for (size_t i = 0; i < rootMoves.size(); i++) {
+      if (rootMoves[i].score == best)
+        rootMoves[j++] = rootMoves[i];
+    }
+  } else { // drawing
+    // Try all moves that preserve the draw.
+    for (size_t i = 0; i < rootMoves.size(); i++) {
+      if (rootMoves[i].score == 0)
+        rootMoves[j++] = rootMoves[i];
+    }
+  }
+  rootMoves.resize(j, Search::RootMove(MOVE_NONE));
+
+  return true;
+}
+
+// Use the WDL tables to filter out moves that don't preserve the win or draw.
+// This is a fallback for the case that some or all DTZ tables are missing.
+//
+// A return value false indicates that not all probes were successful and that
+// no moves were filtered out.
+bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score)
+{
+  int success;
+
+  int wdl = Tablebases::probe_wdl(pos, &success);
+  if (!success) return false;
+  score = wdl_to_Value[wdl + 2];
+
+  StateInfo st;
+  CheckInfo ci(pos);
+
+  int best = -2;
+
+  // Probe each move.
+  for (size_t i = 0; i < rootMoves.size(); i++) {
+    Move move = rootMoves[i].pv[0];
+    pos.do_move(move, st, pos.gives_check(move, ci));
+    int v = -Tablebases::probe_wdl(pos, &success);
+    pos.undo_move(move);
+    if (!success) return false;
+    rootMoves[i].score = (Value)v;
+    if (v > best)
+      best = v;
+  }
+
+  size_t j = 0;
+  for (size_t i = 0; i < rootMoves.size(); i++) {
+    if (rootMoves[i].score == best)
+      rootMoves[j++] = rootMoves[i];
+  }
+  rootMoves.resize(j, Search::RootMove(MOVE_NONE));
+
+  return true;
+}
+

src/syzygy/tbprobe.h

@@ -0,0 +1,18 @@
+#ifndef TBPROBE_H
+#define TBPROBE_H
+
+#include "../search.h"
+
+namespace Tablebases {
+
+extern int MaxCardinality;
+
+void init(const std::string& path);
+int probe_wdl(Position& pos, int *success);
+int probe_dtz(Position& pos, int *success);
+bool root_probe(Position& pos, Search::RootMoveVector& rootMoves, Value& score);
+bool root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves, Value& score);
+
+}
+
+#endif

src/thread.cpp

@@ -0,0 +1,195 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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 <algorithm> // For std::count
+#include <cassert>
+
+#include "movegen.h"
+#include "search.h"
+#include "thread.h"
+#include "uci.h"
+
+using namespace Search;
+
+ThreadPool Threads; // Global object
+
+/// Thread constructor launch the thread and then wait until it goes to sleep
+/// in idle_loop().
+
+Thread::Thread() {
+
+  resetCalls = exit = false;
+  maxPly = callsCnt = 0;
+  history.clear();
+  counterMoves.clear();
+  idx = Threads.size(); // Start from 0
+
+  std::unique_lock<Mutex> lk(mutex);
+  searching = true;
+  nativeThread = std::thread(&Thread::idle_loop, this);
+  sleepCondition.wait(lk, [&]{ return !searching; });
+}
+
+
+/// Thread destructor wait for thread termination before returning
+
+Thread::~Thread() {
+
+  mutex.lock();
+  exit = true;
+  sleepCondition.notify_one();
+  mutex.unlock();
+  nativeThread.join();
+}
+
+
+/// Thread::wait_for_search_finished() wait on sleep condition until not searching
+
+void Thread::wait_for_search_finished() {
+
+  std::unique_lock<Mutex> lk(mutex);
+  sleepCondition.wait(lk, [&]{ return !searching; });
+}
+
+
+/// Thread::wait() wait on sleep condition until condition is true
+
+void Thread::wait(std::atomic_bool& condition) {
+
+  std::unique_lock<Mutex> lk(mutex);
+  sleepCondition.wait(lk, [&]{ return bool(condition); });
+}
+
+
+/// Thread::start_searching() wake up the thread that will start the search
+
+void Thread::start_searching(bool resume) {
+
+  std::unique_lock<Mutex> lk(mutex);
+
+  if (!resume)
+      searching = true;
+
+  sleepCondition.notify_one();
+}
+
+
+/// Thread::idle_loop() is where the thread is parked when it has no work to do
+
+void Thread::idle_loop() {
+
+  while (!exit)
+  {
+      std::unique_lock<Mutex> lk(mutex);
+
+      searching = false;
+
+      while (!searching && !exit)
+      {
+          sleepCondition.notify_one(); // Wake up any waiting thread
+          sleepCondition.wait(lk);
+      }
+
+      lk.unlock();
+
+      if (!exit)
+          search();
+  }
+}
+
+
+/// ThreadPool::init() create and launch requested threads, that will go
+/// immediately to sleep. We cannot use a constructor because Threads is a
+/// static object and we need a fully initialized engine at this point due to
+/// allocation of Endgames in the Thread constructor.
+
+void ThreadPool::init() {
+
+  push_back(new MainThread);
+  read_uci_options();
+}
+
+
+/// ThreadPool::exit() terminate threads before the program exits. Cannot be
+/// done in destructor because threads must be terminated before deleting any
+/// static objects, so while still in main().
+
+void ThreadPool::exit() {
+
+  while (size())
+      delete back(), pop_back();
+}
+
+
+/// ThreadPool::read_uci_options() updates internal threads parameters from the
+/// corresponding UCI options and creates/destroys threads to match requested
+/// number. Thread objects are dynamically allocated.
+
+void ThreadPool::read_uci_options() {
+
+  size_t requested = Options["Threads"];
+
+  assert(requested > 0);
+
+  while (size() < requested)
+      push_back(new Thread);
+
+  while (size() > requested)
+      delete back(), pop_back();
+}
+
+
+/// ThreadPool::nodes_searched() return the number of nodes searched
+
+int64_t ThreadPool::nodes_searched() {
+
+  int64_t nodes = 0;
+  for (Thread* th : *this)
+      nodes += th->rootPos.nodes_searched();
+  return nodes;
+}
+
+
+/// ThreadPool::start_thinking() wake up the main thread sleeping in idle_loop()
+/// and start a new search, then return immediately.
+
+void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
+                                StateStackPtr& states) {
+
+  main()->wait_for_search_finished();
+
+  Signals.stopOnPonderhit = Signals.stop = false;
+
+  main()->rootMoves.clear();
+  main()->rootPos = pos;
+  Limits = limits;
+  if (states.get()) // If we don't set a new position, preserve current state
+  {
+      SetupStates = std::move(states); // Ownership transfer here
+      assert(!states.get());
+  }
+
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (   limits.searchmoves.empty()
+          || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
+          main()->rootMoves.push_back(RootMove(m));
+
+  main()->start_searching();
+}

src/thread.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,80 +18,86 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef THREAD_H_INCLUDED
-#if !defined(THREAD_H_INCLUDED)
 #define THREAD_H_INCLUDED
 
+#include <atomic>
+#include <bitset>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include <vector>
 
-////
+#include "material.h"
-//// Includes
-////
-
-#include <cstring>
-
-#include "lock.h"
 #include "movepick.h"
+#include "pawns.h"
 #include "position.h"
 #include "search.h"
+#include "thread_win32.h"
 
 
-////
+/// Thread struct keeps together all the thread related stuff. We also use
-//// Constants and variables
+/// 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.
 
-const int MAX_THREADS = 16;
+class Thread {
-const int MAX_ACTIVE_SPLIT_POINTS = 8;
 
+  std::thread nativeThread;
+  Mutex mutex;
+  ConditionVariable sleepCondition;
+  bool exit, searching;
 
-////
+public:
-//// Types
+  Thread();
-////
+  virtual ~Thread();
+  virtual void search();
+  void idle_loop();
+  void start_searching(bool resume = false);
+  void wait_for_search_finished();
+  void wait(std::atomic_bool& b);
 
-struct SplitPoint {
+  Pawns::Table pawnsTable;
+  Material::Table materialTable;
+  Endgames endgames;
+  size_t idx, PVIdx;
+  int maxPly, callsCnt;
 
-  // Const data after splitPoint has been setup
+  Position rootPos;
-  SplitPoint* parent;
+  Search::RootMoveVector rootMoves;
-  const Position* pos;
+  Depth rootDepth;
-  Depth depth;
+  HistoryStats history;
-  bool pvNode, mateThreat;
+  MovesStats counterMoves;
-  Value beta;
+  Depth completedDepth;
-  int ply;
+  std::atomic_bool resetCalls;
-  int master;
-  Move threatMove;
-  SearchStack sstack[MAX_THREADS][PLY_MAX_PLUS_2];
-
-  // Const pointers to shared data
-  MovePicker* mp;
-  SearchStack* parentSstack;
-
-  // Shared data
-  Lock lock;
-  volatile int64_t nodes;
-  volatile Value alpha;
-  volatile Value bestValue;
-  volatile int moveCount;
-  volatile bool betaCutoff;
-  volatile int slaves[MAX_THREADS];
-};
-
-// ThreadState type is used to represent thread's current state
-
-enum ThreadState
-{
-  THREAD_INITIALIZING,  // thread is initializing itself
-  THREAD_SEARCHING,     // thread is performing work
-  THREAD_AVAILABLE,     // thread is waiting for work
-  THREAD_BOOKED,        // other thread (master) has booked us as a slave
-  THREAD_WORKISWAITING, // master has ordered us to start
-  THREAD_TERMINATED     // we are quitting and thread is terminated
-};
-
-struct Thread {
-  volatile ThreadState state;
-  SplitPoint* volatile splitPoint;
-  volatile int activeSplitPoints;
-  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
 };
 
 
-#endif // !defined(THREAD_H_INCLUDED)
+/// MainThread is a derived class with a specific overload for the main thread
+
+struct MainThread : public Thread {
+  virtual void search();
+
+  bool easyMovePlayed, failedLow;
+  double bestMoveChanges;
+};
+
+
+/// ThreadPool struct handles all the threads related stuff like init, starting,
+/// parking and, most importantly, launching a thread. All the access to threads
+/// data is done through this class.
+
+struct ThreadPool : public std::vector<Thread*> {
+
+  void init(); // No constructor and destructor, threads rely on globals that should
+  void exit(); // be initialized and valid during the whole thread lifetime.
+
+  MainThread* main() { return static_cast<MainThread*>(at(0)); }
+  void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
+  void read_uci_options();
+  int64_t nodes_searched();
+};
+
+extern ThreadPool Threads;
+
+#endif // #ifndef THREAD_H_INCLUDED

src/thread_win32.h

@@ -0,0 +1,70 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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/>.
+*/
+
+#ifndef THREAD_WIN32_H_INCLUDED
+#define THREAD_WIN32_H_INCLUDED
+
+/// STL thread library used by mingw and gcc when cross compiling for Windows
+/// relies on libwinpthread. Currently libwinpthread implements mutexes directly
+/// on top of Windows semaphores. Semaphores, being kernel objects, require kernel
+/// mode transition in order to lock or unlock, which is very slow compared to
+/// interlocked operations (about 30% slower on bench test). To workaround this
+/// issue, we define our wrappers to the low level Win32 calls. We use critical
+/// sections to support Windows XP and older versions. Unfortunately, cond_wait()
+/// is racy between unlock() and WaitForSingleObject() but they have the same
+/// speed performance of SRW locks.
+
+#include <condition_variable>
+#include <mutex>
+
+#if defined(_WIN32) && !defined(_MSC_VER)
+
+#ifndef NOMINMAX
+#  define NOMINMAX // Disable macros min() and max()
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#undef NOMINMAX
+
+/// Mutex and ConditionVariable struct are wrappers of the low level locking
+/// machinery and are modeled after the corresponding C++11 classes.
+
+struct Mutex {
+  Mutex() { InitializeCriticalSection(&cs); }
+ ~Mutex() { DeleteCriticalSection(&cs); }
+  void lock() { EnterCriticalSection(&cs); }
+  void unlock() { LeaveCriticalSection(&cs); }
+
+private:
+  CRITICAL_SECTION cs;
+};
+
+typedef std::condition_variable_any ConditionVariable;
+
+#else // Default case: use STL classes
+
+typedef std::mutex Mutex;
+typedef std::condition_variable ConditionVariable;
+
+#endif
+
+#endif // #ifndef THREAD_WIN32_H_INCLUDED

src/timeman.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,154 +18,116 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#include <algorithm>
-////
+#include <cfloat>
-//// Includes
-////
-
 #include <cmath>
 
-#include "misc.h"
+#include "search.h"
 #include "timeman.h"
-#include "ucioption.h"
+#include "uci.h"
 
-////
+TimeManagement Time; // Our global time management object
-//// Local definitions
-////
 
 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>
+  const int MoveHorizon   = 50;   // Plan time management at most this many moves ahead
-  int remaining(int myTime, int movesToGo, int currentPly);
+  const double MaxRatio   = 6.93;  // When in trouble, we can step over reserved time with this ratio
-}
+  const double StealRatio = 0.36; // However we must not steal time from remaining moves over this ratio
 
 
-////
+  // move_importance() is a skew-logistic function based on naive statistical
-//// Functions
+  // 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.
 
-void TimeManager::pv_instability(int curChanges, int prevChanges) {
+  double move_importance(int ply) {
 
-    unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
+    const double XScale = 8.27;
-                         + prevChanges * (optimumSearchTime / 3);
+    const double XShift = 59.;
-}
+    const double Skew   = 0.179;
 
-void TimeManager::init(int myTime, int myInc, int movesToGo, int currentPly)
+    return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero
-{
-  /* We support four different kind of time controls:
-
-      Inc == 0 && movesToGo == 0 means: x basetime  [sudden death!]
-      Inc == 0 && movesToGo != 0 means: (x moves) / (y minutes)
-      Inc > 0  && movesToGo == 0 means: x basetime + z inc.
-      Inc > 0  && movesToGo != 0 means: (x moves) / (y minutes) + z inc
-
-    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 = myTime;
-
-  // 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 <= (movesToGo ? Min(movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
-  {
-      // Calculate thinking time for hypothetic "moves to go"-value
-      hypMyTime = Max(myTime + (hypMTG - 1) * myInc - emergencyBaseTime - Min(hypMTG, emergencyMoveHorizon) * emergencyMoveTime, 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);
-}
-
-////
-//// Local functions
-////
-
-namespace {
-
   template<TimeType T>
-  int remaining(int myTime, int movesToGo, int currentPly)
+  int remaining(int myTime, int movesToGo, int ply, int slowMover)
   {
-    const float TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const double TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
-    const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
+    const double TStealRatio = (T == OptimumTime ? 0 : StealRatio);
 
-    int thisMoveImportance = move_importance(currentPly);
+    double moveImportance = (move_importance(ply) * slowMover) / 100;
-    int otherMovesImportance = 0;
+    double otherMovesImportance = 0;
 
-    for (int i = 1; i < movesToGo; i++)
+    for (int i = 1; i < movesToGo; ++i)
-        otherMovesImportance += move_importance(currentPly + 2 * i);
+        otherMovesImportance += move_importance(ply + 2 * i);
 
-    float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
+    double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance);
-    float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
+    double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance);
 
-    return int(floor(myTime * Min(ratio1, ratio2)));
+    return int(myTime * std::min(ratio1, ratio2)); // Intel C++ asks an explicit cast
   }
+
+} // namespace
+
+
+/// init() is called at the beginning of the search and calculates the allowed
+/// thinking time out of the time control and current game ply. We support four
+/// different kinds of time controls, passed in 'limits':
+///
+///  inc == 0 && movestogo == 0 means: x basetime  [sudden death!]
+///  inc == 0 && movestogo != 0 means: x moves in y minutes
+///  inc >  0 && movestogo == 0 means: x basetime + z increment
+///  inc >  0 && movestogo != 0 means: x moves in y minutes + z increment
+
+void TimeManagement::init(Search::LimitsType& limits, Color us, int ply)
+{
+  int minThinkingTime = Options["Minimum Thinking Time"];
+  int moveOverhead    = Options["Move Overhead"];
+  int slowMover       = Options["Slow Mover"];
+  int npmsec          = Options["nodestime"];
+
+  // If we have to play in 'nodes as time' mode, then convert from time
+  // to nodes, and use resulting values in time management formulas.
+  // WARNING: Given npms (nodes per millisecond) must be much lower then
+  // real engine speed to avoid time losses.
+  if (npmsec)
+  {
+      if (!availableNodes) // Only once at game start
+          availableNodes = npmsec * limits.time[us]; // Time is in msec
+
+      // Convert from millisecs to nodes
+      limits.time[us] = (int)availableNodes;
+      limits.inc[us] *= npmsec;
+      limits.npmsec = npmsec;
+  }
+
+  startTime = limits.startTime;
+  unstablePvFactor = 1;
+  optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime);
+
+  const int MaxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon;
+
+  // We calculate optimum time usage for different hypothetical "moves to go"-values
+  // and choose the minimum of calculated search time values. Usually the greatest
+  // hypMTG gives the minimum values.
+  for (int hypMTG = 1; hypMTG <= MaxMTG; ++hypMTG)
+  {
+      // Calculate thinking time for hypothetical "moves to go"-value
+      int hypMyTime =  limits.time[us]
+                     + limits.inc[us] * (hypMTG - 1)
+                     - moveOverhead * (2 + std::min(hypMTG, 40));
+
+      hypMyTime = std::max(hypMyTime, 0);
+
+      int t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
+      int t2 = minThinkingTime + remaining<MaxTime    >(hypMyTime, hypMTG, ply, slowMover);
+
+      optimumTime = std::min(t1, optimumTime);
+      maximumTime = std::min(t2, maximumTime);
+  }
+
+  if (Options["Ponder"])
+      optimumTime += optimumTime / 4;
 }

src/timeman.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,26 +18,33 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef TIMEMAN_H_INCLUDED
-#if !defined(TIMEMAN_H_INCLUDED)
 #define TIMEMAN_H_INCLUDED
 
-////
+#include "misc.h"
-//// Prototypes
+#include "search.h"
-////
+#include "thread.h"
 
-class TimeManager {
+/// The TimeManagement class computes the optimal time to think depending on
+/// the maximum available time, the game move number and other parameters.
+
+class TimeManagement {
 public:
+  void init(Search::LimitsType& limits, Color us, int ply);
+  void pv_instability(double bestMoveChanges) { unstablePvFactor = 1 + bestMoveChanges; }
+  int available() const { return int(optimumTime * unstablePvFactor * 1.016); }
+  int maximum() const { return maximumTime; }
+  int elapsed() const { return int(Search::Limits.npmsec ? Threads.nodes_searched() : now() - startTime); }
 
-  void init(int myTime, int myInc, int movesToGo, int currentPly);
+  int64_t availableNodes; // When in 'nodes as time' mode
-  void pv_instability(int curChanges, int prevChanges);
-  int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
-  int maximum_time() const { return maximumSearchTime; }
 
 private:
-  int optimumSearchTime;
+  TimePoint startTime;
-  int maximumSearchTime;
+  int optimumTime;
-  int unstablePVExtraTime;
+  int maximumTime;
+  double unstablePvFactor;
 };
 
-#endif // !defined(TIMEMAN_H_INCLUDED)
+extern TimeManagement Time;
+
+#endif // #ifndef TIMEMAN_H_INCLUDED

src/tt.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,142 +18,100 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <cstring>   // For std::memset
+#include <iostream>
 
-////
+#include "bitboard.h"
-//// Includes
-////
-
-#include <cassert>
-#include <cstring>
-
 #include "tt.h"
 
-// The main transposition table
+TranspositionTable TT; // Our global transposition table
-TranspositionTable TT;
-
-////
-//// Functions
-////
-
-TranspositionTable::TranspositionTable() {
-
-  size = 0;
-  entries = 0;
-  generation = 0;
-}
-
-TranspositionTable::~TranspositionTable() {
-
-  delete [] entries;
-}
 
 
-/// TranspositionTable::set_size sets the size of the transposition table,
+/// TranspositionTable::resize() sets the size of the transposition table,
-/// measured in megabytes.
+/// measured in megabytes. Transposition table consists of a power of 2 number
+/// of clusters and each cluster consists of ClusterSize number of TTEntry.
 
-void TranspositionTable::set_size(size_t mbSize) {
+void TranspositionTable::resize(size_t mbSize) {
 
-  size_t newSize = 1024;
+  size_t newClusterCount = size_t(1) << msb((mbSize * 1024 * 1024) / sizeof(Cluster));
 
-  // Transposition table consists of clusters and
+  if (newClusterCount == clusterCount)
-  // each cluster consists of ClusterSize number of TTEntries.
+      return;
-  // Each non-empty entry contains information of exactly one position.
-  // newSize is the number of clusters we are going to allocate.
-  while ((2 * newSize) * sizeof(TTCluster) <= (mbSize << 20))
-      newSize *= 2;
 
-  if (newSize != size)
+  clusterCount = newClusterCount;
-  {
+
-      size = newSize;
+  free(mem);
-      delete [] entries;
+  mem = calloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1, 1);
-      entries = new TTCluster[size];
+
-      if (!entries)
+  if (!mem)
   {
       std::cerr << "Failed to allocate " << mbSize
-                    << " MB for transposition table." << std::endl;
+                << "MB for transposition table." << std::endl;
       exit(EXIT_FAILURE);
   }
-      clear();
+
-  }
+  table = (Cluster*)((uintptr_t(mem) + CacheLineSize - 1) & ~(CacheLineSize - 1));
 }
 
 
-/// TranspositionTable::clear overwrites the entire transposition table
+/// TranspositionTable::clear() overwrites the entire transposition table
-/// with zeroes. It is called whenever the table is resized, or when the
+/// with zeros. 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 received?
 
 void TranspositionTable::clear() {
 
-  memset(entries, 0, size * sizeof(TTCluster));
+  std::memset(table, 0, clusterCount * sizeof(Cluster));
 }
 
 
-/// TranspositionTable::store writes a new entry containing position key and
+/// TranspositionTable::probe() looks up the current position in the transposition
-/// valuable information of current position.
+/// table. It returns true and a pointer to the TTEntry if the position is found.
-/// The Lowest order bits of position key are used to decide on which cluster
+/// Otherwise, it returns false and a pointer to an empty or least valuable TTEntry
-/// the position will be placed.
+/// to be replaced later. The replace value of an entry is calculated as its depth
-/// When a new entry is written and there are no empty entries available in cluster,
+/// minus 8 times its relative age. TTEntry t1 is considered more valuable than
-/// it replaces the least valuable of entries.
+/// TTEntry t2 if its replace value is greater than that of t2.
-/// 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 Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
+TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
 
-  int c1, c2, c3;
+  TTEntry* const tte = first_entry(key);
-  TTEntry *tte, *replace;
+  const uint16_t key16 = key >> 48;  // Use the high 16 bits as key inside the cluster
-  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key
 
-  tte = replace = first_entry(posKey);
+  for (int i = 0; i < ClusterSize; ++i)
-  for (int i = 0; i < ClusterSize; i++, tte++)
+      if (!tte[i].key16 || tte[i].key16 == key16)
       {
-      if (!tte->key() || tte->key() == posKey32) // empty or overwrite old
+          if ((tte[i].genBound8 & 0xFC) != generation8 && tte[i].key16)
-      {
+              tte[i].genBound8 = uint8_t(generation8 | tte[i].bound()); // Refresh
-          // Preserve any existing ttMove
-          if (m == MOVE_NONE)
-              m = tte->move();
 
-          tte->save(posKey32, v, t, d, m, generation, statV, kingD);
+          return found = (bool)tte[i].key16, &tte[i];
-          return;
       }
 
-      if (i == 0)  // Replacing first entry is default and already set before entering for-loop
+  // Find an entry to be replaced according to the replacement strategy
-          continue;
+  TTEntry* replace = tte;
+  for (int i = 1; i < ClusterSize; ++i)
+      // Due to our packed storage format for generation and its cyclic
+      // nature we add 259 (256 is the modulus plus 3 to keep the lowest
+      // two bound bits from affecting the result) to calculate the entry
+      // age correctly even after generation8 overflows into the next cycle.
+      if (  replace->depth8 - ((259 + generation8 - replace->genBound8) & 0xFC) * 2 * ONE_PLY
+          >   tte[i].depth8 - ((259 + generation8 -   tte[i].genBound8) & 0xFC) * 2 * ONE_PLY)
+          replace = &tte[i];
 
-      c1 = (replace->generation() == generation ?  2 : 0);
+  return found = false, replace;
-      c2 = (tte->generation() == generation ? -2 : 0);
+}
-      c3 = (tte->depth() < replace->depth() ?  1 : 0);
 
-      if (c1 + c2 + c3 > 0)
+
-          replace = tte;
+/// Returns an approximation of the hashtable occupation during a search. The
+/// hash is x permill full, as per UCI protocol.
+
+int TranspositionTable::hashfull() const
+{
+  int cnt = 0;
+  for (int i = 0; i < 1000 / ClusterSize; i++)
+  {
+      const TTEntry* tte = &table[i].entry[0];
+      for (int j = 0; j < ClusterSize; j++)
+          if ((tte[j].genBound8 & 0xFC) == generation8)
+              cnt++;
   }
-  replace->save(posKey32, v, t, d, m, generation, statV, kingD);
+  return cnt;
-}
-
-
-/// TranspositionTable::retrieve looks up the current position in the
-/// transposition table. Returns a pointer to the TTEntry or NULL
-/// if position is not found.
-
-TTEntry* TranspositionTable::retrieve(const Key posKey) const {
-
-  uint32_t posKey32 = posKey >> 32;
-  TTEntry* tte = first_entry(posKey);
-
-  for (int i = 0; i < ClusterSize; i++, tte++)
-      if (tte->key() == posKey32)
-          return tte;
-
-  return NULL;
-}
-
-
-/// TranspositionTable::new_search() is called at the beginning of every new
-/// search. It increments the "generation" variable, which is used to
-/// distinguish transposition table entries from previous searches from
-/// entries from the current search.
-
-void TranspositionTable::new_search() {
-  generation++;
 }

src/tt.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,131 +18,102 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
+#ifndef TT_H_INCLUDED
-#if !defined(TT_H_INCLUDED)
 #define TT_H_INCLUDED
 
-////
+#include "misc.h"
-//// Includes
+#include "types.h"
-////
 
-#include "depth.h"
+/// TTEntry struct is the 10 bytes transposition table entry, defined as below:
-#include "move.h"
-#include "value.h"
-
-
-////
-//// Types
-////
-
-/// The TTEntry class is the class of transposition table entries
 ///
-/// A TTEntry needs 128 bits to be stored
+/// key        16 bit
-///
+/// move       16 bit
-/// bit  0-31: key
+/// value      16 bit
-/// bit 32-63: data
+/// eval value 16 bit
-/// bit 64-79: value
+/// generation  6 bit
-/// bit 80-95: depth
+/// bound type  2 bit
-/// bit 96-111: static value
+/// depth       8 bit
-/// bit 112-127: margin of static value
-///
-/// the 32 bits of the data field are so defined
-///
-/// bit  0-16: move
-/// bit 17-20: not used
-/// bit 21-22: value type
-/// bit 23-31: generation
 
-class TTEntry {
+struct TTEntry {
 
-public:
+  Move  move()  const { return (Move )move16; }
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value kd) {
+  Value value() const { return (Value)value16; }
+  Value eval()  const { return (Value)eval16; }
+  Depth depth() const { return (Depth)depth8; }
+  Bound bound() const { return (Bound)(genBound8 & 0x3); }
 
-      key32 = k;
+  void save(Key k, Value v, Bound b, Depth d, Move m, Value ev, uint8_t g) {
-      data = (m & 0x1FFFF) | (t << 21) | (g << 23);
+
+    // Preserve any existing move for the same position
+    if (m || (k >> 48) != key16)
+        move16 = (uint16_t)m;
+
+    // Don't overwrite more valuable entries
+    if (  (k >> 48) != key16
+        || d > depth8 - 2
+     /* || g != (genBound8 & 0xFC) // Matching non-zero keys are already refreshed by probe() */
+        || b == BOUND_EXACT)
+    {
+        key16     = (uint16_t)(k >> 48);
         value16   = (int16_t)v;
-      depth16     = (int16_t)d;
+        eval16    = (int16_t)ev;
-      staticValue = (int16_t)statV;
+        genBound8 = (uint8_t)(g | b);
-      staticValueMargin  = (int16_t)kd;
+        depth8    = (int8_t)d;
+    }
   }
-  void set_generation(int g) { data = move() | (type() << 21) | (g << 23); }
-
-  uint32_t key() const { return key32; }
-  Depth depth() const { return Depth(depth16); }
-  Move move() const { return Move(data & 0x1FFFF); }
-  Value value() const { return Value(value16); }
-  ValueType type() const { return ValueType((data >> 21) & 3); }
-  int generation() const { return data >> 23; }
-  Value static_value() const { return Value(staticValue); }
-  Value static_value_margin() const { return Value(staticValueMargin); }
 
 private:
-  uint32_t key32;
+  friend class TranspositionTable;
-  uint32_t data;
+
+  uint16_t key16;
+  uint16_t move16;
   int16_t  value16;
-  int16_t depth16;
+  int16_t  eval16;
-  int16_t staticValue;
+  uint8_t  genBound8;
-  int16_t staticValueMargin;
+  int8_t   depth8;
 };
 
 
-/// This is the number of TTEntry slots for each cluster
+/// A TranspositionTable consists of a power of 2 number of clusters and each
-const int ClusterSize = 4;
+/// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
-
+/// contains information of exactly one position. The size of a cluster should
-/// TTCluster consists of ClusterSize number of TTEntries.
+/// divide the size of a cache line size, to ensure that clusters never cross
-/// Size of TTCluster must not be bigger than a cache line size.
+/// cache lines. This ensures best cache performance, as the cacheline is
-/// In case it is less, it should be padded to guarantee always aligned accesses.
+/// prefetched, as soon as possible.
-
-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 new entries
-/// and reading new ones.
 
 class TranspositionTable {
 
-  TranspositionTable(const TranspositionTable&);
+  static const int CacheLineSize = 64;
-  TranspositionTable& operator=(const TranspositionTable&);
+  static const int ClusterSize = 3;
+
+  struct Cluster {
+    TTEntry entry[ClusterSize];
+    char padding[2]; // Align to a divisor of the cache line size
+  };
+
+  static_assert(CacheLineSize % sizeof(Cluster) == 0, "Cluster size incorrect");
 
 public:
-  TranspositionTable();
+ ~TranspositionTable() { free(mem); }
-  ~TranspositionTable();
+  void new_search() { generation8 += 4; } // Lower 2 bits are used by Bound
-  void set_size(size_t mbSize);
+  uint8_t generation() const { return generation8; }
+  TTEntry* probe(const Key key, bool& found) const;
+  int hashfull() const;
+  void resize(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+
-  TTEntry* retrieve(const Key posKey) const;
+  // The lowest order bits of the key are used to get the index of the cluster
-  void new_search();
+  TTEntry* first_entry(const Key key) const {
-  TTEntry* first_entry(const Key posKey) const;
+    return &table[(size_t)key & (clusterCount - 1)].entry[0];
-  void refresh(const TTEntry* tte) const;
+  }
 
 private:
-  size_t size;
+  size_t clusterCount;
-  TTCluster* entries;
+  Cluster* table;
-  uint8_t generation; // To properly compare, size must be smaller then TT stored value
+  void* mem;
+  uint8_t generation8; // Size must be not bigger than TTEntry::genBound8
 };
 
 extern TranspositionTable TT;
 
-
+#endif // #ifndef TT_H_INCLUDED
-/// 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, before to return.
-
-inline void TranspositionTable::refresh(const TTEntry* tte) const {
-
-  const_cast<TTEntry*>(tte)->set_generation(generation);
-}
-
-#endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,120 +18,412 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#if !defined(TYPES_H_INCLUDED)
+#ifndef TYPES_H_INCLUDED
 #define TYPES_H_INCLUDED
 
-#if !defined(_MSC_VER)
+/// When compiling with provided Makefile (e.g. for Linux and OSX), configuration
-
+/// is done automatically. To get started type 'make help'.
-#include <inttypes.h>
+///
-
+/// When Makefile is not used (e.g. with Microsoft Visual Studio) some switches
-#else
+/// need to be set manually:
-
+///
-// Disable some silly and noisy warning from MSVC compiler
+/// -DNDEBUG      | Disable debugging mode. Always use this for release.
-#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
+///
-#pragma warning(disable: 4127) // Conditional expression is constant
+/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. You may need this to
-
+///               | run on some very old machines.
-typedef __int8 int8_t;
+///
-typedef unsigned __int8 uint8_t;
+/// -DUSE_POPCNT  | Add runtime support for use of popcnt asm-instruction. Works
-typedef __int16 int16;
+///               | only in 64-bit mode and requires hardware with popcnt support.
-typedef unsigned __int16 uint16_t;
+///
-typedef __int32 int32_t;
+/// -DUSE_PEXT    | Add runtime support for use of pext asm-instruction. Works
-typedef unsigned __int32 uint32_t;
+///               | only in 64-bit mode and requires hardware with pext support.
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-
-typedef __int16 int16_t;
-typedef __int64 int64_t;
-
-#endif // !defined(_MSC_VER)
-
-// Hash keys
-typedef uint64_t Key;
-
-// Bitboard type
-typedef uint64_t Bitboard;
 
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cstdint>
 #include <cstdlib>
 
-////
-//// 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.
-// Works only in 64-bit mode. Does not work with MSVC.
-#if defined(_WIN64) && defined(__INTEL_COMPILER)
-#define USE_BSFQ
-#endif
-
-// Cache line alignment specification
-#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
-#define CACHE_LINE_ALIGNMENT __declspec(align(64))
-#else
-#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
-#endif
-
-// Define a __cpuid() function for gcc compilers, for Intel and MSVC
-// is already available as an intrinsic.
 #if defined(_MSC_VER)
-#include <intrin.h>
+// Disable some silly and noisy warning from MSVC compiler
-#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+#pragma warning(disable: 4127) // Conditional expression is constant
-inline void __cpuid(int CPUInfo[4], int InfoType)
+#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
-{
+#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
-  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
 
-// Operators used by enum types like Depth, Piece, Square and so on.
+/// Predefined macros hell:
+///
+/// __GNUC__           Compiler is gcc, Clang or Intel on Linux
+/// __INTEL_COMPILER   Compiler is Intel
+/// _MSC_VER           Compiler is MSVC or Intel on Windows
+/// _WIN32             Building on Windows (any)
+/// _WIN64             Building on Windows 64 bit
 
-#define ENABLE_OPERATORS_ON(T) \
+#if defined(_WIN64) && defined(_MSC_VER) // No Makefile used
-inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \
+#  include <intrin.h> // MSVC popcnt and bsfq instrinsics
-inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \
+#  define IS_64BIT
-inline T operator* (int i, const T d) {  return T(i * int(d)); } \
+#  define USE_BSFQ
-inline T operator* (const T d, int i) {  return T(int(d) * i); } \
+#endif
-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); }
 
-#endif // !defined(TYPES_H_INCLUDED)
+#if defined(USE_POPCNT) && defined(__INTEL_COMPILER) && defined(_MSC_VER)
+#  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
+#endif
+
+#if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
+#  include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
+#endif
+
+#if defined(USE_PEXT)
+#  include <immintrin.h> // Header for _pext_u64() intrinsic
+#  define pext(b, m) _pext_u64(b, m)
+#else
+#  define pext(b, m) (0)
+#endif
+
+#ifdef USE_POPCNT
+const bool HasPopCnt = true;
+#else
+const bool HasPopCnt = false;
+#endif
+
+#ifdef USE_PEXT
+const bool HasPext = true;
+#else
+const bool HasPext = false;
+#endif
+
+#ifdef IS_64BIT
+const bool Is64Bit = true;
+#else
+const bool Is64Bit = false;
+#endif
+
+typedef uint64_t Key;
+typedef uint64_t Bitboard;
+
+const int MAX_MOVES = 256;
+const int MAX_PLY   = 128;
+
+/// 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), castling (3)
+/// NOTE: EN-PASSANT bit is set only when a pawn can be captured
+///
+/// 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.
+
+enum Move {
+  MOVE_NONE,
+  MOVE_NULL = 65
+};
+
+enum MoveType {
+  NORMAL,
+  PROMOTION = 1 << 14,
+  ENPASSANT = 2 << 14,
+  CASTLING  = 3 << 14
+};
+
+enum Color {
+  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
+};
+
+enum CastlingSide {
+  KING_SIDE, QUEEN_SIDE, CASTLING_SIDE_NB = 2
+};
+
+enum CastlingRight {
+  NO_CASTLING,
+  WHITE_OO,
+  WHITE_OOO = WHITE_OO << 1,
+  BLACK_OO  = WHITE_OO << 2,
+  BLACK_OOO = WHITE_OO << 3,
+  ANY_CASTLING = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
+  CASTLING_RIGHT_NB = 16
+};
+
+template<Color C, CastlingSide S> struct MakeCastling {
+  static const CastlingRight
+  right = C == WHITE ? S == QUEEN_SIDE ? WHITE_OOO : WHITE_OO
+                     : S == QUEEN_SIDE ? BLACK_OOO : BLACK_OO;
+};
+
+enum Phase {
+  PHASE_ENDGAME,
+  PHASE_MIDGAME = 128,
+  MG = 0, EG = 1, PHASE_NB = 2
+};
+
+enum ScaleFactor {
+  SCALE_FACTOR_DRAW    = 0,
+  SCALE_FACTOR_ONEPAWN = 48,
+  SCALE_FACTOR_NORMAL  = 64,
+  SCALE_FACTOR_MAX     = 128,
+  SCALE_FACTOR_NONE    = 255
+};
+
+enum Bound {
+  BOUND_NONE,
+  BOUND_UPPER,
+  BOUND_LOWER,
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
+};
+
+enum Value : int {
+  VALUE_ZERO      = 0,
+  VALUE_DRAW      = 0,
+  VALUE_KNOWN_WIN = 10000,
+  VALUE_MATE      = 32000,
+  VALUE_INFINITE  = 32001,
+  VALUE_NONE      = 32002,
+
+  VALUE_MATE_IN_MAX_PLY  =  VALUE_MATE - 2 * MAX_PLY,
+  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY,
+
+  PawnValueMg   = 198,   PawnValueEg   = 258,
+  KnightValueMg = 817,   KnightValueEg = 846,
+  BishopValueMg = 836,   BishopValueEg = 857,
+  RookValueMg   = 1270,  RookValueEg   = 1281,
+  QueenValueMg  = 2521,  QueenValueEg  = 2558,
+
+  MidgameLimit  = 15581, EndgameLimit  = 3998
+};
+
+enum PieceType {
+  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
+  ALL_PIECES = 0,
+  PIECE_TYPE_NB = 8
+};
+
+enum Piece {
+  NO_PIECE,
+  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
+  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
+  PIECE_NB = 16
+};
+
+enum Depth {
+
+  ONE_PLY = 1,
+
+  DEPTH_ZERO          =  0,
+  DEPTH_QS_CHECKS     =  0,
+  DEPTH_QS_NO_CHECKS  = -1,
+  DEPTH_QS_RECAPTURES = -5,
+
+  DEPTH_NONE = -6,
+  DEPTH_MAX  = MAX_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,
+
+  SQUARE_NB = 64,
+
+  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, FILE_NB
+};
+
+enum Rank {
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB
+};
+
+
+/// Score enum stores a middlegame and an endgame value in a single integer
+/// (enum). The least significant 16 bits are used to store the endgame value
+/// and the upper 16 bits are used to store the middlegame value.
+enum Score : int { SCORE_ZERO };
+
+inline Score make_score(int mg, int eg) {
+  return Score((mg << 16) + eg);
+}
+
+/// Extracting the signed lower and upper 16 bits is 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) {
+
+  union { uint16_t u; int16_t s; } mg = { uint16_t(unsigned(s + 0x8000) >> 16) };
+  return Value(mg.s);
+}
+
+inline Value eg_value(Score s) {
+
+  union { uint16_t u; int16_t s; } eg = { uint16_t(unsigned(s)) };
+  return Value(eg.s);
+}
+
+#define ENABLE_BASE_OPERATORS_ON(T)                             \
+inline T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \
+inline T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \
+inline T operator*(int i, T d) { return T(i * int(d)); }        \
+inline T operator*(T d, int i) { return T(int(d) * i); }        \
+inline T operator-(T d) { return T(-int(d)); }                  \
+inline T& operator+=(T& d1, T d2) { return d1 = d1 + d2; }      \
+inline T& operator-=(T& d1, T d2) { return d1 = d1 - d2; }      \
+inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }
+
+#define ENABLE_FULL_OPERATORS_ON(T)                             \
+ENABLE_BASE_OPERATORS_ON(T)                                     \
+inline T& operator++(T& d) { return d = T(int(d) + 1); }        \
+inline T& operator--(T& d) { return d = T(int(d) - 1); }        \
+inline T operator/(T d, int i) { return T(int(d) / i); }        \
+inline int operator/(T d1, T d2) { return int(d1) / int(d2); }  \
+inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
+
+ENABLE_FULL_OPERATORS_ON(Value)
+ENABLE_FULL_OPERATORS_ON(PieceType)
+ENABLE_FULL_OPERATORS_ON(Piece)
+ENABLE_FULL_OPERATORS_ON(Color)
+ENABLE_FULL_OPERATORS_ON(Depth)
+ENABLE_FULL_OPERATORS_ON(Square)
+ENABLE_FULL_OPERATORS_ON(File)
+ENABLE_FULL_OPERATORS_ON(Rank)
+
+ENABLE_BASE_OPERATORS_ON(Score)
+
+#undef ENABLE_FULL_OPERATORS_ON
+#undef ENABLE_BASE_OPERATORS_ON
+
+/// Additional operators to add 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); }
+inline Value& operator+=(Value& v, int i) { return v = v + i; }
+inline Value& operator-=(Value& v, int i) { return v = v - 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);
+
+/// Division of a Score 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);
+}
+
+extern Value PieceValue[PHASE_NB][PIECE_NB];
+
+inline Color operator~(Color c) {
+  return Color(c ^ BLACK);
+}
+
+inline Square operator~(Square s) {
+  return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8
+}
+
+inline CastlingRight operator|(Color c, CastlingSide s) {
+  return CastlingRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
+}
+
+inline Value mate_in(int ply) {
+  return VALUE_MATE - ply;
+}
+
+inline Value mated_in(int ply) {
+  return -VALUE_MATE + ply;
+}
+
+inline Square make_square(File f, Rank r) {
+  return Square((r << 3) | f);
+}
+
+inline Piece make_piece(Color c, PieceType pt) {
+  return Piece((c << 3) | pt);
+}
+
+inline PieceType type_of(Piece pc)  {
+  return PieceType(pc & 7);
+}
+
+inline Color color_of(Piece pc) {
+  assert(pc != NO_PIECE);
+  return Color(pc >> 3);
+}
+
+inline bool is_ok(Square s) {
+  return s >= SQ_A1 && s <= SQ_H8;
+}
+
+inline File file_of(Square s) {
+  return File(s & 7);
+}
+
+inline Rank rank_of(Square s) {
+  return Rank(s >> 3);
+}
+
+inline Square relative_square(Color c, Square s) {
+  return Square(s ^ (c * 56));
+}
+
+inline Rank relative_rank(Color c, Rank r) {
+  return Rank(r ^ (c * 7));
+}
+
+inline Rank relative_rank(Color c, Square s) {
+  return relative_rank(c, rank_of(s));
+}
+
+inline bool opposite_colors(Square s1, Square s2) {
+  int s = int(s1) ^ int(s2);
+  return ((s >> 3) ^ s) & 1;
+}
+
+inline Square pawn_push(Color c) {
+  return c == WHITE ? DELTA_N : DELTA_S;
+}
+
+inline Square from_sq(Move m) {
+  return Square((m >> 6) & 0x3F);
+}
+
+inline Square to_sq(Move m) {
+  return Square(m & 0x3F);
+}
+
+inline MoveType type_of(Move m) {
+  return MoveType(m & (3 << 14));
+}
+
+inline PieceType promotion_type(Move m) {
+  return PieceType(((m >> 12) & 3) + KNIGHT);
+}
+
+inline Move make_move(Square from, Square to) {
+  return Move(to | (from << 6));
+}
+
+template<MoveType T>
+inline Move make(Square from, Square to, PieceType pt = KNIGHT) {
+  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));
+}
+
+inline bool is_ok(Move m) {
+  return from_sq(m) != to_sq(m); // Catch MOVE_NULL and MOVE_NONE
+}
+
+#endif // #ifndef TYPES_H_INCLUDED

src/uci.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,288 +18,270 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
 
 #include "evaluate.h"
-#include "misc.h"
-#include "move.h"
 #include "movegen.h"
 #include "position.h"
-#include "san.h"
 #include "search.h"
-#include "ucioption.h"
+#include "thread.h"
+#include "timeman.h"
+#include "uci.h"
 
 using namespace std;
 
+extern void benchmark(const Position& pos, istream& is);
 
 namespace {
 
-  // FEN string for the initial position
+  // FEN string of the initial position, normal chess
-  const string StartPositionFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+  const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
 
-  // UCIParser is a class for parsing UCI input. The class
+  // Stack to keep track of the position states along the setup moves (from the
-  // is actually a string stream built on a given input string.
+  // start position to the position just before the search starts). Needed by
-  typedef istringstream UCIParser;
+  // 'draw by repetition' detection.
-
+  Search::StateStackPtr SetupStates;
-  // Local functions
-  void set_option(UCIParser& uip);
-  void set_position(Position& pos, UCIParser& uip);
-  bool go(Position& pos, UCIParser& uip);
-  void perft(Position& pos, UCIParser& uip);
-}
 
 
-/// execute_uci_command() takes a string as input, uses a UCIParser
+  // position() is called when engine receives the "position" UCI command.
-/// object to parse this text string as a UCI command, and calls
+  // The function sets up the position described in the given FEN string ("fen")
-/// the appropriate functions. In addition to the UCI commands,
+  // or the starting position ("startpos") and then makes the moves given in the
-/// the function also supports a few debug commands.
+  // following move list ("moves").
 
-bool execute_uci_command(const string& cmd) {
+  void position(Position& pos, istringstream& is) {
 
-  static Position pos(StartPositionFEN, false, 0); // The root position
+    Move m;
-  UCIParser up(cmd);
+    string token, fen;
-  string token;
 
-  if (!(up >> token)) // operator>>() skips any whitespace
+    is >> token;
-      return true;
-
-  if (token == "quit")
-      return false;
-
-  if (token == "go")
-      return go(pos, up);
-
-  if (token == "uci")
-  {
-      cout << "id name " << engine_name()
-           << "\nid author Tord Romstad, Marco Costalba, Joona Kiiski\n";
-      print_uci_options();
-      cout << "uciok" << endl;
-  }
-  else 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);
-
-  // The remaining commands are for debugging purposes only
-  else if (token == "d")
-      pos.print();
-
-  else if (token == "flip")
-  {
-      Position p(pos, pos.thread());
-      pos.flipped_copy(p);
-  }
-  else if (token == "eval")
-  {
-      Value evalMargin;
-      cout << "Incremental mg: "   << mg_value(pos.value())
-           << "\nIncremental eg: " << eg_value(pos.value())
-           << "\nFull eval: "      << evaluate(pos, evalMargin) << 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 == "perft")
-      perft(pos, up);
-
-  else
-      cout << "Unknown command: " << cmd << endl;
-
-  return true;
-}
-
-
-////
-//// Local functions
-////
-
-namespace {
-
-  // set_position() is called when Stockfish receives the "position" UCI
-  // command. The input parameter is a UCIParser. 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(Position& pos, UCIParser& up) {
-
-    string token;
-
-    if (!(up >> token) || (token != "startpos" && token != "fen"))
-        return;
 
     if (token == "startpos")
     {
-        pos.from_fen(StartPositionFEN, false);
+        fen = StartFEN;
-        if (!(up >> token))
+        is >> token; // Consume "moves" token if any
-            return;
     }
-    else // fen
+    else if (token == "fen")
-    {
+        while (is >> token && token != "moves")
-        string fen;
+            fen += token + " ";
-        while (up >> token && token != "moves")
+    else
-        {
-            fen += token;
-            fen += ' ';
-        }
-        pos.from_fen(fen, Options["UCI_Chess960"].value<bool>());
-    }
-
-    if (token != "moves")
         return;
 
-    // Parse optional move list
+    pos.set(fen, Options["UCI_Chess960"], Threads.main());
-    Move move;
+    SetupStates = Search::StateStackPtr(new std::stack<StateInfo>);
-    StateInfo st;
+
-    while (up >> token)
+    // Parse move list (if any)
+    while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE)
     {
-        move = move_from_uci(pos, token);
+        SetupStates->push(StateInfo());
-        pos.do_move(move, st);
+        pos.do_move(m, SetupStates->top(), pos.gives_check(m, CheckInfo(pos)));
-        if (pos.rule_50_counter() == 0)
-            pos.reset_game_ply();
-
-        pos.inc_startpos_ply_counter(); //FIXME: make from_fen to support this and rule50
     }
-    // Our StateInfo st is about going out of scope so copy
-    // its content inside pos before it disappears.
-    pos.detach();
   }
 
 
-  // set_option() is called when Stockfish receives the "setoption" UCI
+  // setoption() is called when engine receives the "setoption" UCI command. The
-  // command. The input parameter is a UCIParser. It is assumed
+  // function updates the UCI option ("name") to the given value ("value").
-  // 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(UCIParser& up) {
+  void setoption(istringstream& is) {
 
     string token, name, value;
 
-    if (!(up >> token) || token != "name") // operator>>() skips any whitespace
+    is >> token; // Consume "name" token
-        return;
 
-    if (!(up >> name))
+    // Read option name (can contain spaces)
-        return;
+    while (is >> token && token != "value")
+        name += string(" ", name.empty() ? 0 : 1) + token;
 
-    // Handle names with included spaces
+    // Read option value (can contain spaces)
-    while (up >> token && token != "value")
+    while (is >> token)
-        name += (" " + token);
+        value += string(" ", value.empty() ? 0 : 1) + token;
 
-    if (Options.find(name) == Options.end())
+    if (Options.count(name))
-    {
+        Options[name] = value;
-        cout << "No such option: " << name << endl;
+    else
-        return;
+        sync_cout << "No such option: " << name << sync_endl;
-    }
-
-    // Is a button ?
-    if (token != "value")
-    {
-        Options[name].set_value("true");
-        return;
-    }
-
-    if (!(up >> value))
-        return;
-
-    // Handle values with included spaces
-    while (up >> token)
-        value += (" " + token);
-
-    Options[name].set_value(value);
   }
 
 
-  // go() is called when Stockfish receives the "go" UCI command. The
+  // go() is called when engine receives the "go" UCI command. The function sets
-  // input parameter is a UCIParser. It is assumed that this
+  // the thinking time and other parameters from the input string, then starts
-  // parser has consumed the first token of the UCI command ("go"),
+  // the search.
-  // 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. Returns false if a quit command is received while
-  // thinking, returns true otherwise.
 
-  bool go(Position& pos, UCIParser& up) {
+  void go(const Position& pos, istringstream& is) {
 
+    Search::LimitsType limits;
     string token;
 
-    int time[2] = {0, 0}, inc[2] = {0, 0};
+    limits.startTime = now(); // As early as possible!
-    int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
-    bool infinite = false, ponder = false;
-    Move searchMoves[MOVES_MAX];
 
-    searchMoves[0] = MOVE_NONE;
+    while (is >> token)
+        if (token == "searchmoves")
+            while (is >> token)
+                limits.searchmoves.push_back(UCI::to_move(pos, token));
 
-    while (up >> token)
+        else if (token == "wtime")     is >> limits.time[WHITE];
+        else if (token == "btime")     is >> limits.time[BLACK];
+        else if (token == "winc")      is >> limits.inc[WHITE];
+        else if (token == "binc")      is >> limits.inc[BLACK];
+        else if (token == "movestogo") is >> limits.movestogo;
+        else if (token == "depth")     is >> limits.depth;
+        else if (token == "nodes")     is >> limits.nodes;
+        else if (token == "movetime")  is >> limits.movetime;
+        else if (token == "mate")      is >> limits.mate;
+        else if (token == "infinite")  limits.infinite = 1;
+        else if (token == "ponder")    limits.ponder = 1;
+
+    Threads.start_thinking(pos, limits, SetupStates);
+  }
+
+} // namespace
+
+
+/// UCI::loop() waits for a command from stdin, parses it and calls the appropriate
+/// function. Also intercepts EOF from stdin to ensure gracefully exiting if the
+/// GUI dies unexpectedly. When called with some command line arguments, e.g. to
+/// run 'bench', once the command is executed the function returns immediately.
+/// In addition to the UCI ones, also some additional debug commands are supported.
+
+void UCI::loop(int argc, char* argv[]) {
+
+  Position pos(StartFEN, false, Threads.main()); // The root position
+  string token, cmd;
+
+  for (int i = 1; i < argc; ++i)
+      cmd += std::string(argv[i]) + " ";
+
+  do {
+      if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF
+          cmd = "quit";
+
+      istringstream is(cmd);
+
+      token.clear(); // getline() could return empty or blank line
+      is >> skipws >> token;
+
+      // The GUI sends 'ponderhit' to tell us to ponder on the same move the
+      // opponent has played. In case Signals.stopOnPonderhit is set we are
+      // waiting for 'ponderhit' to stop the search (for instance because we
+      // already ran out of time), otherwise we should continue searching but
+      // switching from pondering to normal search.
+      if (    token == "quit"
+          ||  token == "stop"
+          || (token == "ponderhit" && Search::Signals.stopOnPonderhit))
       {
-        if (token == "infinite")
+          Search::Signals.stop = true;
-            infinite = true;
+          Threads.main()->start_searching(true); // Could be sleeping
-        else if (token == "ponder")
+      }
-            ponder = true;
+      else if (token == "ponderhit")
-        else if (token == "wtime")
+          Search::Limits.ponder = 0; // Switch to normal search
-            up >> time[0];
+
-        else if (token == "btime")
+      else if (token == "uci")
-            up >> time[1];
+          sync_cout << "id name " << engine_info(true)
-        else if (token == "winc")
+                    << "\n"       << Options
-            up >> inc[0];
+                    << "\nuciok"  << sync_endl;
-        else if (token == "binc")
+
-            up >> inc[1];
+      else if (token == "ucinewgame")
-        else if (token == "movestogo")
-            up >> movesToGo;
-        else if (token == "depth")
-            up >> depth;
-        else if (token == "nodes")
-            up >> nodes;
-        else if (token == "movetime")
-            up >> moveTime;
-        else if (token == "searchmoves")
       {
-            int numOfMoves = 0;
+          Search::clear();
-            while (up >> token)
+          Time.availableNodes = 0;
-                searchMoves[numOfMoves++] = move_from_uci(pos, token);
-
-            searchMoves[numOfMoves] = MOVE_NONE;
       }
+      else if (token == "isready")    sync_cout << "readyok" << sync_endl;
+      else if (token == "go")         go(pos, is);
+      else if (token == "position")   position(pos, is);
+      else if (token == "setoption")  setoption(is);
+
+      // Additional custom non-UCI commands, useful for debugging
+      else if (token == "flip")       pos.flip();
+      else if (token == "bench")      benchmark(pos, is);
+      else if (token == "d")          sync_cout << pos << sync_endl;
+      else if (token == "eval")       sync_cout << Eval::trace(pos) << sync_endl;
+      else if (token == "perft")
+      {
+          int depth;
+          stringstream ss;
+
+          is >> depth;
+          ss << Options["Hash"]    << " "
+             << Options["Threads"] << " " << depth << " current perft";
+
+          benchmark(pos, ss);
       }
+      else
+          sync_cout << "Unknown command: " << cmd << sync_endl;
 
-    assert(pos.is_ok());
+  } while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
 
-    return think(pos, infinite, ponder, time, inc, movesToGo,
+  Threads.main()->wait_for_search_finished();
-                 depth, nodes, moveTime, searchMoves);
+}
-  }
+
-
+
-  void perft(Position& pos, UCIParser& up) {
+/// UCI::value() converts a Value to a string suitable for use with the UCI
-
+/// protocol specification:
-    int depth, tm, n;
+///
-
+/// cp <x>    The score from the engine's point of view in centipawns.
-    if (!(up >> depth))
+/// mate <y>  Mate in y moves, not plies. If the engine is getting mated
-        return;
+///           use negative values for y.
-
+
-    tm = get_system_time();
+string UCI::value(Value v) {
-
+
-    n = perft(pos, depth * ONE_PLY);
+  stringstream ss;
-
+
-    tm = get_system_time() - tm;
+  if (abs(v) < VALUE_MATE - MAX_PLY)
-    std::cout << "\nNodes " << n
+      ss << "cp " << v * 100 / PawnValueEg;
-              << "\nTime (ms) " << tm
+  else
-              << "\nNodes/second " << int(n / (tm / 1000.0)) << std::endl;
+      ss << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
-  }
+
+  return ss.str();
+}
+
+
+/// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.)
+
+std::string UCI::square(Square s) {
+  return std::string{ char('a' + file_of(s)), char('1' + rank_of(s)) };
+}
+
+
+/// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q).
+/// The only special case is castling, where we print in the e1g1 notation in
+/// normal chess mode, and in e1h1 notation in chess960 mode. Internally all
+/// castling moves are always encoded as 'king captures rook'.
+
+string UCI::move(Move m, bool chess960) {
+
+  Square from = from_sq(m);
+  Square to = to_sq(m);
+
+  if (m == MOVE_NONE)
+      return "(none)";
+
+  if (m == MOVE_NULL)
+      return "0000";
+
+  if (type_of(m) == CASTLING && !chess960)
+      to = make_square(to > from ? FILE_G : FILE_C, rank_of(from));
+
+  string move = UCI::square(from) + UCI::square(to);
+
+  if (type_of(m) == PROMOTION)
+      move += " pnbrqk"[promotion_type(m)];
+
+  return move;
+}
+
+
+/// UCI::to_move() converts a string representing a move in coordinate notation
+/// (g1f3, a7a8q) to the corresponding legal Move, if any.
+
+Move UCI::to_move(const Position& pos, string& str) {
+
+  if (str.length() == 5) // Junior could send promotion piece in uppercase
+      str[4] = char(tolower(str[4]));
+
+  for (const auto& m : MoveList<LEGAL>(pos))
+      if (str == UCI::move(m, pos.is_chess960()))
+          return m;
+
+  return MOVE_NONE;
 }

src/uci.h

@@ -0,0 +1,80 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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/>.
+*/
+
+#ifndef UCI_H_INCLUDED
+#define UCI_H_INCLUDED
+
+#include <map>
+#include <string>
+
+#include "types.h"
+
+class Position;
+
+namespace UCI {
+
+class Option;
+
+/// Custom comparator because UCI options should be case insensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
+
+/// Our options container is actually a std::map
+typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
+
+/// Option class implements an option as defined by UCI protocol
+class Option {
+
+  typedef void (*OnChange)(const Option&);
+
+public:
+  Option(OnChange = nullptr);
+  Option(bool v, OnChange = nullptr);
+  Option(const char* v, OnChange = nullptr);
+  Option(int v, int min, int max, OnChange = nullptr);
+
+  Option& operator=(const std::string&);
+  void operator<<(const Option&);
+  operator int() const;
+  operator std::string() const;
+
+private:
+  friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
+
+  std::string defaultValue, currentValue, type;
+  int min, max;
+  size_t idx;
+  OnChange on_change;
+};
+
+void init(OptionsMap&);
+void loop(int argc, char* argv[]);
+std::string value(Value v);
+std::string square(Square s);
+std::string move(Move m, bool chess960);
+std::string pv(const Position& pos, Depth depth, Value alpha, Value beta);
+Move to_move(const Position& pos, std::string& str);
+
+} // namespace UCI
+
+extern UCI::OptionsMap Options;
+
+#endif // #ifndef UCI_H_INCLUDED

src/ucioption.cpp

@@ -1,7 +1,8 @@
 /*
   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
+  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
@@ -17,162 +18,146 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <cctype>
+#include <algorithm>
-#include <iostream>
+#include <cassert>
-#include <sstream>
+#include <ostream>
 
 #include "misc.h"
+#include "search.h"
 #include "thread.h"
-#include "ucioption.h"
+#include "tt.h"
+#include "uci.h"
+#include "syzygy/tbprobe.h"
 
 using std::string;
-using std::cout;
-using std::endl;
 
-OptionsMap Options; // Global object
+UCI::OptionsMap Options; // Global object
+
+namespace UCI {
+
+/// 'On change' actions, triggered by an option's value change
+void on_clear_hash(const Option&) { Search::clear(); }
+void on_hash_size(const Option& o) { TT.resize(o); }
+void on_logger(const Option& o) { start_logger(o); }
+void on_threads(const Option&) { Threads.read_uci_options(); }
+void on_tb_path(const Option& o) { Tablebases::init(o); }
 
 
-// Our case insensitive less() function as required by UCI protocol
+/// Our case insensitive less() function as required by UCI protocol
 bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
 
-  int c1, c2;
+  return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
-  size_t i = 0;
+         [](char c1, char c2) { return tolower(c1) < tolower(c2); });
+}
 
-  while (i < s1.size() && i < s2.size())
+
+/// init() initializes the UCI options to their hard-coded default values
+
+void init(OptionsMap& o) {
+
+  const int MaxHashMB = Is64Bit ? 1024 * 1024 : 2048;
+
+  o["Write Debug Log"]       << Option(false, on_logger);
+  o["Contempt"]              << Option(0, -100, 100);
+  o["Threads"]               << Option(1, 1, 128, on_threads);
+  o["Hash"]                  << Option(16, 1, MaxHashMB, on_hash_size);
+  o["Clear Hash"]            << Option(on_clear_hash);
+  o["Ponder"]                << Option(false);
+  o["MultiPV"]               << Option(1, 1, 500);
+  o["Skill Level"]           << Option(20, 0, 20);
+  o["Move Overhead"]         << Option(30, 0, 5000);
+  o["Minimum Thinking Time"] << Option(20, 0, 5000);
+  o["Slow Mover"]            << Option(84, 10, 1000);
+  o["nodestime"]             << Option(0, 0, 10000);
+  o["UCI_Chess960"]          << Option(false);
+  o["SyzygyPath"]            << Option("<empty>", on_tb_path);
+  o["SyzygyProbeDepth"]      << Option(1, 1, 100);
+  o["Syzygy50MoveRule"]      << Option(true);
+  o["SyzygyProbeLimit"]      << Option(6, 0, 6);
+}
+
+
+/// operator<<() is used to print all the options default values in chronological
+/// insertion order (the idx field) and in the format defined by the UCI protocol.
+
+std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
+
+  for (size_t idx = 0; idx < om.size(); ++idx)
+      for (const auto& it : om)
+          if (it.second.idx == idx)
           {
-      c1 = tolower(s1[i]);
+              const Option& o = it.second;
-      c2 = tolower(s2[i++]);
+              os << "\noption name " << it.first << " type " << o.type;
-
-      if (c1 != c2)
-          return c1 < c2;
-  }
-  return s1.size() < s2.size();
-}
-
-
-// stringify() converts a numeric value of type T to a std::string
-template<typename T>
-static string stringify(const T& v) {
-
-  std::ostringstream ss;
-  ss << v;
-  return ss.str();
-}
-
-
-/// init_uci_options() 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.
-
-void init_uci_options() {
-
-  Options["Use Search Log"] = Option(false);
-  Options["Search Log Filename"] = Option("SearchLog.txt");
-  Options["Book File"] = Option("book.bin");
-  Options["Best Book Move"] = Option(false);
-  Options["Mobility (Middle Game)"] = Option(100, 0, 200);
-  Options["Mobility (Endgame)"] = Option(100, 0, 200);
-  Options["Pawn Structure (Middle Game)"] = Option(100, 0, 200);
-  Options["Pawn Structure (Endgame)"] = Option(100, 0, 200);
-  Options["Passed Pawns (Middle Game)"] = Option(100, 0, 200);
-  Options["Passed Pawns (Endgame)"] = Option(100, 0, 200);
-  Options["Space"] = Option(100, 0, 200);
-  Options["Aggressiveness"] = Option(100, 0, 200);
-  Options["Cowardice"] = Option(100, 0, 200);
-  Options["Check Extension (PV nodes)"] = Option(2, 0, 2);
-  Options["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
-  Options["Single Evasion Extension (PV nodes)"] = Option(2, 0, 2);
-  Options["Single Evasion Extension (non-PV nodes)"] = Option(2, 0, 2);
-  Options["Mate Threat Extension (PV nodes)"] = Option(2, 0, 2);
-  Options["Mate Threat Extension (non-PV nodes)"] = Option(2, 0, 2);
-  Options["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
-  Options["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2);
-  Options["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2);
-  Options["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2);
-  Options["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2);
-  Options["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2);
-  Options["Minimum Split Depth"] = Option(4, 4, 7);
-  Options["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
-  Options["Threads"] = Option(1, 1, MAX_THREADS);
-  Options["Use Sleeping Threads"] = Option(false);
-  Options["Hash"] = Option(32, 4, 8192);
-  Options["Clear Hash"] = Option(false, "button");
-  Options["Ponder"] = Option(true);
-  Options["OwnBook"] = Option(true);
-  Options["MultiPV"] = Option(1, 1, 500);
-  Options["Emergency Move Horizon"] = Option(40, 0, 50);
-  Options["Emergency Base Time"] = Option(200, 0, 60000);
-  Options["Emergency Move Time"] = Option(70, 0, 5000);
-  Options["Minimum Thinking Time"] = Option(20, 0, 5000);
-  Options["UCI_Chess960"] = Option(false); // Just a dummy but needed by GUIs
-  Options["UCI_AnalyseMode"] = Option(false);
-
-  // Set some SMP parameters accordingly to the detected CPU count
-  Option& thr = Options["Threads"];
-  Option& msd = Options["Minimum Split Depth"];
-
-  thr.defaultValue = thr.currentValue = stringify(cpu_count());
-
-  if (cpu_count() >= 8)
-      msd.defaultValue = msd.currentValue = stringify(7);
-}
-
-
-/// print_uci_options() prints all the UCI options to the standard output,
-/// in chronological insertion order (the idx field) and in the format
-/// defined by the UCI protocol.
-
-void print_uci_options() {
-
-  for (size_t i = 0; i <= Options.size(); i++)
-      for (OptionsMap::const_iterator it = Options.begin(); it != Options.end(); ++it)
-          if (it->second.idx == i)
-          {
-              const Option& o = it->second;
-              cout << "\noption name " << it->first << " type " << o.type;
 
               if (o.type != "button")
-                  cout << " default " << o.defaultValue;
+                  os << " default " << o.defaultValue;
 
               if (o.type == "spin")
-                  cout << " min " << o.minValue << " max " << o.maxValue;
+                  os << " min " << o.min << " max " << o.max;
 
               break;
           }
-  cout << endl;
+
+  return os;
 }
 
 
-/// Option class c'tors
+/// Option class constructors and conversion operators
 
-Option::Option(const char* def) : type("string"), idx(Options.size()), minValue(0), maxValue(0)
+Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
-{ defaultValue = currentValue = def; }
+{ defaultValue = currentValue = v; }
 
-Option::Option(bool def, string t) : type(t), idx(Options.size()), minValue(0), maxValue(0)
+Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
-{ defaultValue = currentValue = (def ? "true" : "false"); }
+{ defaultValue = currentValue = (v ? "true" : "false"); }
 
-Option::Option(int def, int minv, int maxv) : type("spin"), idx(Options.size()), minValue(minv), maxValue(maxv)
+Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
-{ defaultValue = currentValue = stringify(def); }
+{}
+
+Option::Option(int v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
+{ defaultValue = currentValue = std::to_string(v); }
+
+Option::operator int() const {
+  assert(type == "check" || type == "spin");
+  return (type == "spin" ? stoi(currentValue) : currentValue == "true");
+}
+
+Option::operator std::string() const {
+  assert(type == "string");
+  return currentValue;
+}
 
 
-/// set_value() updates currentValue of the Option object. Normally it's up to
+/// operator<<() inits options and assigns idx in the correct printing order
-/// 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.
 
-void Option::set_value(const string& value) {
+void Option::operator<<(const Option& o) {
+
+  static size_t insert_order = 0;
+
+  *this = o;
+  idx = insert_order++;
+}
+
+
+/// operator=() updates currentValue and triggers on_change() action. It's up to
+/// the GUI to check for option's limits, but we could receive the new value from
+/// the user by console window, so let's check the bounds anyway.
+
+Option& Option::operator=(const string& v) {
 
   assert(!type.empty());
 
-  if (    (type == "check" || type == "button")
+  if (   (type != "button" && v.empty())
-      && !(value == "true" || value == "false"))
+      || (type == "check" && v != "true" && v != "false")
-      return;
+      || (type == "spin" && (stoi(v) < min || stoi(v) > max)))
+      return *this;
 
-  if (type == "spin")
+  if (type != "button")
-  {
+      currentValue = v;
-      int v = atoi(value.c_str());
-      if (v < minValue || v > maxValue)
-          return;
-  }
 
-  currentValue = value;
+  if (on_change)
+      on_change(*this);
+
+  return *this;
 }
+
+} // namespace UCI

src/ucioption.h

@@ -1,80 +0,0 @@
-/*
-  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(UCIOPTION_H_INCLUDED)
-#define UCIOPTION_H_INCLUDED
-
-#include <cassert>
-#include <cstdlib>
-#include <map>
-#include <string>
-
-class Option {
-public:
-  Option() {} // To allow insertion in a std::map
-  Option(const char* defaultValue);
-  Option(bool defaultValue, std::string type = "check");
-  Option(int defaultValue, int minValue, int maxValue);
-
-  void set_value(const std::string& value);
-  template<typename T> T value() const;
-
-private:
-  friend void init_uci_options();
-  friend void print_uci_options();
-
-  std::string defaultValue, currentValue, type;
-  size_t idx;
-  int minValue, maxValue;
-};
-
-template<typename T>
-inline T Option::value() const {
-
-  assert(type == "spin");
-  return T(atoi(currentValue.c_str()));
-}
-
-template<>
-inline std::string Option::value<std::string>() const {
-
-  assert(type == "string");
-  return currentValue;
-}
-
-template<>
-inline bool Option::value<bool>() const {
-
-  assert(type == "check" || type == "button");
-  return currentValue == "true";
-}
-
-
-// Custom comparator because UCI options should not be case sensitive
-struct CaseInsensitiveLess {
-  bool operator() (const std::string&, const std::string&) const;
-};
-
-typedef std::map<std::string, Option, CaseInsensitiveLess> OptionsMap;
-
-extern OptionsMap Options;
-extern void init_uci_options();
-extern void print_uci_options();
-
-#endif // !defined(UCIOPTION_H_INCLUDED)

src/value.h

@@ -1,119 +0,0 @@
-/*
-  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(VALUE_H_INCLUDED)
-#define VALUE_H_INCLUDED
-
-////
-//// Types
-////
-
-enum ValueType {
-  VALUE_TYPE_NONE  = 0,
-  VALUE_TYPE_UPPER = 1,  // Upper bound
-  VALUE_TYPE_LOWER = 2,  // Lower bound
-  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_ENSURE_SIGNED = -1
-};
-
-ENABLE_OPERATORS_ON(Value)
-
-
-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_32_BITS_SIZE_P =  (1 << 16),
-    SCORE_ENSURE_32_BITS_SIZE_N = -(1 << 16)
-};
-
-// Extracting the _signed_ lower and upper 16 bits it not so trivial
-// because according to the standard a simple cast to short is
-// implementation defined and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); }
-
-// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in
-// this case, although not 100% standard compliant it seems to work for Intel and MSVC.
-#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
-inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
-#else
-inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); }
-#endif
-
-inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
-
-// 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);
-
-// Rest of 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); }
-
-
-////
-//// Inline functions
-////
-
-inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
-inline Value operator- (Value v, int i) { return Value(int(v) - i); }
-
-
-inline Value value_mate_in(int ply) {
-  return VALUE_MATE - ply;
-}
-
-inline Value value_mated_in(int ply) {
-  return -VALUE_MATE + ply;
-}
-
-#endif // !defined(VALUE_H_INCLUDED)