Stockfish 2.1.1

stockfish bench signature is: 6487630

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

Readme.txt

@@ -1,99 +1,88 @@
-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 8 CPUs, but has not been
-tested thoroughly with more than 2.  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.
-
-
-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 experimental support for PolyGlot opening
-books. For information about how to create such books, consult the
-PolyGlot documentation.  The book file can be selected by setting the
-UCI parameter "Book File".
-
-
-
-4. Compiling it yourself
-------------------------
-
-On Unix-like systems, it should usually be possible to compile
-Stockfish directly from the source code with the included Makefile.
-The exception is computer with big-endian CPUs, like PowerPC
-Macintoshes. Some of the bitboard routines in the current version of
-Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
-Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
-of bitboard.h is commented out should solve this problem.
-Commenting out the line with "#define USE_32BIT_ATTACKS" near the
-
-There is also a problem with compiling Stockfish on certain 64-bit
-systems, regardless of the endianness.  If Stockfish segfaults
-immediately after startup, try to comment out the line with
-"#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
-recompile.
-
-Finally, even if Stockfish does work without any changes on your
-computer, it might be possible to improve the performance by changing
-some of the #define directives in bitboard.h.  The default settings
-are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
-to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
-BITCOUNT_SWAR_64.  For computers with very little memory (like
-handheld devices), it is possible to conserve memory by defining
-USE_COMPACT_ROOK_ATTACKS.
-
-
-6. 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.
-
-
-7. Feedback
------------
-
-The author's e-mail address is mcostalba@gmail.com
+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 32 CPUs, but has not been
+tested thoroughly with more than 4.  The program tries to detect the
+number of CPUs on your computer and set the number of search threads
+accordingly, but please be aware that the detection is not always
+correct.  It is therefore recommended to inspect the value of the
+"Threads" UCI parameter, and to make sure it equals the number of CPU
+cores on your computer. 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 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,70 +1,39 @@
-
-[PolyGlot]
-
-EngineDir = .
-EngineCommand = ./glaurung
-
-Book = false
-BookFile = book.bin
-
-Log = true
-LogFile = glaurung.log
-
-Resign = true
-ResignScore = 600
-
-[Engine]
-
-Hash = 128
-Threads = 1
-OwnBook = false
-Book File = book.bin
-Use Search Log = false
-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
-Aggressiveness = 100
-Cowardice = 100
-King Safety Curve = Quadratic
-Quadratic = Linear
-King Safety Coefficient = 40
-King Safety X Intercept = 0
-King Safety Max Slope = 30
-King Safety Max Value = 500
-Queen Contact Check Bonus = 4
-Rook Contact Check Bonus = 2
-Queen Check Bonus = 2
-Rook Check Bonus = 1
-Bishop Check Bonus = 1
-Knight Check Bonus = 1
-Discovered Check Bonus = 3
-Mate Threat Bonus = 3
-Check Extension (PV nodes) = 2
-Check Extension (non-PV nodes) = 1
-Single Reply Extension (PV nodes) = 2
-Single Reply Extension (non-PV nodes) = 2
-Mate Threat Extension (PV nodes) = 0
-Mate Threat Extension (non-PV nodes) = 0
-Pawn Push to 7th Extension (PV nodes) = 1
-Pawn Push to 7th Extension (non-PV nodes) = 1
-Passed Pawn Extension (PV nodes) = 1
-Passed Pawn Extension (non-PV nodes) = 0
-Pawn Endgame Extension (PV nodes) = 2
-Pawn Endgame Extension (non-PV nodes) = 2
-Full Depth Moves (PV nodes) = 14
-Full Depth Moves (non-PV nodes) = 3
-Threat Depth = 5
-Selective Plies = 7
-Futility Pruning (Main Search) = true
-Futility Pruning (Quiescence Search) = true
-Futility Margin 0 = 50
-Futility Margin 1 = 100
-Futility Margin 2 = 300
-Maximum Razoring Depth = 3
-Razoring Margin = 300
-Randomness = 0
-Minimum Split Depth = 4
-Maximum Number of Threads per Split Point = 5
+
+[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
+Passed Pawns (Middle Game) = 100
+Passed Pawns (Endgame) = 100
+Space = 100
+Aggressiveness = 100
+Cowardice = 100
+Minimum Split Depth = 4
+Maximum Number of Threads per Split Point = 5
+Use Sleeping Threads = false
+Skill Level = 20
+Emergency Move Horizon = 40
+Emergency Base Time = 200
+Emergency Move Time = 70
+Minimum Thinking Time = 20

src/COPYING

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

src/Makefile

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

src/benchmark.cpp

@@ -1,44 +1,36 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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 <fstream>
-#include <sstream>
+#include <iostream>
 #include <vector>
 
-#include "benchmark.h"
+#include "position.h"
 #include "search.h"
-#include "thread.h"
 #include "ucioption.h"
 
+using namespace std;
 
-////
-//// Variables
-////
-
-const std::string BenchmarkPositions[] = {
+static const string Defaults[] = {
   "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
-  "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
-  "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
+  "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -",
+  "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
   "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14",
   "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14",
@@ -50,83 +42,112 @@ const std::string BenchmarkPositions[] = {
   "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16",
   "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
   "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
-  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b  - 3 22",
-  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
+  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
+  "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26",
+  ""
 };
-  
 
-////
-//// Functions
-////
 
 /// benchmark() runs a simple benchmark by letting Stockfish analyze a set
-/// of positions for a given time each.  There are four 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 time in seconds spent for each position (optional, default
-/// is 60) and an optional file name where to look for positions in fen
-/// format (default are the BenchmarkPositions defined above).
+/// be used, the limit value spent for each position (optional, default
+/// is ply 12), an optional file name where to look for positions in fen
+/// format (default are the BenchmarkPositions defined above) and the type
+/// of the limit value: depth (default), time in secs or number of nodes.
 /// The analysis is written to a file named bench.txt.
 
-void benchmark(const std::string& commandLine) {
+void benchmark(int argc, char* argv[]) {
 
-  std::istringstream csVal(commandLine);
-  std::istringstream csStr(commandLine);
-  std::string ttSize, threads, fileName;
-  int val, secsPerPos;
+  vector<string> fenList;
+  SearchLimits limits;
+  int64_t totalNodes;
+  int time;
 
-  csStr >> ttSize;
-  csVal >> val;
-  if (val < 4 || val > 1024)
+  // Load default positions
+  for (int i = 0; !Defaults[i].empty(); i++)
+      fenList.push_back(Defaults[i]);
+
+  // Assign default values to missing arguments
+  string ttSize  = argc > 2 ? argv[2] : "128";
+  string threads = argc > 3 ? argv[3] : "1";
+  string valStr  = argc > 4 ? argv[4] : "12";
+  string fenFile = argc > 5 ? argv[5] : "default";
+  string valType = argc > 6 ? argv[6] : "depth";
+
+  Options["Hash"].set_value(ttSize);
+  Options["Threads"].set_value(threads);
+  Options["OwnBook"].set_value("false");
+
+  // Search should be limited by nodes, time or depth ?
+  if (valType == "nodes")
+      limits.maxNodes = atoi(valStr.c_str());
+  else if (valType == "time")
+      limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
+  else
+      limits.maxDepth = atoi(valStr.c_str());
+
+  // Do we need to load positions from a given FEN file ?
+  if (fenFile != "default")
   {
-      std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
-      exit(EXIT_FAILURE);
-  }
-  csStr >> threads;
-  csVal >> val;
-  if (val < 1 || val > THREAD_MAX)
-  {
-      std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
-                << std::endl;
-      exit(EXIT_FAILURE);
-  }  
-  set_option_value("Hash", ttSize);
-  set_option_value("Threads", threads);
-  set_option_value("OwnBook", "false");
-  set_option_value("Use Search Log", "true");
-  set_option_value("Search Log Filename", "bench.txt");
+      string fen;
+      ifstream f(fenFile.c_str());
 
-  csVal >> secsPerPos;
-  csVal >> fileName;
-
-  std::vector<std::string> positions;
-  
-  if (fileName != "default")
-  {
-      std::ifstream fenFile(fileName.c_str());
-      if (!fenFile.is_open())
+      if (f.is_open())
       {
-          std::cerr << "Unable to open positions file " << fileName
-                    << std::endl;
-          exit(EXIT_FAILURE);
-      }        
-      std::string pos;
-      while (fenFile.good())
-      {
-          std::getline(fenFile, pos);
-          if (!pos.empty())
-              positions.push_back(pos);
+          fenList.clear();
+
+          while (getline(f, fen))
+              if (!fen.empty())
+                  fenList.push_back(fen);
+
+          f.close();
+      }
+      else
+      {
+          cerr << "Unable to open FEN file " << fenFile << endl;
+          exit(EXIT_FAILURE);
       }
-      fenFile.close();
-  } else
-      for (int i = 0; i < 16; i++)
-          positions.push_back(std::string(BenchmarkPositions[i]));
-
-  std::vector<std::string>::iterator it;
-  for (it = positions.begin(); it != positions.end(); ++it)
-  {
-      Move moves[1] = {MOVE_NONE};
-      int dummy[2] = {0, 0};
-      Position pos(*it);
-      think(pos, true, false, 0, dummy, dummy, 0, 0, 0, secsPerPos * 1000, moves);
   }
+
+  // Ok, let's start the benchmark !
+  totalNodes = 0;
+  time = get_system_time();
+
+  for (size_t i = 0; i < fenList.size(); i++)
+  {
+      Move moves[] = { MOVE_NONE };
+      Position pos(fenList[i], false, 0);
+
+      cerr << "\nBench position: " << i + 1 << '/' << fenList.size() << endl;
+
+      if (valType == "perft")
+      {
+          int64_t cnt = perft(pos, limits.maxDepth * ONE_PLY);
+          totalNodes += cnt;
+
+          cerr << "\nPerft " << limits.maxDepth << " nodes counted: " << cnt << endl;
+      }
+      else
+      {
+          if (!think(pos, limits, moves))
+              break;
+
+          totalNodes += pos.nodes_searched();
+      }
+  }
+
+  time = get_system_time() - time;
+
+  cerr << "\n==============================="
+       << "\nTotal time (ms) : " << time
+       << "\nNodes searched  : " << totalNodes
+       << "\nNodes/second    : " << (int)(totalNodes / (time / 1000.0)) << endl << endl;
+
+  // MS Visual C++ debug window always unconditionally closes when program
+  // exits, this is bad because we want to read results before.
+  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
+  cerr << "Press any key to exit" << endl;
+  cin >> time;
+  #endif
 }

src/benchmark.h

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

src/bitbase.cpp

@@ -1,38 +1,26 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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 "bitbase.h"
 #include "bitboard.h"
-#include "move.h"
-#include "square.h"
-
-
-////
-//// Local definitions
-////
+#include "types.h"
 
 namespace {
 
@@ -46,304 +34,251 @@ namespace {
 
   struct KPKPosition {
     void from_index(int index);
-    int to_index() const;
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;
-    Bitboard wk_attacks() const;
-    Bitboard bk_attacks() const;
-    Bitboard pawn_attacks() const;
-    
+    Bitboard wk_attacks()   const { return StepAttacksBB[WK][whiteKingSquare]; }
+    Bitboard bk_attacks()   const { return StepAttacksBB[BK][blackKingSquare]; }
+    Bitboard pawn_attacks() const { return StepAttacksBB[WP][pawnSquare]; }
+
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
   };
-    
 
-  Result *Bitbase;
-  const int IndexMax = 2*24*64*64;
-  int UnknownCount = 0;
+  // The possible pawns squares are 24, the first 4 files and ranks from 2 to 7
+  const int IndexMax = 2 * 24 * 64 * 64; // color * wp_sq * wk_sq * bk_sq
 
-  void initialize();
-  bool next_iteration();
-  Result classify_wtm(const KPKPosition &p);
-  Result classify_btm(const KPKPosition &p);
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm);
-  int compress_result(Result r);
-  
+  // Each uint32_t stores results of 32 positions, one per bit
+  uint32_t KPKBitbase[IndexMax / 32];
+
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]);
+  Result classify_btm(const KPKPosition& pos, const Result bb[]);
+  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm);
 }
 
 
-////
-//// Functions
-////
+uint32_t probe_kpk_bitbase(Square wksq, Square wpsq, Square bksq, Color stm) {
 
-void generate_kpk_bitbase(uint8_t bitbase[]) {
-  // Allocate array and initialize:
-  Bitbase = new Result[IndexMax];
-  initialize();
+  int index = compute_index(wksq, bksq, wpsq, stm);
 
-  // Iterate until all positions are classified:
-  while(next_iteration());
+  return KPKBitbase[index / 32] & (1 << (index & 31));
+}
 
-  // Compress bitbase into the supplied parameter:
-  int i, j, b;
-  for(i = 0; i < 24576; i++) {
-    for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
-    bitbase[i] = b;
+
+void init_kpk_bitbase() {
+
+  Result bb[IndexMax];
+  KPKPosition pos;
+  bool repeat;
+
+  // Initialize table
+  for (int i = 0; i < IndexMax; i++)
+  {
+      pos.from_index(i);
+      bb[i] = !pos.is_legal()          ? RESULT_INVALID
+             : pos.is_immediate_draw() ? RESULT_DRAW
+             : pos.is_immediate_win()  ? RESULT_WIN : RESULT_UNKNOWN;
   }
 
-  // Release allocated memory:
-  delete [] Bitbase;
+  // Iterate until all positions are classified (30 cycles needed)
+  do {
+      repeat = false;
+
+      for (int i = 0; i < IndexMax; i++)
+          if (bb[i] == RESULT_UNKNOWN)
+          {
+              pos.from_index(i);
+
+              bb[i] = (pos.sideToMove == WHITE) ? classify_wtm(pos, bb)
+                                                : classify_btm(pos, bb);
+              if (bb[i] != RESULT_UNKNOWN)
+                  repeat = true;
+          }
+
+  } while (repeat);
+
+  // Map 32 position results into one KPKBitbase[] entry
+  for (int i = 0; i < IndexMax / 32; i++)
+      for (int j = 0; j < 32; j++)
+          if (bb[32 * i + j] == RESULT_WIN || bb[32 * i + j] == RESULT_LOSS)
+              KPKBitbase[i] |= (1 << j);
 }
 
 
 namespace {
 
+ // A KPK bitbase index is an integer in [0, IndexMax] range
+ //
+ // Information is mapped in this way
+ //
+ // bit     0: side to move (WHITE or BLACK)
+ // bit  1- 6: black king square (from SQ_A1 to SQ_H8)
+ // bit  7-12: white king square (from SQ_A1 to SQ_H8)
+ // bit 13-14: white pawn file (from FILE_A to FILE_D)
+ // bit 15-17: white pawn rank - 1 (from RANK_2 - 1 to RANK_7 - 1)
+
+  int compute_index(Square wksq, Square bksq, Square wpsq, Color stm) {
+
+    assert(square_file(wpsq) <= FILE_D);
+
+    int p = int(square_file(wpsq)) + 4 * int(square_rank(wpsq) - 1);
+    int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p;
+
+    assert(r >= 0 && r < IndexMax);
+
+    return r;
+  }
+
   void KPKPosition::from_index(int index) {
-    int s;
+
+    int s = (index / 8192) % 24;
+
     sideToMove = Color(index % 2);
     blackKingSquare = Square((index / 2) % 64);
     whiteKingSquare = Square((index / 128) % 64);
-    s = (index / 8192) % 24;
     pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
   }
 
-
-  int KPKPosition::to_index() const {
-    return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
-                         sideToMove);
-  }
-    
-
   bool KPKPosition::is_legal() const {
-    if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
-       pawnSquare == blackKingSquare)
-      return false;
-    if(sideToMove == WHITE) {
-      if(bit_is_set(this->wk_attacks(), blackKingSquare))
-        return false;
-      if(bit_is_set(this->pawn_attacks(), blackKingSquare))
+
+    if (   whiteKingSquare == pawnSquare
+        || whiteKingSquare == blackKingSquare
+        || blackKingSquare == pawnSquare)
         return false;
+
+    if (sideToMove == WHITE)
+    {
+        if (   bit_is_set(wk_attacks(), blackKingSquare)
+            || bit_is_set(pawn_attacks(), blackKingSquare))
+            return false;
     }
-    else {
-      if(bit_is_set(this->bk_attacks(), whiteKingSquare))
+    else if (bit_is_set(bk_attacks(), whiteKingSquare))
         return false;
-    }
+
     return true;
   }
 
-
   bool KPKPosition::is_immediate_draw() const {
-    if(sideToMove == BLACK) {
-      Bitboard wka = this->wk_attacks();
-      Bitboard bka = this->bk_attacks();
-    
-      // Case 1: Stalemate
-      if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
-        return true;
 
-      // Case 2: King can capture pawn
-      if(bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
-        return true;
-    }
-    else {
-      // Case 1: Stalemate
-      if(whiteKingSquare == SQ_A8 && pawnSquare == SQ_A7 &&
-         (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
-        return true;
-    }
+    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
+    {
+        // Case 1: Stalemate (possible pawn files are only from A to D)
+        if (   whiteKingSquare == SQ_A8
+            && pawnSquare == SQ_A7
+            && (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
+            return true;
+    }
     return false;
   }
 
-
   bool KPKPosition::is_immediate_win() const {
-    // The position is an immediate win if it is white to move and the white
-    // pawn can be promoted without getting captured:
-    return
-      sideToMove == WHITE &&
-      square_rank(pawnSquare) == RANK_7 &&
-      (square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
-       bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
-  }
-    
 
-  Bitboard KPKPosition::wk_attacks() const {
-    return StepAttackBB[WK][whiteKingSquare];
+    // The position is an immediate win if it is white to move and the
+    // white pawn can be promoted without getting captured.
+    return   sideToMove == WHITE
+          && square_rank(pawnSquare) == RANK_7
+          && whiteKingSquare != pawnSquare + DELTA_N
+          && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
+              || bit_is_set(wk_attacks(), pawnSquare + DELTA_N));
   }
 
-
-  Bitboard KPKPosition::bk_attacks() const {
-    return StepAttackBB[BK][blackKingSquare];
-  }
-
-
-  Bitboard KPKPosition::pawn_attacks() const {
-    return StepAttackBB[WP][pawnSquare];
-  }
-
-
-  void initialize() {
-    KPKPosition p;
-    for(int i = 0; i < IndexMax; i++) {
-      p.from_index(i);
-      if(!p.is_legal())
-        Bitbase[i] = RESULT_INVALID;
-      else if(p.is_immediate_draw())
-        Bitbase[i] = RESULT_DRAW;
-      else if(p.is_immediate_win())
-        Bitbase[i] = RESULT_WIN;
-      else {
-        Bitbase[i] = RESULT_UNKNOWN;
-        UnknownCount++;
-      }
-    }
-  }
-
-
-  bool next_iteration() {
-    KPKPosition p;
-    int previousUnknownCount = UnknownCount;
-    
-    for(int i = 0; i < IndexMax; i++)
-      if(Bitbase[i] == RESULT_UNKNOWN) {
-        p.from_index(i);
-
-        Bitbase[i] = (p.sideToMove == WHITE)? classify_wtm(p) : classify_btm(p);
-
-        if(Bitbase[i] == RESULT_WIN || Bitbase[i] == RESULT_LOSS ||
-           Bitbase[i] == RESULT_DRAW)
-          UnknownCount--;
-      }
-
-    return UnknownCount != previousUnknownCount;
-  }
-
-
-  Result classify_wtm(const KPKPosition &p) {
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]) {
 
     // If one move leads to a position classified as RESULT_LOSS, the result
-    // of the current position is RESULT_WIN.  If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified as
-    // RESULT_DRAW.  Otherwise, the current position is classified as
-    // RESULT_UNKNOWN.
+    // of the current position is RESULT_WIN. If all moves lead to positions
+    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
+    // otherwise the current position is classified as RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
-    
+    Result r;
+
     // King moves
-    b = p.wk_attacks();
-    while(b) {
-      s = pop_1st_bit(&b);
-      switch(Bitbase[compute_index(s, p.blackKingSquare, p.pawnSquare,
-                                   BLACK)]) {
-      case RESULT_LOSS:
-        return RESULT_WIN;
+    b = pos.wk_attacks();
+    while (b)
+    {
+        s = pop_1st_bit(&b);
+        r = bb[compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK)];
 
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
+        if (r == RESULT_LOSS)
+            return RESULT_WIN;
 
-      case RESULT_DRAW: case RESULT_INVALID:
-        break;
-
-      default:
-        assert(false);
-      }
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
     }
 
     // Pawn moves
-    if(square_rank(p.pawnSquare) < RANK_7) {
-      s = p.pawnSquare + DELTA_N;
-      switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
-                                   BLACK)]) {
-      case RESULT_LOSS:
-        return RESULT_WIN;
-        
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
-          
-      case RESULT_DRAW: case RESULT_INVALID:
-        break;
-        
-      default:
-        assert(false);
-      }
+    if (square_rank(pos.pawnSquare) < RANK_7)
+    {
+        s = pos.pawnSquare + DELTA_N;
+        r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
 
-      if(square_rank(s) == RANK_3 &&
-         s != p.whiteKingSquare && s != p.blackKingSquare) {
-        s += DELTA_N;
-        switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
-                                     BLACK)]) {
-        case RESULT_LOSS:
-          return RESULT_WIN;
-          
-        case RESULT_UNKNOWN:
-          unknownFound = true;
-          break;
-          
-        case RESULT_DRAW: case RESULT_INVALID:
-          break;
-          
-        default:
-          assert(false);
+        if (r == RESULT_LOSS)
+            return RESULT_WIN;
+
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
+
+        // Double pawn push
+        if (   square_rank(s) == RANK_3
+            && s != pos.whiteKingSquare
+            && s != pos.blackKingSquare)
+        {
+            s += DELTA_N;
+            r = bb[compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK)];
+
+            if (r == RESULT_LOSS)
+                return RESULT_WIN;
+
+            if (r == RESULT_UNKNOWN)
+                unknownFound = true;
         }
-      }
     }
-    
-    return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
+    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
   }
 
 
-  Result classify_btm(const KPKPosition &p) {
+  Result classify_btm(const KPKPosition& pos, const Result bb[]) {
 
     // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW.  If all moves lead to positions
+    // of the current position is RESULT_DRAW. If all moves lead to positions
     // classified as RESULT_WIN, the current position is classified as
-    // RESULT_LOSS.  Otherwise, the current position is classified as
+    // RESULT_LOSS. Otherwise, the current position is classified as
     // RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
+    Result r;
 
     // King moves
-    b = p.bk_attacks();
-    while(b) {
-      s = pop_1st_bit(&b);
-      switch(Bitbase[compute_index(p.whiteKingSquare, s, p.pawnSquare,
-                                   WHITE)]) {
-      case RESULT_DRAW:
-        return RESULT_DRAW;
+    b = pos.bk_attacks();
+    while (b)
+    {
+        s = pop_1st_bit(&b);
+        r = bb[compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE)];
 
-      case RESULT_UNKNOWN:
-        unknownFound = true;
-        break;
+        if (r == RESULT_DRAW)
+            return RESULT_DRAW;
 
-      case RESULT_WIN: case RESULT_INVALID:
-        break;
-
-      default:
-        assert(false);
-      }
+        if (r == RESULT_UNKNOWN)
+            unknownFound = true;
     }
-
-    return unknownFound? RESULT_UNKNOWN : RESULT_LOSS;
+    return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS;
   }
 
-
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
-    int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
-    int result = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*p;
-    assert(result >= 0 && result < IndexMax);
-    return result;
-  }
-
-
-  int compress_result(Result r) {
-    return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
-  }
-      
-}  
+}

src/bitbase.h

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

src/bitboard.cpp

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

src/bitboard.h

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

src/bitcount.h

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

src/book.cpp

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

src/book.h

@@ -1,91 +1,62 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
-////
-
+// A Polyglot book is a series of "entries" of 16 bytes. All integers are
+// stored highest byte first (regardless of size). The entries are ordered
+// according to key. Lowest key first.
 struct BookEntry {
   uint64_t key;
   uint16_t move;
   uint16_t count;
-  uint16_t n;
-  uint16_t sum;
+  uint32_t learn;
 };
 
 class Book {
-
 public:
-  // Constructors
   Book();
-
-  // Open and close book files
-  void open(const std::string &fName);
+  ~Book();
+  void open(const std::string& fileName);
   void close();
-
-  // Testing if a book is opened
-  bool is_open() const;
-
-  // The file name of the currently active book
-  const std::string file_name() const;
-
-  // Get a book move for a given position
-  Move get_move(const Position &pos) const;
+  Move get_move(const Position& pos, bool findBestMove);
+  const std::string name() const { return bookName; }
 
 private:
-  int find_key(uint64_t key) const;
-  void read_entry(BookEntry &entry, int n) const;
+  template<typename T> void get_number(T& n);
 
-  std::string fileName;
-  mutable std::ifstream bookFile;
+  BookEntry read_entry(int idx);
+  int find_entry(uint64_t key);
+
+  std::ifstream bookFile;
+  std::string bookName;
   int bookSize;
+  RKISS RKiss;
 };
 
-
-////
-//// Global variables
-////
-
-extern Book OpeningBook;
-
-
 #endif // !defined(BOOK_H_INCLUDED)

src/color.cpp

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

src/depth.h

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

src/direction.cpp

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

src/direction.h

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

src/endgame.h

@@ -1,243 +1,112 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(ENDGAME_H_INCLUDED)
 #define ENDGAME_H_INCLUDED
 
-////
-//// Includes
-////
+#include <string>
+#include <map>
 
 #include "position.h"
-#include "scale.h"
-#include "value.h"
+#include "types.h"
 
 
-////
-//// Types
-////
+/// EndgameType lists all supported endgames
 
-/// Abstract base class for all special endgame evaluation functions:
+enum EndgameType {
 
-class EndgameEvaluationFunction {
-public:
-  EndgameEvaluationFunction(Color c);
-  virtual ~EndgameEvaluationFunction() { }
+  // Evaluation functions
 
-  virtual Value apply(const Position &pos) =0;
+  KXK,   // Generic "mate lone king" eval
+  KBNK,  // KBN vs K
+  KPK,   // KP vs K
+  KRKP,  // KR vs KP
+  KRKB,  // KR vs KB
+  KRKN,  // KR vs KN
+  KQKR,  // KQ vs KR
+  KBBKN, // KBB vs KN
+  KNNK,  // KNN vs K
+  KmmKm, // K and two minors vs K and one or two minors
 
-protected:
+
+  // Scaling functions
+
+  KBPsK,   // KB+pawns vs K
+  KQKRPs,  // KQ vs KR+pawns
+  KRPKR,   // KRP vs KR
+  KRPPKRP, // KRPP vs KRP
+  KPsK,    // King and pawns vs king
+  KBPKB,   // KBP vs KB
+  KBPPKB,  // KBPP vs KB
+  KBPKN,   // KBP vs KN
+  KNPK,    // KNP vs K
+  KPKP     // KP vs KP
+};
+
+
+/// Base and derived templates for endgame evaluation and scaling functions
+
+template<typename T>
+struct EndgameBase {
+
+  typedef EndgameBase<T> Base;
+
+  virtual ~EndgameBase() {}
+  virtual Color color() const = 0;
+  virtual T apply(const Position&) const = 0;
+};
+
+
+template<typename T, EndgameType>
+struct Endgame : public EndgameBase<T> {
+
+  explicit Endgame(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
+  Color color() const { return strongerSide; }
+  T apply(const Position&) const;
+
+private:
   Color strongerSide, weakerSide;
 };
 
 
-/// Subclasses for various concrete endgames:
+/// Endgames class stores in two std::map the pointers to endgame evaluation
+/// and scaling base objects. Then we use polymorphism to invoke the actual
+/// endgame function calling its apply() method that is virtual.
+
+class Endgames {
+
+  typedef std::map<Key, EndgameBase<Value>* > EFMap;
+  typedef std::map<Key, EndgameBase<ScaleFactor>* > SFMap;
 
-// Generic "mate lone king" eval:
-class KXKEvaluationFunction : public EndgameEvaluationFunction {
 public:
-  KXKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
+  Endgames();
+  ~Endgames();
+  template<class T> T* get(Key key) const;
+
+private:
+  template<class T> void add(const std::string& keyCode);
+
+  // Here we store two maps, for evaluate and scaling functions...
+  std::pair<EFMap, SFMap> maps;
+
+  // ...and here is the accessing template function
+  template<typename T> const std::map<Key, T*>& get() const;
 };
 
-// KBN vs K:
-class KBNKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KBNKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KP vs K:
-class KPKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KPKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KP:
-class KRKPEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKPEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KB:
-class KRKBEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKBEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KN:
-class KRKNEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKNEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KQ vs KR:
-class KQKREvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KQKREvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-
-/// Abstract base class for all evaluation scaling functions:
-
-class ScalingFunction {
-public:
-  ScalingFunction(Color c);
-  virtual ~ScalingFunction() { }
-
-  virtual ScaleFactor apply(const Position &pos) =0;
-
-protected:
-  Color strongerSide, weakerSide;
-};
-
-
-/// Subclasses for various concrete endgames:
-
-// KBP vs K:
-class KBPKScalingFunction : public ScalingFunction {
-public:
-  KBPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KQ vs KRP:
-class KQKRPScalingFunction: public ScalingFunction {
-public:
-  KQKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRP vs KR:
-class KRPKRScalingFunction : public ScalingFunction {
-public:
-  KRPKRScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRPP vs KRP:
-class KRPPKRPScalingFunction : public ScalingFunction {
-public:
-  KRPPKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// King and pawns vs king:
-class KPsKScalingFunction : public ScalingFunction {
-public:
-  KPsKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KB:
-class KBPKBScalingFunction : public ScalingFunction {
-public:
-  KBPKBScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KN:
-class KBPKNScalingFunction : public ScalingFunction {
-public:
-  KBPKNScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KNP vs K:
-class KNPKScalingFunction : public ScalingFunction {
-public:
-  KNPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KP vs KP:
-class KPKPScalingFunction : public ScalingFunction {
-public:
-  KPKPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-
-////
-//// Constants and variables
-////
-
-// Generic "mate lone king" eval:
-extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
-
-// KBN vs K:
-extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
-
-// KP vs K:
-extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
-
-// KR vs KP:
-extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
-
-// KR vs KB:
-extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
-
-// KR vs KN:
-extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
-
-// KQ vs KR:
-extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
-
-// KBP vs K:
-extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
-
-// KQ vs KRP:
-extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
-
-// KRP vs KR:
-extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
-
-// KRPP vs KRP:
-extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
-
-// King and pawns vs king:
-extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
-
-// KBP vs KB:
-extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
-
-// KBP vs KN:
-extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
-
-// KNP vs K:
-extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
-
-// KP vs KP:
-extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
-
-
-////
-//// Prototypes
-////
-
-extern void init_bitbases();
-
-
 #endif // !defined(ENDGAME_H_INCLUDED)

src/evaluate.h

@@ -1,110 +1,31 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(EVALUATE_H_INCLUDED)
 #define EVALUATE_H_INCLUDED
 
-////
-//// Includes
-////
+#include "types.h"
 
-#include "material.h"
-#include "pawns.h"
-#include "position.h"
-
-
-////
-//// Types
-////
-
-/// The EvalInfo struct contains various information computed and collected
-/// by the evaluation function.  An EvalInfo object is passed as one of the
-/// arguments to the evaluation function, and the search can make use of its
-/// contents to make intelligent search decisions.
-///
-/// At the moment, this is not utilized very much:  The only part of the
-/// EvalInfo object which is used by the search is futilityMargin.
-
-struct EvalInfo {
-  
-  // Middle game and endgame evaluations:
-  Value mgValue, egValue;
-
-  // Pointers to material and pawn hash table entries:
-  MaterialInfo *mi;
-  PawnInfo *pi;
-
-  // attackedBy[color][piece type] is a bitboard representing all squares
-  // attacked by a given color and piece type.  attackedBy[color][0] contains
-  // all squares attacked by the given color.
-  Bitboard attackedBy[2][8];
-  Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
-  Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
-
-  // kingZone[color] is the zone around the enemy king which is considered
-  // by the king safety evaluation.  This consists of the squares directly
-  // adjacent to the king, and the three (or two, for a king on an edge file)
-  // squares two ranks in front of the king.  For instance, if black's king
-  // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
-  // f7, g7, h7, f6, g6 and h6.
-  Bitboard kingZone[2];
-
-  // kingAttackersCount[color] is the number of pieces of the given color
-  // which attack a square in the kingZone of the enemy king.
-  int kingAttackersCount[2];
-
-  // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
-  // given color which attack a square in the kingZone of the enemy king. The
-  // weights of the individual piece types are given by the variables
-  // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
-  // KnightAttackWeight in evaluate.cpp
-  int kingAttackersWeight[2];
-
-  // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
-  // directly adjacent to the king of the given color. Pieces which attack
-  // more than one square are counted multiple times. For instance, if black's
-  // king is on g8 and there's a white knight on g5, this knight adds
-  // 2 to kingAdjacentZoneAttacksCount[BLACK].
-  int kingAdjacentZoneAttacksCount[2];
-
-  // mateThreat[color] is a move for the given side which gives a direct mate.
-  Move mateThreat[2];
-
-  // Middle game and endgame mobility scores.
-  Value mgMobility, egMobility;
-
-  // Extra futility margin.  This is added to the standard futility margin
-  // in the quiescence search.  
-  Value futilityMargin;
-};
-
-
-////
-//// Prototypes
-////
-
-extern Value evaluate(const Position &pos, EvalInfo &ei, int threadID);
-extern Value quick_evaluate(const Position &pos);
-extern void init_eval(int threads);
-extern void quit_eval();
-extern void read_weights(Color sideToMove);
+class Position;
 
+extern Value evaluate(const Position& pos, Value& margin);
+extern std::string trace_evaluate(const Position& pos);
+extern void read_evaluation_uci_options(Color sideToMove);
 
 #endif // !defined(EVALUATE_H_INCLUDED)

src/history.cpp

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

src/history.h

@@ -1,77 +1,70 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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 <cstring>
+#include "types.h"
 
-#include "depth.h"
-#include "move.h"
-#include "piece.h"
-
-
-////
-//// Types
-////
-
-/// The History class stores statistics about how often different moves have
-/// been successful or unsuccessful during the current search.  These
-/// statistics are used for reduction and move ordering decisions.
+/// The History class stores statistics about how often different moves
+/// have been successful or unsuccessful during the current search. These
+/// statistics are used for reduction and move ordering decisions. History
+/// entries are stored according only to moving piece and destination square,
+/// in particular two moves with different origin but same destination and
+/// same piece will be considered identical.
 
 class History {
 
 public:
-  History();
   void clear();
-  void success(Piece p, Move m, Depth d);
-  void failure(Piece p, Move m);
-  int move_ordering_score(Piece p, Move m) const;
-  bool ok_to_prune(Piece p, Move m, Depth d) const;
+  Value value(Piece p, Square to) const;
+  void update(Piece p, Square to, Value bonus);
+  Value gain(Piece p, Square to) const;
+  void update_gain(Piece p, Square to, Value g);
+
+  static const Value MaxValue = Value(2000);
 
 private:
-  int history[16][64];  // [piece][square]
-  int successCount[16][64];
-  int failureCount[16][64];
+  Value history[16][64];  // [piece][to_square]
+  Value maxGains[16][64]; // [piece][to_square]
 };
 
+inline void History::clear() {
+  memset(history,  0, 16 * 64 * sizeof(Value));
+  memset(maxGains, 0, 16 * 64 * sizeof(Value));
+}
 
-////
-//// Constants and variables
-////
+inline Value History::value(Piece p, Square to) const {
+  return history[p][to];
+}
 
-/// HistoryMax controls how often the history counters will be scaled down:
-/// When the history score for a move gets bigger than HistoryMax, all
-/// entries in the table are divided by 2.  It is difficult to guess what
-/// the ideal value of this constant is.  Scaling down the scores often has
-/// the effect that parts of the search tree which have been searched
-/// recently have a bigger importance for move ordering than the moves which
-/// have been searched a long time ago.
-///
-/// Note that HistoryMax should probably be changed whenever the constant
-/// OnePly in depth.h is changed.  This is somewhat annoying.  Perhaps it
-/// would be better to scale down the history table at regular intervals?
+inline void History::update(Piece p, Square to, Value bonus) {
+  if (abs(history[p][to] + bonus) < MaxValue) history[p][to] += bonus;
+}
 
-const int HistoryMax = 50000;
+inline Value History::gain(Piece p, Square to) const {
+  return maxGains[p][to];
+}
 
+inline void History::update_gain(Piece p, Square to, Value g) {
+  maxGains[p][to] = Max(g, maxGains[p][to] - 1);
+}
 
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,102 +1,79 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
 
-
-// x86 assembly language locks or OS spin locks may perform faster than
-// mutex locks on some platforms.  On my machine, mutexes seem to be the
-// best.
-
-//#define ASM_LOCK
-//#define OS_SPIN_LOCK
-
-
-#if defined(ASM_LOCK)
-
-
-typedef volatile int Lock;
-
-static inline void LockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("1:          movl    $1, %0" "\n\t"
-      "            xchgl   (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jz      3f" "\n\t" "2:          pause" "\n\t"
-      "            movl    (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jnz     2b" "\n\t" "            jmp     1b" "\n\t" "3:"
-      "\n\t":"=&q"(dummy)
-      :"q"(lock)
-      :"cc");
-}
-
-static inline void UnlockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("movl    $0, (%1)":"=&q"(dummy)
-      :"q"(lock));
-}
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) LockX86(x)
-#  define lock_release(x) UnlockX86(x)
-#  define lock_destroy(x)
-
-
-#elif defined(OS_SPIN_LOCK)
-
-
-#  include <libkern/OSAtomic.h>
-
-typedef OSSpinLock Lock;
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) OSSpinLockLock(x)
-#  define lock_release(x) OSSpinLockUnlock(x)
-#  define lock_destroy(x)
-
-
-#elif !defined(_MSC_VER)
+#if !defined(_MSC_VER)
 
 #  include <pthread.h>
 
 typedef pthread_mutex_t Lock;
+typedef pthread_cond_t WaitCondition;
 
-#  define lock_init(x, y) pthread_mutex_init(x, y)
+#  define lock_init(x) pthread_mutex_init(x, NULL)
 #  define lock_grab(x) pthread_mutex_lock(x)
 #  define lock_release(x) pthread_mutex_unlock(x)
 #  define lock_destroy(x) pthread_mutex_destroy(x)
-
+#  define cond_destroy(x) pthread_cond_destroy(x)
+#  define cond_init(x) pthread_cond_init(x, NULL)
+#  define cond_signal(x) pthread_cond_signal(x)
+#  define cond_wait(x,y) pthread_cond_wait(x,y)
 
 #else
 
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
 
-#  include <windows.h>
+// Default fast and race free locks and condition variables
+#if !defined(OLD_LOCKS)
+
+typedef SRWLOCK Lock;
+typedef CONDITION_VARIABLE WaitCondition;
+
+#  define lock_init(x) InitializeSRWLock(x)
+#  define lock_grab(x) AcquireSRWLockExclusive(x)
+#  define lock_release(x) ReleaseSRWLockExclusive(x)
+#  define lock_destroy(x) (x)
+#  define cond_destroy(x) (x)
+#  define cond_init(x) InitializeConditionVariable(x)
+#  define cond_signal(x) WakeConditionVariable(x)
+#  define cond_wait(x,y) SleepConditionVariableSRW(x, y, INFINITE,0)
+
+// Fallback solution to build for Windows XP and older versions, note that
+// cond_wait() is racy between lock_release() and WaitForSingleObject().
+#else
 
 typedef CRITICAL_SECTION Lock;
-#  define lock_init(x, y) InitializeCriticalSection(x)
+typedef HANDLE WaitCondition;
+
+#  define lock_init(x) InitializeCriticalSection(x)
 #  define lock_grab(x) EnterCriticalSection(x)
 #  define lock_release(x) LeaveCriticalSection(x)
 #  define lock_destroy(x) DeleteCriticalSection(x)
-
+#  define cond_init(x) { *x = CreateEvent(0, FALSE, FALSE, 0); }
+#  define cond_destroy(x) CloseHandle(*x)
+#  define cond_signal(x) SetEvent(*x)
+#  define cond_wait(x,y) { lock_release(y); WaitForSingleObject(*x, INFINITE); lock_grab(y); }
+#endif
 
 #endif
 
-
 #endif // !defined(LOCK_H_INCLUDED)

src/main.cpp

@@ -1,96 +1,87 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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/>.
 */
 
+// To profile with callgrind uncomment following line
+//#define USE_CALLGRIND
 
-////
-//// Includes
-////
-
+#include <cstdio>
 #include <iostream>
+#include <string>
 
-#include "benchmark.h"
 #include "bitboard.h"
-#include "direction.h"
-#include "endgame.h"
 #include "evaluate.h"
-#include "material.h"
-#include "mersenne.h"
-#include "misc.h"
-#include "movepick.h"
 #include "position.h"
-#include "search.h"
 #include "thread.h"
-#include "uci.h"
+#include "search.h"
 #include "ucioption.h"
 
-using std::string;
+#ifdef USE_CALLGRIND
+#include <valgrind/callgrind.h>
+#endif
 
-//// 
-//// Functions
-////
+using namespace std;
 
-int main(int argc, char *argv[]) {
+extern bool execute_uci_command(const string& cmd);
+extern void benchmark(int argc, char* argv[]);
+extern void init_kpk_bitbase();
 
-  // Disable IO buffering
-  std::cout.rdbuf()->pubsetbuf(NULL, 0);
-  std::cin.rdbuf()->pubsetbuf(NULL, 0);
+int main(int argc, char* argv[]) {
 
-  // Initialization
+  // Disable IO buffering for C and C++ standard libraries
+  setvbuf(stdin, NULL, _IONBF, 0);
+  setvbuf(stdout, NULL, _IONBF, 0);
+  cout.rdbuf()->pubsetbuf(NULL, 0);
+  cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  init_mersenne();
-  init_direction_table();
+  // Startup initializations
   init_bitboards();
-  init_uci_options();
   Position::init_zobrist();
   Position::init_piece_square_tables();
-  MovePicker::init_phase_table();
-  init_eval(1);
-  init_bitbases();
-  init_threads();
+  init_kpk_bitbase();
+  init_search();
+  Threads.init();
 
-  // Make random number generation less deterministic, for book moves
-  for (int i = abs(get_system_time() % 10000); i > 0; i--)
-      genrand_int32();
+#ifdef USE_CALLGRIND
+  CALLGRIND_START_INSTRUMENTATION;
+#endif
 
-  // Process command line arguments
-  if (argc >= 2 && string(argv[1]) == "bench")
+  if (argc < 2)
   {
-      if (argc < 4 || argc > 6)
-      {
-        std::cout << "Usage: glaurung bench <hash size> <threads> "
-                  << "[time = 60s] [fen positions file = default]"
-                  << std::endl;
-        exit(0);
-      }
-      string time = argc > 4 ? argv[4] : "60";
-      string fen = argc > 5 ? argv[5] : "default";
-      benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen);
-      return 0;
+      // Print copyright notice
+      cout << engine_name() << " by " << engine_authors() << endl;
+
+      if (CpuHasPOPCNT)
+          cout << "Good! CPU has hardware POPCNT." << endl;
+
+      // Wait for a command from the user, and passes this command to
+      // execute_uci_command() and also intercepts EOF from stdin to
+      // ensure that we exit gracefully if the GUI dies unexpectedly.
+      string cmd;
+      while (getline(cin, cmd) && execute_uci_command(cmd)) {}
   }
+  else if (string(argv[1]) == "bench" && argc < 8)
+      benchmark(argc, argv);
+  else
+      cout << "Usage: stockfish bench [hash size = 128] [threads = 1] "
+           << "[limit = 12] [fen positions file = default] "
+           << "[limited by depth, time, nodes or perft = depth]" << endl;
 
-  // Print copyright notice
-  std::cout << engine_name() << ".  Copyright (C) "
-            << "2004-2008 Tord Romstad, Marco Costalba. "
-            << std::endl;
-
-  // Enter UCI mode
-  uci_main_loop();
-
+  Threads.exit();
   return 0;
 }

src/material.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,98 +17,76 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
 #include <cassert>
-#include <map>
+#include <cstring>
 
 #include "material.h"
 
-
-////
-//// Local definitions
-////
+using namespace std;
 
 namespace {
 
-  const Value BishopPairMidgameBonus = Value(100);
-  const Value BishopPairEndgameBonus = Value(100);
+  // Values modified by Joona Kiiski
+  const Value MidgameLimit = Value(15581);
+  const Value EndgameLimit = Value(3998);
 
-  Key KNNKMaterialKey, KKNNMaterialKey;
+  // Scale factors used when one side has no more pawns
+  const int NoPawnsSF[4] = { 6, 12, 32 };
 
-}
+  // Polynomial material balance parameters
+  const Value RedundantQueenPenalty = Value(320);
+  const Value RedundantRookPenalty  = Value(554);
 
-////
-//// Classes
-////
+  const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
 
+  const int QuadraticCoefficientsSameColor[][8] = {
+  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
+  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
 
-/// See header for a class description. It is declared here to avoid
-/// to include <map> in the header file.
+  const int QuadraticCoefficientsOppositeColor[][8] = {
+  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
+  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
 
-class EndgameFunctions {
+  // Endgame evaluation and scaling functions accessed direcly and not through
+  // the function maps because correspond to more then one material hash key.
+  Endgame<Value, KmmKm> EvaluateKmmKm[] = { Endgame<Value, KmmKm>(WHITE), Endgame<Value, KmmKm>(BLACK) };
+  Endgame<Value, KXK>   EvaluateKXK[]   = { Endgame<Value, KXK>(WHITE),   Endgame<Value, KXK>(BLACK) };
 
-public:
-  EndgameFunctions();
-  EndgameEvaluationFunction* getEEF(Key key) const;
-  ScalingFunction* getESF(Key key, Color* c) const;
+  Endgame<ScaleFactor, KBPsK>  ScaleKBPsK[]  = { Endgame<ScaleFactor, KBPsK>(WHITE),  Endgame<ScaleFactor, KBPsK>(BLACK) };
+  Endgame<ScaleFactor, KQKRPs> ScaleKQKRPs[] = { Endgame<ScaleFactor, KQKRPs>(WHITE), Endgame<ScaleFactor, KQKRPs>(BLACK) };
+  Endgame<ScaleFactor, KPsK>   ScaleKPsK[]   = { Endgame<ScaleFactor, KPsK>(WHITE),   Endgame<ScaleFactor, KPsK>(BLACK) };
+  Endgame<ScaleFactor, KPKP>   ScaleKPKP[]   = { Endgame<ScaleFactor, KPKP>(WHITE),   Endgame<ScaleFactor, KPKP>(BLACK) };
 
-private:
-  void add(Key k, EndgameEvaluationFunction* f);
-  void add(Key k, Color c, ScalingFunction* f);
-
-  struct ScalingInfo
-  {
-      Color col;
-      ScalingFunction* fun;
-  };
-
-  std::map<Key, EndgameEvaluationFunction*> EEFmap;
-  std::map<Key, ScalingInfo> ESFmap;
-};
-
-
-////
-//// Functions
-////
-
-
-/// Constructor for the MaterialInfoTable class
-
-MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {
-
-  size = numOfEntries;
-  entries = new MaterialInfo[size];
-  funcs = new EndgameFunctions();
-  if (!entries || !funcs)
-  {
-      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
-                << " bytes for material hash table." << std::endl;
-      exit(EXIT_FAILURE);
+  // Helper templates used to detect a given material distribution
+  template<Color Us> bool is_KXK(const Position& pos) {
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return   pos.non_pawn_material(Them) == VALUE_ZERO
+          && pos.piece_count(Them, PAWN) == 0
+          && pos.non_pawn_material(Us)   >= RookValueMidgame;
   }
-  clear();
-}
+
+  template<Color Us> bool is_KBPsKs(const Position& pos) {
+    return   pos.non_pawn_material(Us)   == BishopValueMidgame
+          && pos.piece_count(Us, BISHOP) == 1
+          && pos.piece_count(Us, PAWN)   >= 1;
+  }
+
+  template<Color Us> bool is_KQKRPs(const Position& pos) {
+    const Color Them = (Us == WHITE ? BLACK : WHITE);
+    return   pos.piece_count(Us, PAWN)    == 0
+          && pos.non_pawn_material(Us)    == QueenValueMidgame
+          && pos.piece_count(Us, QUEEN)   == 1
+          && pos.piece_count(Them, ROOK)  == 1
+          && pos.piece_count(Them, PAWN)  >= 1;
+  }
+
+} // namespace
 
 
-/// Destructor for the MaterialInfoTable class
+/// MaterialInfoTable c'tor and d'tor allocate and free the space for Endgames
 
-MaterialInfoTable::~MaterialInfoTable() {
-
-  delete [] entries;
-  delete funcs;
-}
-
-
-/// MaterialInfoTable::clear() clears a material hash table by setting
-/// all entries to 0.
-
-void MaterialInfoTable::clear() {
-
-  memset(entries, 0, size * sizeof(MaterialInfo));
-}
+void MaterialInfoTable::init() { Base::init(); if (!funcs) funcs = new Endgames(); }
+MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
 
 
 /// MaterialInfoTable::get_material_info() takes a position object as input,
@@ -117,11 +95,10 @@ void MaterialInfoTable::clear() {
 /// is stored there, so we don't have to recompute everything when the
 /// same material configuration occurs again.
 
-MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
+MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
 
   Key key = pos.get_material_key();
-  int index = key & (size - 1);
-  MaterialInfo* mi = entries + index;
+  MaterialInfo* mi = probe(key);
 
   // If mi->key matches the position's material hash key, it means that we
   // have analysed this material configuration before, and we can simply
@@ -129,223 +106,180 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   if (mi->key == key)
       return mi;
 
-  // Clear the MaterialInfo object, and set its key
-  mi->clear();
+  // Initialize MaterialInfo entry
+  memset(mi, 0, sizeof(MaterialInfo));
   mi->key = key;
+  mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
 
-  // A special case before looking for a specialized evaluation function
-  // KNN vs K is a draw.
-  if (key == KNNKMaterialKey || key == KKNNMaterialKey)
-  {
-      mi->factor[WHITE] = mi->factor[BLACK] = 0;
-      return mi;
-  }
+  // Store game phase
+  mi->gamePhase = MaterialInfoTable::game_phase(pos);
 
   // Let's look if we have a specialized evaluation function for this
-  // particular material configuration.
-  if ((mi->evaluationFunction = funcs->getEEF(key)) != NULL)
+  // particular material configuration. First we look for a fixed
+  // configuration one, then a generic one if previous search failed.
+  if ((mi->evaluationFunction = funcs->get<EndgameBase<Value> >(key)) != NULL)
       return mi;
 
-  else if (   pos.non_pawn_material(BLACK) == Value(0)
-           && pos.piece_count(BLACK, PAWN) == 0
-           && pos.non_pawn_material(WHITE) >= RookValueEndgame)
+  if (is_KXK<WHITE>(pos))
   {
-      mi->evaluationFunction = &EvaluateKXK;
+      mi->evaluationFunction = &EvaluateKXK[WHITE];
       return mi;
   }
-  else if (   pos.non_pawn_material(WHITE) == Value(0)
-           && pos.piece_count(WHITE, PAWN) == 0
-           && pos.non_pawn_material(BLACK) >= RookValueEndgame)
+
+  if (is_KXK<BLACK>(pos))
   {
-      mi->evaluationFunction = &EvaluateKKX;
+      mi->evaluationFunction = &EvaluateKXK[BLACK];
       return mi;
   }
 
+  if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN))
+  {
+      // Minor piece endgame with at least one minor piece per side and
+      // no pawns. Note that the case KmmK is already handled by KXK.
+      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
+      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
+
+      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      {
+          mi->evaluationFunction = &EvaluateKmmKm[WHITE];
+          return mi;
+      }
+  }
+
   // OK, we didn't find any special evaluation function for the current
   // material configuration. Is there a suitable scaling function?
   //
-  // The code below is rather messy, and it could easily get worse later,
-  // if we decide to add more special cases.  We face problems when there
-  // are several conflicting applicable scaling functions and we need to
-  // decide which one to use.
-  Color c;
-  ScalingFunction* sf;
+  // We face problems when there are several conflicting applicable
+  // scaling functions and we need to decide which one to use.
+  EndgameBase<ScaleFactor>* sf;
 
-  if ((sf = funcs->getESF(key, &c)) != NULL)
+  if ((sf = funcs->get<EndgameBase<ScaleFactor> >(key)) != NULL)
   {
-      mi->scalingFunction[c] = sf;
+      mi->scalingFunction[sf->color()] = sf;
       return mi;
   }
 
-  if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
-      && pos.piece_count(WHITE, BISHOP) == 1
-      && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKBPK;
+  // Generic scaling functions that refer to more then one material
+  // distribution. Should be probed after the specialized ones.
+  // Note that these ones don't return after setting the function.
+  if (is_KBPsKs<WHITE>(pos))
+      mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
 
-  if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
-      && pos.piece_count(BLACK, BISHOP) == 1
-      && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKKBP;
+  if (is_KBPsKs<BLACK>(pos))
+      mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
 
-  if (   pos.piece_count(WHITE, PAWN) == 0
-      && pos.non_pawn_material(WHITE) == QueenValueMidgame
-      && pos.piece_count(WHITE, QUEEN) == 1
-      && pos.piece_count(BLACK, ROOK) == 1
-      && pos.piece_count(BLACK, PAWN) >= 1)
-      mi->scalingFunction[WHITE] = &ScaleKQKRP;
+  if (is_KQKRPs<WHITE>(pos))
+      mi->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE];
 
-  else if (   pos.piece_count(BLACK, PAWN) == 0
-           && pos.non_pawn_material(BLACK) == QueenValueMidgame
-           && pos.piece_count(BLACK, QUEEN) == 1
-           && pos.piece_count(WHITE, ROOK) == 1
-           && pos.piece_count(WHITE, PAWN) >= 1)
-      mi->scalingFunction[BLACK] = &ScaleKRPKQ;
+  else if (is_KQKRPs<BLACK>(pos))
+      mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
 
-  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
+  Value npm_w = pos.non_pawn_material(WHITE);
+  Value npm_b = pos.non_pawn_material(BLACK);
+
+  if (npm_w + npm_b == VALUE_ZERO)
   {
       if (pos.piece_count(BLACK, PAWN) == 0)
       {
           assert(pos.piece_count(WHITE, PAWN) >= 2);
-          mi->scalingFunction[WHITE] = &ScaleKPsK;
+          mi->scalingFunction[WHITE] = &ScaleKPsK[WHITE];
       }
       else if (pos.piece_count(WHITE, PAWN) == 0)
       {
           assert(pos.piece_count(BLACK, PAWN) >= 2);
-          mi->scalingFunction[BLACK] = &ScaleKKPs;
+          mi->scalingFunction[BLACK] = &ScaleKPsK[BLACK];
       }
       else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
       {
-          mi->scalingFunction[WHITE] = &ScaleKPKPw;
-          mi->scalingFunction[BLACK] = &ScaleKPKPb;
+          // This is a special case because we set scaling functions
+          // for both colors instead of only one.
+          mi->scalingFunction[WHITE] = &ScaleKPKP[WHITE];
+          mi->scalingFunction[BLACK] = &ScaleKPKP[BLACK];
       }
   }
 
-  // Evaluate the material balance
-
-  int sign;
-  Value egValue = Value(0);
-  Value mgValue = Value(0);
-
-  for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
+  // No pawns makes it difficult to win, even with a material advantage
+  if (pos.piece_count(WHITE, PAWN) == 0 && npm_w - npm_b <= BishopValueMidgame)
   {
-    // No pawns makes it difficult to win, even with a material advantage
-    if (   pos.piece_count(c, PAWN) == 0
-        && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
-    {
-        if (   pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c))
-            || pos.non_pawn_material(c) < RookValueMidgame)
-            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;
-            }
-        }
-    }
-
-    // Bishop pair
-    if (pos.piece_count(c, BISHOP) >= 2)
-    {
-        mgValue += sign * BishopPairMidgameBonus;
-        egValue += sign * BishopPairEndgameBonus;
-    }
-
-    // Knights are stronger when there are many pawns on the board.  The
-    // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess":
-    // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
-    egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
-
-    // Redundancy of major pieces, again based on Kaufman's paper:
-    if (pos.piece_count(c, ROOK) >= 1)
-    {
-        Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
-        mgValue -= sign * v;
-        egValue -= sign * v;
-    }
+      mi->factor[WHITE] = uint8_t
+      (npm_w == npm_b || npm_w < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(WHITE, BISHOP), 2)]);
   }
-  mi->mgValue = int16_t(mgValue);
-  mi->egValue = int16_t(egValue);
+
+  if (pos.piece_count(BLACK, PAWN) == 0 && npm_b - npm_w <= BishopValueMidgame)
+  {
+      mi->factor[BLACK] = uint8_t
+      (npm_w == npm_b || npm_b < RookValueMidgame ? 0 : NoPawnsSF[Min(pos.piece_count(BLACK, BISHOP), 2)]);
+  }
+
+  // Compute the space weight
+  if (npm_w + npm_b >= 2 * QueenValueMidgame + 4 * RookValueMidgame + 2 * KnightValueMidgame)
+  {
+      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT) + pos.piece_count(WHITE, BISHOP)
+                           + pos.piece_count(BLACK, KNIGHT) + pos.piece_count(BLACK, BISHOP);
+
+      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  }
+
+  // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
+  // for the bishop pair "extended piece", this allow us to be more flexible
+  // in defining bishop pair bonuses.
+  const int pieceCount[2][8] = {
+  { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
+    pos.piece_count(WHITE, BISHOP)    , pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
+  { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
+    pos.piece_count(BLACK, BISHOP)    , pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+
+  mi->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
   return mi;
 }
 
 
-/// EndgameFunctions member definitions. This class is used to store the maps
-/// of end game and scaling functions that MaterialInfoTable will query for 
-/// each key. The maps are constant and are populated only at construction,
-/// but are per-thread instead of globals to avoid expensive locks.
+/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
+/// piece type for both colors.
 
-EndgameFunctions::EndgameFunctions() {
+template<Color Us>
+int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
 
-  typedef Key ZM[2][8][16];
-  const ZM& z = Position::zobMaterial;
+  const Color Them = (Us == WHITE ? BLACK : WHITE);
 
-  static const Color W = WHITE;
-  static const Color B = BLACK;
+  int pt1, pt2, pc, v;
+  int value = 0;
 
-  KNNKMaterialKey = z[W][KNIGHT][1] ^ z[W][KNIGHT][2];
-  KKNNMaterialKey = z[B][KNIGHT][1] ^ z[B][KNIGHT][2];
+  // Redundancy of major pieces, formula based on Kaufman's paper
+  // "The Evaluation of Material Imbalances in Chess"
+  if (pieceCount[Us][ROOK] > 0)
+      value -=  RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
+              + RedundantQueenPenalty * pieceCount[Us][QUEEN];
 
-  add(z[W][PAWN][1], &EvaluateKPK);
-  add(z[B][PAWN][1], &EvaluateKKP);
+  // Second-degree polynomial material imbalance by Tord Romstad
+  for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
+  {
+      pc = pieceCount[Us][pt1];
+      if (!pc)
+          continue;
 
-  add(z[W][BISHOP][1] ^ z[W][KNIGHT][1], &EvaluateKBNK);
-  add(z[B][BISHOP][1] ^ z[B][KNIGHT][1], &EvaluateKKBN);
-  add(z[W][ROOK][1]   ^ z[B][PAWN][1],   &EvaluateKRKP);
-  add(z[W][PAWN][1]   ^ z[B][ROOK][1],   &EvaluateKPKR);
-  add(z[W][ROOK][1]   ^ z[B][BISHOP][1], &EvaluateKRKB);
-  add(z[W][BISHOP][1] ^ z[B][ROOK][1],   &EvaluateKBKR);
-  add(z[W][ROOK][1]   ^ z[B][KNIGHT][1], &EvaluateKRKN);
-  add(z[W][KNIGHT][1] ^ z[B][ROOK][1],   &EvaluateKNKR);
-  add(z[W][QUEEN][1]  ^ z[B][ROOK][1],   &EvaluateKQKR);
-  add(z[W][ROOK][1]   ^ z[B][QUEEN][1],  &EvaluateKRKQ);
+      v = LinearCoefficients[pt1];
 
-  add(z[W][KNIGHT][1] ^ z[W][PAWN][1], W, &ScaleKNPK);
-  add(z[B][KNIGHT][1] ^ z[B][PAWN][1], B, &ScaleKKNP);
+      for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
+          v +=  QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+              + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
 
-  add(z[W][ROOK][1]   ^ z[W][PAWN][1]   ^ z[B][ROOK][1]  , W, &ScaleKRPKR);
-  add(z[W][ROOK][1]   ^ z[B][ROOK][1]   ^ z[B][PAWN][1]  , B, &ScaleKRKRP);
-  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][BISHOP][1], W, &ScaleKBPKB);
-  add(z[W][BISHOP][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKBKBP);
-  add(z[W][BISHOP][1] ^ z[W][PAWN][1]   ^ z[B][KNIGHT][1], W, &ScaleKBPKN);
-  add(z[W][KNIGHT][1] ^ z[B][BISHOP][1] ^ z[B][PAWN][1]  , B, &ScaleKNKBP);
-
-  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[W][PAWN][2] ^ z[B][ROOK][1] ^ z[B][PAWN][1], W, &ScaleKRPPKRP);
-  add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP);
+      value += pc * v;
+  }
+  return value;
 }
 
-void EndgameFunctions::add(Key k, EndgameEvaluationFunction* f) {
 
-  EEFmap.insert(std::pair<Key, EndgameEvaluationFunction*>(k, f));
-}
-
-void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) {
-
-  ScalingInfo s = {c, f};
-  ESFmap.insert(std::pair<Key, ScalingInfo>(k, s));
-}
-
-EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const {
-
-  std::map<Key, EndgameEvaluationFunction*>::const_iterator it(EEFmap.find(key));
-  return (it != EEFmap.end() ? it->second : NULL);
-}
-
-ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const {
-
-  std::map<Key, ScalingInfo>::const_iterator it(ESFmap.find(key));
-  if (it == ESFmap.end())
-      return NULL;
-
-  *c = it->second.col;
-  return it->second.fun;
+/// MaterialInfoTable::game_phase() calculates the phase given the current
+/// position. Because the phase is strictly a function of the material, it
+/// is stored in MaterialInfo.
+
+Phase MaterialInfoTable::game_phase(const Position& pos) {
+
+  Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
+
+  return  npm >= MidgameLimit ? PHASE_MIDGAME
+        : npm <= EndgameLimit ? PHASE_ENDGAME
+        : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
 }

src/material.h

@@ -1,38 +1,31 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(MATERIAL_H_INCLUDED)
 #define MATERIAL_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "endgame.h"
 #include "position.h"
-#include "scale.h"
+#include "tt.h"
+#include "types.h"
 
-
-////
-//// Types
-////
+const int MaterialTableSize = 8192;
 
 /// MaterialInfo is a class which contains various information about a
 /// material configuration. It contains a material balance evaluation,
@@ -49,84 +42,44 @@ class MaterialInfo {
   friend class MaterialInfoTable;
 
 public:
-  Value mg_value() const;
-  Value eg_value() const;
+  Score material_value() const;
   ScaleFactor scale_factor(const Position& pos, Color c) const;
+  int space_weight() const;
+  Phase game_phase() const;
   bool specialized_eval_exists() const;
   Value evaluate(const Position& pos) const;
 
 private:
-  void clear();
-  
   Key key;
-  int16_t mgValue;
-  int16_t egValue;
+  int16_t value;
   uint8_t factor[2];
-  EndgameEvaluationFunction* evaluationFunction;
-  ScalingFunction* scalingFunction[2];
+  EndgameBase<Value>* evaluationFunction;
+  EndgameBase<ScaleFactor>* scalingFunction[2];
+  int spaceWeight;
+  Phase gamePhase;
 };
 
 
-/// EndgameFunctions class stores the endgame evaluation functions std::map.
-/// Because STL library is not thread safe even for read access, the maps,
-/// although with identical content, are replicated for each thread. This
-/// is faster then using locks with an unique set of global maps.
-
-class EndgameFunctions;
-
-
-/// The MaterialInfoTable class represents a pawn hash table. It is basically
-/// just an array of MaterialInfo objects and a few methods for accessing these
-/// objects. The most important method is get_material_info, which looks up a
-/// position in the table and returns a pointer to a MaterialInfo object.
-
-class MaterialInfoTable {
+/// The MaterialInfoTable class represents a pawn hash table. The most important
+/// method is get_material_info, which returns a pointer to a MaterialInfo object.
 
+class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
 public:
-  MaterialInfoTable(unsigned numOfEntries);
   ~MaterialInfoTable();
-  void clear();
-  MaterialInfo* get_material_info(const Position& pos);
+  void init();
+  MaterialInfo* get_material_info(const Position& pos) const;
+  static Phase game_phase(const Position& pos);
 
 private:
-  unsigned size;
-  MaterialInfo* entries;
-  EndgameFunctions* funcs;
+  template<Color Us>
+  static int imbalance(const int pieceCount[][8]);
+
+  Endgames* funcs;
 };
 
 
-////
-//// Inline functions
-////
-
-/// MaterialInfo::mg_value and MaterialInfo::eg_value simply returns the
-/// material balance evaluation for the middle game and the endgame.
-
-inline Value MaterialInfo::mg_value() const {
-
-  return Value(mgValue);
-}
-
-inline Value MaterialInfo::eg_value() const {
-
-  return Value(egValue);
-}
-
-
-/// MaterialInfo::clear() resets a MaterialInfo object to an empty state,
-/// with all slots at their default values.
-
-inline void MaterialInfo::clear() {
-
-  mgValue = egValue = 0;
-  factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
-  evaluationFunction = NULL;
-  scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
-}
-
-
 /// MaterialInfo::scale_factor takes a position and a color as input, and
-/// returns a scale factor for the given color.  We have to provide the
+/// returns a scale factor for the given color. We have to provide the
 /// position in addition to the color, because the scale factor need not
 /// 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
@@ -134,33 +87,31 @@ inline void MaterialInfo::clear() {
 
 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]);
+  if (!scalingFunction[c])
+      return ScaleFactor(factor[c]);
+
+  ScaleFactor sf = scalingFunction[c]->apply(pos);
+  return sf == SCALE_FACTOR_NONE ? ScaleFactor(factor[c]) : sf;
 }
 
-
-/// 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);
 }
 
+inline Score MaterialInfo::material_value() const {
+  return make_score(value, value);
+}
+
+inline int MaterialInfo::space_weight() const {
+  return spaceWeight;
+}
+
+inline Phase MaterialInfo::game_phase() const {
+  return gamePhase;
+}
+
+inline bool MaterialInfo::specialized_eval_exists() const {
+  return evaluationFunction != NULL;
+}
+
 #endif // !defined(MATERIAL_H_INCLUDED)

src/mersenne.cpp

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

src/mersenne.h

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

src/misc.cpp

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

src/misc.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,64 +17,25 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MISC_H_INCLUDED)
 #define MISC_H_INCLUDED
 
-
-////
-//// Includes
-////
-
 #include <string>
-
-
-////
-//// Constants
-////
-
-
-/// Version number.  If this is left empty, the current date (in the format
-/// YYMMDD) is used as a version number.
-
-const std::string EngineVersion = "1.0";
-
-
-////
-//// Macros
-////
-
-#define Min(x, y) (((x) < (y))? (x) : (y))
-#define Max(x, y) (((x) < (y))? (y) : (x))
-
-
-////
-//// Prototypes
-////
+#include "types.h"
 
 extern const std::string engine_name();
+extern const std::string engine_authors();
 extern int get_system_time();
 extern int cpu_count();
-extern int Bioskey();
-
-////
-//// Debug
-////
-extern long dbg_cnt0;
-extern long dbg_cnt1;
-
-inline void dbg_hit_on(bool b) { dbg_cnt0++; if (b) dbg_cnt1++; }
-inline void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
-
-inline void dbg_before() { dbg_cnt0++; }
-inline void dbg_after() { dbg_cnt1++; }
-
-inline void dbg_mean_of(int v) { dbg_cnt0++; dbg_cnt1 += v; }
+extern int input_available();
+extern void prefetch(char* addr);
 
+extern void dbg_hit_on(bool b);
+extern void dbg_hit_on_c(bool c, bool b);
+extern void dbg_before();
+extern void dbg_after();
+extern void dbg_mean_of(int v);
 extern void dbg_print_hit_rate();
 extern void dbg_print_mean();
 
-extern bool dbg_show_mean;
-extern bool dbg_show_hit_rate;
-
 #endif // !defined(MISC_H_INCLUDED)

src/move.cpp

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

src/move.h

@@ -1,47 +1,48 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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 <string>
 
 #include "misc.h"
-#include "piece.h"
-#include "square.h"
+#include "types.h"
 
+// Maximum number of allowed moves per position
+const int MAX_MOVES = 256;
 
-////
-//// Types
-////
-
-class Position;
+/// A move needs 16 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)
+/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in
+/// because in any normal move destination square is always different
+/// from origin square while MOVE_NONE and MOVE_NULL have the same
+/// origin and destination square, 0 and 1 respectively.
 
 enum Move {
   MOVE_NONE = 0,
-  MOVE_NULL = 65, 
-  MOVE_MAX = 0xFFFFFF
+  MOVE_NULL = 65
 };
 
 
@@ -50,29 +51,106 @@ struct MoveStack {
   int score;
 };
 
+inline bool operator<(const MoveStack& f, const MoveStack& s) { return f.score < s.score; }
+
+// An helper insertion sort implementation, works with pointers and iterators
+template<typename T, typename K>
+inline void insertion_sort(K firstMove, K lastMove)
+{
+    T value;
+    K cur, p, d;
+
+    if (firstMove != lastMove)
+        for (cur = firstMove + 1; cur != lastMove; cur++)
+        {
+            p = d = cur;
+            value = *p--;
+            if (*p < value)
+            {
+                do *d = *p;
+                while (--d != firstMove && *--p < value);
+                *d = value;
+            }
+        }
+}
+
+// Our dedicated sort in range [firstMove, lastMove), first splits
+// positive scores from ramining then order seaprately the two sets.
+template<typename T>
+inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
+{
+    T tmp;
+    T *p, *d;
+
+    d = lastMove;
+    p = firstMove - 1;
+
+    d->score = -1; // right guard
+
+    // Split positives vs non-positives
+    do {
+        while ((++p)->score > 0) {}
+
+        if (p != d)
+        {
+            while (--d != p && d->score <= 0) {}
+
+            tmp = *p;
+            *p = *d;
+            *d = tmp;
+        }
+
+    } while (p != d);
+
+    // Sort just positive scored moves, remaining only when we get there
+    insertion_sort<T, T*>(firstMove, p);
+    *lastPositive = p;
+}
+
+// Picks up the best move in range [curMove, lastMove), one per cycle.
+// It is faster then sorting all the moves in advance when moves are few,
+// as normally are the possible captures. Note that is not a stable alghoritm.
+template<typename T>
+inline T pick_best(T* curMove, T* lastMove)
+{
+    T bestMove, tmp;
+
+    bestMove = *curMove;
+    while (++curMove != lastMove)
+    {
+        if (bestMove < *curMove)
+        {
+            tmp = *curMove;
+            *curMove = bestMove;
+            bestMove = tmp;
+        }
+    }
+    return bestMove;
+}
 
-////
-//// Inline functions
-////
 
 inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 077);
+  return Square((int(m) >> 6) & 0x3F);
 }
 
 inline Square move_to(Move m) {
-  return Square(m & 077);
+  return Square(m & 0x3F);
 }
 
-inline PieceType move_promotion(Move m) {
-  return PieceType((int(m) >> 12) & 7);
+inline bool move_is_special(Move m) {
+  return m & (3 << 14);
 }
 
-inline bool move_is_ep(Move m) {
-  return bool((int(m) >> 15) & 1);
+inline bool move_is_promotion(Move m) {
+  return (m & (3 << 14)) == (1 << 14);
 }
 
-inline bool move_is_castle(Move m) {
-  return bool((int(m) >> 16) & 1);
+inline int move_is_ep(Move m) {
+  return (m & (3 << 14)) == (2 << 14);
+}
+
+inline int move_is_castle(Move m) {
+  return (m & (3 << 14)) == (3 << 14);
 }
 
 inline bool move_is_short_castle(Move m) {
@@ -83,31 +161,35 @@ inline bool move_is_long_castle(Move m) {
   return move_is_castle(m) && (move_to(m) < move_from(m));
 }
 
-inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
-  return Move(int(to) | (int(from) << 6) | (int(promotion) << 12));
+inline PieceType move_promotion_piece(Move m) {
+  return move_is_promotion(m) ? PieceType(((int(m) >> 12) & 3) + 2) : PIECE_TYPE_NONE;
 }
 
 inline Move make_move(Square from, Square to) {
   return Move(int(to) | (int(from) << 6));
 }
 
-inline Move make_castle_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (1 << 16));
+inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
+  return Move(int(to) | (int(from) << 6) | ((int(promotion) - 2) << 12) | (1 << 14));
 }
 
 inline Move make_ep_move(Square from, Square to) {
-  return Move(int(to) | (int(from) << 6) | (1 << 15));
+  return Move(int(to) | (int(from) << 6) | (2 << 14));
 }
 
+inline Move make_castle_move(Square from, Square to) {
+  return Move(int(to) | (int(from) << 6) | (3 << 14));
+}
 
-////
-//// Prototypes
-////
+inline bool move_is_ok(Move m) {
+  return move_from(m) != move_to(m); // Catches also MOVE_NONE
+}
 
-extern std::ostream &operator << (std::ostream &os, Move m);
-extern Move move_from_string(const Position &pos, const std::string &str);
-extern const std::string move_to_string(Move m);
-extern bool move_is_ok(Move m);
+class Position;
 
+extern const std::string move_to_uci(Move m, bool chess960);
+extern Move move_from_uci(const Position& pos, const std::string& str);
+extern const std::string move_to_san(Position& pos, Move m);
+extern const std::string pretty_pv(Position& pos, int depth, Value score, int time, Move pv[]);
 
 #endif // !defined(MOVE_H_INCLUDED)

src/movegen.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,27 +17,24 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined(MOVEGEN_H_INCLUDED)
 #define MOVEGEN_H_INCLUDED
 
-////
-//// Includes
-////
-
+#include "move.h"
 #include "position.h"
 
+enum MoveType {
+  MV_CAPTURE,
+  MV_NON_CAPTURE,
+  MV_CHECK,
+  MV_NON_CAPTURE_CHECK,
+  MV_EVASION,
+  MV_NON_EVASION,
+  MV_LEGAL,
+  MV_PSEUDO_LEGAL
+};
 
-////
-//// Prototypes
-////
-
-extern int generate_captures(const Position &pos, MoveStack *mlist);
-extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
-extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
-extern int generate_evasions(const Position &pos, MoveStack *mlist);
-extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
-extern bool move_is_legal(const Position &pos, const Move m, Bitboard pinned);
-
+template<MoveType>
+MoveStack* generate(const Position& pos, MoveStack* mlist);
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

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

src/movepick.h

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,100 +17,47 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
 #if !defined MOVEPICK_H_INCLUDED
 #define MOVEPICK_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "depth.h"
-#include "lock.h"
+#include "history.h"
+#include "move.h"
 #include "position.h"
+#include "types.h"
 
-
-////
-//// Types
-////
+struct SearchStack;
 
 /// MovePicker is a class which is used to pick one legal move at a time from
-/// the current position.  It is initialized with a Position object and a few
-/// moves we have reason to believe are good.  The most important method is
-/// MovePicker::pick_next_move(), which returns a new legal move each time it
+/// the current position. It is initialized with a Position object and a few
+/// moves we have reason to believe are good. The most important method is
+/// MovePicker::get_next_move(), which returns a new legal move each time it
 /// is called, until there are no legal moves left, when MOVE_NONE is returned.
 /// In order to improve the efficiency of the alpha beta algorithm, MovePicker
-/// attempts to return the moves which are most likely to be strongest first.
+/// attempts to return the moves which are most likely to get a cut-off first.
 
 class MovePicker {
 
+  MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC
+
 public:
-
-  enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
-    PH_MATE_KILLER,    // Mate killer from the current ply
-    PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
-    PH_NONCAPTURES,    // Non-captures and underpromotions
-    PH_EVASIONS,       // Check evasions
-    PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
-    PH_STOP
-  };
-
-  MovePicker(const Position& p, bool pvnode, Move ttm, Move mk, Move k1, Move k2, Depth d);
+  MovePicker(const Position&, Move, Depth, const History&, SearchStack*, Value);
+  MovePicker(const Position&, Move, Depth, const History&);
   Move get_next_move();
-  Move get_next_move(Lock &lock);
-  int number_of_moves() const;
-  int current_move_score() const;
-  MovegenPhase current_move_type() const;
-  Bitboard discovered_check_candidates() const;
-
-  static void init_phase_table();
 
 private:
   void score_captures();
   void score_noncaptures();
   void score_evasions();
-  void score_qcaptures();
-  Move pick_move_from_list();
-  int find_best_index();
+  void go_next_phase();
 
   const Position& pos;
-  Move ttMove, mateKiller, killer1, killer2;
-  Bitboard pinned, dc;
-  MoveStack moves[256], badCaptures[64];
-  bool pvNode;
-  Depth depth;
-  int phaseIndex;
-  int numOfMoves, numOfBadCaptures;
-  int movesPicked, badCapturesPicked;
-  bool finished;
+  const History& H;
+  Bitboard pinned;
+  MoveStack ttMoves[2], killers[2];
+  int badCaptureThreshold, phase;
+  const uint8_t* phasePtr;
+  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *badCaptures;
+  MoveStack moves[MAX_MOVES];
 };
 
-
-////
-//// Inline functions
-////
-
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable. It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-inline int MovePicker::number_of_moves() const {
-
-  return numOfMoves;
-}
-
-/// MovePicker::discovered_check_candidates() returns a bitboard containing
-/// all pieces which can possibly give discovered check.  This bitboard is
-/// computed by the constructor function.
-
-inline Bitboard MovePicker::discovered_check_candidates() const {
-  return dc;
-}
-
 #endif // !defined(MOVEPICK_H_INCLUDED)

src/pawns.cpp

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

src/pawns.h

@@ -1,41 +1,35 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(PAWNS_H_INCLUDED)
 #define PAWNS_H_INCLUDED
 
-////
-//// Includes
-////
-
 #include "position.h"
+#include "tt.h"
+#include "types.h"
 
+const int PawnTableSize = 16384;
 
-////
-//// Types
-////
-
-/// PawnInfo is a class which contains various information about a pawn 
-/// structure.  Currently, it only includes a middle game and an end game
-/// pawn structure evaluation, and a bitboard of passed pawns.  We may want
-/// to add further information in the future.  A lookup to the pawn hash table
+/// PawnInfo is a class which contains various information about a pawn
+/// structure. Currently, it only includes a middle game and an end game
+/// pawn structure evaluation, and a bitboard of passed pawns. We may want
+/// to add further information in the future. A lookup to the pawn hash table
 /// (performed by calling the get_pawn_info method in a PawnInfoTable object)
 /// returns a pointer to a PawnInfo object.
 
@@ -44,88 +38,70 @@ class PawnInfo {
   friend class PawnInfoTable;
 
 public:
-  Value mg_value() const;
-  Value eg_value() const;
-  Value kingside_storm_value(Color c) const;
-  Value queenside_storm_value(Color c) const;
-  Bitboard passed_pawns() const;
-  bool file_is_half_open(Color c, File f) const;
-  bool has_open_file_to_left(Color c, File f) const;
-  bool has_open_file_to_right(Color c, File f) const;
+  Score pawns_value() const;
+  Bitboard pawn_attacks(Color c) const;
+  Bitboard passed_pawns(Color c) const;
+  int file_is_half_open(Color c, File f) const;
+  int has_open_file_to_left(Color c, File f) const;
+  int has_open_file_to_right(Color c, File f) const;
+
+  template<Color Us>
+  Score king_shelter(const Position& pos, Square ksq);
 
 private:
-  void clear();
+  template<Color Us>
+  Score updateShelter(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns;
-  int16_t mgValue, egValue;
-  int8_t ksStormValue[2], qsStormValue[2];
-  uint8_t halfOpenFiles[2];
+  Bitboard passedPawns[2];
+  Bitboard pawnAttacks[2];
+  Square kingSquares[2];
+  Score value;
+  int halfOpenFiles[2];
+  Score kingShelters[2];
 };
 
 
-/// The PawnInfoTable class represents a pawn hash table.  It is basically
-/// just an array of PawnInfo objects and a few methods for accessing these
-/// objects.  The most important method is get_pawn_info, which looks up a
-/// position in the table and returns a pointer to a PawnInfo object.
-
-class PawnInfoTable {
+/// The PawnInfoTable class represents a pawn hash table. The most important
+/// method is get_pawn_info, which returns a pointer to a PawnInfo object.
 
+class PawnInfoTable : public SimpleHash<PawnInfo, PawnTableSize> {
 public:
-  PawnInfoTable(unsigned numOfEntries);
-  ~PawnInfoTable();
-  void clear();
-  PawnInfo *get_pawn_info(const Position &pos);
+  PawnInfo* get_pawn_info(const Position& pos) const;
 
 private:
-  unsigned size;
-  PawnInfo *entries;
+  template<Color Us>
+  static Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
 };
 
 
-////
-//// Inline functions
-////
-
-inline Value PawnInfo::mg_value() const {
-  return Value(mgValue);
+inline Score PawnInfo::pawns_value() const {
+  return value;
 }
 
-inline Value PawnInfo::eg_value() const {
-  return Value(egValue);
+inline Bitboard PawnInfo::pawn_attacks(Color c) const {
+  return pawnAttacks[c];
 }
 
-inline Bitboard PawnInfo::passed_pawns() const {
-  return passedPawns;
+inline Bitboard PawnInfo::passed_pawns(Color c) const {
+  return passedPawns[c];
 }
 
-inline Value PawnInfo::kingside_storm_value(Color c) const {
-  return Value(ksStormValue[c]);
+inline int PawnInfo::file_is_half_open(Color c, File f) const {
+  return halfOpenFiles[c] & (1 << int(f));
 }
 
-inline Value PawnInfo::queenside_storm_value(Color c) const {
-  return Value(qsStormValue[c]);
-}
-
-inline bool PawnInfo::file_is_half_open(Color c, File f) const {
-  return (halfOpenFiles[c] & (1 << int(f)));
-}
-
-inline bool PawnInfo::has_open_file_to_left(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
   return halfOpenFiles[c] & ((1 << int(f)) - 1);
 }
 
-inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
-inline void PawnInfo::clear() {
-  mgValue = egValue = 0;
-  passedPawns = EmptyBoardBB;
-  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
-  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
-  halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
+template<Color Us>
+inline Score PawnInfo::king_shelter(const Position& pos, Square ksq) {
+  return kingSquares[Us] == ksq ? kingShelters[Us] : updateShelter<Us>(pos, ksq);
 }
 
-
 #endif // !defined(PAWNS_H_INCLUDED)

src/phase.h

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

src/piece.cpp

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

src/piece.h

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

src/position.h

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

src/psqtab.h

@@ -1,189 +1,185 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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 "position.h"
-#include "value.h"
+#include "types.h"
 
+namespace {
 
 ////
-//// Variables
+//// Constants modified by Joona Kiiski
 ////
 
-static const Value MP = PawnValueMidgame;
-static const Value MK = KnightValueMidgame;
-static const Value MB = BishopValueMidgame;
-static const Value MR = RookValueMidgame;
-static const Value MQ = QueenValueMidgame;
+const Value MP = PawnValueMidgame;
+const Value MK = KnightValueMidgame;
+const Value MB = BishopValueMidgame;
+const Value MR = RookValueMidgame;
+const Value MQ = QueenValueMidgame;
 
-static const int MgPST[][64] = {
+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-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
-    MP-38, MP-12, MP+ 6, MP+38, MP+38, MP+ 6, MP-12, MP-38,
-    MP-38, MP-12, MP+16, MP+64, MP+64, MP+16, MP-12, MP-38,
-    MP-38, MP-12, MP+16, MP+38, MP+38, MP+16, MP-12, MP-38,
-    MP-38, MP-12, MP+ 6, MP+12, MP+12, MP+ 6, MP-12, MP-38,
-    MP-38, MP-12, MP- 0, MP+12, MP+12, MP- 0, MP-12, MP-38,
-        0,     0,     0,     0,     0,     0,     0,     0
+   // 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-128, MK-102, MK-76, MK-64, MK-64, MK-76, MK-102, MK-128,
-    MK- 89, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK- 89,
-    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
-    MK- 25, MK-  0, MK+25, MK+38, MK+38, MK+25, MK-  0, MK- 25,
-    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
-    MK- 12, MK+ 12, MK+38, MK+51, MK+51, MK+38, MK+ 12, MK- 12,
-    MK- 51, MK- 25, MK- 0, MK+12, MK+12, MK- 0, MK- 25, MK- 51,
-    MK-182, MK- 64, MK-38, MK-25, MK-25, MK-38, MK- 64, MK-182
+    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-46, MB-46, MB-40, MB-35, MB-35, MB-40, MB-46, MB-46,
-    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
-    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
-    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
-    MB-10, MB- 0, MB+ 5, MB+20, MB+20, MB+ 5, MB- 0, MB-10,
-    MB-15, MB- 5, MB+10, MB+ 5, MB+ 5, MB+10, MB- 5, MB-15,
-    MB-20, MB- 0, MB- 5, MB- 0, MB- 0, MB- 5, MB- 0, MB-20,
-    MB-20, MB-20, MB-15, MB-10, MB-10, MB-15, MB-20, MB-20
+    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-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18,
-    MR-18, MR-10, MR-3, MR+4, MR+4, MR-3, MR-10, MR-18
+   // 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, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ,
-    MQ, MQ, MQ, MQ, MQ, MQ, MQ, MQ
+   // 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
-    302, 328, 276, 225, 225, 276, 328, 302,
-    276, 302, 251, 200, 200, 251, 302, 276,
-    225, 251, 200, 149, 149, 200, 251, 225,
-    200, 225, 175, 124, 124, 175, 225, 200,
-    175, 200, 149,  98,  98, 149, 200, 175,
-    149, 175, 124,  72,  72, 124, 175, 149,
-    124, 149,  98,  47,  47,  98, 149, 124,
-     98, 124,  72,  21,  21,  72, 124,  98
+    287, 311, 262, 214, 214, 262, 311, 287,
+    262, 287, 238, 190, 190, 238, 287, 262,
+    214, 238, 190, 142, 142, 190, 238, 214,
+    190, 214, 167, 119, 119, 167, 214, 190,
+    167, 190, 142,  94,  94, 142, 190, 167,
+    142, 167, 119,  69,  69, 119, 167, 142,
+    119, 142,  94,  46,  46,  94, 142, 119,
+     94, 119,  69,  21,  21,  69, 119,  94
   }
 };
 
-static const Value EP = PawnValueEndgame;
-static const Value EK = KnightValueEndgame;
-static const Value EB = BishopValueEndgame;
-static const Value ER = RookValueEndgame;
-static const Value EQ = QueenValueEndgame;
-
-static const int EgPST[][64] = {
+const int EgPST[][64] = {
   { },
   {// Pawn
-   //A   B   C   D   E   F   G   H
-     0,  0,  0,  0,  0,  0,  0,  0,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-    EP, EP, EP, EP, EP, EP, EP, EP,
-     0,  0,  0,  0,  0,  0,  0,  0
+   // 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-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102,
-    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
-    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
-    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
-    EK- 38, EK-12, EK+12, EK+25, EK+25, EK+12, EK-12, EK-38,
-    EK- 51, EK-25, EK- 0, EK+12, EK+12, EK- 0, EK-25, EK-51,
-    EK- 76, EK-51, EK-25, EK-12, EK-12, EK-25, EK-51, EK-76,
-    EK-102, EK-76, EK-51, EK-38, EK-38, EK-51, EK-76, EK-102
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104,
+    EK- 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-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46,
-    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
-    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
-    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
-    EB-15, EB- 0, EB+ 7, EB+15, EB+15, EB+ 7, EB- 0, EB-15,
-    EB-23, EB- 7, EB- 0, EB+ 7, EB+ 7, EB- 0, EB- 7, EB-23,
-    EB-30, EB-15, EB- 7, EB- 0, EB- 0, EB- 7, EB-15, EB-30,
-    EB-46, EB-30, EB-23, EB-15, EB-15, EB-23, EB-30, EB-46
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59,
+    EB-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
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3
   },
   {// Queen
    // A      B      C      D      E      F      G      H
-    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61,
-    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
-    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
-    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
-    EQ-20, EQ- 0, EQ+10, EQ+20, EQ+20, EQ+10, EQ- 0, EQ-20,
-    EQ-30, EQ-10, EQ- 0, EQ+10, EQ+10, EQ- 0, EQ-10, EQ-30,
-    EQ-40, EQ-20, EQ-10, EQ- 0, EQ- 0, EQ-10, EQ-20, EQ-40,
-    EQ-61, EQ-40, EQ-30, EQ-20, EQ-20, EQ-30, EQ-40, EQ-61
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80,
+    EQ-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
-     16,  78, 108, 139, 139, 108,  78,  16,
-     78, 139, 170, 200, 200, 170, 139,  78,
-    108, 170, 200, 230, 230, 200, 170, 108,
-    139, 200, 230, 261, 261, 230, 200, 139,
-    139, 200, 230, 261, 261, 230, 200, 139,
-    108, 170, 200, 230, 230, 200, 170, 108,
-     78, 139, 170, 200, 200, 170, 139,  78,
-     16,  78, 108, 139, 139, 108,  78,  16
+     18,  77, 105, 135, 135, 105,  77,  18,
+     77, 135, 165, 193, 193, 165, 135,  77,
+    105, 165, 193, 222, 222, 193, 165, 105,
+    135, 193, 222, 251, 251, 222, 193, 135,
+    135, 193, 222, 251, 251, 222, 193, 135,
+    105, 165, 193, 222, 222, 193, 165, 105,
+     77, 135, 165, 193, 193, 165, 135,  77,
+     18,  77, 105, 135, 135, 105,  77,  18
   }
 };
 
+} // namespace
 
 #endif // !defined(PSQTAB_H_INCLUDED)

src/rkiss.h

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

src/san.cpp

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

src/san.h

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

src/scale.h

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

src/search.h

@@ -1,51 +1,32 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(SEARCH_H_INCLUDED)
 #define SEARCH_H_INCLUDED
 
-////
-//// Includes
-////
+#include <cstring>
 
+#include "move.h"
 #include "types.h"
-#include "depth.h"
-#include "history.h"
-#include "lock.h"
-#include "movegen.h"
-#include "position.h"
-#include "tt.h"
-#include "value.h"
 
-
-////
-//// Constants
-////
-
-const int PLY_MAX = 100;
-const int PLY_MAX_PLUS_2 = 102;
-
-
-////
-//// Types
-////
+class Position;
+struct SplitPoint;
 
 /// The SearchStack struct keeps track of the information we need to remember
 /// from nodes shallower and deeper in the tree during the search.  Each
@@ -53,39 +34,40 @@ const int PLY_MAX_PLUS_2 = 102;
 /// current ply.
 
 struct SearchStack {
-  Move pv[PLY_MAX];
+  int ply;
   Move currentMove;
-  Value currentMoveCaptureValue;
-  Move mateKiller, killer1, killer2;
-  Move threatMove;
+  Move mateKiller;
+  Move excludedMove;
+  Move bestMove;
+  Move killers[2];
   Depth reduction;
+  Value eval;
+  Value evalMargin;
+  bool skipNullMove;
+  SplitPoint* sp;
 };
 
 
-////
-//// Global variables
-////
+/// The SearchLimits struct stores information sent by GUI about available time
+/// to search the current move, maximum depth/time, if we are in analysis mode
+/// or if we have to ponder while is our opponent's side to move.
 
-extern TranspositionTable TT;
+struct SearchLimits {
 
-extern int ActiveThreads;
+  SearchLimits() { memset(this, 0, sizeof(SearchLimits)); }
 
-extern Lock SMPLock;
+  SearchLimits(int t, int i, int mtg, int mt, int md, int mn, bool inf, bool pon)
+              : time(t), increment(i), movesToGo(mtg), maxTime(mt), maxDepth(md),
+                maxNodes(mn), infinite(inf), ponder(pon) {}
 
-// Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;  
+  bool useTimeManagement() const { return !(maxTime | maxDepth | maxNodes | int(infinite)); }
 
+  int time, increment, movesToGo, maxTime, maxDepth, maxNodes;
+  bool infinite, ponder;
+};
 
-////
-//// Prototypes
-////
-
-extern void init_threads();
-extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
-                  int time[], int increment[], int movesToGo, int maxDepth, 
-                  int maxNodes, int maxTime, Move searchMoves[]);
-extern int64_t nodes_searched();
-
+extern void init_search();
+extern int64_t perft(Position& pos, Depth depth);
+extern bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]);
 
 #endif // !defined(SEARCH_H_INCLUDED)

src/square.cpp

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

src/square.h

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

src/thread.cpp

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

src/thread.h

@@ -1,79 +1,132 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(THREAD_H_INCLUDED)
 #define THREAD_H_INCLUDED
 
-
-////
-//// Includes
-////
+#include <cstring>
 
 #include "lock.h"
+#include "material.h"
 #include "movepick.h"
+#include "pawns.h"
 #include "position.h"
-#include "search.h"
 
-
-////
-//// Constants and variables
-////
-
-const int THREAD_MAX = 8;
-
-
-////
-//// Types
-////
+const int MAX_THREADS = 32;
+const int MAX_ACTIVE_SPLIT_POINTS = 8;
 
 struct SplitPoint {
-  SplitPoint *parent;
-  Position pos;
-  SearchStack sstack[THREAD_MAX][PLY_MAX];
-  SearchStack *parentSstack;
-  int ply;
+
+  // Const data after splitPoint has been setup
+  SplitPoint* parent;
+  const Position* pos;
   Depth depth;
-  volatile Value alpha, beta, bestValue;
   bool pvNode;
-  Bitboard dcCandidates;
-  int master, slaves[THREAD_MAX];
+  Value beta;
+  int ply;
+  int master;
+  Move threatMove;
+
+  // Const pointers to shared data
+  MovePicker* mp;
+  SearchStack* ss;
+
+  // Shared data
   Lock lock;
-  MovePicker *mp;
-  volatile int moves;
-  volatile int cpus;
-  bool finished;
+  volatile int64_t nodes;
+  volatile Value alpha;
+  volatile Value bestValue;
+  volatile int moveCount;
+  volatile bool is_betaCutoff;
+  volatile bool is_slave[MAX_THREADS];
 };
 
 
+/// Thread struct is used to keep together all the thread related stuff like locks,
+/// state and especially split points. We also use per-thread pawn and material hash
+/// tables so that once we get a pointer to an entry its life time is unlimited and
+/// we don't have to care about someone changing the entry under our feet.
+
 struct Thread {
-  SplitPoint *splitPoint;
-  int activeSplitPoints;
-  uint64_t nodes;
-  bool failHighPly1;
-  volatile bool stop;
-  volatile bool running;
-  volatile bool idle;
-  volatile bool workIsWaiting;
-  volatile bool printCurrentLine;
-  unsigned char pad[64];
+
+  enum ThreadState
+  {
+    INITIALIZING,  // Thread is initializing itself
+    SEARCHING,     // Thread is performing work
+    AVAILABLE,     // Thread is waiting for work
+    BOOKED,        // Other thread (master) has booked us as a slave
+    WORKISWAITING, // Master has ordered us to start
+    TERMINATED     // We are quitting and thread is terminated
+  };
+
+  void wake_up();
+  bool cutoff_occurred() const;
+  bool is_available_to(int master) const;
+
+  MaterialInfoTable materialTable;
+  PawnInfoTable pawnTable;
+  int maxPly;
+  Lock sleepLock;
+  WaitCondition sleepCond;
+  volatile ThreadState state;
+  SplitPoint* volatile splitPoint;
+  volatile int activeSplitPoints;
+  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
 };
 
 
+/// ThreadsManager class is used to handle all the threads related stuff like init,
+/// starting, parking and, the most important, launching a slave thread at a split
+/// point. All the access to shared thread data is done through this class.
+
+class ThreadsManager {
+  /* As long as the single ThreadsManager object is defined as a global we don't
+     need to explicitly initialize to zero its data members because variables with
+     static storage duration are automatically set to zero before enter main()
+  */
+public:
+  Thread& operator[](int threadID) { return threads[threadID]; }
+  void init();
+  void exit();
+  void init_hash_tables();
+
+  int min_split_depth() const { return minimumSplitDepth; }
+  int size() const { return activeThreads; }
+  void set_size(int cnt) { activeThreads = cnt; }
+
+  void read_uci_options();
+  bool available_slave_exists(int master) const;
+  void idle_loop(int threadID, SplitPoint* sp);
+
+  template <bool Fake>
+  void split(Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,
+             Depth depth, Move threatMove, int moveCount, MovePicker* mp, bool pvNode);
+private:
+  Lock mpLock;
+  Depth minimumSplitDepth;
+  int maxThreadsPerSplitPoint;
+  bool useSleepingThreads;
+  int activeThreads;
+  volatile bool allThreadsShouldExit;
+  Thread threads[MAX_THREADS];
+};
+
+extern ThreadsManager Threads;
+
 #endif // !defined(THREAD_H_INCLUDED)

src/timeman.cpp

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

src/timeman.h

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

src/timeoday.cpp

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

src/tt.cpp

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

src/tt.h

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

src/types.h

@@ -1,47 +1,470 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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(TYPES_H_INCLUDED)
 #define TYPES_H_INCLUDED
 
-#if !defined(_MSC_VER)
+#include <climits>
+#include <cstdlib>
 
-#include <inttypes.h>
+#if defined(_MSC_VER)
+
+// Disable some silly and noisy warning from MSVC compiler
+#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
+#pragma warning(disable: 4127) // Conditional expression is constant
+#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
+
+// MSVC does not support <inttypes.h>
+typedef   signed __int8    int8_t;
+typedef unsigned __int8   uint8_t;
+typedef   signed __int16  int16_t;
+typedef unsigned __int16 uint16_t;
+typedef   signed __int32  int32_t;
+typedef unsigned __int32 uint32_t;
+typedef   signed __int64  int64_t;
+typedef unsigned __int64 uint64_t;
 
 #else
 
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64;
-typedef unsigned __int64 uint64_t;
+#include <inttypes.h>
 
-typedef __int16 int16_t;
-typedef __int64 int64_t;
+#endif
 
-#endif // !defined(_MSC_VER)
+#define Min(x, y) (((x) < (y)) ? (x) : (y))
+#define Max(x, y) (((x) < (y)) ? (y) : (x))
+
+////
+//// Configuration
+////
+
+//// For Linux and OSX configuration is done automatically using Makefile.
+//// To get started type "make help".
+////
+//// For windows part of the configuration is detected automatically, but
+//// some switches need to be set manually:
+////
+//// -DNDEBUG       | Disable debugging mode. Use always.
+////
+//// -DNO_PREFETCH  | Disable use of prefetch asm-instruction. A must if you want the
+////                | executable to run on some very old machines.
+////
+//// -DUSE_POPCNT   | Add runtime support for use of popcnt asm-instruction.
+////                | Works only in 64-bit mode. For compiling requires hardware
+////                | with popcnt support. Around 4% speed-up.
+////
+//// -DOLD_LOCKS    | By default under Windows are used the fast Slim Reader/Writer (SRW)
+////                | Locks and Condition Variables: these are not supported by Windows XP
+////                | and older, to compile for those platforms you should enable OLD_LOCKS.
+
+// Automatic detection for 64-bit under Windows
+#if defined(_WIN64)
+#define IS_64BIT
+#endif
+
+// Automatic detection for use of bsfq asm-instruction under Windows
+#if defined(_WIN64)
+#define USE_BSFQ
+#endif
+
+// Intel header for _mm_popcnt_u64() intrinsic
+#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
+#include <nmmintrin.h>
+#endif
+
+// Cache line alignment specification
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#else
+#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#endif
+
+// Define a __cpuid() function for gcc compilers, for Intel and MSVC
+// is already available as an intrinsic.
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+inline void __cpuid(int CPUInfo[4], int InfoType)
+{
+  int* eax = CPUInfo + 0;
+  int* ebx = CPUInfo + 1;
+  int* ecx = CPUInfo + 2;
+  int* edx = CPUInfo + 3;
+
+  *eax = InfoType;
+  *ecx = 0;
+  __asm__("cpuid" : "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)
+                  : "0" (*eax), "2" (*ecx));
+}
+#else
+inline void __cpuid(int CPUInfo[4], int)
+{
+   CPUInfo[0] = CPUInfo[1] = CPUInfo[2] = CPUInfo[3] = 0;
+}
+#endif
+
+// Define FORCE_INLINE macro to force inlining overriding compiler choice
+#if defined(_MSC_VER)
+#define FORCE_INLINE  __forceinline
+#elif defined(__GNUC__)
+#define FORCE_INLINE  inline __attribute__((always_inline))
+#else
+#define FORCE_INLINE  inline
+#endif
+
+/// cpu_has_popcnt() detects support for popcnt instruction at runtime
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+/// CpuHasPOPCNT is a global constant initialized at startup that
+/// is set to true if CPU on which application runs supports popcnt
+/// hardware instruction. Unless USE_POPCNT is not defined.
+#if defined(USE_POPCNT)
+const bool CpuHasPOPCNT = cpu_has_popcnt();
+#else
+const bool CpuHasPOPCNT = false;
+#endif
+
+
+/// CpuIs64Bit is a global constant initialized at compile time that
+/// is set to true if CPU on which application runs is a 64 bits.
+#if defined(IS_64BIT)
+const bool CpuIs64Bit = true;
+#else
+const bool CpuIs64Bit = false;
+#endif
+
+#include <string>
 
-// Hash keys:
 typedef uint64_t Key;
+typedef uint64_t Bitboard;
+
+const int PLY_MAX = 100;
+const int PLY_MAX_PLUS_2 = PLY_MAX + 2;
+
+enum ValueType {
+  VALUE_TYPE_NONE  = 0,
+  VALUE_TYPE_UPPER = 1,
+  VALUE_TYPE_LOWER = 2,
+  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+};
+
+enum Value {
+  VALUE_ZERO      = 0,
+  VALUE_DRAW      = 0,
+  VALUE_KNOWN_WIN = 15000,
+  VALUE_MATE      = 30000,
+  VALUE_INFINITE  = 30001,
+  VALUE_NONE      = 30002,
+
+  VALUE_MATE_IN_PLY_MAX  =  VALUE_MATE - PLY_MAX,
+  VALUE_MATED_IN_PLY_MAX = -VALUE_MATE + PLY_MAX,
+
+  VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+  VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN
+};
+
+enum PieceType {
+  PIECE_TYPE_NONE = 0,
+  PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
+};
+
+enum Piece {
+  PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
+  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
+};
+
+enum Color {
+  WHITE, BLACK, COLOR_NONE
+};
+
+enum Depth {
+
+  ONE_PLY = 2,
+
+  DEPTH_ZERO         =  0 * ONE_PLY,
+  DEPTH_QS_CHECKS    = -1 * ONE_PLY,
+  DEPTH_QS_NO_CHECKS = -2 * ONE_PLY,
+
+  DEPTH_NONE = -127 * ONE_PLY
+};
+
+enum Square {
+  SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,
+  SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
+  SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,
+  SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4,
+  SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5,
+  SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6,
+  SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
+  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,
+  SQ_NONE,
+
+  DELTA_N =  8,
+  DELTA_E =  1,
+  DELTA_S = -8,
+  DELTA_W = -1,
+
+  DELTA_NN = DELTA_N + DELTA_N,
+  DELTA_NE = DELTA_N + DELTA_E,
+  DELTA_SE = DELTA_S + DELTA_E,
+  DELTA_SS = DELTA_S + DELTA_S,
+  DELTA_SW = DELTA_S + DELTA_W,
+  DELTA_NW = DELTA_N + DELTA_W
+};
+
+enum File {
+  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H
+};
+
+enum Rank {
+  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8
+};
+
+enum SquareColor {
+  DARK, LIGHT
+};
+
+enum ScaleFactor {
+  SCALE_FACTOR_ZERO   = 0,
+  SCALE_FACTOR_NORMAL = 64,
+  SCALE_FACTOR_MAX    = 128,
+  SCALE_FACTOR_NONE   = 255
+};
+
+
+/// Score enum keeps a midgame and an endgame value in a single
+/// integer (enum), first LSB 16 bits are used to store endgame
+/// value, while upper bits are used for midgame value. Compiler
+/// is free to choose the enum type as long as can keep its data,
+/// so ensure Score to be an integer type.
+enum Score {
+    SCORE_ZERO = 0,
+    SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX,
+    SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN
+};
+
+#define ENABLE_OPERATORS_ON(T) \
+inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \
+inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \
+inline T operator* (int i, const T d) {  return T(i * int(d)); } \
+inline T operator* (const T d, int i) {  return T(int(d) * i); } \
+inline T operator/ (const T d, int i) { return T(int(d) / i); } \
+inline T operator- (const T d) { return T(-int(d)); } \
+inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \
+inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \
+inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \
+inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \
+inline void operator*= (T& d, int i) { d = T(int(d) * i); } \
+inline void operator/= (T& d, int i) { d = T(int(d) / i); }
+
+ENABLE_OPERATORS_ON(Value)
+ENABLE_OPERATORS_ON(PieceType)
+ENABLE_OPERATORS_ON(Piece)
+ENABLE_OPERATORS_ON(Color)
+ENABLE_OPERATORS_ON(Depth)
+ENABLE_OPERATORS_ON(Square)
+ENABLE_OPERATORS_ON(File)
+ENABLE_OPERATORS_ON(Rank)
+
+#undef ENABLE_OPERATORS_ON
+
+// Extra operators for adding integers to a Value
+inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
+inline Value operator- (Value v, int i) { return Value(int(v) - i); }
+
+// Extracting the _signed_ lower and upper 16 bits it not so trivial
+// because according to the standard a simple cast to short is
+// implementation defined and so is a right shift of a signed integer.
+inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); }
+
+// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in
+// this case, although not 100% standard compliant it seems to work for Intel and MSVC.
+#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
+inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); }
+#else
+inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); }
+#endif
+
+inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
+
+// Division must be handled separately for each term
+inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); }
+
+// Only declared but not defined. We don't want to multiply two scores due to
+// a very high risk of overflow. So user should explicitly convert to integer.
+inline Score operator*(Score s1, Score s2);
+
+// Remaining Score operators are standard
+inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); }
+inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); }
+inline Score operator* (int i, const Score d) {  return Score(i * int(d)); }
+inline Score operator* (const Score d, int i) {  return Score(int(d) * i); }
+inline Score operator- (const Score d) { return Score(-int(d)); }
+inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; }
+inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; }
+inline void operator*= (Score& d, int i) { d = Score(int(d) * i); }
+inline void operator/= (Score& d, int i) { d = Score(int(d) / i); }
+
+const Value PawnValueMidgame   = Value(0x0C6);
+const Value PawnValueEndgame   = Value(0x102);
+const Value KnightValueMidgame = Value(0x331);
+const Value KnightValueEndgame = Value(0x34E);
+const Value BishopValueMidgame = Value(0x344);
+const Value BishopValueEndgame = Value(0x359);
+const Value RookValueMidgame   = Value(0x4F6);
+const Value RookValueEndgame   = Value(0x4FE);
+const Value QueenValueMidgame  = Value(0x9D9);
+const Value QueenValueEndgame  = Value(0x9FE);
+
+inline Value value_mate_in(int ply) {
+  return VALUE_MATE - ply;
+}
+
+inline Value value_mated_in(int ply) {
+  return -VALUE_MATE + ply;
+}
+
+inline Piece make_piece(Color c, PieceType pt) {
+  return Piece((int(c) << 3) | int(pt));
+}
+
+inline PieceType type_of_piece(Piece p)  {
+  return PieceType(int(p) & 7);
+}
+
+inline Color color_of_piece(Piece p) {
+  return Color(int(p) >> 3);
+}
+
+inline Color opposite_color(Color c) {
+  return Color(int(c) ^ 1);
+}
+
+inline bool color_is_ok(Color c) {
+  return c == WHITE || c == BLACK;
+}
+
+inline bool piece_type_is_ok(PieceType pt) {
+  return pt >= PAWN && pt <= KING;
+}
+
+inline bool piece_is_ok(Piece p) {
+  return piece_type_is_ok(type_of_piece(p)) && color_is_ok(color_of_piece(p));
+}
+
+inline char piece_type_to_char(PieceType pt) {
+  static const char ch[] = " PNBRQK";
+  return ch[pt];
+}
+
+inline Square make_square(File f, Rank r) {
+  return Square((int(r) << 3) | int(f));
+}
+
+inline File square_file(Square s) {
+  return File(int(s) & 7);
+}
+
+inline Rank square_rank(Square s) {
+  return Rank(int(s) >> 3);
+}
+
+inline Square flip_square(Square s) {
+  return Square(int(s) ^ 56);
+}
+
+inline Square flop_square(Square s) {
+  return Square(int(s) ^ 7);
+}
+
+inline Square relative_square(Color c, Square s) {
+  return Square(int(s) ^ (int(c) * 56));
+}
+
+inline Rank relative_rank(Color c, Rank r) {
+  return Rank(int(r) ^ (int(c) * 7));
+}
+
+inline Rank relative_rank(Color c, Square s) {
+  return relative_rank(c, square_rank(s));
+}
+
+inline SquareColor square_color(Square s) {
+  return SquareColor(int(square_rank(s) + s) & 1);
+}
+
+inline bool opposite_color_squares(Square s1, Square s2) {
+  int s = int(s1) ^ int(s2);
+  return ((s >> 3) ^ s) & 1;
+}
+
+inline int file_distance(Square s1, Square s2) {
+  return abs(square_file(s1) - square_file(s2));
+}
+
+inline int rank_distance(Square s1, Square s2) {
+  return abs(square_rank(s1) - square_rank(s2));
+}
+
+inline int square_distance(Square s1, Square s2) {
+  return Max(file_distance(s1, s2), rank_distance(s1, s2));
+}
+
+inline File file_from_char(char c) {
+  return File(c - 'a') + FILE_A;
+}
+
+inline char file_to_char(File f) {
+  return char(f - FILE_A + int('a'));
+}
+
+inline Rank rank_from_char(char c) {
+  return Rank(c - '1') + RANK_1;
+}
+
+inline char rank_to_char(Rank r) {
+  return char(r - RANK_1 + int('1'));
+}
+
+inline const std::string square_to_string(Square s) {
+  char ch[] = { file_to_char(square_file(s)), rank_to_char(square_rank(s)), 0 };
+  return std::string(ch);
+}
+
+inline bool file_is_ok(File f) {
+  return f >= FILE_A && f <= FILE_H;
+}
+
+inline bool rank_is_ok(Rank r) {
+  return r >= RANK_1 && r <= RANK_8;
+}
+
+inline bool square_is_ok(Square s) {
+  return s >= SQ_A1 && s <= SQ_H8;
+}
+
+inline Square pawn_push(Color c) {
+  return c == WHITE ? DELTA_N : DELTA_S;
+}
 
 #endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,311 +17,231 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
+#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <string>
 
-#include "book.h"
 #include "evaluate.h"
 #include "misc.h"
 #include "move.h"
-#include "movegen.h"
 #include "position.h"
-#include "san.h"
 #include "search.h"
-#include "uci.h"
 #include "ucioption.h"
 
-
-////
-//// Local definitions:
-////
+using namespace std;
 
 namespace {
 
-  // UCIInputParser is a class for parsing UCI input.  The class
+  // FEN string for the initial position
+  const string StartPositionFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
+  // UCIParser is a class for parsing UCI input. The class
   // is actually a string stream built on a given input string.
+  typedef istringstream UCIParser;
 
-  typedef std::istringstream UCIInputParser;
-
-  // The root position.  This is set up when the user (or in practice, the GUI)
-  // sends the "position" UCI command.  The root position is sent to the think()
-  // function when the program receives the "go" command.
-  Position RootPosition;
-
-  // Local functions
-  void get_command();
-  void handle_command(const std::string &command);
-  void set_option(UCIInputParser &uip);
-  void set_position(UCIInputParser &uip);
-  void go(UCIInputParser &uip);
+  void set_option(UCIParser& up);
+  void set_position(Position& pos, UCIParser& up);
+  bool go(Position& pos, UCIParser& up);
+  void perft(Position& pos, UCIParser& up);
 }
 
 
-////
-//// Functions
-////
+/// execute_uci_command() takes a string as input, uses a UCIParser
+/// object to parse this text string as a UCI command, and calls
+/// the appropriate functions. In addition to the UCI commands,
+/// the function also supports a few debug commands.
 
-/// uci_main_loop() is the only global function in this file.  It is
-/// called immediately after the program has finished initializing.
-/// The program remains in this loop until it receives the "quit" UCI
-/// command.
+bool execute_uci_command(const string& cmd) {
 
-void uci_main_loop() {
+  static Position pos(StartPositionFEN, false, 0); // The root position
 
-  RootPosition.from_fen(StartPosition);
+  UCIParser up(cmd);
+  string token;
 
-  while (1)
-      get_command();
+  up >> token; // operator>>() skips any whitespace
+
+  if (token == "quit")
+      return false;
+
+  if (token == "go")
+      return go(pos, up);
+
+  if (token == "ucinewgame")
+      pos.from_fen(StartPositionFEN, false);
+
+  else if (token == "isready")
+      cout << "readyok" << endl;
+
+  else if (token == "position")
+      set_position(pos, up);
+
+  else if (token == "setoption")
+      set_option(up);
+
+  else if (token == "perft")
+      perft(pos, up);
+
+  else if (token == "d")
+      pos.print();
+
+  else if (token == "flip")
+      pos.flip();
+
+  else if (token == "eval")
+  {
+      read_evaluation_uci_options(pos.side_to_move());
+      cout << trace_evaluate(pos) << endl;
+  }
+
+  else if (token == "key")
+      cout << "key: " << hex     << pos.get_key()
+           << "\nmaterial key: " << pos.get_material_key()
+           << "\npawn key: "     << pos.get_pawn_key() << endl;
+
+  else if (token == "uci")
+      cout << "id name "     << engine_name()
+           << "\nid author " << engine_authors()
+           << "\n"           << Options.print_all()
+           << "\nuciok"      << endl;
+  else
+      cout << "Unknown command: " << cmd << endl;
+
+  return true;
 }
 
 
-////
-//// Local functions
-////
-
 namespace {
 
-  // get_command() waits for a command from the user, and passes
-  // this command to handle_command.  get_command also intercepts
-  // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Stockfish exits gracefully if the GUI dies
-  // unexpectedly.
+  // set_position() is called when engine receives the "position" UCI
+  // command. The function sets up the position described in the given
+  // fen string ("fen") or the starting position ("startpos") and then
+  // makes the moves given in the following move list ("moves").
 
-  void get_command() {
+  void set_position(Position& pos, UCIParser& up) {
 
-    std::string command;
+    string token, fen;
 
-    if (!std::getline(std::cin, command))
-        command = "quit";
-
-    handle_command(command);
-  }
-
-
-  // handle_command() takes a text string as input, uses a
-  // UCIInputParser object to parse this text string as a UCI command,
-  // and calls the appropriate functions.  In addition to the UCI
-  // commands, the function also supports a few debug commands.
-
-  void handle_command(const std::string &command) {
-
-    UCIInputParser uip(command);
-    std::string token;
-
-    uip >> token; // operator >> skips any whitespace
-
-    if (token == "quit")
-    {
-        OpeningBook.close();
-        stop_threads();
-        quit_eval();
-        exit(0);
-    }
-    else if (token == "uci")
-    {
-        std::cout << "id name " << engine_name() << std::endl
-                  << "id author Tord Romstad, Marco Costalba"
-                  << std::endl;
-        print_uci_options();
-        std::cout << "uciok" << std::endl;
-    }
-    else if (token == "ucinewgame")
-    {
-        TT.clear();
-        Position::init_piece_square_tables();
-        RootPosition.from_fen(StartPosition);
-    }
-    else if (token == "isready")
-        std::cout << "readyok" << std::endl;
-    else if (token == "position")
-        set_position(uip);
-    else if (token == "setoption")
-        set_option(uip);
-    else if (token == "go")
-        go(uip);
-
-    // The remaining commands are for debugging purposes only.
-    // Perhaps they should be removed later in order to reduce the
-    // size of the program binary.
-    else if (token == "d")
-        RootPosition.print();
-    else if (token == "flip")
-    {
-        Position p(RootPosition);
-        RootPosition.flipped_copy(p);
-    }
-    else if (token == "eval")
-    {
-        EvalInfo ei;
-        std::cout << "Incremental mg: " << RootPosition.mg_value()
-                  << std::endl;
-        std::cout << "Incremental eg: " << RootPosition.eg_value()
-                  << std::endl;
-        std::cout << "Full eval: "
-                  << evaluate(RootPosition, ei, 0)
-                  << std::endl;
-    }
-    else if (token == "key")
-    {
-        std::cout << "key: " << RootPosition.get_key()
-                  << " material key: " << RootPosition.get_material_key()
-                  << " pawn key: " << RootPosition.get_pawn_key()
-                  << std::endl;
-    }
-    else
-    {
-        std::cout << "Unknown command: " << command << std::endl;
-        while (!uip.eof())
-        {
-            uip >> token;
-            std::cout << token << std::endl;
-        }
-    }
-  }
-
-
-  // set_position() is called when Stockfish receives the "position" UCI
-  // command.  The input parameter is a UCIInputParser.  It is assumed
-  // that this parser has consumed the first token of the UCI command
-  // ("position"), and is ready to read the second token ("startpos"
-  // or "fen", if the input is well-formed).
-
-  void set_position(UCIInputParser &uip) {
-
-    std::string token;
-
-    uip >> token; // operator >> skips any whitespace
+    up >> token; // operator>>() skips any whitespace
 
     if (token == "startpos")
-        RootPosition.from_fen(StartPosition);
+    {
+        pos.from_fen(StartPositionFEN, false);
+        up >> token; // Consume "moves" token if any
+    }
     else if (token == "fen")
     {
-        std::string fen;
-        while (token != "moves" && !uip.eof())
-        {
-          uip >> token;
-          fen += token;
-          fen += ' ';
-        }
-        RootPosition.from_fen(fen);
-    }
+        while (up >> token && token != "moves")
+            fen += token + " ";
 
-    if (!uip.eof())
-    {
-        if (token != "moves")
-          uip >> token;
-        if (token == "moves")
-        {
-            Move move;
-            UndoInfo u;
-            while (!uip.eof())
-            {
-                uip >> token;
-                move = move_from_string(RootPosition, token);
-                RootPosition.do_move(move, u);
-                if (RootPosition.rule_50_counter() == 0)
-                    RootPosition.reset_game_ply();
-            }
-        }
+        pos.from_fen(fen, Options["UCI_Chess960"].value<bool>());
     }
+    else return;
+
+    // Parse move list (if any)
+    while (up >> token)
+        pos.do_setup_move(move_from_uci(pos, token));
   }
 
 
-  // set_option() is called when Stockfish receives the "setoption" UCI
-  // command.  The input parameter is a UCIInputParser.  It is assumed
-  // that this parser has consumed the first token of the UCI command
-  // ("setoption"), and is ready to read the second token ("name", if
-  // the input is well-formed).
+  // set_option() is called when engine receives the "setoption" UCI
+  // command. The function updates the corresponding UCI option ("name")
+  // to the given value ("value").
 
-  void set_option(UCIInputParser &uip) {
+  void set_option(UCIParser& up) {
 
-    std::string token, name;
+    string token, name;
+    string value = "true"; // UCI buttons don't have a "value" field
 
-    uip >> token;
-    if (token == "name")
-    {
-        uip >> name;
-        uip >> token;
-        while (!uip.eof() && token != "value")
-        {
-          name += (" " + token);
-          uip >> token;
-        }
-        if (token == "value")
-        {
-            std::getline(uip, token); // reads until end of line
-            set_option_value(name, token);
-        } else
-            push_button(name);
-    }
+    up >> token; // Consume "name" token
+    up >> name;  // Read option name
+
+    // Handle names with included spaces
+    while (up >> token && token != "value")
+        name += " " + token;
+
+    up >> value; // Read option value
+
+    // Handle values with included spaces
+    while (up >> token)
+        value += " " + token;
+
+    if (Options.find(name) != Options.end())
+        Options[name].set_value(value);
+    else
+        cout << "No such option: " << name << endl;
   }
 
 
-  // go() is called when Stockfish receives the "go" UCI command.  The
-  // input parameter is a UCIInputParser.  It is assumed that this
-  // parser has consumed the first token of the UCI command ("go"),
-  // and is ready to read the second token.  The function sets the
-  // thinking time and other parameters from the input string, and
-  // calls think() (defined in search.cpp) with the appropriate
-  // parameters.
+  // go() is called when engine receives the "go" UCI command. The
+  // function sets the thinking time and other parameters from the input
+  // string, and then calls think(). Returns false if a quit command
+  // is received while thinking, true otherwise.
 
-  void go(UCIInputParser &uip) {
+  bool go(Position& pos, UCIParser& up) {
 
-    std::string token;
+    string token;
+    SearchLimits limits;
+    Move searchMoves[MAX_MOVES], *cur = searchMoves;
+    int time[] = { 0, 0 }, inc[] = { 0, 0 };
 
-    int time[2] = {0, 0}, inc[2] = {0, 0};
-    int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
-    bool infinite = false, ponder = false;
-    Move searchMoves[500];
-
-    searchMoves[0] = MOVE_NONE;
-
-    while (!uip.eof())
+    while (up >> token)
     {
-        uip >> token;
-
         if (token == "infinite")
-            infinite = true;
+            limits.infinite = true;
         else if (token == "ponder")
-            ponder = true;
+            limits.ponder = true;
         else if (token == "wtime")
-            uip >> time[0];
+            up >> time[WHITE];
         else if (token == "btime")
-            uip >> time[1];
+            up >> time[BLACK];
         else if (token == "winc")
-            uip >> inc[0];
+            up >> inc[WHITE];
         else if (token == "binc")
-            uip >> inc[1];
+            up >> inc[BLACK];
         else if (token == "movestogo")
-            uip >> movesToGo;
+            up >> limits.movesToGo;
         else if (token == "depth")
-            uip >> depth;
+            up >> limits.maxDepth;
         else if (token == "nodes")
-            uip >> nodes;
+            up >> limits.maxNodes;
         else if (token == "movetime")
-            uip >> moveTime;
+            up >> limits.maxTime;
         else if (token == "searchmoves")
-        {
-            int numOfMoves = 0;
-            while (!uip.eof())
-            {
-                uip >> token;
-                searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
-            }
-            searchMoves[numOfMoves] = MOVE_NONE;
-        }
+            while (up >> token)
+                *cur++ = move_from_uci(pos, token);
     }
 
-    if (moveTime)
-        infinite = true;  // HACK
+    *cur = MOVE_NONE;
+    limits.time = time[pos.side_to_move()];
+    limits.increment = inc[pos.side_to_move()];
 
-    think(RootPosition, infinite, ponder, RootPosition.side_to_move(), time,
-          inc, movesToGo, depth, nodes, moveTime, searchMoves);
+    assert(pos.is_ok());
+
+    return think(pos, limits, searchMoves);
+  }
+
+
+  // perft() is called when engine receives the "perft" command.
+  // The function calls perft() passing the required search depth
+  // then prints counted leaf nodes and elapsed time.
+
+  void perft(Position& pos, UCIParser& up) {
+
+    int depth, time;
+    int64_t n;
+
+    if (!(up >> depth))
+        return;
+
+    time = get_system_time();
+
+    n = perft(pos, depth * ONE_PLY);
+
+    time = get_system_time() - time;
+
+    std::cout << "\nNodes " << n
+              << "\nTime (ms) " << time
+              << "\nNodes/second " << int(n / (time / 1000.0)) << std::endl;
   }
 }

src/uci.h

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

src/ucioption.cpp

@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
@@ -17,351 +17,154 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-////
-//// Includes
-////
-
-#include <cassert>
-#include <string>
+#include <cctype>
+#include <iostream>
 #include <sstream>
-#include <vector>
 
 #include "misc.h"
 #include "thread.h"
 #include "ucioption.h"
 
+using std::string;
+using std::cout;
+using std::endl;
 
-////
-//// Variables
-////
-
-bool Chess960 = false;
+OptionsMap Options; // Global object
 
 
-////
-//// Local definitions
-////
+// Our case insensitive less() function as required by UCI protocol
+bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {
 
-namespace {
+  int c1, c2;
+  size_t i = 0;
 
-  ///
-  /// Types
-  ///
-
-  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
-
-  typedef std::vector<std::string> ComboValues;
-
-  struct Option {
-
-    std::string name, defaultValue, currentValue;
-    OptionType type;
-    int minValue, maxValue;
-    ComboValues comboValues;
-
-    Option(const char* name, const char* defaultValue, OptionType = STRING);
-    Option(const char* name, bool defaultValue, OptionType = CHECK);
-    Option(const char* name, int defaultValue, int minValue, int maxValue);
-  };
-
-  typedef std::vector<Option> Options;
-
-  ///
-  /// Constants
-  ///
-
-  // load_defaults populates the options vector with the hard
-  // coded names and default values.
-
-  void load_defaults(Options& o) {
-
-    o.push_back(Option("Use Search Log", false));
-    o.push_back(Option("Search Log Filename", "SearchLog.txt"));
-    o.push_back(Option("Book File", "book.bin"));
-    o.push_back(Option("Mobility (Middle Game)", 100, 0, 200));
-    o.push_back(Option("Mobility (Endgame)", 100, 0, 200));
-    o.push_back(Option("Pawn Structure (Middle Game)", 100, 0, 200));
-    o.push_back(Option("Pawn Structure (Endgame)", 100, 0, 200));
-    o.push_back(Option("Passed Pawns (Middle Game)", 100, 0, 200));
-    o.push_back(Option("Passed Pawns (Endgame)", 100, 0, 200));
-    o.push_back(Option("Aggressiveness", 100, 0, 200));
-    o.push_back(Option("Cowardice", 100, 0, 200));
-    o.push_back(Option("King Safety Curve", "Quadratic", COMBO));
-
-       o.back().comboValues.push_back("Quadratic");
-       o.back().comboValues.push_back("Linear");  /*, "From File"*/
-
-    o.push_back(Option("King Safety Coefficient", 40, 1, 100));
-    o.push_back(Option("King Safety X Intercept", 0, 0, 20));
-    o.push_back(Option("King Safety Max Slope", 30, 10, 100));
-    o.push_back(Option("King Safety Max Value", 500, 100, 1000));
-    o.push_back(Option("Queen Contact Check Bonus", 4, 0, 8));
-    o.push_back(Option("Rook Contact Check Bonus", 2, 0, 4));
-    o.push_back(Option("Queen Check Bonus", 2, 0, 4));
-    o.push_back(Option("Rook Check Bonus", 1, 0, 4));
-    o.push_back(Option("Bishop Check Bonus", 1, 0, 4));
-    o.push_back(Option("Knight Check Bonus", 1, 0, 4));
-    o.push_back(Option("Discovered Check Bonus", 3, 0, 8));
-    o.push_back(Option("Mate Threat Bonus", 3, 0, 8));
-    o.push_back(Option("Check Extension (PV nodes)", 2, 0, 2));
-    o.push_back(Option("Check Extension (non-PV nodes)", 1, 0, 2));
-    o.push_back(Option("Single Reply Extension (PV nodes)", 2, 0, 2));
-    o.push_back(Option("Single Reply Extension (non-PV nodes)", 2, 0, 2));
-    o.push_back(Option("Mate Threat Extension (PV nodes)", 0, 0, 2));
-    o.push_back(Option("Mate Threat Extension (non-PV nodes)", 0, 0, 2));
-    o.push_back(Option("Pawn Push to 7th Extension (PV nodes)", 1, 0, 2));
-    o.push_back(Option("Pawn Push to 7th Extension (non-PV nodes)", 1, 0, 2));
-    o.push_back(Option("Passed Pawn Extension (PV nodes)", 1, 0, 2));
-    o.push_back(Option("Passed Pawn Extension (non-PV nodes)", 0, 0, 2));
-    o.push_back(Option("Pawn Endgame Extension (PV nodes)", 2, 0, 2));
-    o.push_back(Option("Pawn Endgame Extension (non-PV nodes)", 2, 0, 2));
-    o.push_back(Option("Full Depth Moves (PV nodes)", 14, 1, 100));
-    o.push_back(Option("Full Depth Moves (non-PV nodes)", 3, 1, 100));
-    o.push_back(Option("Threat Depth", 5, 0, 100));
-    o.push_back(Option("Selective Plies", 7, 0, 10));
-    o.push_back(Option("Futility Pruning (Main Search)", true));
-    o.push_back(Option("Futility Pruning (Quiescence Search)", true));
-    o.push_back(Option("Futility Margin 0", 50, 0, 1000));
-    o.push_back(Option("Futility Margin 1", 100, 0, 1000));
-    o.push_back(Option("Futility Margin 2", 300, 0, 1000));
-    o.push_back(Option("Maximum Razoring Depth", 3, 0, 4));
-    o.push_back(Option("Razoring Margin", 300, 150, 600));
-    o.push_back(Option("LSN filtering", false));
-    o.push_back(Option("LSN Time Margin (sec)", 4, 1, 10));
-    o.push_back(Option("LSN Value Margin", 200, 100, 600));
-    o.push_back(Option("Randomness", 0, 0, 10));
-    o.push_back(Option("Minimum Split Depth", 4, 4, 7));
-    o.push_back(Option("Maximum Number of Threads per Split Point", 5, 4, 8));
-    o.push_back(Option("Threads", 1, 1, 8));
-    o.push_back(Option("Hash", 32, 4, 4096));
-    o.push_back(Option("Clear Hash", false, BUTTON));
-    o.push_back(Option("Ponder", true));
-    o.push_back(Option("OwnBook", true));
-    o.push_back(Option("MultiPV", 1, 1, 500));
-    o.push_back(Option("UCI_ShowCurrLine", false));
-    o.push_back(Option("UCI_Chess960", false));
-  }
-
-  ///
-  /// Variables
-  ///
-
-  Options options;
-
-  // Local functions
-  Options::iterator option_with_name(const std::string& optionName);
-
-  // stringify converts a value of type T to a std::string
-  template<typename T>
-  std::string stringify(const T& v) {
-
-     std::ostringstream ss;
-     ss << v;
-     return ss.str();
-  }
-
-  // We want conversion from a bool value to be "true" or "false",
-  // not "1" or "0", so add a specialization for bool type.
-  template<>
-  std::string stringify<bool>(const bool& v) {
-
-    return v ? "true" : "false";
-  }
-
-  // get_option_value implements the various get_option_value_<type>
-  // functions defined later, because only the option value
-  // type changes a template seems a proper solution.
-
-  template<typename T>
-  T get_option_value(const std::string& optionName) {
-
-      T ret;
-      Options::iterator it = option_with_name(optionName);
-
-      if (it != options.end())
-      {
-          std::istringstream ss(it->currentValue);
-          ss >> ret;
-      }
-      return ret;
-  }
-
-  // Unfortunatly we need a specialization to convert "false" and "true"
-  // to proper bool values. The culprit is that we use a non standard way
-  // to store a bool value in a string, in particular we use "false" and
-  // "true" instead of "0" and "1" due to how UCI protocol works.
-
-  template<>
-  bool get_option_value<bool>(const std::string& optionName) {
-
-      Options::iterator it = option_with_name(optionName);
-
-      return it != options.end() && it->currentValue == "true";
-  }
-}
-
-////
-//// Functions
-////
-
-/// init_uci_options() initializes the UCI options.  Currently, the only
-/// thing this function does is to initialize the default value of the
-/// "Threads" parameter to the number of available CPU cores.
-
-void init_uci_options() {
-
-  load_defaults(options);
-
-  // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
-  // According to Ken Dail's tests, Glaurung plays much better with 7 than
-  // with 8 threads.  This is weird, but it is probably difficult to find out
-  // why before I have a 8-core computer to experiment with myself.
-  Options::iterator it = option_with_name("Threads");
-
-  assert(it != options.end());
-
-  it->defaultValue = stringify(Min(cpu_count(), 7));
-  it->currentValue = stringify(Min(cpu_count(), 7));
-
-  // Increase the minimum split depth when the number of CPUs is big.
-  // It would probably be better to let this depend on the number of threads
-  // instead.
-  if(cpu_count() > 4)
+  while (i < s1.size() && i < s2.size())
   {
-      it = option_with_name("Minimum Split Depth");
+      c1 = tolower(s1[i]);
+      c2 = tolower(s2[i++]);
 
-      assert(it != options.end());
-
-      it->defaultValue = "6";
-      it->currentValue = "6";
+      if (c1 != c2)
+          return c1 < c2;
   }
+  return s1.size() < s2.size();
 }
 
 
-/// print_uci_options() prints all the UCI options to the standard output,
-/// in the format defined by the UCI protocol.
+// stringify() converts a numeric value of type T to a std::string
+template<typename T>
+static string stringify(const T& v) {
 
-void print_uci_options() {
+  std::ostringstream ss;
+  ss << v;
+  return ss.str();
+}
 
-  static const char optionTypeName[][16] = {
-    "spin", "combo", "check", "string", "button"
-  };
 
-  for (Options::iterator it = options.begin(); it != options.end(); ++it)
+/// OptionsMap c'tor initializes the UCI options to their hard coded default
+/// values and initializes the default value of "Threads" and "Minimum Split Depth"
+/// parameters according to the number of CPU cores.
+
+OptionsMap::OptionsMap() {
+
+  OptionsMap& o = *this;
+
+  o["Use Search Log"] = UCIOption(false);
+  o["Search Log Filename"] = UCIOption("SearchLog.txt");
+  o["Book File"] = UCIOption("book.bin");
+  o["Best Book Move"] = UCIOption(false);
+  o["Mobility (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Mobility (Endgame)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Middle Game)"] = UCIOption(100, 0, 200);
+  o["Passed Pawns (Endgame)"] = UCIOption(100, 0, 200);
+  o["Space"] = UCIOption(100, 0, 200);
+  o["Aggressiveness"] = UCIOption(100, 0, 200);
+  o["Cowardice"] = UCIOption(100, 0, 200);
+  o["Minimum Split Depth"] = UCIOption(4, 4, 7);
+  o["Maximum Number of Threads per Split Point"] = UCIOption(5, 4, 8);
+  o["Threads"] = UCIOption(1, 1, MAX_THREADS);
+  o["Use Sleeping Threads"] = UCIOption(false);
+  o["Hash"] = UCIOption(32, 4, 8192);
+  o["Clear Hash"] = UCIOption(false, "button");
+  o["Ponder"] = UCIOption(true);
+  o["OwnBook"] = UCIOption(true);
+  o["MultiPV"] = UCIOption(1, 1, 500);
+  o["Skill Level"] = UCIOption(20, 0, 20);
+  o["Emergency Move Horizon"] = UCIOption(40, 0, 50);
+  o["Emergency Base Time"] = UCIOption(200, 0, 30000);
+  o["Emergency Move Time"] = UCIOption(70, 0, 5000);
+  o["Minimum Thinking Time"] = UCIOption(20, 0, 5000);
+  o["UCI_Chess960"] = UCIOption(false);
+  o["UCI_AnalyseMode"] = UCIOption(false);
+
+  // Set some SMP parameters accordingly to the detected CPU count
+  UCIOption& thr = o["Threads"];
+  UCIOption& msd = o["Minimum Split Depth"];
+
+  thr.defaultValue = thr.currentValue = stringify(cpu_count());
+
+  if (cpu_count() >= 8)
+      msd.defaultValue = msd.currentValue = stringify(7);
+}
+
+
+/// OptionsMap::print_all() returns a string with all the UCI options in chronological
+/// insertion order (the idx field) and in the format defined by the UCI protocol.
+
+string OptionsMap::print_all() const {
+
+  std::stringstream s;
+
+  for (size_t i = 0; i <= size(); i++)
+      for (OptionsMap::const_iterator it = begin(); it != end(); ++it)
+          if (it->second.idx == i)
+          {
+              const UCIOption& o = it->second;
+              s << "\noption name " << it->first << " type " << o.type;
+
+              if (o.type != "button")
+                  s << " default " << o.defaultValue;
+
+              if (o.type == "spin")
+                  s << " min " << o.minValue << " max " << o.maxValue;
+
+              break;
+          }
+  return s.str();
+}
+
+
+/// Option class c'tors
+
+UCIOption::UCIOption(const char* def) : type("string"), minValue(0), maxValue(0), idx(Options.size())
+{ defaultValue = currentValue = def; }
+
+UCIOption::UCIOption(bool def, string t) : type(t), minValue(0), maxValue(0), idx(Options.size())
+{ defaultValue = currentValue = (def ? "true" : "false"); }
+
+UCIOption::UCIOption(int def, int minv, int maxv) : type("spin"), minValue(minv), maxValue(maxv), idx(Options.size())
+{ defaultValue = currentValue = stringify(def); }
+
+
+/// set_value() updates currentValue of the Option object. Normally it's up to
+/// the GUI to check for option's limits, but we could receive the new value
+/// directly from the user by teminal window. So let's check the bounds anyway.
+
+void UCIOption::set_value(const string& v) {
+
+  assert(!type.empty());
+
+  if (v.empty())
+      return;
+
+  if ((type == "check" || type == "button") != (v == "true" || v == "false"))
+      return;
+
+  if (type == "spin")
   {
-      std::cout << "option name " << it->name
-                << " type "       << optionTypeName[it->type];
-
-      if (it->type != BUTTON)
-      {
-          std::cout << " default " << it->defaultValue;
-
-          if (it->type == SPIN)
-              std::cout << " min " << it->minValue
-                        << " max " << it->maxValue;
-
-          else if (it->type == COMBO)
-              for(ComboValues::iterator itc = it->comboValues.begin();
-                  itc != it->comboValues.end(); ++itc)
-                      std::cout << " var " << *itc;
-      }
-      std::cout << std::endl;
-  }
-}
-
-/// get_option_value_bool() returns the current value of a UCI parameter of
-/// type "check".
-
-bool get_option_value_bool(const std::string& optionName) {
-
-  return get_option_value<bool>(optionName);
-}
-
-
-/// get_option_value_int() returns the value of a UCI parameter as an integer.
-/// Normally, this function will be used for a parameter of type "spin", but
-/// it could also be used with a "combo" parameter, where all the available
-/// values are integers.
-
-int get_option_value_int(const std::string& optionName) {
-
-  return get_option_value<int>(optionName);
-}
-
-
-/// get_option_value_string() returns the current value of a UCI parameter as
-/// a string.  It is used with parameters of type "combo" and "string".
-
-const std::string get_option_value_string(const std::string& optionName) {
-
-   return get_option_value<std::string>(optionName);
-}
-
-
-/// button_was_pressed() tests whether a UCI parameter of type "button" has
-/// been selected since the last time the function was called.
-
-bool button_was_pressed(const std::string& buttonName) {
-
-  if (get_option_value<bool>(buttonName))
-  {
-    set_option_value(buttonName, "false");
-    return true;
+      int val = atoi(v.c_str());
+      if (val < minValue || val > maxValue)
+          return;
   }
 
-  return false;
-}
-
-
-/// set_option_value() inserts a new value for a UCI parameter.  Note that
-/// the function does not check that the new value is legal for the given
-/// parameter:  This is assumed to be the responsibility of the GUI.
-
-void set_option_value(const std::string& optionName,
-                      const std::string& newValue) {
-
-  Options::iterator it = option_with_name(optionName);
-
-  if (it != options.end())
-      it->currentValue = newValue;
-  else
-      std::cout << "No such option: " << optionName << std::endl;
-}
-
-
-/// push_button() is used to tell the engine that a UCI parameter of type
-/// "button" has been selected:
-
-void push_button(const std::string& buttonName) {
-
-  set_option_value(buttonName, "true");
-}
-
-
-namespace {
-
-    // Define constructors of Option class.
-
-    Option::Option(const char* nm, const char* def, OptionType t)
-    : name(nm), defaultValue(def), currentValue(def), type(t), minValue(0), maxValue(0) {}
-
-    Option::Option(const char* nm, bool def, OptionType t)
-    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(t), minValue(0), maxValue(0) {}
-
-    Option::Option(const char* nm, int def, int minv, int maxv)
-    : name(nm), defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), minValue(minv), maxValue(maxv) {}
-
-    // option_with_name() tries to find a UCI option with a given
-    // name.  It returns an iterator to the UCI option or to options.end(),
-    // depending on whether an option with the given name exists.
-
-    Options::iterator option_with_name(const std::string& optionName) {
-
-        for (Options::iterator it = options.begin(); it != options.end(); ++it)
-            if (it->name == optionName)
-                return it;
-
-        return options.end();
-    }
+  currentValue = v;
 }

src/ucioption.h

@@ -1,53 +1,85 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-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
 
-////
-//// Includes
-////
-
+#include <cassert>
+#include <cstdlib>
+#include <map>
 #include <string>
 
+class UCIOption {
+public:
+  UCIOption() {} // To be used in a std::map
+  UCIOption(const char* defaultValue);
+  UCIOption(bool defaultValue, std::string type = "check");
+  UCIOption(int defaultValue, int minValue, int maxValue);
 
-////
-//// Variables
-////
+  void set_value(const std::string& v);
+  template<typename T> T value() const;
 
-extern bool Chess960;
+private:
+  friend class OptionsMap;
+
+  std::string defaultValue, currentValue, type;
+  int minValue, maxValue;
+  size_t idx;
+};
 
 
-////
-//// Prototypes
-////
+/// Custom comparator because UCI options should not be case sensitive
+struct CaseInsensitiveLess {
+  bool operator() (const std::string&, const std::string&) const;
+};
 
-extern void init_uci_options();
-extern void print_uci_options();
-extern bool get_option_value_bool(const std::string &optionName);
-extern int get_option_value_int(const std::string &optionName);
-extern const std::string get_option_value_string(const std::string &optionName);
-extern bool button_was_pressed(const std::string &buttonName);
-extern void set_option_value(const std::string &optionName, 
-                             const std::string &newValue);
-extern void push_button(const std::string &buttonName);
 
+/// Our options container is actually a map with a customized c'tor
+class OptionsMap : public std::map<std::string, UCIOption, CaseInsensitiveLess> {
+public:
+  OptionsMap();
+  std::string print_all() const;
+};
+
+extern OptionsMap Options;
+
+
+/// Option::value() definition and specializations
+template<typename T>
+T UCIOption::value() const {
+
+  assert(type == "spin");
+  return T(atoi(currentValue.c_str()));
+}
+
+template<>
+inline std::string UCIOption::value<std::string>() const {
+
+  assert(type == "string");
+  return currentValue;
+}
+
+template<>
+inline bool UCIOption::value<bool>() const {
+
+  assert(type == "check" || type == "button");
+  return currentValue == "true";
+}
 
 #endif // !defined(UCIOPTION_H_INCLUDED)

src/value.cpp

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

src/value.h

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