opelly/Stockfish
1
0
Fork 0
mirror of https://github.com/opelly27/Stockfish.git synced 2026-05-20 12:07:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: opelly/Stockfish:sf_9
Branches Tags
opelly/Stockfish:master opelly/Stockfish:patch-1 opelly/Stockfish:cluster opelly/Stockfish:tools opelly/Stockfish:nnue-player-wip opelly/Stockfish:sf_2.3.1_base
opelly/Stockfish:stockfish-dev-20250213-fa6c30af opelly/Stockfish:sf_17 opelly/Stockfish:sf_16.1 opelly/Stockfish:stockfish-dev-20230629-68e1e9b3 opelly/Stockfish:sf_16 opelly/Stockfish:sf_15.1 opelly/Stockfish:sf_15 opelly/Stockfish:sf_14.1 opelly/Stockfish:sf_14 opelly/Stockfish:sf_13 opelly/Stockfish:sf_12 opelly/Stockfish:SF_NNUE opelly/Stockfish:SF_classical opelly/Stockfish:sf_11 opelly/Stockfish:sf_10 opelly/Stockfish:sf_9 opelly/Stockfish:sf_8 opelly/Stockfish:sf_7 opelly/Stockfish:sf_6 opelly/Stockfish:sf_0 opelly/Stockfish:sf_5 opelly/Stockfish:sf_dd opelly/Stockfish:sf_4 opelly/Stockfish:sf_3 opelly/Stockfish:sf_2.3.1 opelly/Stockfish:sf_2.3 opelly/Stockfish:sf_2.2.2 opelly/Stockfish:sf_2.2.1 opelly/Stockfish:sf_2.2 opelly/Stockfish:sf_2.1.1 opelly/Stockfish:sf_2.1 opelly/Stockfish:sf_2.0.1 opelly/Stockfish:sf_2.0 opelly/Stockfish:sf_1.9.1 opelly/Stockfish:sf_1.9 opelly/Stockfish:sf_1.8 opelly/Stockfish:sf_1.8_beta_2 opelly/Stockfish:sf_1.8_beta_1 opelly/Stockfish:sf_1.7.1 opelly/Stockfish:sf_1.7 opelly/Stockfish:sf_1.6.3 opelly/Stockfish:sf_1.6.2 opelly/Stockfish:sf_1.6.1 opelly/Stockfish:sf_1.6 opelly/Stockfish:sf_1.5.1 opelly/Stockfish:sf_1.5 opelly/Stockfish:sf_1.4 opelly/Stockfish:sf_1.3.1 opelly/Stockfish:sf_1.3 opelly/Stockfish:sf_1.3rc1 opelly/Stockfish:sf_1.2_optimistic opelly/Stockfish:sf_1.2 opelly/Stockfish:sf_1.1a opelly/Stockfish:sf_1.1 opelly/Stockfish:sf_1.01 opelly/Stockfish:sf_1.0
...
compare: opelly/Stockfish:sf_11
Branches Tags
opelly/Stockfish:master opelly/Stockfish:patch-1 opelly/Stockfish:cluster opelly/Stockfish:tools opelly/Stockfish:nnue-player-wip opelly/Stockfish:sf_2.3.1_base
opelly/Stockfish:stockfish-dev-20250213-fa6c30af opelly/Stockfish:sf_17 opelly/Stockfish:sf_16.1 opelly/Stockfish:stockfish-dev-20230629-68e1e9b3 opelly/Stockfish:sf_16 opelly/Stockfish:sf_15.1 opelly/Stockfish:sf_15 opelly/Stockfish:sf_14.1 opelly/Stockfish:sf_14 opelly/Stockfish:sf_13 opelly/Stockfish:sf_12 opelly/Stockfish:SF_NNUE opelly/Stockfish:SF_classical opelly/Stockfish:sf_11 opelly/Stockfish:sf_10 opelly/Stockfish:sf_9 opelly/Stockfish:sf_8 opelly/Stockfish:sf_7 opelly/Stockfish:sf_6 opelly/Stockfish:sf_0 opelly/Stockfish:sf_5 opelly/Stockfish:sf_dd opelly/Stockfish:sf_4 opelly/Stockfish:sf_3 opelly/Stockfish:sf_2.3.1 opelly/Stockfish:sf_2.3 opelly/Stockfish:sf_2.2.2 opelly/Stockfish:sf_2.2.1 opelly/Stockfish:sf_2.2 opelly/Stockfish:sf_2.1.1 opelly/Stockfish:sf_2.1 opelly/Stockfish:sf_2.0.1 opelly/Stockfish:sf_2.0 opelly/Stockfish:sf_1.9.1 opelly/Stockfish:sf_1.9 opelly/Stockfish:sf_1.8 opelly/Stockfish:sf_1.8_beta_2 opelly/Stockfish:sf_1.8_beta_1 opelly/Stockfish:sf_1.7.1 opelly/Stockfish:sf_1.7 opelly/Stockfish:sf_1.6.3 opelly/Stockfish:sf_1.6.2 opelly/Stockfish:sf_1.6.1 opelly/Stockfish:sf_1.6 opelly/Stockfish:sf_1.5.1 opelly/Stockfish:sf_1.5 opelly/Stockfish:sf_1.4 opelly/Stockfish:sf_1.3.1 opelly/Stockfish:sf_1.3 opelly/Stockfish:sf_1.3rc1 opelly/Stockfish:sf_1.2_optimistic opelly/Stockfish:sf_1.2 opelly/Stockfish:sf_1.1a opelly/Stockfish:sf_1.1 opelly/Stockfish:sf_1.01 opelly/Stockfish:sf_1.0

584 Commits
sf_9 ... sf_11

Author SHA1 Message Date
Stéphane Nicolet c3483fa9a7 Stockfish 11 
Official release version of Stockfish 11.

Bench: 5156767

-----------------------

It is our pleasure to release Stockfish 11 to our fans and supporters.

Downloads are freely available at http://stockfishchess.org/download/

This version 11 of Stockfish is 50 Elo stronger than the last version, and
150 Elo stronger than the version which famously lost a match to AlphaZero
two years ago. This makes Stockfish the strongest chess engine running on
your smartphone or normal desktop PC, and we estimate that on a modern four
cores CPU, Stockfish 11 could give 1:1000 time odds to the human chess champion
having classical time control, and be on par with him. More specific data,
including nice cumulative curves for the progression of Stockfish strength
over the last seven years, can be found on [our progression page][1], at
[Stefan Pohl site][2] or at [NextChessMove][3].

In October 2019 Stockfish has regained its crown in the TCEC competition,
beating in the superfinal of season 16 an evolution of the neural-network
engine Leela that had won the previous season. This clash of style between an
alpha-beta and an neural-network engine produced spectacular chess as always,
with Stockfish [emerging victorious this time][0].

Compared to Stockfish 10, we have made hundreds of improvements to the
[codebase][4], from the evaluation function (improvements in king attacks,
middlegame/endgame transitions, and many more) to the search algorithm (some
innovative coordination methods for the searching threads, better pruning of
unsound tactical lines, etc), and fixed a couple of bugs en passant.

Our testing framework [Fishtest][5] has also seen its share of improvements
to continue propelling Stockfish forward. Along with a lot of small enhancements,
Fishtest has switched to new SPRT bounds to increase the chance of catching Elo
gainers, along with a new testing book and the use of pentanomial statistics to
be more resource-efficient.

Overall the Stockfish project is an example of open-source at its best, as
its buzzing community of programmers sharing ideas and daily reviewing their
colleagues' patches proves to be an ideal form to develop innovative ideas for
chess programming, while the mathematical accuracy of the testing framework
allows us an unparalleled level of quality control for each patch we put in
the engine. If you wish, you too can help our ongoing efforts to keep improving
it, just [get involved][6] :-)

Stockfish is also special in that every chess fan, even if not a programmer,
[can easily help][7] the team to improve the engine by connecting their PC to
Fishtest and let it play some games in the background to test new patches.
Individual contributions vary from 1 to 32 cores, but this year Bojun Guo
made it a little bit special by plugging a whole data center during the whole
year: it was a vertiginous experience to see Fishtest spikes with 17466 cores
connected playing [25600 games/minute][8]. Thanks Guo!

The Stockfish team

[0]: <http://mytcecexperience.blogspot.com/2019/10/season-16-superfinal-games-91-100.html>
[1]: <https://github.com/glinscott/fishtest/wiki/Regression-Tests>
[2]: <https://www.sp-cc.de/index.htm>
[3]: <https://nextchessmove.com/dev-builds>
[4]: <https://github.com/official-stockfish/Stockfish>
[5]: <https://tests.stockfishchess.org/tests>
[6]: <https://stockfishchess.org/get-involved/>
[7]: <https://github.com/glinscott/fishtest/wiki>
[8]: <https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/lebEmG5vgng%5B1-25%5D>
 2020-01-18 01:44:37 +01:00
Stéphane Nicolet 446a3c2522 Update Readme.md for the compiler command 
No functional change
 2020-01-15 22:25:05 +01:00
Joost VandeVondele baf184e8d9 Tweak late move reductions at root 
More LMR at root, unless a fail low might happen.

passed STC:
 LLR: 2.94 (-2.94,2.94) {-1.00,3.00}
Total: 25428 W: 4960 L: 4789 D: 15679
Ptnml(0-2): 424, 2948, 5832, 3045, 460
http://tests.stockfishchess.org/tests/view/5e1c9afed12216a2857e6401

passed LTC:
 LLR: 2.94 (-2.94,2.94) {0.00,2.00}
Total: 187423 W: 24253 L: 23599 D: 139571
Ptnml(0-2): 1284, 17437, 55536, 18085, 1292
http://tests.stockfishchess.org/tests/view/5e1ceb9975be933c8fe635a3

Closes https://github.com/official-stockfish/Stockfish/pull/2493

Bench: 5156767
 2020-01-15 11:40:44 +01:00
Stefan Geschwentner 7150183d07 Tweak reductions for captures/promotions 
From the third move reduce captures and promotions more if remaining depth is low.

STC:
LLR: 2.94 (-2.94,2.94) {-1.00,3.00}
Total: 25218 W: 5008 L: 4837 D: 15373
Ptnml(0-2): 439, 2950, 5717, 3001, 499
http://tests.stockfishchess.org/tests/view/5e1b33abd12216a2857e6359

LTC:
LLR: 2.95 (-2.94,2.94) {0.00,2.00}
Total: 35491 W: 4760 L: 4524 D: 26207
Ptnml(0-2): 264, 3288, 10413, 3460, 294
http://tests.stockfishchess.org/tests/view/5e1b88d5d12216a2857e6385

Closes https://github.com/official-stockfish/Stockfish/pull/2488

Bench: 4979757
 2020-01-13 12:09:23 +01:00
Vizvezdenec 4901218d4c Tweak futility pruning constants 
Based on recent improvement of futility pruning by @locutus2 : we lower
the futility margin to apply it for more nodes but as a compensation
we also lower the history threshold to apply it to less nodes. Further
work in tweaking constants can always be done - numbers are guessed
"by hand" and are not results of some tuning, maybe there is some more
Elo to squeeze from this part of code.

Passed STC
LLR: 2.98 (-2.94,2.94) {-1.00,3.00}
Total: 15300 W: 3081 L: 2936 D: 9283
Ptnml(0-2): 260, 1816, 3382, 1900, 290
http://tests.stockfishchess.org/tests/view/5e18da3b27dab692fcf9a158

Passed LTC
LLR: 2.94 (-2.94,2.94) {0.00,2.00}
Total: 108670 W: 14509 L: 14070 D: 80091
Ptnml(0-2): 813, 10259, 31736, 10665, 831
http://tests.stockfishchess.org/tests/view/5e18fc9627dab692fcf9a180

Bench: 4643972
 2020-01-13 11:49:27 +01:00
xoto10 01dfdb95dc Fix previous patch in case of ponder 
No functional change
 2020-01-13 10:47:14 +01:00
xoto10 69204f0720 Smarter time management near stop limit 
This patch makes Stockfish search same depth again if > 60% of optimum time is
already used, instead of trying the next iteration. The idea is that the next
iteration will generally take about the same amount of time as has already been
used in total. When we are likely to begin the last iteration, as judged by total
time taken so far > 0.6 * optimum time, searching the last depth again instead of
increasing the depth still helps the other threads in lazy SMP and prepares better
move ordering for the next moves.

STC :
LLR: 2.95 (-2.94,2.94) {-1.00,3.00}
Total: 13436 W: 2695 L: 2558 D: 8183
Ptnml(0-2): 222, 1538, 3087, 1611, 253
https://tests.stockfishchess.org/tests/view/5e1618a761fe5f83a67dd964

LTC :
LLR: 2.94 (-2.94,2.94) {0.00,2.00}
Total: 32160 W: 4261 L: 4047 D: 23852
Ptnml(0-2): 211, 2988, 9448, 3135, 247
https://tests.stockfishchess.org/tests/view/5e162ca061fe5f83a67dd96d

The code was revised as suggested by @vondele for multithreading:

STC (8 threads):
LLR: 2.95 (-2.94,2.94) {0.00,2.00}
Total: 16640 W: 2049 L: 1885 D: 12706
Ptnml(0-2): 119, 1369, 5158, 1557, 108
https://tests.stockfishchess.org/tests/view/5e19826a2cc590e03c3c2f52

LTC (8 threads):
LLR: 2.95 (-2.94,2.94) {-1.00,3.00}
Total: 16536 W: 2758 L: 2629 D: 11149
Ptnml(0-2): 182, 1758, 4296, 1802, 224
https://tests.stockfishchess.org/tests/view/5e18b91a27dab692fcf9a140

Thanks to those discussing Stockfish lazy SMP on fishcooking which made me
try this, and to @vondele for suggestions and doing related tests.

See full discussion in the pull request thread:
https://github.com/official-stockfish/Stockfish/pull/2482

Bench: 4586187
 2020-01-12 22:37:24 +01:00
Stéphane Nicolet 9f800a2577 Show compiler info at startup 
This patch shows a description of the compiler used to compile Stockfish,
when starting from the console.

Usage:

```
./stockfish
compiler
```

Example of output:

```
Stockfish 120120 64 POPCNT by T. Romstad, M. Costalba, J. Kiiski, G. Linscott

Compiled by clang++ 9.0.0 on Apple
 __VERSION__ macro expands to: 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.38)
```

No functional change
 2020-01-12 11:54:15 +01:00
Joost VandeVondele 114ddb789b Update Elo estimates for terms in search 
This updates estimates from 1.5 year ago, and adds missing terms. All estimates
from tests run on fishtest at 10+0.1 (STC), 20000 games, error bars +- 3 Elo,
see the original message in the pull request for the full list of tests.
Noteworthy changes are step 7 (futility pruning) going from ~30 to ~50 Elo
and step 13 (pruning at shallow depth) going from ~170 to ~200 Elo.

Full list of tests: https://github.com/official-stockfish/Stockfish/pull/2401

@Rocky640 made the suggestion to look at time control dependence of these terms.
I picked two large terms (early futility pruning and singular extension), so with
small relative error. It turns out it is actually quite interesting (see figure 1).
Contrary to my expectation, the Elo gain for early futility pruning is pretty time
control sensitive, while singular extension gain is not.

Figure 1: TC dependence of two search terms
![elo_search_tc]( http://cassio.free.fr/divers/elo_search_tc.png )

Going back to the old measurement of futility pruning (30 Elo vs today 50 Elo),
the code is actually identical but the margins have changed. It seems like a nice
example of how connected terms in search really are, i.e. the value of early futility
pruning increased significantly due to changes elsewhere in search.

No functional change.
 2020-01-10 03:31:44 +01:00
protonspring 7f623206f4 Rewrite initialization of PseudoMoves 
This is a non-functional code style change. I believe master is a bit convoluted
here and propose this version for clarity.

No functional change
 2020-01-10 01:58:27 +01:00
Stéphane Nicolet 384bff4264 Assorted trivial cleanups January 2020 
Assorted trivial cleanups.

No functional change
 2020-01-09 21:57:21 +01:00
joergoster bae019b53e 50-moves rule improvement for transposition table 
User "adentong" reported recently of a game where Stockfish blundered a game
in a tournament because during a search there was an hash-table issue for
positions inside the tree very close to the 50-moves draw rule. This is part
of a problem which is commonly referred to as the Graph History Interaction (GHI),
and is difficult to solve in computer chess because storing the 50-moves counter
in the hash-table loses Elo in general.

Links:
Issue 2451    : https://github.com/official-stockfish/Stockfish/issues/2451
About the GHI : https://www.chessprogramming.org/Graph_History_Interaction

This patch tries to address the issue in this particular game and similar
reported games: it prevents that values from the transposition table are
getting used when the 50-move counter is close to reaching 100 (). The idea
is that in such cases values from previous searches, with a much lower 50-move
count, become less and less reliable.

More precisely, the heuristic we use in this patch is that we don't take the
transposition table cutoff  when we have reached a 45-moves limit, but let the
search continue doing its job. There is a possible slowdown involved, but it will
also help to find either a draw when it thought to be losing, or a way to avoid
the draw by 50-move rule. This heuristics probably will not fix all possible cases,
but seems to be working reasonably well in practice while not losing too much Elo.

Passed non-regression tests:
STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 274452 W: 59700 L: 60075 D: 154677
http://tests.stockfishchess.org/tests/view/5df546116932658fe9b451bf

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 95235 W: 15297 L: 15292 D: 64646
http://tests.stockfishchess.org/tests/view/5df69c926932658fe9b4520e

Closes https://github.com/official-stockfish/Stockfish/pull/2453

Bench: 4586187
 2020-01-09 19:48:47 +01:00
Alain SAVARD 09bef14c76 Update lists of authors and contributors 
Preparing for version 11 of Stockfish: update lists of authors,
contributors giving CPU time to the fishtest framework, etc.

No functional change
 2020-01-09 01:43:47 +01:00
lantonov 44f79bdf5a Tuned nullmove search 
Tuning was done with Bayesian optimisation and sequential use of gaussian process
regressor and gaussian process classifier. The latter is used in lieu of ordinal
categorical modelling. Details will be given in Fishcooking forum topic: https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/b3uhBBJcJG4

STC:
LLR: 2.96 (-2.94,2.94) {-1.00,3.00}
Total: 10248 W: 2361 L: 2233 D: 5654
Ptnml(0-2): 191, 1153, 2303, 1276, 194
http://tests.stockfishchess.org/tests/view/5e0ba4159d3fbe26f672d4e6

LTC:
LLR: 2.94 (-2.94,2.94) {0.00,2.00}
Total: 16003 W: 2648 L: 2458 D: 10897
Ptnml(0-2): 121, 1595, 4394, 1718, 153
http://tests.stockfishchess.org/tests/view/5e0bb8519d3fbe26f672d4fd

Closes https://github.com/official-stockfish/Stockfish/pull/2468

Bench 4747984
 2020-01-07 11:47:39 +01:00
Vizvezdenec de4e1cb88d Introduce king infiltration bonus 
Add king infiltration bonus to initiative calculation. Idea is somewhat similar
to outflanking - endgames are hard to win if each king is on it side of the board.
So this adds extra bonus for one of kings crossing the middle line.

STC
LLR: 2.94 (-2.94,2.94) {-1.00,3.00}
Total: 10533 W: 2372 L: 2242 D: 5919
Ptnml(0-2): 196, 1198, 2352, 1316, 202
http://tests.stockfishchess.org/tests/view/5e0e6fd1e97ea42ea89da9b3

LTC
LLR: 2.96 (-2.94,2.94) {0.00,2.00}
Total: 15074 W: 2563 L: 2381 D: 10130
Ptnml(0-2): 118, 1500, 4111, 1663, 129
http://tests.stockfishchess.org/tests/view/5e0e857ae97ea42ea89da9cc

Closes https://github.com/official-stockfish/Stockfish/pull/2471

Bench: 5146339
 2020-01-07 11:33:53 +01:00
Stefan Geschwentner 56d5504f65 Tweak futility pruning 
Exclude moves with a good history total from futility pruning. This adds
a condition for quiet futility pruning: history total has to be low.

STC:
LLR: 2.94 (-2.94,2.94) {-1.00,3.00}
Total: 20095 W: 4503 L: 4342 D: 11250
Ptnml(0-2): 362, 2380, 4422, 2486, 388
http://tests.stockfishchess.org/tests/view/5e0d7c5387585b1706b68370

LTC:
LLR: 2.94 (-2.94,2.94) {0.00,2.00}
Total: 53016 W: 8587 L: 8302 D: 36127
Ptnml(0-2): 353, 5397, 14751, 5545, 423
http://tests.stockfishchess.org/tests/view/5e0e30d062fb773bb7047e95

Closes https://github.com/official-stockfish/Stockfish/pull/2472

Bench: 5215200
 2020-01-07 11:18:50 +01:00
Alain SAVARD 83ecfa7c33 Use a faster implementation of Static Exchange Evaluation 
SEE (Static Exchange Evaluation) is a critical component, so we might
indulge some tricks to make it faster. Another pull request #2469 showed
some speedup by removing templates, this version uses Ronald de Man
(@syzygy1) SEE implementation which also unrolls the for loop by
suppressing the min_attacker() helper function and exits as soon as
the last swap is conclusive.

See Ronald de Man version there:
https://github.com/syzygy1/Cfish/blob/master/src/position.c

Patch testes against pull request #2469:
LLR: 2.95 (-2.94,2.94) {-1.00,3.00}
Total: 19365 W: 3771 L: 3634 D: 11960
Ptnml(0-2): 241, 1984, 5099, 2092, 255
http://tests.stockfishchess.org/tests/view/5e10eb135e5436dd91b27ba3

And since we are using new SPRT statistics, and that both pull requests
finished with less than 20000 games I also tested against master as
a speed-up:

LLR: 2.99 (-2.94,2.94) {-1.00,3.00}
Total: 18878 W: 3674 L: 3539 D: 11665
Ptnml(0-2): 193, 1999, 4966, 2019, 250
http://tests.stockfishchess.org/tests/view/5e10febf12ef906c8b388745

Non functional change
 2020-01-07 11:00:54 +01:00
ppigazzini 44f56e04e2 Update Readme.md 
Update fishtest server URL, fix a broken wiki link, fix a typo.
 2020-01-04 21:54:20 +01:00
xoto10 13f70d0392 Tune search constants 
STC failed red :
LLR: -2.95 (-2.94,2.94) [0.00,3.50]
Total: 41667 W: 9094 L: 9138 D: 23435
https://tests.stockfishchess.org/tests/view/5df7bb566932658fe9b45253

LTC failed yellow :
LLR: -2.96 (-2.94,2.94) [0.00,3.50]
Total: 113667 W: 18330 L: 18196 D: 77141
https://tests.stockfishchess.org/tests/view/5df562386932658fe9b451c7

VLTC turned green :
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 128630 W: 17747 L: 17273 D: 93610
https://tests.stockfishchess.org/tests/view/5df9054dcde01bf360ab78db

Bench 5180012
 2019-12-25 00:12:07 +01:00
Guenther Demetz b6482472a0 Refine improving-logic 
Don't rely on the assumption that we are improving after surviving a
check. Instead, compare with the static eval of 2 moves before.

STC
https://tests.stockfishchess.org/tests/view/5dedfd7f3cff9a249bb9e44d
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 38859 W: 8621 L: 8397 D: 21841

LTC
https://tests.stockfishchess.org/tests/view/5dee1b5a3cff9a249bb9e465
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 51130 W: 8308 L: 7996 D: 34826

Bench: 5371271
 2019-12-10 08:07:34 +01:00
lantonov 443787b0d1 Tuned razor and futility margins 
Tuning was done with Bayesian optimisation with the following parameters:
Acquisition function: Expected Improvement
alpha: 0.05
xi: 1e-4
TC: 60+0.6
Number of iterations: 100
Initial points: 5
Batch size: 20 games

STC
http://tests.stockfishchess.org/tests/view/5dee291e3cff9a249bb9e470
LLR: 2.97 (-2.94,2.94) [-1.50,4.50]
Total: 19586 W: 4382 L: 4214 D: 10990

LTC
http://tests.stockfishchess.org/tests/view/5dee4e273cff9a249bb9e473
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 38840 W: 6315 L: 6036 D: 26489

Bench: 5033242
 2019-12-10 01:10:19 +01:00
xoto10 3ef0c3c34a TrappedRook value and King positional tables 
Small tweak to increase the TrappedRook penalty. Nice idea by Alain Savard!

STC
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 36977 W: 8212 L: 7993 D: 20772
https://tests.stockfishchess.org/tests/view/5dee1c1e3cff9a249bb9e46d

LTC
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 36395 W: 6070 L: 5795 D: 24530
https://tests.stockfishchess.org/tests/view/5dee90153cff9a249bb9e479

Closes https://github.com/official-stockfish/Stockfish/pull/2447

Bench: 5176990

-------------------------

Comments by Alain Savard:

For the record, the idea was to run an experimental tuning with disabled
castling in the hope to get more hits on the TrappedRook and the king in
the c1- f1-f2-c2 area
http://tests.stockfishchess.org/tests/view/5dec57be51219d7befdc76e1

A first interpretation of that tuning was green STC (0, 4) and yellow LTC (0, 4):
http://tests.stockfishchess.org/tests/view/5ded04bc51219d7befdc773a
http://tests.stockfishchess.org/tests/view/5ded1e7a51219d7befdc7760

Thank you @xoto for trying this. Indeed, because the tuned Kc2 and Kf2 values
were quite different, it was a good idea to try something more neutral.
 2019-12-10 01:04:07 +01:00
Vizvezdenec 764b9adda6 Exclude blockers for king from mobility area 
This patch excludes blockers for king from mobility area. It was tried a couple
of times by now but now it passed. Performance is not enormously good but this
patch makes a lot of sence - blockers for king can't really move until king moves
(in most cases) so logic behind it is the same as behind excluding king square
from mobility area.

STC
http://tests.stockfishchess.org/tests/view/5dec388651219d7befdc76be
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 6155 W: 1428 L: 1300 D: 3427

LTC
http://tests.stockfishchess.org/tests/view/5dec4a3151219d7befdc76d3
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 120800 W: 19636 L: 19134 D: 82030

Bench: 5173081
 2019-12-09 00:38:16 +01:00
Vizvezdenec d00b2ec6bd Do last capture extensions for every single node 
This patch simplifies latest @MJZ1977 elo gainer. Seems like PvNode check in
condition of last capture extension is not needed. Note - even if this is a
simplification it actually causes this extension to be applied more often, thus
strengthening effect of @MJZ1977's patch.

passed STC
http://tests.stockfishchess.org/tests/view/5deb9a3eb7bdefd50db28d0e
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 80244 W: 17421 L: 17414 D: 45409

passed LTC
http://tests.stockfishchess.org/tests/view/5deba860b7bdefd50db28d11
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 21506 W: 3565 L: 3446 D: 14495

Bench: 5097036
 2019-12-09 00:32:37 +01:00
protonspring 78eeba29a2 Simplify pruning moves with negative SEE 
This patch simplifies pruning moves with negative SEE values.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 18847 W: 4211 L: 4084 D: 10552
http://tests.stockfishchess.org/tests/view/5de983f2caa7c610e4d1866e

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 25556 W: 4200 L: 4087 D: 17269
http://tests.stockfishchess.org/tests/view/5de99e21caa7c610e4d18676

Bench 5390930
 2019-12-09 00:27:12 +01:00
joergoster a6b5ba1b64 Fix output of PV lines with invalid scores #2439 
As reported on the forum it is possible, on very rare occasions, that we are
trying to print a PV line with an invalid previousScore, although this line
has a valid actual score. This patch fixes output of PV lines with invalid
scores in a MultiPV search. This is a follow-up patch to 8b15961 and makes
the fix finally complete.

The reason is the i <= pvIdx condition which probably is a leftover from the
times there was a special root search function. This check is no longer needed
today and prevents PV lines past the current one (current pvIdx) to be flagged
as updated even though they do have a valid score.

https://github.com/official-stockfish/Stockfish/commit/8b15961349e18a9ba113973c53f53913d0cd0fad
https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/PrnoDLvMvro

No functional change.
 2019-12-09 00:16:55 +01:00
xoto10 20484ccdd5 Tweak time management (failing eval) 
Adjust fallingEval with score change in last 5 iterations. FallingEval adjusts
the time used on a move depending on whether the position score is better or
worse than on the previous move. This change adds a dependency on the score
change in the last 5 iterations of the current search.

Tests with original code:
STC :
LLR: 2.97 (-2.94,2.94) [-1.50,4.50]
Total: 18728 W: 4170 L: 4005 D: 10553
https://tests.stockfishchess.org/tests/view/5de68a5bb407ee7bfda68a94

LTC :
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 180217 W: 29214 L: 28551 D: 122452
https://tests.stockfishchess.org/tests/view/5de690a4b407ee7bfda68a9a

Revised code using a simple array instead of a deque and different values
gave a slightly quicker pass at LTC. The merged patch now uses this:

STC :
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 18616 W: 4114 L: 3950 D: 10552
https://tests.stockfishchess.org/tests/view/5debb790b7bdefd50db28d14

LTC :
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 134151 W: 21729 L: 21191 D: 91231
https://tests.stockfishchess.org/tests/view/5debc13fb7bdefd50db28d19

No functional change
 2019-12-09 00:10:47 +01:00
Joost VandeVondele 0256416bb7 Remove unneeded & incorrect check. 
the removed line is not needed, since with the conditions on SE, eval
equals ttValue (except inCheck), which must be larger than beta if the second condition
is true.

The removed line is also incorrect as eval might be VALUE_NONE at this
location if inCheck. This removal addresses part of https://github.com/official-stockfish/Stockfish/pull/2406#issuecomment-552642608

No functional change.
 2019-12-09 00:05:25 +01:00
Stéphane Nicolet 6a6fc28551 The sudo tag is deprecated in Travis CI 
Reported by Christian Clauss. Thanks!

No functional change
 2019-12-09 00:00:34 +01:00
FauziAkram 97a0e4e817 UnblockedStorm tuned 
STC
http://tests.stockfishchess.org/tests/view/5de155980294ec4750cba9bd
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 60206 W: 13295 L: 12895 D: 34016

LTC
http://tests.stockfishchess.org/tests/view/5de22f6f0294ec4750cba9e7
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 182005 W: 29571 L: 28902 D: 123532

VLTC
http://tests.stockfishchess.org/tests/view/5de4adca5e868d334be516c1
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42101 W: 6068 L: 5978 D: 30055

Bench: 5122362
 2019-12-03 00:27:58 +01:00
Alain SAVARD f0047ce08e King proximity tweak for passed pawns 
Decrease slightly the penalty for opponent king distance to passed pawn.
Instead of 5:2 ratio (or 20:8) we now have 19:8

STC
http://tests.stockfishchess.org/tests/view/5de281b2727dc1d26718a673
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 28638 W: 6297 L: 6104 D: 16237

LTC
http://tests.stockfishchess.org/tests/view/5de2a2ff727dc1d26718a67b
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 59586 W: 9766 L: 9429 D: 40391

Where to go from here:
Further tests will try a similar tweak on the friendly king proximity penalty,
because recent experiments indicate that this penalty is quite sensitive,
but I wanted to try first on the larger term.

Closes https://github.com/official-stockfish/Stockfish/pull/2435

bench: 5258928

---------------

Increasing the penalty ratio to 21:8 was neutral.
http://tests.stockfishchess.org/tests/view/5de2814d727dc1d26718a671

Decreasing the penalty ratio a bit more to 9:4 seems less promising
http://tests.stockfishchess.org/tests/view/5de2f4c2727dc1d26718a691
http://tests.stockfishchess.org/tests/view/5de32ecc727dc1d26718a6b0
 2019-12-01 19:12:39 +01:00
Joost VandeVondele 54253bcce6 Extend bench to static evaluations 
this patch extends bench to print static evaluations.

./stockfish bench 16 1 1 filename eval

will now print the evaluations for all fens in the file.

This complements the various 'go' flavors for bench and might be useful for debugging and/or tuning.

No functional change.
 2019-11-28 10:39:02 +01:00
Vizvezdenec df340a839c Simplify king danger 
This patch is a cleanup/simplification of king flank defenders patch,
removing king flanks attacks linear dependance in kingdanger. Result
of experiments with quadratic kingflank defenders scaling. Rebased on
the latest master.

passed STC
http://tests.stockfishchess.org/tests/view/5ddc2b99e0b4af579302bacf
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 19660 W: 4309 L: 4184 D: 11167

passed LTC
http://tests.stockfishchess.org/tests/view/5ddc3168e0b4af579302bade
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 24362 W: 3974 L: 3859 D: 16529

Closes https://github.com/official-stockfish/Stockfish/pull/2428

bench 5742013
 2019-11-26 01:28:05 +01:00
Moez Jellouli 53125902e4 Extend last non-pawn captures 
Extend last non-pawn captures at principal variation nodes because
they are in general decisive moves with clear endgame result.

STC
http://tests.stockfishchess.org/tests/view/5ddafc86e75c0005326d2140
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 9892 W: 2238 L: 2099 D: 5555

LTC
http://tests.stockfishchess.org/tests/view/5ddb0401e75c0005326d2150
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 30369 W: 5013 L: 4756 D: 20600

Closes https://github.com/official-stockfish/Stockfish/pull/2425

Bench: 5059526
 2019-11-26 00:01:49 +01:00
31m059 87ed9facf1 King danger: retire attacked-by-bishop defense 
In a recent commit, "Introduce king flank defenders," a term was introduced
by Michael Chaly (@Vizvezdenec) to reduce king danger based on king defenders,
i.e., friendly attacks on our King Flank and Camp. This is a powerful idea
and broadly applicable to all of our pieces.

An earlier, but narrower, version of a similar idea was already coded into
king danger, with a term reducing king danger simply if we had a bishop and
king attacking the same square -- there is also a similar term for knights,
but roughly three times larger. I had attempted to tweak this term's coefficient
fairly recently, in a series of tests in early September which increased this
coefficient.  All failed STC with significantly negative scores.

Now that the king flank defenders term has been introduced, it appears that
the bishop-defense term can be simplified away without compensation or
significant Elo loss.

Where do we go from here? This PR is a natural follow-up to "Introduce king
flank defenders," which proposed simplification with existing and overlapping
terms, such as this one.  That PR also mentioned that the coefficient it
introduced appeared arbitrary, so perhaps this PR can facilitate a tweak to
increase king flank defenders' coefficient.

Additionally, this pull request is extremely similar to https://github.com/official-stockfish/Stockfish/pull/1821,
which was (coincidentally) merged a year ago, to the day (November 23, 2018).
That patch also simplified away a linear king danger tropism term, which was
soon after replaced with a quadratic term by @Vizvezdenec (which would not have
passed without the simplification).  @Vizvezdenec, again by coincidence, has
recently been trying to implement a quadratic term, this time for defenders
rather than attackers.  This history of this evaluation code suggests that
this simplification might be enough to help a patch for quadratic king-flank
defenders pass.

Bench: 4959670

STC:
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 22209 W: 4920 L: 4800 D: 12489
https://tests.stockfishchess.org/tests/view/5dd444d914339111b9b6bed7

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 152107 W: 24658 L: 24743 D: 102706
https://tests.stockfishchess.org/tests/view/5dd4be31f531e81cf278ea9d

Interesting discussion on Github about this pull request:
https://github.com/official-stockfish/Stockfish/pull/2424

---

This pull request was opened less than one week before the holiday of
Thanksgiving here in the United States.  In keeping with the holiday
tradition of expressing gratitude, I would like to thank our generous
CPU donors, talented forum contributors, innovative developers, speedy
fishtest approvers, and especially our hardworking server maintainers
(@ppigazzini and @tomtor). Thank you all for a year of great Stockfish
progress!
 2019-11-24 00:34:43 +01:00
SFisGOD 1fdf1f1ff5 Simplify endgame factor for opposite colored bishops 
Stockfish is continually improving. Patches that gain elo in the past may
no longer be needed as stockfish improved elsewhere. This patch removes
passed pawns count dependence in opposite colored bishops scale factor.
We used the mean of passed count pawns (~1.4) to compensate, and changed
the base value from 16 to 22.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 57879 W: 12657 L: 12607 D: 32615
http://tests.stockfishchess.org/tests/view/5dd1644f42928ff08153dc1e

Passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 121648 W: 19622 L: 19659 D: 82367
http://tests.stockfishchess.org/tests/view/5dd24572ccb823d41d4b47bb

Closes https://github.com/official-stockfish/Stockfish/pull/2419

Bench: 5067864
 2019-11-24 00:23:06 +01:00
Vizvezdenec 3f4191392c Do lmr for more captures 
Based on machinery introduced by vondele. Logic behind patch if relatively simple -
if we reduce less with high hit rate of transposition table somewhat logical is to
reduce more with low hit rate. For example enable all captures for LMR.

Threshold 0.375 is arbitrary and can be tweaked :)

STC
http://tests.stockfishchess.org/tests/view/5dd4d51df531e81cf278eaac
LLR: 2.97 (-2.94,2.94) [-1.50,4.50]
Total: 16495 W: 3591 L: 3434 D: 9470

LTC
http://tests.stockfishchess.org/tests/view/5dd52265f531e81cf278eace
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 23598 W: 3956 L: 3716 D: 15926

Closes https://github.com/official-stockfish/Stockfish/pull/2420

Bench: 5067870
 2019-11-21 09:52:13 +01:00
Alain SAVARD 37698b0396 Outpost Endgame values 
Remove the recent rank based Outpost array by using a weighted average value
computed using a frequency analysis by rank from a large set of middle game
positions.

The higher eg values introduced by the new Outpost array (which were about
twice the previous masters) are thus preserved.

STC
http://tests.stockfishchess.org/tests/view/5dd05c870ebc5902579e1f7f
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 42466 W: 9232 L: 9151 D: 24083

LTC
http://tests.stockfishchess.org/tests/view/5dd146e342928ff08153dab1
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 66968 W: 10921 L: 10873 D: 45174

Closes https://github.com/official-stockfish/Stockfish/pull/2418

Bench: 5103360
 2019-11-21 09:32:19 +01:00
Vizvezdenec e0f42aa956 Simplify advanced pawn push pruning 
This patch simplifies away all conditions related to advanced pawn pushes
in shallow depth pruning. Idea is based on fact that in master we have
advanced pawn pushes not being pruned what we are only in PV node and
when non-pawn material of opponent is > Bishop, so pretty rarely. With
this patch we will have all pruning heuristics working for this moves as
for every other move.

STC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 159143 W: 34271 L: 34418 D: 90454
http://tests.stockfishchess.org/tests/view/5dcdb3110ebc5902563249d7

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 63900 W: 10375 L: 10322 D: 43203
http://tests.stockfishchess.org/tests/view/5dd05e820ebc5902579e1fb8

Closes https://github.com/official-stockfish/Stockfish/pull/2416

bench 4897149
 2019-11-19 23:18:14 +01:00
Joost VandeVondele fe124896b2 Use exploration rate for reductions 
This patch measures how frequently search is exploring new configurations.
This is done be computing a running average of ttHit. The ttHitAverage rate
is somewhat low (e.g. 30% for startpos) in the normal case, while it can be
very high if no progress is made (e.g. 90% for the fortress I used for testing).

This information can be used to influence search. In this patch, by adjusting
reductions if the rate > 50%. A first version (using a low ttHitAverageResolution
and this 50% threshold) passed  testing:

STC
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 26425 W: 5837 L: 5650 D: 14938
http://tests.stockfishchess.org/tests/view/5dcede8b0ebc5902563258fa

LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 32313 W: 5392 L: 5128 D: 21793
http://tests.stockfishchess.org/tests/view/5dcefb1f0ebc590256325c0e

However, as discussed in pull request 2414, using a larger ttHitAverageResolution
gives a better approximation of the underlying distributions. This needs a slight
adjustment for the threshold as the new distributions are shifted a bit compared
to the older ones, and this threshold seemingly is sensitive (we used 0.53125 here).
https://github.com/official-stockfish/Stockfish/pull/2414

This final version also passed testing, and is used for the patch:

STC
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 16025 W: 3555 L: 3399 D: 9071
http://tests.stockfishchess.org/tests/view/5dd070b90ebc5902579e20c2

LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 37576 W: 6277 L: 5998 D: 25301
http://tests.stockfishchess.org/tests/view/5dd0f58e6f544e798086f224

Closes https://github.com/official-stockfish/Stockfish/pull/2414

Bench: 4989584
 2019-11-18 09:57:53 +01:00
Vizvezdenec 3468138210 Introduce king flank defenders 
This patch implements what we have been trying for quite some time -
dependance of kingdanger on balance of attackers and defenders of king
flank, to avoid overestimate attacking power if the opponent has enough
defenders of king position. We already have some form of it in bishop
and knight defenders - this is further work in this direction.

What to do based on this?

1) constant 4 is arbitrary, maybe it is not optimal
2) maybe we can use quadratic formula as in kingflankattack
3) simplification into alrealy existing terms is always a possibility :)
4) overall kingdanger tuning always can be done.

passed STC:
http://tests.stockfishchess.org/tests/view/5dcf40560ebc590256325f30
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 26298 W: 5819 L: 5632 D: 14847

passed LTC:
http://tests.stockfishchess.org/tests/view/5dcfa5760ebc590256326464
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 30600 W: 5042 L: 4784 D: 20774

Closes https://github.com/official-stockfish/Stockfish/pull/2415

Bench: 4496847
 2019-11-16 17:29:53 +01:00
Stefan Geschwentner a00a336946 Prune before extension 
Switch execution order in search: do move pruning before extension detection.

STC:
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 5762 W: 1307 L: 1181 D: 3274
http://tests.stockfishchess.org/tests/view/5dcc56e90ebc59025bcbb833

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 72956 W: 11959 L: 11585 D: 49412
http://tests.stockfishchess.org/tests/view/5dcc62840ebc59025bcbb96f

Closes https://github.com/official-stockfish/Stockfish/pull/2413

Bench: 4532366
 2019-11-14 20:26:15 +01:00
SFisGOD a131975170 Rank-based outposts 
Introduce OutpostRank[RANK_NB] which contains a bonus according to
the rank of the outpost. We use it for the primary Outpost bonus.
The values are based on the trends of the SPSA tuning run with some
manual tweaks.

Passed STC:
LLR: 2.96 (-2.94,2.94) [-1.50,4.50]
Total: 27454 W: 6059 L: 5869 D: 15526
http://tests.stockfishchess.org/tests/view/5dcadba20ebc590256922f09

Passed LTC:
LLR: 2.94 (-2.94,2.94) [0.00,3.50]
Total: 57950 W: 9443 L: 9112 D: 39395
http://tests.stockfishchess.org/tests/view/5dcaea880ebc5902569230bc

Bench: 4778405

----------------------------

The inspiration for this patch came from Stefan Geschwentner's attempt
of modifying BishopPawns into a rank-based penalty. Michael Stembera
suggested that maybe the S(0, 0) ranks (3rd, 7th and also maybe 8th)
can still be tuned. This would expand our definition of Outpost and
OutpostRanks would be removed altogether. Special thanks to Mark Tenzer
for all the help and excellent suggestions.
 2019-11-13 11:01:00 +01:00
Miguel Lahoz 9ab2590963 Shallow depth pruning on NonPV advanced pawn push 
Usually advanced pawn pushes are not considered in shallow depth pruning
because it is risky to do so with possible promotions near the horizon.
However, this heuristic is not also beneficial on NonPV nodes since we
can afford to take slightly more risk on less important nodes.

STC:
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 54530 W: 11955 L: 11686 D: 30889
http://tests.stockfishchess.org/tests/view/5dc7dda30ebc5902ea57efd0

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 77336 W: 12786 L: 12399 D: 52151
http://tests.stockfishchess.org/tests/view/5dc8050d0ebc5902ea57f491

Closes https://github.com/official-stockfish/Stockfish/pull/2408

Bench: 4422068
 2019-11-12 01:36:06 +01:00
Joost VandeVondele 44b6697f19 Remove explicit moveCount pruning 
The removed lines approximately duplicate equivalent logic in the movePicker.
Adjust the futility_move_count to componsate for some difference
(the movePicker prunes one iteration of the move loop later).

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 8114 W: 1810 L: 1663 D: 4641
http://tests.stockfishchess.org/tests/view/5dc6afe60ebc5902562bd318

Passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 89956 W: 14473 L: 14460 D: 61023
http://tests.stockfishchess.org/tests/view/5dc6bdcf0ebc5902562bd3c0

Closes https://github.com/official-stockfish/Stockfish/pull/2407

Bench: 4256440

---------------------

How to continue from there?

It would be interesting to see if we can extract some Elo gain
from the new futility_move_count formula, for instance by somehow
incorporating the final -1 in the 5 constant, or adding a linear
term to the quadratics...

```
   futility_move_count = (5 + depth * depth) * (1 + improving) / 2 - 1
```
 2019-11-12 01:27:06 +01:00
Alain SAVARD 9b8b259388 Sequencing tweak in tbprobe() 
Followup of "issue" #2372, which was in fact a small speed-up
proposal by user @d3vv for the probing code of tablebases.

See comments on this issue where it was proven by Alin Savard that the
proposed change is more efficient on average than master on all type of
sequences it will usually be called.

Note that on gcc 4.3, this will produce a bogus warning which was solved
with ulterior gcc versions: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43949

Closes https://github.com/official-stockfish/Stockfish/issues/2372
Closes https://github.com/official-stockfish/Stockfish/pull/2379

Non functional change
 2019-11-12 01:18:54 +01:00
Joost VandeVondele 5ae195ee7e Fix incorrect mate score. 
Current master 648c7ec25d will generate an
incorrect mate score for:

```
setoption name Hash value 8
setoption name Threads value 1
position fen 8/1p2KP2/1p4q1/1Pp5/2P5/N1Pp1k2/3P4/1N6 b - - 76 40
go depth 49
```
even though the position is a draw. Generally, SF tries to display only
proven mate scores, so this is a bug.

This was posted http://www.talkchess.com/forum3/viewtopic.php?f=2&t=72166
by Uri Blass, with the correct analysis that this must be related to the
50 moves draw rule being ignored somewhere.

Indeed, this is possible as positions and there eval are stored in the TT,
without reference to the 50mr counter. Depending on the search path followed
a position can thus be mate or draw in the TT (GHI or Graph history interaction).
Therefore, to prove mate lines, the TT content has to be used with care. Rather
than ignoring TT content in general or for mate scores (which impact search or
mate finding), it is possible to be more selective. In particular, @WOnder93
suggested to only ignore the TT if the 50mr draw ply is closer than the mate
ply. This patch implements this idea, by clamping the eval in the TT to
+-VALUE_MATED_IN_MAX_PLY. This retains the TTmove, but causes a research of
these lines (with the current 50mr counter) as needed.

This patch hardly ever affects search (as indicated by the unchanged
bench), but fixes the testcase. As the conditions are very specific,
also mate finding will almost never be less efficient (testing welcome).

It was also shown to pass STC and LTC non-regression testing, in a form
using if/then/else instead of ternary operators:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 93605 W: 15346 L: 15340 D: 62919
http://tests.stockfishchess.org/tests/view/5db45bb00ebc5908127538d4

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 33873 W: 7359 L: 7261 D: 19253
http://tests.stockfishchess.org/tests/view/5db4c8940ebc5902d6b146fc

closes https://github.com/official-stockfish/Stockfish/issues/2370

Bench: 4362323
 2019-11-12 01:09:57 +01:00
Stéphane Nicolet 9f312c80d9 Revert "Rook PSQT Tuned" 
This reverts the previous commit. The PSQT changes in this previous
commit originated from tests against quite an old version of master
which did not include the other PSQT changes of 474d133 for the other
pieces, and there might be some unknown interactions between the PSQT
tables. So we made a non-regression test of the last commit against the
last-but-one commit. This test failed, leading to the revert decision.

Failed non-regression test:
LLR: -2.96 (-2.94,2.94) [-3.00,1.00]
Total: 95536 W: 15047 L: 15347 D: 65142
http://tests.stockfishchess.org/tests/view/5dc0ba1d0ebc5904493b0112

Closes https://github.com/official-stockfish/Stockfish/pull/2395

Bench: 4362323
 2019-11-06 11:07:38 +01:00
SFisGOD 3804effb34 Rook PSQT Tuned 
This patch uses about half the changes of the SPSA tuning run:
http://tests.stockfishchess.org/tests/view/5dba93d30ebc5925b64ed3bf

About a month ago, xoto10's patch raised the mg value of the third rank
center files from -1 to 7 to encourage rook lifts to the third rank. About
three days later, Rocky's patch lowered this value from 7 to 3. This patch
raises that again from 3 to 12 and ends up greater than the original rook
lift patch.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 104094 W: 22573 L: 22161 D: 59360
http://tests.stockfishchess.org/tests/view/5dbc77f20ebc5925b64ef1d0

Passed LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 168291 W: 27410 L: 26777 D: 114104
http://tests.stockfishchess.org/tests/view/5dbd9f1e0ebc5925b64f0647

Bench: 4707799
 2019-11-05 00:15:23 +01:00
MichaelB7 ef38046e73 Remove shuffle extension 
It was noted in an earlier patch that all of the positions below needed the
Shuffle Detection idea to be solved:

3r4/p3r1pk/PpBb1pRp/1KpPpP1P/2P1P1R1/8/8/8 b - - 32 86
8/8/8/1k6/2p5/p1K5/N2B2r1/8 b - - 59 109
1r4k1/1r1bq3/4p1p1/3pPpPp/pNpN1P1P/P1PnQ3/1PK5/1R3R2 b - - 13 82
5k2/3b4/5p2/p1p1pPp1/PpPpP1Pp/1P1P3P/8/3R1K2 w - - 20 1

But Stockfish has envolved a bit since the Shuffle Detection patch introduction,
and this patch proves Stockfish is able to solves these drawn positions without it,
even on single core without EGTB.

Passed STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 14231 W: 3114 L: 2978 D: 8139
http://tests.stockfishchess.org/tests/view/5dbe1a610ebc5925b64f09d9

Passed LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42781 W: 6917 L: 6831 D: 29033
http://tests.stockfishchess.org/tests/view/5dbe24c20ebc5925b64f0a7a

Passed VLTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 32556 W: 4573 L: 4469 D: 23514
http://tests.stockfishchess.org/tests/view/5dbec3830ebc5925b64f11aa

Closes https://github.com/official-stockfish/Stockfish/pull/2394

Bench: 4362323

----------------------------

Example of search by Michael Byrne for the FEN position:
q1B5/1P1q4/8/8/8/6R1/8/1K1k4 w - - 0 1

This position is win for white and the only moves that wins is Rg1 - all other moves
either draw or lose. With single core and 1024M hash, it is solved without shuffle
detection in 38 seconds on my machine (with no EGTB). This was the position that was
locked in a loop in the initial shuffle detection patch!

```
dep	score	nodes	time	(not shown:  tbhits	knps	seldep)
 50	+1.71 	298.9M	2:43.63	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Qe5+ Kb1 Qe4+ Ka2 Qd5+ Rb3 Qd2+ Ka3 Qc1+ Kb4 Qc7 Ka4 Qb8 Rb6 Ke5 Kb3 Qg8+ Kb4 Qf8+ Ka5 Qb8 Bb3 Kd4 Kb4 Qf8+ Ka4 Qb8 Ka5 K
<snip>
 49	+1.68 	288.5M	2:38.35	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Qe5+ Kb1 Qe4+ Ka2 Qd5+ Rb3 Qd2+ Ka3 Qc1+ Kb4 Qc7 Ka4 Qb8 Rb6 Ke5 Kb3 Qg8+ Kb4 Qf8+ Ka5 Qb8 Bb3 Kd4 Kb4 Ke3 Be6 Ke4 Bc4 Ke
<snip>
 48	+1.78 	228.5M	2:01.93	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Qe5+ Kb1 Qe4+ Ka2 Qd5+ Rb3 Qd2+ Ka3 Qa5+ Kb2 Qe5+ Ka2 Qb8 Rb5 Ke3 Kb1 Ke4 Bb3 Kf4 Be6 Ke3 Rb4 Kd3 Kb2 Ke3 Bd5 Qe5+ Kc2 Qh
<snip>
 46	+1.49 	198.4M	1:44.89	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Qe5+ Kb1 Qe4+ Ka2 Qd5+ Rb3 Qd2+ Ka3 Qc1+ Kb4 Qc7 Ka4 Qb8 Rb6 Qe8+ Rb5 Qb8 Bc2 Qa7+ Kb3 Qe3+ Kc4 Qe6+ Kb4 Qd6+ Kb3 Qb8 Rb4
<snip>
 45	+1.45 	154.5M	1:20.75	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke3 Bg2 Kd4 Rb5 Kc4 Bf1+ Kd4 Kb2 Qh2+ Kb3 Qg3+ Ka4 Qb8 Be2 Ke3 Bc4 Kf4 Kb4 Qd6+ Kc3 Qb8 Kc2 Ke4 Be6 Qh2+ Kb3 Qg3+ Ka4 Qb8 Bb3 Kd4 Bd5 Ke3
<snip>
 44	+1.36 	141.9M	1:14.40	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Qd6 Rc2+ Kd3 Be2+ Ke3 Rb2 Qb8 Bd1 Ke4 Rb5 Kd4 Bf3 Kc4 Be2+ Kc3 Rb6 Kd2 Bc4 Kc3 Bd5 Kd4 Bg2 Ke5 Kb2 Kd4 Rb5 Kc4 Bf1+ Kd4 Be2 Ke4 Bc4 Qh2+ Kb3 Qg3+ Ka4 Qb8 Bd5+ Kd4 Be6 Ke4
<snip>
 43	+1.36 	134.1M	1:10.46	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Qd6 Rc2+ Kd3 Be2+ Ke3 Rb2 Qb8 Bd1 Ke4 Rb5 Kd4 Bf3 Kc4 Be2+ Kc3 Rb6 Kd2 Bc4 Kc3 Be6 Kd4 Rb5 Kc3 Bf7 Kd4 Kb2 Ke4 Kb3 Kf4 Kc3 Ke4 Kb2 Qh2+ Kb3 Qg3+ Ka4 Qb8 Rb4+ Ke5 Rb6 Kf4
<snip>
 42	+1.36 	118.7M	1:01.60	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Qd6 Rc2+ Kd3 Be2+ Ke3 Rb2 Qb8 Bd1 Ke4 Rb5 Kd4 Bf3 Kc4 Be2+ Kc3 Rb6 Kd2 Bc4 Kc3 Be6 Kd4 Rb5 Kc3 Bf7 Kd4 Kb2 Ke4 Bc4 Qh2+ Kb3 Qg3+ Ka4 Qb8 Bd5+ Kd4 Bb3 Qa7+ Kb4 Qb8 Bc4 Ke4
<snip>
 41	+1.38 	110.3M	0:56.80	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Qd6 Rc2+ Kd3 Be2+ Ke3 Rb2 Qb8 Bd1 Ke4 Rb5 Kd4 Bf3 Kc4 Be2+ Kc3 Rb6 Kd2 Bc4 Kc3 Be6 Kd4 Rb5 Kc3 Bd5 Kd4 Ba2 Ke4 Be6 Kd4 Kb2 Qh2+ Kb3 Qb8 Bc4 Ke3 Kc3 Qh8+ Kb4 Qb2+ Ka4 Qa1+
 <snip>
 39	+1.25 	87.3M  	0:44.48	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Kg5 Kb1 Kf5 Bb3 Ke5 Kb2 Kd4 Rb5 Qh2+ Bc2 Qb8 Bd1 Kc4 Be2+ Kd4 Kc2 Ke3 Bd1 Kd4 Kb3 Qg3+ Ka4 Qb8 Bb3 Kc3 Rb6 Kd4 Kb5 Ke5 K
 38	+1.25 	82.0M  	0:41.90	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kd4 Rb5 Kc4 Be2+ Kc3 Rb6 Kd4 Bf3 Ke5 Kb2 Kf4 Bd1 Kg5 Kb1 Kf5 Bb3 Ke5 Kb2 Kd4 Rb5 Qh2+ Bc2 Qb8 Kb3 Qg3+ Ka4 Qb8 Bb3 Kc3 Rb6 Kd4 Kb5 Ke5 Kb4 Kd4 Be6 Kd3 Bd5 Kd4 Bf3 Ke5 Be
<snip>
 37	+0.13 	79.3M  	0:40.44	Rg1+ Kd2 Rg2+ Kc3 Rc2+ Kb3 Rb2+ Kc3 Bxd7 Qf8 Ba4 Qb8 Bd1 Kc4 Bf3 Kd4 Rb5 Kc4 Rb6 Kd4 Rb2 Ke5 Rb3 Kd6 Rb5 Ke6 Rb4 Kd6 Kc2 Kc5 Kb3 Kd6 Be4 Ke7 Kc3 Qc7+ Kd3 Qg3+ Kc2 Qf2+ Kb3 Qe3+ Ka2 Qa7+ Kb2 Qb8 Kb3 Kd6 Bf3 Qg8+ Ka3 Kc7 b8=R Qx
 37	+0.67!	78.3M  	0:39.90	Rg1+!
 37	+0.47!	77.0M  	0:39.18	Rg1+!
 37	+0.32!	76.8M  	0:39.11	Rg1+!
 37	+0.23!	76.8M  	0:39.07	Rg1+!
 36	+0.57!	76.1M  	0:38.72	Rg1+!
 36	+0.37!	75.8M  	0:38.59	Rg1+!
 36	+0.23!	75.7M  	0:38.51	Rg1+!
 36	+0.13!	75.6M  	0:38.49	Rg1+!
 35	+0.03?	58.0M  	0:29.84	bxa8=Q Qb5+?
```
 2019-11-05 00:01:49 +01:00
31m059 cff9a8672c Make Square and Bitboard operators commutative 
As Stockfish developers, we aim to make our code as legible and as close
to simple English as possible. However, one of the more notable exceptions
to this rule concerns operations between Squares and Bitboards.

Prior to this pull request, AND, OR, and XOR were only defined when the
Bitboard was the first operand, and the Square the second. For example,
for a Bitboard b and Square s, "b & s" would be valid but "s & b" would not.
This conflicts with natural reasoning about logical operators, both
mathematically and intuitively, which says that logical operators should
commute.

More dangerously, however, both Square and Bitboard are defined as integers
"under the hood." As a result, code like "s & b" would still compile and give
reasonable bench values. This trap occasionally ensnares even experienced
Stockfish developers, but it is especially dangerous for new developers not
aware of this peculiarity. Because there is no compilation or runtime error,
and a reasonable bench, only a close review by approvers can spot this error
when a test has been submitted--and many times, these bugs have slipped past
review. This is by far the most common logical error on Fishtest, and has
wasted uncountable STC games over the years.

However, it can be fixed by adding three non-functional lines of code. In this
patch, we define the operators when the operands are provided in the opposite
order, i.e., we make AND, OR, and XOR commutative for Bitboards and Squares.
Because these are inline methods and implemented identically, the executable
does not change at all.

This patch has the small side-effect of requiring Squares to be explicitly
cast to integers before AND, OR, or XOR with integers. This is only performed
twice in Stockfish's source code, and again does not change the executable at
all (since Square is an enum defined as an integer anyway).

For demonstration purposes, this pull request also inverts the order of one AND
and one OR, to show that neither the bench nor the executable change. (This
change can be removed before merging, if preferred.)

I hope that this pull request significantly lowers the barrier-of-entry for new
developer to join the Stockfish project. I also hope that this change will improve
our efficiency in using our generous CPU donors' machines, since it will remove
one of the most common causes of buggy tests.

Following helpful review and comments by Michael Stembera (@mstembera), we add
a further clean-up by implementing OR for two Squares, to anticipate additional
traps developers may encounter and handle them cleanly.

Closes https://github.com/official-stockfish/Stockfish/pull/2387

No functional change.
 2019-11-04 23:50:14 +01:00
SFisGOD 474d133565 Combo of Parameter Tweaks 
This patch is a combo of the following tweaks:

Complexity parameters
Knight PSQT
Bishop PSQT
King PSQT
Piece Values

Passed STC:
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 56527 W: 12326 L: 12052 D: 32149
http://tests.stockfishchess.org/tests/view/5dbbca3f0ebc5925b64ee6d6

Passed LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 64010 W: 10549 L: 10199 D: 43262
http://tests.stockfishchess.org/tests/view/5dbc30dc0ebc5925b64eee0c

Closes https://github.com/official-stockfish/Stockfish/pull/2390

Bench: 4312945
 2019-11-02 21:19:35 +01:00
protonspring e8fca71342 Simplify kingRing 
Simplify the king ring initialization and make it more regular, by just
moving the king square off the edges and using PseudoAttacks by king from
this new square.

There is a small functional difference from the previous master, as the
old master excludes the original ksq square while this patch always includes
the nine squares block (after moving the king from the edges). Additionally,
master does not adjust the kingRing down if we are on relative rank 8,
while this patch treats all of the edges the same.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 13263 W: 2968 L: 2830 D: 7465
http://tests.stockfishchess.org/tests/view/5db872830ebc5902d1f388aa

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 72996 W: 11819 L: 11780 D: 49397
http://tests.stockfishchess.org/tests/view/5db899c20ebc5902d1f38b5e

Closes https://github.com/official-stockfish/Stockfish/pull/2384

Bench: 4959244
 2019-10-31 17:47:23 +01:00
protonspring 6f3796adaf Consolidate pawn_push and up 
This is a non-functional simplification. Pawn_push and Up are redundant.
If we make up pawn_push, we can use it for all of the Up's and Down's.
In this version, I've also left the Up and Down constants so that there
is no worse readability.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23878 W: 5202 L: 5085 D: 13591
http://tests.stockfishchess.org/tests/view/5db5569a0ebc5902d6b14de4

Closes https://github.com/official-stockfish/Stockfish/pull/2378

No functional change
 2019-10-31 17:22:09 +01:00
Stefan Geschwentner 1725ed39ad Tweak dynamic contempt (the birthday patch) 
Make dynamic contempt weight factor dependent on static contempt so that higher
static contempt implies less dynamic contempt and vice versa. For default contempt
24 this is a non-functional change. But tests with contempt 0 shows an elo gain.
Also today is my birthday so i have already give to myself a gift with this patch :-)!

Further proceedings:

in the past we checked for default contempt that it doesn't regress against
contempt 0. Now that the later is stronger and the former is the same strength
this should be rechecked. Perhaps the default contempt have to be lowered.
It would be interesting to get some idea of the impact of this patch outside
of the 0-24 contempt range.

STC: (both with contempt=0)
LLR: 2.95 (-2.94,2.94) [-1.50,4.50]
Total: 21912 W: 3898 L: 3740 D: 14274
http://tests.stockfishchess.org/tests/view/5db74b6f0ebc5902d1f37405

LTC: (both with contempt=0)
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 27172 W: 3350 L: 3126 D: 20696
http://tests.stockfishchess.org/tests/view/5db760020ebc5902d1f375d0

Closes https://github.com/official-stockfish/Stockfish/pull/2382

No functional change (for current default contempt 24).
 2019-10-31 17:05:29 +01:00
Joost VandeVondele 648c7ec25d Refactor final stats updates. 
This PR refactors update_quiet_stats, update_capture_stats and search to more clearly reflect what is actually done.

Effectively, all stat updates that need to be done after search is finished and a bestmove is found,
are collected in a new function ```final_stats_update()```. This shortens our main search routine, and simplifies ```update_quiet_stats```.
The latter function is now more easily reusable with fewer arguments, as the handling of ```quietsSearched``` is only needed in ```final_stats_update```.
```update_capture_stats```, which was only called once is now integrated in ```final_stats_update```, which allows for removing a branch and reusing some ```stat_bonus``` calls. The need for refactoring was also suggested by the fact that the comments of ```update_quiet_stats``` and ```update_capture_stats``` were incorrect (e.g. ```update_capture_stats``` was called, correctly, also when the bestmove was a quiet and not a capture).

passed non-regression STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 75196 W: 16364 L: 16347 D: 42485
http://tests.stockfishchess.org/tests/view/5db004ec0ebc5902c06db9e1

The diff is most easily readable as ```git diff master --patience```

No functional change
 2019-10-26 01:10:55 +02:00
Stéphane Nicolet 90c0385724 Assorted trivial cleanups 
- Cleanups by Alain
- Group king attacks and king defenses
- Signature of futility_move_count()
- Use is_discovery_check_on_king()
- Simplify backward definition
- Use static asserts in move generator
- Factor a statement in move generator

No functional change
 2019-10-26 00:29:12 +02:00
Joost VandeVondele 7e89a71624 Simplify reductions on singular extension 
Current master employs a scheme to adjust reductions on singular
nodes that is somewhat controversial, see
https://github.com/official-stockfish/Stockfish/pull/2167

This patch removes this use of a search result outside of [a,b],
by observing that the main effect of this code is to adjust the
reduction by an average of ~2 (1.7) rather than 1.

Claims the first blue at STC and LTC:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 30142 W: 6547 L: 6442 D: 17153
http://tests.stockfishchess.org/tests/view/5daf16c40ebc5902c06da566

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 45715 W: 7380 L: 7298 D: 31037
http://tests.stockfishchess.org/tests/view/5daf2f3c0ebc5902c06da6c7

Closes https://github.com/official-stockfish/Stockfish/pull/2367

Bench: 5115841
 2019-10-23 10:49:08 +02:00
Joost VandeVondele 215cd19108 Avoid crashing on Log File opening 
Stockfish crashes immediately if users enter a wrong file name (or even an existing
folder name) for debug log file. It may be hard for users to find out since it prints
nothing. If they enter the string via a chess GUI, the chess GUI may remember and
auto-send to Stockfish next time, makes Stockfish crashes all the time. Bug report by
Nguyen Hong Pham in this issue: https://github.com/official-stockfish/Stockfish/issues/2365

This patch avoids the crash and instead prefers to exit gracefully with a error
message on std:cerr, like we do with the fenFile for instance.

Closes https://github.com/official-stockfish/Stockfish/pull/2366

No functional change.
 2019-10-22 00:02:46 +02:00
xoto10 12d58adc68 Remove uithread 
With the current questions and issues around threading, I had a look at
https://github.com/official-stockfish/Stockfish/issues/2299.

It seems there was a problem with data races when requesting eval via UCI while
a search was already running. To fix this an extra thread uithread was created,
presumably to avoid an overlap with Threads.main() that was causing problems.
Making this eval request seems to be outside the scope of UCI, and @vondele also
reports that the data race is not even fixed reliably by this change. I suggest
we simplify the threading here by removing this uithread and adding a comment
signaling that user should not request eval when a search is already running.

Closes https://github.com/official-stockfish/Stockfish/pull/2310

No functional change.
 2019-10-20 00:27:17 +02:00
VoyagerOne 472de897cb Current capture for Counter-Move history 
Use current capture to index the CMH table instead of prior capture.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 61908 W: 13626 L: 13220 D: 35062
http://tests.stockfishchess.org/tests/view/5da8aa670ebc597ba8eda558

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 49057 W: 8071 L: 7765 D: 33221
http://tests.stockfishchess.org/tests/view/5da8e99d0ebc597ba8eda9ca

Closes https://github.com/official-stockfish/Stockfish/pull/2362

Bench: 4423737
 2019-10-18 17:05:23 +02:00
Joost VandeVondele b8e5092d07 Add four positions to bench 
The current bench is missing a position with high 50 moves rule counter,
making most 'shuffle' tests based on 50mr > N seem non-functional.
This patch adds one FEN with high 50mr counter to address this issue
(taken from a recent tcec game).

Four new FENs:
- position with high 50mr counter
- tactical position with many captures, checks, extensions, fails high/low
- two losses by Stockfish in the S16 bonus games against Houdini

See the pull request for nice comments by @Alayan-stk-2 about each position
in bench: https://github.com/official-stockfish/Stockfish/pull/2338

Bench: 4590210
 2019-10-17 15:03:30 +02:00
VoyagerOne 80d59eea39 Introduce separate counter-move tables for inCheck 
Enhance counter-move history table by adding a inCheck dimension. This doubles
the size of the table but provides more accurate move ordering.

STC: (yellow)
LLR: -2.94 (-2.94,2.94) [0.50,4.50]
Total: 36217 W: 7790 L: 7777 D: 20650
http://tests.stockfishchess.org/tests/view/5d9b9a290ebc5902b6d04fe0

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 36665 W: 6063 L: 5788 D: 24814
http://tests.stockfishchess.org/tests/view/5d9b9fcc0ebc5902b6d05985

Closes https://github.com/official-stockfish/Stockfish/pull/2353

Bench: 4053577
 2019-10-09 15:22:16 +09:00
31m059 23a022980b No reachable outpost bonus for bishops 
Previously, we used various control statements and ternary operators to divide
Outpost into four bonuses, based on whether the outpost was for a knight or
bishop, and whether it was currently an Outpost or merely a potential ("reachable")
one in the future. Bishop outposts, however, have traditionally been worth far
less Elo in testing. An attempt to remove them altogether passed STC, but failed LTC.

Here we include a narrower simplification, removing the reachable Outpost bonus
for bishops. This bonus was always suspect, given that its current implementation
conflicts directly with BishopPawns. BishopPawns penalizes our bishops based on the
number of friendly pawns on the same color of square, but by definition, Outposts
must be pawn-protected! This PR helps to alleviate this conceptual contradiction
without loss of Elo and with slightly simpler code.

On a code level, this allows us to simplify a ternary operator into the previous
"if" block and distribute a multiplication into an existing constant Score. On a
conceptual level, we retire one of the four traditional Outpost bonuses.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 22277 W: 4882 L: 4762 D: 12633
http://tests.stockfishchess.org/tests/view/5d9aeed60ebc5902b6cf9751

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 51206 W: 8353 L: 8280 D: 34573
http://tests.stockfishchess.org/tests/view/5d9af1940ebc5902b6cf9cd5

Closes https://github.com/official-stockfish/Stockfish/pull/2352

Bench: 3941591
 2019-10-09 14:17:52 +09:00
Alayan 0150da5c2b Adjust aspiration window with eval 
This patch changes the base aspiration window size depending on the absolute
value of the previous iteration score, increasing it away from zero. This
stems from the observation that the further away from zero, the more likely
the  evaluation is to change significantly with more depth. Conversely, a
tighter aspiration window is more efficient when close to zero.

A beneficial side-effect is that analysis of won positions without a quick
mate is less prone to waste nodes in repeated fail-high that change the eval
by tiny steps.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 60102 W: 13327 L: 12868 D: 33907
http://tests.stockfishchess.org/tests/view/5d9a70d40ebc5902b6cf39ba

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 155553 W: 25745 L: 25141 D: 104667
http://tests.stockfishchess.org/tests/view/5d9a7ca30ebc5902b6cf4028

Future work : the values used in this patch were only a reasonable guess.
Further testing should unveil more optimal values. However, the aspiration
window is rather tight with a minimum of 21 internal units, so discrete
integers put a practical limitation to such tweaking.

More exotic experiments around the aspiration window parameters could also
be tried, but efficient conditions to adjust the base aspiration window size
or allow it to not be centered on the current evaluation are not obvious.

The aspiration window increases after a fail-high or a fail-low is another
avenue to explore for potential enhancements.

Bench: 4043748
 2019-10-07 22:30:04 +02:00
SFisGOD 0b0b21c608 Tweak kingFlankAttacks factor in kingDanger 
Increase kingFlankAttacks factor in kingDanger from 5/16 to 6/16.

Failed STC:
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 77947 W: 16989 L: 16848 D: 44110
http://tests.stockfishchess.org/tests/view/5d9ac0280ebc5902b6cf63cd

Passed LTC 1:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 13443 W: 2231 L: 2037 D: 9175
http://tests.stockfishchess.org/tests/view/5d9ac88d0ebc5902b6cf6ffb

Passed LTC 2:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 23340 W: 3842 L: 3617 D: 15881
http://tests.stockfishchess.org/tests/view/5d9acf7f0ebc5902b6cf7c27

Closes https://github.com/official-stockfish/Stockfish/pull/2349

Bench: 4042155
 2019-10-07 11:14:33 +02:00
Alain SAVARD 7264540107 Adjust pawn span 
Run as a simplification

a) insures that pawn attacks are always included in the pawn span
  (this "fixes" the case where some outpost or reachable outpost
  bonus were awarded on squares controlled by enemy pawns).

b) compute the full span only if not "backward" or not "blocked".

By looking at "blocked" instead of "opposed", we get a nice simpli-
fication and the "new" outpost detection is almost identical, except
a few borderline cases on rank 4.

passed STC
http://tests.stockfishchess.org/tests/view/5d9950730ebc5902b6cefb90
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 79113 W: 17168 L: 17159 D: 44786

passed LTC
http://tests.stockfishchess.org/tests/view/5d99d14e0ebc5902b6cf0692
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 41286 W: 6819 L: 6731 D: 27736

See https://github.com/official-stockfish/Stockfish/pull/2348

bench: 3812891
 2019-10-07 00:50:54 +02:00
Ondrej Mosnacek c78f8ddd86 Make priorCapture a bool 
It is always used as a bool, so let's make it a bool straight away.
We can always redefine it as a Piece in a later patch if we want
to use the piece type or the piece color.

No functional change.
 2019-10-06 23:05:30 +02:00
VoyagerOne 2e96c513ad Introduce separate counter-move tables for captures 
Enhance counter-move history table by adding a capture/no-capture dimension,
depending wether the previous move was a quiet move or a capture. This doubles
the size of the table but provides more accurate move ordering.

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 79702 W: 17720 L: 17164 D: 44818
http://tests.stockfishchess.org/tests/view/5d97945e0ebc590c21aa724b

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 29147 W: 4907 L: 4651 D: 19589
http://tests.stockfishchess.org/tests/view/5d97ccb90ebc590c21aa7bc0

Closes https://github.com/official-stockfish/Stockfish/pull/2344

Bench: 4131643
 2019-10-06 02:04:19 +02:00
Brian Sheppard ca7d4e9ac7 Eliminate ONE_PLY 
Simplification that eliminates ONE_PLY, based on a suggestion in the forum that
support for fractional plies has never been used, and @mcostalba's openness to
the idea of eliminating it. We lose a little bit of type safety by making Depth
an integer, but in return we simplify the code in search.cpp quite significantly.

No functional change

------------------------------------------

The argument favoring eliminating ONE_PLY:

* The term “ONE_PLY” comes up in a lot of forum posts (474 to date)
https://groups.google.com/forum/?fromgroups=#!searchin/fishcooking/ONE_PLY%7Csort:relevance

* There is occasionally a commit that breaks invariance of the code
with respect to ONE_PLY
https://groups.google.com/forum/?fromgroups=#!searchin/fishcooking/ONE_PLY%7Csort:date/fishcooking/ZIPdYj6k0fk/KdNGcPWeBgAJ

* To prevent such commits, there is a Travis CI hack that doubles ONE_PLY
and rechecks bench

* Sustaining ONE_PLY has, alas, not resulted in any improvements to the
  engine, despite many individuals testing many experiments over 5 years.

The strongest argument in favor of preserving ONE_PLY comes from @locutus:
“If we use par example ONE_PLY=256 the parameter space is increases by the
factor 256. So it seems very unlikely that the optimal setting is in the
subspace of ONE_PLY=1.”

There is a strong theoretical impediment to fractional depth systems: the
transposition table uses depth to determine when a stored result is good
enough to supply an answer for a current search. If you have fractional
depths, then different pathways to the position can be at fractionally
different depths.

In the end, there are three separate times when a proposal to remove ONE_PLY
was defeated by the suggestion to “give it a few more months.” So… it seems
like time to remove this distraction from the community.

See the pull request here:
https://github.com/official-stockfish/Stockfish/pull/2289
 2019-10-06 00:57:00 +02:00
Stéphane Nicolet 328bdd0947 Fix compare function in previous patch 
Bench: 4012371
 2019-10-05 11:15:24 +02:00
mstembera 5d1568632c Remove temporary shelter array 
Remove temporary array of shelters and avoid iterating over it each time to find
if the shelter values after castling are better than the current value.
Work done on top of https://github.com/official-stockfish/Stockfish/pull/2277

Speed benchmark did not measure any difference.

No functional change
 2019-10-05 10:45:37 +02:00
Moez Jellouli e6f4b5f463 More accurate pawn attack span definition 
Tweak the pawn attack span for backward pawns and the zone behind
opponent opposing pawns. This is important in positional play and
one of weaknesses of the engine in recent high level games.

STC
LLR: -2.95 (-2.94,2.94) [0.50,4.50]
Total: 66843 W: 14884 L: 14717 D: 37242
http://tests.stockfishchess.org/tests/view/5d8dcb1b0ebc590f3beb2956

LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 77699 W: 12993 L: 12602 D: 52104
http://tests.stockfishchess.org/tests/view/5d8de9bc0ebc590f3beb3d00

See discussion in https://github.com/official-stockfish/Stockfish/pull/2332

Bench: 4012371
 2019-10-02 13:37:00 +02:00
Joost VandeVondele 005ad170c1 Adjust reductions based on the number of threads 
In lazySMP it makes sense to prune a little more, as multiple threads
search wider. We thus increase the prefactor of the reductions slowly
as a function of the threads. The prefactor of the log(threads) term
is a parameter, this pull request uses 1/2 after testing.

passed STC @ 8threads:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 118125 W: 23151 L: 22462 D: 72512
http://tests.stockfishchess.org/tests/view/5d8bbf4d0ebc59509180f217

passed LTC @ 8threads:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 67546 W: 10630 L: 10279 D: 46637
http://tests.stockfishchess.org/tests/view/5d8c463b0ebc5950918167e8

passed ~LTC @ 14threads:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 74271 W: 12421 L: 12040 D: 49810
http://tests.stockfishchess.org/tests/view/5d8db1f50ebc590f3beb24ef

Note:
A larger prefactor (1) passed similar tests at STC and LTC (8 threads),
while a very large one (2) passed STC quickly but failed LTC (8 threads).

For the single-threaded case there is no functional change.

Closes https://github.com/official-stockfish/Stockfish/pull/2337

Bench: 4088701

Fixup: remove redundant code.
 2019-10-02 01:43:02 +02:00
protonspring abd4400c87 Remove ThreatByRank 
This is a functional simplification that removes ThreatByRank.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 48009 W: 10630 L: 10560 D: 26819
http://tests.stockfishchess.org/tests/view/5d92095c0ebc594fb88eb61e

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 18682 W: 3177 L: 3053 D: 12452
http://tests.stockfishchess.org/tests/view/5d9231120ebc594fb88ebacd

Moving forward, it's possible that ThreatByMinor and ThreatByRook
could be combined, but I haven't really contemplated that yet.

Closes https://github.com/official-stockfish/Stockfish/pull/2336

bench 4088701
 2019-10-01 09:12:57 +02:00
Joost VandeVondele 70a38d7264 Remove depth dependence in value_draw(). 
The condition "depth >= 4 * ONE_PLY" does not seem needed at this point.

passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 32751 W: 7178 L: 7078 D: 18495
http://tests.stockfishchess.org/tests/view/5d8e46660ebc590f3bebad5e

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 31693 W: 5299 L: 5196 D: 21198
http://tests.stockfishchess.org/tests/view/5d8e4b4f0ebc590f3bebb165

Bench: 4062526
 2019-09-30 10:16:43 +02:00
31m059 3a3ca6af03 Extend castling independently of singular extension 
A curious feature of Stockfish's current extension code is its repeated
use of "else if." In most cases, this makes no functional difference,
because no more than one extension is applied; once one extension has
been applied, the remaining ones can be safely ignored.

However, if most singular extension search conditions are true, except
"value < singularBeta", no non-singular extensions (e.g., castling) can
be performed!

Three tests were submitted, for three of Stockfish's four non-singular
extensions. I excluded the shuffle extension, because historically there
have been concerns about the fragility of its conditions, and I did not
want to risk causing any serious search problems.

- Modifying the passed pawn extension appeared roughly neutral at STC. At
best, it appeared to be an improvement of less than 1 Elo.
- Modifying check extension performed very poorly at STC
- Modifying castling extension (this patch) produced a long "yellow" run
 at STC (insufficient to pass, but positive score) and a strong LTC.

In simple terms, prior to this patch castling extension was occasionally
not applied during search--on castling moves. The effect of this patch is
to perform castling extension on more castling moves. It does so without
adding any code complexity, simply by replacing an "else if" with "if" and
reordering some existing code.

STC:
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 108114 W: 23877 L: 23615 D: 60622
http://tests.stockfishchess.org/tests/view/5d8d86bd0ebc590f3beb0c88

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 20862 W: 3517 L: 3298 D: 14047
http://tests.stockfishchess.org/tests/view/5d8d99cd0ebc590f3beb1899

Bench: 3728191

--------

Where do we go from here?

- It seems strange to me that check extension performed so poorly -- clearly
some of the singular extension conditions are also very important for check
extension. I am not an expert in search, and I do not have any intuition
about which of the eight conditions is/are the culprit. I will try a
succession of eight STC tests to identify the relevant conditions, then try
to replicate this PR for check extension.

- Recent tests interacting with the castle extension may deserve retesting.
I will shortly resubmit a few of my recent castling extension tweaks, rebased
on this PR/commit.

My deepest thanks to @noobpwnftw for the extraordinary CPU donation, and to
all our other fishtest volunteers, who made it possible for a speculative LTC
to pass in 70 minutes!

Closes https://github.com/official-stockfish/Stockfish/pull/2331
 2019-09-27 12:46:47 +02:00
Alain SAVARD 28dcd700a9 Simplify RookOnPawn 
Remove the RookOnPawn logic (for rook on rank 5 and above aligning with pawns
on same row or file) which was overlapping with a few other parameters.

Inspired by @31m059 interesting result hinting that a direct attack on pawns
instead of PseudoAttacks might work.
http://tests.stockfishchess.org/tests/view/5d89a7c70ebc595091801b8d

After a few attempts by me and @31m059, and some long STC greens but red LTC,
as a proof of concept I first tried a local SPSA at VSTC trying to tune related
rook psqt rows, and mainly some rook related stuff in evaluate.cpp.
Result was STC green, but still red LTC,

Finally a 100M fishtest SPSA at LTC proved successful both at STC and LTC.

All this was possible with the awesome fishtest contributors.
At some point, I had 850 workers on the last test !

Run as a simplification

STC
http://tests.stockfishchess.org/tests/view/5d8d68f40ebc590f3beaf171
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 7399 W: 1693 L: 1543 D: 4163

LTC
http://tests.stockfishchess.org/tests/view/5d8d70270ebc590f3beaf63c
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 41617 W: 6981 L: 6894 D: 27742

Closes https://github.com/official-stockfish/Stockfish/pull/2329

bench: 4037914
 2019-09-27 12:37:49 +02:00
Joost VandeVondele d703d2b5e7 Remove custom mutex implementation 
As part of the investigation of the hang caused by an incorrect implementation
of condition_variable in libwinpthread, it was realized that our custom Mutex
implementation is no longer needed. Prior to lazySMP this custom implementation
resulted in a 30% speedup, but now no speed difference can be measured as no
mutex is used on the hot path in lazySMP.

https://github.com/official-stockfish/Stockfish/issues/2291
https://github.com/official-stockfish/Stockfish/issues/2309#issuecomment-533733393  https://github.com/official-stockfish/Stockfish/issues/2309#issuecomment-533737515

The interest of this patch is that it removes platform-specific code, which is
always less tested.

No functional change.
 2019-09-27 00:16:49 +02:00
Stéphane Nicolet 8726beba59 Restore development version (revert previous commit) 
Revert the previous patch now that the binary for the super-final
of TCEC season 16 has been sent.

Maybe the feature of showing the name of compiler will be added to the
master branch in the future. But we may use a cleaner way to code it, see
some ideas using the Makefile approach at the end of pull request #2327 :
https://github.com/official-stockfish/Stockfish/pull/2327

Bench: 3618154
 2019-09-26 23:27:48 +02:00
Stéphane Nicolet 0436f01d05 Temporary patch to show the compiler for TCEC submission 
This patch shows a description of the compiler used to compile Stockfish,
when starting from the console.

Usage:

```
./stockfish
compiler
```

Example of output:

```
Stockfish 240919 64 POPCNT by T. Romstad, M. Costalba, J. Kiiski, G. Linscott

Compiled by clang++ 9.0.0 on Apple
 __VERSION__ macro expands to: 4.2.1 Compatible Apple LLVM 9.0.0 (clang-900.0.38)
```

No functional change
 2019-09-25 22:28:51 +02:00
Stéphane Nicolet 667d24f227 Increase weight for supported pawns 
This patch changes the weight for counting supports of pawns
from 17 to 21. Hopefully Stockfish will accept to play a bit
more of closed or semi-closed positions.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 13822 W: 3158 L: 2939 D: 7725
http://tests.stockfishchess.org/tests/view/5d89c3a10ebc595091802379

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 63066 W: 10590 L: 10236 D: 42240
http://tests.stockfishchess.org/tests/view/5d89ca7f0ebc595091802680

Future work: try to tweak the evaluation to better understand
the French structures.

Closes https://github.com/official-stockfish/Stockfish/pull/2326

Bench: 3618154
 2019-09-24 12:54:02 +02:00
nickpelling d232a4ae68 Clarify the mapping of files to queenside 
This patch replaces the obscure expressions mapping files ABCDEFGH to ABCDDCBA
by explicite calls to an auxiliary function:

  old:   f = min(f, ~f)
  new:   f = map_to_queenside(f)

We used the Golbolt web site (https://godbolt.org) to check that the current
code for the auxiliary function is optimal.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 30292 W: 6756 L: 6651 D: 16885
http://tests.stockfishchess.org/tests/view/5d8676720ebc5971531d6aa1

Achieved with a bit of help from Sopel97, snicolet and vondele, thanks everyone!
Closes https://github.com/official-stockfish/Stockfish/pull/2325

No functional change
 2019-09-24 10:05:54 +02:00
xoto10 defa1ccaa9 Encourage rook lift to third rank 
This change to the Rook psqt encourages rook lifts to the third rank
on the two center files.

STC 10+0.1 th 1 :
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 40654 W: 9028 L: 8704 D: 22922
http://tests.stockfishchess.org/tests/view/5d885da60ebc5906dd3e9fcd

LTC 60+0.6 th 1 :
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 56963 W: 9530 L: 9196 D: 38237
http://tests.stockfishchess.org/tests/view/5d88618c0ebc5906dd3ea45f

Thanks to @snicolet for mentioning that Komodo does this a lot and
Stockfish doesn't, which gave me the idea for this patch, and to
@noobpwnftw for providing cores to fishtest which allowed very quick
testing.

Future work: perhaps this can be refined somehow to encourage this
on other files, my attempts have failed.

Closes https://github.com/official-stockfish/Stockfish/pull/2322

Bench: 3950249
 2019-09-23 09:50:34 +02:00
Stéphane Nicolet 302e0f70c6 Revert "Clarify the mapping of files to queenside" 
This reverts commit 7756344d5d.
 2019-09-23 09:10:28 +02:00
Stéphane Nicolet 7756344d5d Clarify the mapping of files to queenside 
Author: @nickpelling

We replace in the code the obscure expressions mapping files ABCDEFGH to ABCDDCBA
by an explicite call to an auxiliary function :

  old:   f = min(f, ~f)
  new:   f = map_to_queenside(f)

We used the Golbolt web site (https://godbolt.org) to find the optimal code
for the auxiliary function.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 30292 W: 6756 L: 6651 D: 16885
http://tests.stockfishchess.org/tests/view/5d8676720ebc5971531d6aa1

No functional change
 2019-09-23 08:54:20 +02:00
Joost VandeVondele 770c8d92f3 More random draw evaluations 
Use the randomized draw function value_draw() also for draw evalutions.

This extends the earlier commit
https://github.com/official-stockfish/Stockfish/commit/97d2cc9a9c1c4b6ff1b470676fa18c7fc6509886
which did this only for 3folds.

As in that case, this test was yellow at STC and LTC, but green at VLTC,
indicative of the fact that the higher the drawrate, the more likely this
idea is beneficial.

STC:
LLR: -2.96 (-2.94,2.94) [0.50,4.50]
Total: 83573 W: 18584 L: 18335 D: 46654
http://tests.stockfishchess.org/tests/view/5d84e44d0ebc5971531d4f94

LTC:
LLR: -2.96 (-2.94,2.94) [0.00,3.50]
Total: 92252 W: 15240 L: 15160 D: 61852
http://tests.stockfishchess.org/tests/view/5d865dd90ebc5971531d68e1

VLTC: 120+1.2 @ 2th
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 51902 W: 7323 L: 7028 D: 37551
http://tests.stockfishchess.org/tests/view/5d8763620ebc595f57c22b15

Closes https://github.com/official-stockfish/Stockfish/pull/2321

Bench: 3441237
 2019-09-23 07:29:00 +02:00
protonspring 7e4c3256aa Simplify connected pawn scoring 
When scoring the connected pawns, replace the intricate ternary expressions
choosing the coefficient by a simpler addition of boolean conditions:

` value = Connected * (2 + phalanx - opposed) `

This is the map showing the old coefficients and the new ones:

```
phalanx and unopposed:     3x   -> 3x
phalanx and opposed:       1.5x -> 2x
not phalanx and unopposed: 2x   -> 2x
not phalanx and opposed:   1x   -> 1x
```

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 11354 W: 2579 L: 2437 D: 6338
http://tests.stockfishchess.org/tests/view/5d8151f00ebc5971531d244f

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 41221 W: 7001 L: 6913 D: 27307
http://tests.stockfishchess.org/tests/view/5d818f930ebc5971531d26d6

Bench: 3959889

blah
 2019-09-23 07:12:32 +02:00
Joost VandeVondele 64af5434ed Acknowledge fishtest authors 
Explicitly acknowledge fishtest authors.
Their efforts are almost invisible, but essential for the project.

Many thanks to https://github.com/glinscott/fishtest/blob/master/AUTHORS !

No functional change.
 2019-09-23 06:47:59 +02:00
noobpwnftw a858defd33 Raise stack size to 8MB for pthreads 
It seems there is no other way to specify stack size on std::thread than linker
flags and the effective flags are named differently in many toolchains. On
toolchains where pthread is always available, this patch changes the stack
size change in our C++ code via pthread to ensure a minimum stack size of 8MB,
instead of relying on linker defaults which may be platform-specific.

Also raises default stack size on OSX to current Linux default (8MB) just to
be safe.

Closes https://github.com/official-stockfish/Stockfish/pull/2303

No functional change
 2019-09-16 15:09:45 +02:00
Stéphane Nicolet 7b06475294 Scale down endgame factor when shuffling 
This patch decreases the endgame scale factor using the 50 moves counter.
Looking at some games with this patch, it seems to have two effects on
the playing style:

1) when no progress can be made in late endgames (for instance in fortresses
   or opposite bishops endgames) the evaluation will be largely tamed down
   towards a draw value.

2) more interestingly, there is also a small effect in the midgame play because
   Stockfish will panic a little bit if there are more than four consecutive
   shuffling moves with an advantage: the engine will try to move a pawn or to
   exchange a piece to keep the advantage, so the follow-ups of the position
   will be discovered earlier by the alpha-beta search.

passed STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 23017 W: 5080 L: 4805 D: 13132
http://tests.stockfishchess.org/tests/view/5d7e4aef0ebc59069c36fc74

passed LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 30746 W: 5171 L: 4911 D: 20664
http://tests.stockfishchess.org/tests/view/5d7e513d0ebc59069c36ff26

Pull request: https://github.com/official-stockfish/Stockfish/pull/2304

Bench: 4272173
 2019-09-16 01:37:39 +02:00
Vizvezdenec 843a6c4305 Introduce midgame initiative 
This patch finally introduces something that was tried for years: midgame score
dependance on complexity of position. More precisely, if the position is very
simplified and the complexity measure calculated in the initiative() function
is inferior to -50 by an amount d, then we add this value d to the midgame score.

One example of play of this patch will be (again!) 4 vs 3 etc same flank endgames
where sides have a lot of non-pawn material: 4 vs 3 draw mostly remains the same
draw even if we add a lot of equal material to both sides.

STC run was stopped after 200k games (and not converging):
LLR: -1.75 (-2.94,2.94) [0.50,4.50]
Total: 200319 W: 44197 L: 43310 D: 112812
http://tests.stockfishchess.org/tests/view/5d7cfdb10ebc5902d386572c

passed LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 41051 W: 6858 L: 6570 D: 27623
http://tests.stockfishchess.org/tests/view/5d7d14680ebc5902d3866196

This is the first and not really precise version, a lot of other stuff can be
tried on top of it (separate complexity for middlegame, some more terms, even
simple retuning of values).

Bench: 4248476
 2019-09-15 00:32:54 +02:00
Stéphane Nicolet e5cfa14f40 Assorted trivial cleanups 
No functional change
 2019-09-14 08:33:00 +02:00
31m059 a83d1a0e80 Use queens of either color in RookOnQueenFile 
The recently-added RookOnQueenFile evaluation term (36e4a86) provided a bonus
for placing our rook on the same file as an enemy queen.

Here, we relax a condition in this bonus, broadening its effect to any queen.
It is also strategically desirable to place the rook on the same file as a friendly
queen, so the restriction on the queen's color is removed.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 66856 W: 14847 L: 14815 D: 37194
http://tests.stockfishchess.org/tests/view/5d7b3c6a0ebc5902d385bcf5

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 86786 W: 14264 L: 14248 D: 58274
http://tests.stockfishchess.org/tests/view/5d7b4e9b0ebc5902d385c178

Closes https://github.com/official-stockfish/Stockfish/pull/2302

Bench: 3703909
 2019-09-14 07:47:05 +02:00
Stéphane Nicolet 8a04b3a13c Update Makefile documentation 
Follow-up to previous commit. Update the documentation for the user when using `make`,
to show the preferred bmi2 compile in the advanced examples section.

Note: I made a mistake in the previous commit comment, the documentation is shown when
using `make` or `make help`, not `make --help`.

No functional change
 2019-09-14 07:34:19 +02:00
Joost VandeVondele db00e1625e Add sse4 if bmi2 is enabled 
The only change done to the Makefile to get a somewhat faster binary as
discussed in #2291 is to add -msse4 to the compile options of the bmi2 build.
Since all processors supporting bmi2 also support sse4 this can be done easily.
It is a useful step to avoid sending around custom and poorly tested builds.

The speedup isn't enough to pass [0,4] but it is roughly 1.15Elo and a LOS of 90%:
LLR: -2.95 (-2.94,2.94) [0.00,4.00]
Total: 93009 W: 20519 L: 20316 D: 52174

Also rewrite the documentation for the user when using `make --help`, so that
the order of architectures for x86-64 has the more performant build one on top.

Closes https://github.com/official-stockfish/Stockfish/pull/2300

No functional change
 2019-09-14 07:11:23 +02:00
Vizvezdenec 8aecf26981 Scale down complexity for almost unwinnable endgames 
This patch greatly scales down complexity of endgames when the
following conditions are all true together:

- pawns are all on one flank
- stronger side king is not outflanking weaker side
- no passed pawns are present

This should improve stockfish evaluation of obvious draws 4 vs 3, 3 vs 2
and 2 vs 1 pawns in rook/queen/knight/bishop single flank endgames where
strong side can not make progress.

passed STC
LLR: 2.94 (-2.94,2.94) [0.50,4.50]
Total: 15843 W: 3601 L: 3359 D: 8883

passed LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 121275 W: 20107 L: 19597 D: 81571

Closes https://github.com/official-stockfish/Stockfish/pull/2298

Bench: 3954190

==========================

How to continue from there?

a) This could be a powerful idea for refining some parts of the evaluation
   function, a bit like when we try quadratics or other equations to emphasize
   certain situations (xoto10).

b) Some other combinaison values for this bonus can be done further, or
   overall retuning of weight and offset while keeping the formula simple.
 2019-09-12 10:33:18 +02:00
xoto10 36e4a86c08 Bonus for rook on same file as their queen 
This patch creates a simple bonus for a rook that is on the same file as the
opponent's queen.

STC 10+0.1 th 1 :
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 45609 W: 10120 L: 9733 D: 25756
http://tests.stockfishchess.org/tests/view/5d79895a0ebc5902d385484a

LTC 60+0.6 th 1 :
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 51651 W: 8606 L: 8288 D: 34757
http://tests.stockfishchess.org/tests/view/5d79a0850ebc5902d3854d27

Many thanks to @noobpwnftw for providing the extra cpu resources for fishtest,
which led to me doing these tests.

Closes https://github.com/official-stockfish/Stockfish/pull/2297

Bench: 4024461
 2019-09-12 10:05:35 +02:00
protonspring 270b241ec1 Simplify Weak Lever 
This is a simplification that integrated WeakLever into doubled pawns.
Since we already check for !support for Doubled pawns, it is trivial
to check for weak lever by just checking more_than_one(lever).

We also introduce the Score * bool operation overload to remove some
casts in the code.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 26757 W: 5842 L: 5731 D: 15184
http://tests.stockfishchess.org/tests/view/5d77ee220ebc5902d384e5a4

Closes https://github.com/official-stockfish/Stockfish/pull/2295

No functional change
 2019-09-12 09:44:40 +02:00
Stefan Geschwentner 61f44ce578 Update reverse move stats 
For a good quiet non-pawn move consider the reverse move as bad
and update the main history with a negative stat bonus.

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 19292 W: 4401 L: 4141 D: 10750
http://tests.stockfishchess.org/tests/view/5d7751d50ebc594e7864973c

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 111952 W: 18762 L: 18275 D: 74915
http://tests.stockfishchess.org/tests/view/5d7771cf0ebc594e786498fa

Closes https://github.com/official-stockfish/Stockfish/pull/2294

Bench: 3914238
 2019-09-11 18:37:08 +02:00
Stefan Geschwentner 8fec883471 Tweak Late Move Reduction at root 
Maintain best move counter at the root and allow there only moves which has a counter
of zero for Late Move Reduction. For compensation only the first three moves are excluded
from Late Move Reduction per default instead the first four moves.

What we can further do:

- here we use a simple counting scheme but perhaps some aging to fade out early iterations
  could be helpful
- use the best move counter also at inner nodes for LMR and/or pruning

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 17414 W: 3984 L: 3733 D: 9697
http://tests.stockfishchess.org/tests/view/5d6234bb0ebc5939d09f2aa2

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 38058 W: 6448 L: 6166 D: 25444
http://tests.stockfishchess.org/tests/view/5d62681a0ebc5939d09f2f27

Closes https://github.com/official-stockfish/Stockfish/pull/2282

Bench: 3568210
 2019-08-26 08:49:55 +02:00
VoyagerOne 0e295fee25 NMP Tweaks 
Tweak again the null move pruning preconditions.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 19675 W: 4430 L: 4169 D: 11076
http://tests.stockfishchess.org/tests/view/5d52bc0e0ebc5925cf108300

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 73895 W: 12496 L: 12114 D: 49285
http://tests.stockfishchess.org/tests/view/5d52dcbc0ebc5925cf108552

Closes https://github.com/official-stockfish/Stockfish/pull/2268

Bench: 3690065
 2019-08-25 11:09:08 +02:00
protonspring d799529b48 Improve signature of evaluate_shelter() 
Remove one parameter in function evaluate_shelter(), making all
comparisons for castled/uncastled shelter locally in do_king_safety().
Also introduce BlockedStorm penalty.

Passed non-regression test at STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 65864 W: 14630 L: 14596 D: 36638
http://tests.stockfishchess.org/tests/view/5d5fc80c0ebc5939d09f0acc

No functional change
 2019-08-24 08:21:30 +02:00
protonspring 3984b8f8f0 Consolidate CastlingSide and CastlingRights 
This is a non-functional simplification that removes CastlingSide and
implements the functionality in CastlingRights (thanks to Jörg Oster
for a comment on the first version of this patch).

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 53854 W: 12077 L: 12019 D: 29758
http://tests.stockfishchess.org/tests/view/5d517b940ebc5925cf107474

Closes https://github.com/official-stockfish/Stockfish/pull/2265

No functional change
 2019-08-23 16:29:29 +02:00
protonspring a016626825 Simplify futility equation 
This is a functional simplification. The 178 constant for the futility equation
in master can be removed.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42626 W: 9508 L: 9428 D: 23690
http://tests.stockfishchess.org/tests/view/5d5d4e320ebc5925cf11254e

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 26182 W: 4432 L: 4320 D: 17430
http://tests.stockfishchess.org/tests/view/5d5df70d0ebc5925cf112fee

Closes https://github.com/official-stockfish/Stockfish/pull/2278

Bench: 3985701
 2019-08-23 09:37:12 +02:00
Vizvezdenec 10d2ebc6ae Late move reduction, captures and CUT nodes 
Expand of Stefan Geschwentner's original idea: we always do LMR for captures at cutnodes.

Passed STC
http://tests.stockfishchess.org/tests/view/5d5b2f8e0ebc5925cf1111b8
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 36026 W: 8122 L: 7779 D: 20125

Passed LTC
http://tests.stockfishchess.org/tests/view/5d5b40c80ebc5925cf111353
LLR: 3.22 (-2.94,2.94) [0.00,3.50]
Total: 133502 W: 22508 L: 21943 D: 89051

Closes https://github.com/official-stockfish/Stockfish/pull/2273

Bench: 3494372
 2019-08-21 10:47:40 +02:00
protonspring 18279b24fc Tuned Futility Equation 
@Vizvezdenec array suggested that alternate values may be better than current
master (see pull request #2270 ). I tuned some linear equations to more closely
represent his values and it passed. These futility values seem quite sensitive,
so perhaps additional Elo improvements can be found here.

STC
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 12257 W: 2820 L: 2595 D: 6842
http://tests.stockfishchess.org/tests/view/5d5b2f360ebc5925cf1111ac

LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 20273 W: 3497 L: 3264 D: 13512
http://tests.stockfishchess.org/tests/view/5d5c0d250ebc5925cf111ac3

Closes https://github.com/official-stockfish/Stockfish/pull/2272

------------------------------------------
How to continue from there ?

a) we can try a simpler version for the futility margin, this would
   be a simplification :
    margin = 188 * (depth - improving)

b) on the other direction, we can try a complexification by trying
   again to gain Elo with an complete array of futility values.

------------------------------------------

Bench: 4330402
 2019-08-21 09:34:46 +02:00
Jean Gauthier d4dca9187e Slight speep up fetching the endgame table 
Replace calls to count(key) + operator[key] with a single call to find(key).
Replace the std::map with std::unordered_map which provide O(1) access,
although the map has a really small number of objects.

Test with [0..4] failed yellow:

TC	10+0.1
SPRT	elo0: 0.00  alpha: 0.05  elo1: 4.00  beta: 0.05
LLR	-2.96 [-2.94,2.94] (rejected)
Elo	1.01 [-0.87,3.08] (95%)
LOS	85.3%
Games	71860 [w:22.3%, l:22.2%, d:55.5%]
http://tests.stockfishchess.org/tests/view/5d5432210ebc5925cf109d61

Closes https://github.com/official-stockfish/Stockfish/pull/2269

No functional change
 2019-08-21 09:11:17 +02:00
Alain SAVARD 7efc39d683 Assorted trivial cleanups (July 2019) 
No functional change
 2019-08-14 22:15:48 +02:00
Stefan Geschwentner 66a3c2968b Tweak unsafe checks 
Remove mobility area for unsafe checks. Also separate the evaluation terms
for unsafe checks and blockers for king with adjusted weights.

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 124526 W: 28292 L: 27504 D: 68730
http://tests.stockfishchess.org/tests/view/5d5138290ebc5925cf1070c3

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 84968 W: 14499 L: 14083 D: 56386
http://tests.stockfishchess.org/tests/view/5d527cfa0ebc5925cf107f93

Bench: 4139590
 2019-08-14 20:59:04 +02:00
joergoster fcee0ce6a3 Revert "Improve multiPV mode" 
This reverts commit a8de07cc26.
 2019-08-01 09:28:34 +02:00
xoto10 8152a74ab4 Tune search constants 
This is the result of a 200k tuning run at LTC:
http://tests.stockfishchess.org/tests/view/5d3576b70ebc5925cf0e9e1e

which passed quickly at LTC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 12954 W: 2280 L: 2074 D: 8600
http://tests.stockfishchess.org/tests/view/5d3ff3f70ebc5925cf0f87a2

STC failed, but second LTC at [0,4] passed easily:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 8004 W: 1432 L: 1252 D: 5320
http://tests.stockfishchess.org/tests/view/5d407cff0ebc5925cf0f9119

Further work?
No doubt some of these changes produce most of the gain and some are neutral
or even bad, so further testing on individual/groups of parameters changed
here might show more gains. It does look like these tests might need to be
at LTC though, so maybe not too practical to do. See the thread in the pull
request for an interesting discussion:
https://github.com/official-stockfish/Stockfish/pull/2260

Bench: 4024328
 2019-07-31 09:35:20 +02:00
protonspring d980d7c0d4 Simplify weak lever 
STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 14844 W: 3347 L: 3212 D: 8285
http://tests.stockfishchess.org/tests/view/5d3a2d7b0ebc5925cf0f1632

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 55261 W: 9374 L: 9309 D: 36578
http://tests.stockfishchess.org/tests/view/5d3a3d9e0ebc5925cf0f1786

Closes https://github.com/official-stockfish/Stockfish/pull/2257

bench: 3484124
 2019-07-28 19:48:57 +02:00
mstembera 9d3a2ecaa2 Bug fix: always choose shortest mate in multithread mode 
In current master, with the voting scheme the best thread selection may
pick a non mate or not the shortest mate thread. This patch fixes this bug.
Formatting suggestion by Jörg Oster.

Related past pull requests:
https://github.com/official-stockfish/Stockfish/pull/1074
https://github.com/official-stockfish/Stockfish/pull/1215

Passed a [-4..0] verification test with 3 threads:
LLR: 2.95 (-2.94,2.94) [-4.00,0.00]
Total: 57158 W: 11374 L: 11424 D: 34360
http://tests.stockfishchess.org/tests/view/5d22deb30ebc5925cf0caefd

Closes https://github.com/official-stockfish/Stockfish/pull/2226

No functional change (in single threaded mode)

----------------------------------------------------

Comment by Jörg Oster

Just one sample output to demonstrate the effect of this patch.
5 Threads, 1 GB Hash

 +---+---+---+---+---+---+---+---+
 | r |   | b |   |   | r | k |   |
 +---+---+---+---+---+---+---+---+
 |   |   |   | n |   | p | b |   |
 +---+---+---+---+---+---+---+---+
 |   |   | p |   | p |   | p |   |
 +---+---+---+---+---+---+---+---+
 | p |   |   |   |   |   | P |   |
 +---+---+---+---+---+---+---+---+
 | P | p |   |   | B |   | N | Q |
 +---+---+---+---+---+---+---+---+
 |   | q |   |   |   |   | P |   |
 +---+---+---+---+---+---+---+---+
 |   |   | R |   |   | P |   |   |
 +---+---+---+---+---+---+---+---+
 |   |   |   | R |   |   | K |   |
 +---+---+---+---+---+---+---+---+

Fen: r1b2rk1/3n1pb1/2p1p1p1/p5P1/Pp2B1NQ/1q4P1/2R2P2/3R2K1 w - - 8 34
Key: 38B4CA1067D4F477
Checkers:
ucinewgame
isready
readyok
go mate 17 searchmoves d1d7
info depth 65 seldepth 36 multipv 1 score mate 18 nodes 785875935 nps 8650448 hashfull 1000 tbhits 0 time 90848 pv d1d7 c8d7 g4f6 g7f6 g5f6 b3a3 g1g2 a3a1 h4g5 a1f6 g5f6 e6e5 c2c1 d7h3 g2h3 a8a6 h3g2 c6c5 f6a6 g8g7 c1c5 f7f6 a6e6 f8f7 c5c8 f6f5 e4d5 g7h6 e6f7 f5f4 f7e7 f4f3 d5f3 b4b3 c8h8
info depth 63 seldepth 36 multipv 1 score mate 17 nodes 785875935 nps 8650448 hashfull 1000 tbhits 0 time 90848 pv d1d7 c8d7 g4f6 g7f6 g5f6 b3a3 g1g2 a3a1 h4g5 a1f6 g5f6 e6e5 c2c1 d7h3 g2h3 a8a6 c1d1 b4b3 h3g2 c6c5 f6a6 g8g7 d1d7 g7g8 a6f6 b3b2 e4g6 b2b1q g6f7 f8f7 f6f7 g8h8 f7g7
bestmove d1d7 ponder c8d7
 2019-07-26 03:33:32 +02:00
protonspring aec918a2b6 Remove operators for color 
This is a non-functional and untested simplification. The increment operator
for color isn't really necessary and seems a bit unnatural to me.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 47027 W: 10589 L: 10518 D: 25920
http://tests.stockfishchess.org/tests/view/5d3472d10ebc5925cf0e8d3e

Closes https://github.com/official-stockfish/Stockfish/pull/2247

No functional change
 2019-07-26 02:12:23 +02:00
Vizvezdenec acdda38b93 Tweak of SEE pruning condition 
passed STC
http://tests.stockfishchess.org/tests/view/5d386bda0ebc5925cf0ef49a
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 56874 W: 12820 L: 12373 D: 31681

passed LTC
http://tests.stockfishchess.org/tests/view/5d38873a0ebc5925cf0ef86e
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 43512 W: 7547 L: 7247 D: 28718

Additional thanks to @locutus2 , @miguel-l and @xoto10 for fruitful discussion.
There may be some more elo there since this tweak was the first one and numbers
are more or less arbitrary.

Closes https://github.com/official-stockfish/Stockfish/pull/2256

Bench 3935523
 2019-07-25 09:16:53 +02:00
Alain SAVARD 33c3a04653 Pawn clean up 
Non functional simplification when we find the passed pawns in pawn.cpp
and some code clean up. It also better follows the pattern "flag the pawn"
and "score the pawn".

-------------------------

The idea behind the third condition for candidate passed pawn is a little
bit difficult to visualize. Just for the record, the idea is the following:

Consider White e5 d4 against black e6. d4 can (in some endgames) push
to d5 and lever e6. Thanks to this sacrifice, or after d5xe6, we consider
e5 as "passed".

However:
- if White e5/d4 against black e6/c6: d4 cannot safely push to d5 since d5 is double attacked;
- if White e5/d4 against black e6/d5: d4 cannot safely push to d5 since it is occupied.

This is exactly what the following expression does:

```
   && (shift<Up>(support) & ~(theirPawns | dblAttackThem)))
```

--------------------------

http://tests.stockfishchess.org/tests/view/5d3325bb0ebc5925cf0e6e91
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 124666 W: 27586 L: 27669 D: 69411

Closes https://github.com/official-stockfish/Stockfish/pull/2255

No functional change
 2019-07-25 09:05:08 +02:00
VoyagerOne dc243a3c88 LMR Tweak 
Reset statScore to zero if negative and most stats shows >= 0

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 23097 W: 5242 L: 4963 D: 12892
http://tests.stockfishchess.org/tests/view/5d31dd650ebc5925cf0e598f

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 227597 W: 39013 L: 38191 D: 150393
http://tests.stockfishchess.org/tests/view/5d31fcdf0ebc5925cf0e5c13

Closes https://github.com/official-stockfish/Stockfish/pull/2252

Bench: 3242229
 2019-07-25 08:46:26 +02:00
Alain SAVARD 9dc57b660e Passed file cleanup 
Protonspring had a successful functional simplification that removes the
PassedFile array using a simple linear equation.

Merge the additive term S(5, 10) of protonspring passed file simplification
(pull request https://github.com/official-stockfish/Stockfish/pull/2250)
into the PassedRank array. This harmless change has a different bench because
the candidate passer evaluation will always get less compared to #2250,
as we apply bonus = bonus /2.

Tested as a non-regression against #2250

Passed STC
http://tests.stockfishchess.org/tests/view/5d33427e0ebc5925cf0e6fa2
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 81459 W: 18174 L: 18171 D: 45114

Passed LTC
http://tests.stockfishchess.org/tests/view/5d335c8d0ebc5925cf0e731e
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 18525 W: 3176 L: 3052 D: 12297

Closes https://github.com/official-stockfish/Stockfish/pull/2250
Closes https://github.com/official-stockfish/Stockfish/pull/2251

Bench: 3859856
 2019-07-25 08:32:49 +02:00
Lolligerhans fd96cba676 No influence on unsafeSquares of passers by pieces 
Remove their pieces from influencing 'unsafeSquares' in passer
evaluation.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 36421 W: 8170 L: 8078 D: 20173
http://tests.stockfishchess.org/tests/view/5d22fc8e0ebc5925cf0cb26e

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 18927 W: 3253 L: 3129 D: 12545
http://tests.stockfishchess.org/tests/view/5d26e2b20ebc5925cf0d3218

Closes https://github.com/official-stockfish/Stockfish/pull/2248

Bench: 3285659
 2019-07-25 08:23:43 +02:00
Vizvezdenec 19509e5f13 Tweak LMR and killers 
Give extra stat bonus/malus in case of LMR for killers.

passed STC
http://tests.stockfishchess.org/tests/view/5d2c8e760ebc5925cf0dcf23
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 67188 W: 15030 L: 14534 D: 37624

passed LTC
http://tests.stockfishchess.org/tests/view/5d2d0ce40ebc5925cf0de115
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 144355 W: 24739 L: 24153 D: 95463

Closes https://github.com/official-stockfish/Stockfish/pull/2246

bench 3723147
 2019-07-25 08:17:11 +02:00
Alain SAVARD 3ec362e4b2 Space Invaders 
Try a more ambitius simplification of the space bonus

STC http://tests.stockfishchess.org/tests/view/5d2b62c90ebc5925cf0da2a4
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 51299 W: 11320 L: 11257 D: 28722

LTC http://tests.stockfishchess.org/tests/view/5d2bac270ebc5925cf0db215
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 49761 W: 8409 L: 8335 D: 33017

Closes https://github.com/official-stockfish/Stockfish/pull/2243

bench: 3395999
 2019-07-25 08:07:55 +02:00
Marco Costalba 7090d2561a Fix bench 
Bench: 3357457
 2019-07-14 15:21:08 +02:00
Joost VandeVondele 0dbc72d82e UCI_Elo implementation (#2225) 
This exploits the recent fractional Skill Level, and is a result from some discussion in #2221 and the older #758.

Basically, if UCI_LimitStrength is set, it will internally convert UCI_Elo to a matching fractional Skill Level.
The Elo estimate is based on games at  TC 60+0.6, Hash 64Mb, 8moves_v3.pgn, rated with Ordo, anchored to goldfish1.13 (CCRL 40/4 ~2000).
Note that this is mostly about internal consistency, the anchoring to CCRL is a bit weak, e.g. within this tournament,
goldfish and sungorus only have a 200Elo difference, their rating difference on CCRL is 300Elo.

I propose that we continue to expose 'Skill Level' as an UCI option, for backwards compatibility.

The result of a tournament under those conditions are given by the following table, where the player name reflects the UCI_Elo.

   # PLAYER          :  RATING  ERROR  POINTS  PLAYED   (%)  CFS(%)
   1 Elo2837         :  2792.2   50.8   536.5     711    75     100
   2 Elo2745         :  2739.0   49.0   487.5     711    69     100
   3 Elo2654         :  2666.4   49.2   418.0     711    59     100
   4 Elo2562         :  2604.5   38.5   894.5    1383    65     100
   5 Elo2471         :  2515.2   38.1   651.5     924    71     100
   6 Elo2380         :  2365.9   35.4   478.5     924    52     100
   7 Elo2289         :  2290.0   28.0   864.0    1596    54     100
   8 sungorus1.4     :  2204.9   27.8   680.5    1596    43      60
   9 Elo2197         :  2201.1   30.1   523.5     924    57     100
  10 Elo2106         :  2103.8   24.5   730.5    1428    51     100
  11 Elo2014         :  2030.5   30.3   377.5     756    50      98
  12 goldfish1.13    :  2000.0   ----   511.0    1428    36     100
  13 Elo1923         :  1928.5   30.9   641.5    1260    51     100
  14 Elo1831         :  1829.0   42.1   370.5     756    49     100
  15 Elo1740         :  1738.3   42.9   277.5     756    37     100
  16 Elo1649         :  1625.0   42.1   525.5    1260    42     100
  17 Elo1558         :  1521.5   49.9   298.0     756    39     100
  18 Elo1467         :  1471.3   51.3   246.5     756    33     100
  19 Elo1375         :  1407.1   51.9   183.0     756    24     ---

It can be observed that all set Elos correspond within the error bars with the observed Ordo rating.

No functional change
 2019-07-14 14:47:50 +02:00
protonspring 650aeaf242 Remove std::pow from reduction. (#2234) 
This is a functional simplification that removes the std::pow from reduction. The resulting reduction values are within 1% of master.

This is a simplification because i believe an fp addition and multiplication is much faster than a call to std::pow() which is historically slow and performance varies widely on different architectures.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23471 W: 5245 L: 5127 D: 13099
http://tests.stockfishchess.org/tests/view/5d27ac1b0ebc5925cf0d476b

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 51533 W: 8736 L: 8665 D: 34132
http://tests.stockfishchess.org/tests/view/5d27b74e0ebc5925cf0d493c

Bench 3765158
 2019-07-14 14:46:10 +02:00
31m059 13ba67801f Just blockSq, not forward file. Bench: 3377831 (#2240) 
This is another functional simplification to Stockfish passed pawn evaluation.

Stockfish evaluates some pawns which are not yet passed as "candidate" passed pawns, which are given half the bonus of fully passed ones. Prior to this commit, Stockfish considered a passed pawn to be a "candidate" if (a) it would not be a passed pawn if moved one square forward (the blocking square), or (b) there were other pawns (of either color) in front of it on the file. This latter condition used a fairly complicated method, forward_file_bb; here, rather than inspect the entire forward file, we simply re-use the blocking square. As a result, some pawns previously considered "candidates", but which are able to push forward, no longer have their bonus halved.

Simplification tests passed quickly at both STC and LTC. The results from both tests imply that this simplification is, most likely, additionally a small Elo gain, with a LTC likelihood of superiority of 87 percent.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 12908 W: 2909 L: 2770 D: 7229
http://tests.stockfishchess.org/tests/view/5d2a1c880ebc5925cf0d9006

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20723 W: 3591 L: 3470 D: 13662
http://tests.stockfishchess.org/tests/view/5d2a21fd0ebc5925cf0d9118

Bench: 3377831
 2019-07-14 14:42:30 +02:00
Michael Chaly 0a8a3b8d9c tviigg. (#2238) 
Current master code made sence when we had 2 types of bonuses for protected path to queen. But it was simplified so we have only one bonus now and code was never cleaned.
This non-functional simplification removes useless defendedsquares bitboard and removes one bitboard assignment (defendedSquares &= attackedBy[Us][ALL_PIECES] + defendedSquares & blockSq becomes just attackedBy[Us][ALL_PIECES] & blockSq also we never assign defendedSquares = squaresToQueen because we don't need it).
So should be small non-functional speedup.
Passed simplification SPRT.
http://tests.stockfishchess.org/tests/view/5d2966ef0ebc5925cf0d7659
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23319 W: 5152 L: 5034 D: 13133

bench 3361902
 2019-07-14 14:41:28 +02:00
31m059 a0360cc2d4 Linear formula for w. Bench: 3328507 (#2239) 
In Stockfish, both the middlegame and endgame bonus for a passed pawn are calculated as a product of two factors. The first is k, chosen based on the presence of defended and unsafe squares. The second is w, a quadratic function of the pawn's rank. Both are only applied if the pawn's relative rank is at least RANK_4.

It does not appear that the complexity of a quadratic function is necessary for w. Here, we replace it with a simpler linear one, which performs equally at both STC and LTC.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 46814 W: 10386 L: 10314 D: 26114
http://tests.stockfishchess.org/tests/view/5d29686e0ebc5925cf0d76a1

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 82372 W: 13845 L: 13823 D: 54704
http://tests.stockfishchess.org/tests/view/5d2980650ebc5925cf0d7bfd

Bench: 3328507
 2019-07-14 14:40:45 +02:00
Stefan Geschwentner ff69d570d7 Full bonus for LMR stats update 
Simplify previous commit by using the full bonus for LMR-triggered stats update.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 23684 W: 5255 L: 5137 D: 13292
http://tests.stockfishchess.org/tests/view/5d2826660ebc5925cf0d5180

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 16245 W: 2832 L: 2704 D: 10709
http://tests.stockfishchess.org/tests/view/5d282e9c0ebc5925cf0d529b

Closes https://github.com/official-stockfish/Stockfish/pull/2236

Bench: 3361902
 2019-07-13 05:49:14 +02:00
Stefan Geschwentner 389e60741f Late Move reduction and continuation history 
Update continuation history after LMR-triggered full depth research.
Directly after a LMR-triggered full depth research, we update the
continuation history for quiet moves (but with only half stat bonus).

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 39657 W: 8966 L: 8604 D: 22087
http://tests.stockfishchess.org/tests/view/5d279fa40ebc5925cf0d4566

LTC:
LLR: 2.96 (-2.94,2.94) [0.50,3.50]
Total: 32582 W: 5740 L: 5427 D: 21415
http://tests.stockfishchess.org/tests/view/5d27dbf90ebc5925cf0d4b7e

Bench: 3239357
 2019-07-12 09:26:45 +02:00
31m059 82d66f6b72 Exclude passed pawns from Attacked2Unsupported 
We recently added a bonus for double pawn attacks on unsupported enemy pawns,
on June 27. However, it is possible that the unsupported pawn may become a passer
by simply pushing forward out of the double attack. By rewarding double attacks,
we may inadvertently reward the creation of enemy passers, by encouraging both of
our would-be stoppers to attack the enemy pawn even if there is no opposing
friendly pawn on the same file.

Here, we revise this term to exclude passed pawns. In order to simplify the code
with this change included, we non-functionally rewrite Attacked2Unsupported to
be a penalty for enemy attacks on friendly pawns, rather than a bonus for our
attacks on enemy pawns. This allows us to exclude passed pawns with a simple
& ~e->passedPawns[Us], while passedPawns[Them] is not yet defined in this part
of the code.

This dramatically reduces the proportion of positions in which Attacked2Unsupported
is applied, to about a third of the original. To compensate, maintaining the same
average effect across our bench positions, we nearly triple Attacked2Unsupported
from S(0, 20) to S(0, 56). Although this pawn formation is rare, it is worth more
than half a pawn in the endgame!

STC: (stopped automatically by fishtest after 250,000 games)
LLR: -0.87 (-2.94,2.94) [0.50,4.50]
Total: 250000 W: 56585 L: 55383 D: 138032
http://tests.stockfishchess.org/tests/view/5d25795e0ebc5925cf0cfb51

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 81038 W: 13965 L: 13558 D: 53515
http://tests.stockfishchess.org/tests/view/5d25f3920ebc5925cf0d10dd

Closes https://github.com/official-stockfish/Stockfish/pull/2233

Bench: 3765158
 2019-07-11 23:05:28 +02:00
Marco Costalba 4ae5a7b45a Assorted trivial cleanups June 2019 
No functional change.
 2019-07-11 12:22:20 +02:00
VoyagerOne c83cbe42f3 Tweak capture scoring formula 
STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 20556 W: 4685 L: 4438 D: 11433
http://tests.stockfishchess.org/tests/view/5d25d26e0ebc5925cf0d0b4a

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 14856 W: 2649 L: 2446 D: 9761
http://tests.stockfishchess.org/tests/view/5d25d8b20ebc5925cf0d0c6d

bench: 3206912
 2019-07-11 11:59:36 +02:00
xoto10 5a7827d59d Combo of statscore divisor and pawn psqt changes 
Passed STC 10+0.1 th 1:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 13282 W: 3100 L: 2881 D: 7301
http://tests.stockfishchess.org/tests/view/5d21132e0ebc5925cf0c81f4

Passed LTC 60+0.6 th 1:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 44243 W: 7768 L: 7468 D: 29007
http://tests.stockfishchess.org/tests/view/5d2119050ebc5925cf0c832b

Bench 3705891
 2019-07-11 11:51:27 +02:00
protonspring 93349d0dbd Use score instead of array to evaluate shelter 
This is a non-functional simplification. Instead of an array of values, just use a Score.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 16309 W: 3673 L: 3541 D: 9095
http://tests.stockfishchess.org/tests/view/5d24f3b80ebc5925cf0ceb5b

No functional change
 2019-07-11 11:42:08 +02:00
Daniel Axtens fa1a2a0667 Enable popcount and prefetch for ppc-64 
PowerPC has had popcount instructions for a long time, at least as far
back as POWER5 (released 2004). Enable them via a gcc builtin.

Using a gcc builtin has the added bonus that if compiled for a processor
that lacks a hardware instruction, gcc will include a software popcount
implementation that does not use the instruction. It might be slower
than the table lookups (or it might be faster) but it will certainly work.
So this isn't going to break anything.

On my POWER8 VM, this leads to a ~4.27% speedup.

Fir prefetch, the gcc builtin generates a 'dcbt' instruction, which is
supported at least as far back as the G5 (2002) and POWER4 (2001).

This leads to a ~5% speedup on my POWER8 VM.

No functional change
 2019-07-11 11:30:09 +02:00
Joost VandeVondele ca51d1ee63 Smoothly change playing strength with skill level. (#2142) 
The current skill levels (1-20) allow for adjusting playing strengths, but
do so in big steps (e.g. level 10 vs level 11 is a ~143 Elo jump at STC).
Since the 'Skill Level' input can already be a floating point number, this
patch uses the fractional part of the input to provide the user with
fine control, allowing for varying the playing strength essentially
continuously.

The implementation internally still uses integer skill levels (needed since they pick Depths),
but non-deterministically rounds up or down the used skill level such that the average integer
skill corresponds to the input floating point one. As expected, intermediate
(fractional) skill levels yield intermediate playing strenghts.

Tested at STC, playing level 10 against levels between 10 and 11 for 10000 games

level 10.25 ELO:  24.26 +-6.2
level 10.5  ELO:  67.51 +-6.3
level 10.75 ELO:  98.52 +-6.4
level 11    ELO: 143.65 +-6.7

http://tests.stockfishchess.org/tests/view/5cd9c6b40ebc5925cf056791
http://tests.stockfishchess.org/tests/view/5cd9d22b0ebc5925cf056989
http://tests.stockfishchess.org/tests/view/5cd9cf610ebc5925cf056906
http://tests.stockfishchess.org/tests/view/5cd9d2490ebc5925cf05698e

No functional change.
 2019-07-01 14:07:54 +02:00
Joost VandeVondele 217840a6a5 Introduce coordination between searching threads (#2204) 
this patch improves threading performance by introducing some coordination between threads.

The observation is that threading is an area where a lot of Elo can potentially be gained:
https://github.com/glinscott/fishtest/wiki/UsefulData#elo-from-threading
At STC, 8 threads gain roughly 320 Elo, vs sequential at the same time,
however, loses 66 Elo against a single thread with 8x more time.
This 66 Elo should be partially recoverable with improved threading.

To improve threading, this patch introduces some LMR at nodes that are already being searched by other threads.
This requires some coordination between threads, avoiding however synchronisation.
To do so, threads leave a trail of breadcrumbs to mark the nodes they are searching.
These breadcrumbs are stored in a small hash table, which is only probed at low plies (currently ply < 8).

A couple of variants of this patch passed both STC and LTC threaded tests.
I picked the simpler, more robust version.
I expect that further tests can find further improvements.

STC (5+0.05 @ 8 threads):
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 26209 W: 5359 L: 5079 D: 15771
http://tests.stockfishchess.org/tests/view/5d0a9b030ebc5925cf0a8e6f

LTC (20+0.2 @ 8 threads):
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 34832 W: 5650 L: 5382 D: 23800
http://tests.stockfishchess.org/tests/view/5d0c67a20ebc5925cf0aafa7

other passed/tested variants:
http://tests.stockfishchess.org/tests/view/5d0a9b030ebc5925cf0a8e6f
http://tests.stockfishchess.org/tests/view/5d0c67ca0ebc5925cf0aafa9
http://tests.stockfishchess.org/tests/view/5d0c67810ebc5925cf0aafa3
http://tests.stockfishchess.org/tests/view/5d0958ca0ebc5925cf0a74c6

For the sequential code there is no change in bench, and an earlier version of this patch passed a non-regression test.
STC (10+0.1 @ 1 thread)
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 10471 W: 2364 L: 2220 D: 5887
http://tests.stockfishchess.org/tests/view/5d087ee20ebc5925cf0a6381

passed the additional non-regression tests at 2 and 4 threads 20+0.2 TC. The code was rebased on master prior to testing.

2 threads:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 218863 W: 40927 L: 41153 D: 136783
http://tests.stockfishchess.org/tests/view/5d18c6c30ebc5925cf0b9566

4threads:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 16839 W: 3017 L: 2889 D: 10933
http://tests.stockfishchess.org/tests/view/5d18c6ea0ebc5925cf0b9568

No functional change.
 2019-07-01 14:07:23 +02:00
protonspring 79d06d8840 Move storm special condition to UnblockedStorm array (#2210) 
This is a functional simplification.

Looks like we can accommodate the special initialization of Value in evaluate_shelter in the UnblockedStorm array.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 32483 W: 7422 L: 7322 D: 17739
http://tests.stockfishchess.org/tests/view/5d14c5f80ebc5925cf0b48da

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 35361 W: 6139 L: 6042 D: 23180
http://tests.stockfishchess.org/tests/view/5d14d69c0ebc5925cf0b4bd0

Bench 3596270
 2019-06-30 15:22:37 +02:00
Jörg Oster c9d73d1aa5 Try to get a more precise bench time (#2211) 
Initialization of larger hash sizes can take some time.
Don't include this time in the bench by resetting the timer after Search::clear().
Also move 'ucinewgame' command down in the list, so that it is processed
after the configuration of Threads and Hash size.

No functional change.
 2019-06-30 15:16:20 +02:00
protonspring d889bb4718 Bonus for double attacks on unsupported pawns 
This is a functional change that rewards double attacks on an unsupported pawns.

STC (non-functional difference)
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 83276 W: 18981 L: 18398 D: 45897
http://tests.stockfishchess.org/tests/view/5d0970500ebc5925cf0a77d4

LTC (incomplete looping version)
LLR: 0.50 (-2.94,2.94) [0.00,3.50]
Total: 82999 W: 14244 L: 13978 D: 54777
http://tests.stockfishchess.org/tests/view/5d0a8d480ebc5925cf0a8d58

LTC (completed non-looping version).
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 223381 W: 38323 L: 37512 D: 147546
http://tests.stockfishchess.org/tests/view/5d0e80510ebc5925cf0ad320

Closes https://github.com/official-stockfish/Stockfish/pull/2205

Bench 3633546

----------------------------------

Comments by Alain SAVARD:

interesting result ! I would have expected that search would resolve such positions
correctly on the very next move. This is not a very common pattern, and when it happens,
it will quickly disappear. So I'm quite surprised that it passed LTC.
I would be even more surprised if this would resist a simplification.

Anyway, let's try to imagine a few cases.

a) If you have White d5 f5 against Black e6, and White to move
last move by Black was probably a capture on e6 and White is about to recapture on e6

b) If you have White d5 f5 against e6, and Black to move
last move by White was possibly a capture on d5 or f5
or the pawn on e6 was pinned or could not move for some reason.
and white wants to blast open the position and just pushed d4-d5 or f4-f5

Some possible follow-ups
a) Motif is so rare that the popcount() can be safely replaced with a bool()
But this would not pass a SPRT[0,4],
So try a simplification with bool() and also without the & ~theirAttacks

b) If it works, we probably can simply have this in the loop
if (lever) score += S(0, 20);

c) remove all this and tweak something in search for pawn captures (priority, SEE, extension,..)
 2019-06-27 09:46:36 +02:00
Vizvezdenec dab66631e8 Introduce attacks on space area 
This patch introduces a small malus for every square in our space mask
that is attacked by enemy. The value of the malus is completely arbitrary
and is something we can tweak, also maybe we can gain some elo with tweaking
space threshold after this addition.

Passed STC
http://tests.stockfishchess.org/tests/view/5d10ce590ebc5925cf0af30b
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 7082 W: 1648 L: 1449 D: 3985

Passed LTC
http://tests.stockfishchess.org/tests/view/5d10d2d80ebc5925cf0af3fd
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 79494 W: 13727 L: 13324 D: 52443

Closes https://github.com/official-stockfish/Stockfish/pull/2207

bench 3516460
 2019-06-27 09:26:08 +02:00
Sergei Ivanov 8b4521df83 Do not define increment operators on Value, Depth and Direction 
These operators are never used and do not make sense for these types.

No functional change.
 2019-06-27 09:05:03 +02:00
joergoster a8de07cc26 Improve multiPV mode 
Skip all moves during the Non-PV (zero-window) search which will be
searched as PV moves later anyways. We also wake sure the moves will
be reported to the GUI despite they're not being searched — some GUIs
may get confused otherwise, and it would unnecessarily complicate the
code.

Tested with MultiPV=4
STC
http://tests.stockfishchess.org/tests/view/5ce7137c0ebc5925cf070d69
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 8233 W: 3708 L: 3424 D: 1101

LTC
http://tests.stockfishchess.org/tests/view/5ce798d60ebc5925cf071d17
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 7369 W: 3197 L: 2911 D: 1261

Closes https://github.com/official-stockfish/Stockfish/pull/2163

No functional change. (in single PV mode)
 2019-06-27 08:57:59 +02:00
Joost VandeVondele 4c986b0501 Make the debug counters thread safe. 
needed to use them in a threaded run.

No functional change.
 2019-06-22 09:57:07 +02:00
Vizvezdenec 7cb8817ef2 Rewrite "More bonus for free passed pawn" 
-removes wideUnsafeSquares bitboard
-removes a couple of bitboard operations
-removes one if operator
-updates comments so they actually represent what this part of code is doing now.

passed non-regression STC
http://tests.stockfishchess.org/tests/view/5d0c1ae50ebc5925cf0aa8db
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 16892 W: 3865 L: 3733 D: 9294

No functional change
 2019-06-21 10:05:50 +02:00
Vizvezdenec 37ffacf209 More bonus for free passed pawn 
Give even more bonus to passed pawn if adjacent squares to its path
are not attacked.

passed STC
http://tests.stockfishchess.org/tests/view/5d08c9b10ebc5925cf0a6630
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 175197 W: 39859 L: 38816 D: 96522

passed LTC
http://tests.stockfishchess.org/tests/view/5d0ab8240ebc5925cf0a8fe4
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 92928 W: 16124 L: 15682 D: 61122

Bench: 3398333
 2019-06-20 16:52:02 +02:00
Miguel Lahoz 8bf21a723e Change multi-cut pruning condition 
Use comparison of eval with beta to predict potential cutNodes. This
allows multi-cut pruning to also prune possibly mislabeled Pv and NonPv
nodes.

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 54305 W: 12302 L: 11867 D: 30136
http://tests.stockfishchess.org/tests/view/5d048ba50ebc5925cf0a15e8

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 189512 W: 32620 L: 31904 D: 124988
http://tests.stockfishchess.org/tests/view/5d04bf740ebc5925cf0a17f0

Normally I would think such changes are risky, specially for PvNodes,
but after trying a few other versions, it seems this version is more
sound than I initially thought.

Aside from this, a small funtional change is made to return
singularBeta instead of beta to be more consistent with the fail-soft
logic used in other parts of search.

=============================

How to continue from there ?

We could try to audit other parts of the search where the "cutNode"
variable is used, and try to use dynamic info based on heuristic
eval rather than on this variable, to check if the idea behind this
patch could also be applied successfuly.

Bench: 3503788
 2019-06-20 16:39:22 +02:00
VoyagerOne 297c40291a QuietPick Speed-up 
Non-functional speedup: no need to generate, score, or sort quiet moves
if SkipQuiet is true. Thanks to @mstembera for his suggestion.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 27910 W: 6406 L: 6129 D: 15375
http://tests.stockfishchess.org/tests/view/5d07e0920ebc5925cf0a58a8

Closes https://github.com/official-stockfish/Stockfish/pull/2194

No functional change
 2019-06-20 16:22:45 +02:00
Joost VandeVondele 59f1d0c7dd Fix progress issue with shuffling extensions 
Fixes issues #2126 and #2189 where no progress in rootDepth is made for particular fens:

8/8/3P3k/8/1p6/8/1P6/1K3n2 b - - 0 1
8/1r1rp1k1/1b1pPp2/2pP1Pp1/1pP3Pp/pP5P/P5K1/8 w - - 79 46

the cause are the shuffle extensions. Upon closer analysis, it appears that in these cases a shuffle extension is made for every node searched, and progess can not be made. This patch implements a fix, namely to limit the number of extensions relative to the number of nodes searched. The ratio employed is 1/4, which fixes the issues seen so far, but it is a heuristic, and I expect that certain positions might require an even smaller fraction.

The patch was tested as a bug fix and passed:

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 56601 W: 12633 L: 12581 D: 31387
http://tests.stockfishchess.org/tests/view/5d02b37a0ebc5925cf09f6da

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 52042 W: 8907 L: 8837 D: 34298
http://tests.stockfishchess.org/tests/view/5d0319420ebc5925cf09fe57

Furthermore, to confirm that the shuffle extension in this form indeed still brings Elo, one more test at VLTC was performed:
VLTC:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 142022 W: 20963 L: 20435 D: 100624
http://tests.stockfishchess.org/tests/view/5d03630d0ebc5925cf0a011a

Bench: 3961247
 2019-06-20 16:15:57 +02:00
syzygy1 466daf6fba Partial revert of "Assorted trivial cleanups 5/2019". 
Since root_probe() and root_probe_wdl() do not reset all tbRank values if they fail,
it is necessary to do this in rank_root_move(). This fixes issue #2196.
Alternatively, the loop could be moved into both root_probe() and root_probe_wdl().

No functional change
 2019-06-20 16:09:40 +02:00
VoyagerOne 46ce245763 Simplify SEE Pruning (#2191) 
Simplify SEE Pruning
Note this should also be a speedup...
If givesCheck is extended we know (except for DC) that it will have a positive SEE. So this new logic will be triggered before doing another expensive SEE function.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 24429 W: 5484 L: 5368 D: 13577
http://tests.stockfishchess.org/tests/view/5cffbccd0ebc5925cf09a154

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 28428 W: 4873 L: 4765 D: 18790
http://tests.stockfishchess.org/tests/view/5d0015f60ebc5925cf09acb1

Bench: 3897263
 2019-06-14 19:59:17 +02:00
protonspring 8cfe27b765 Remove backmost_sq (#2190) 
This is a non-functional simplification.

backmost_sq and frontmost_sq are redundant. It seems quite clear to always use frontmost_sq and use the correct color.

Non functional change.
 2019-06-14 08:22:02 +02:00
Stefan Geschwentner f9518de974 Increase pawns cache (#2187) 
Increase size of the pawns table by the factor 8. This decreases the number of recalculations of pawn structure information significantly (at least at LTC).

I have done measurements for different depths and pawn cache sizes.
First are given the number of pawn entry calculations are done (in parentheses is the frequency that a call to probe triggers a pawn entry calculation). The delta% are the percentage of less done pawn entry calculations in comparison to master

VSTC:   bench 1 1 12
STC:    bench 8 1 16
LTC:    bench 64 1 20
VLTC:   bench 512 1 24

            VSTC       STC         LTC          VLTC
master      82218(6%)  548935(6%)  2415422(7%)  9548071(7%)
pawncache*2 79859(6%)  492943(5%)  2084794(6%)  8275206(6%)
pawncache*4 78551(6%)  458758(5%)  1827770(5%)  7112531(5%)
pawncache*8 77963(6%)  439421(4%)  1649169(5%)  6128652(4%)

delta%(p2-m)  -2.9%      -10.2%      -13.7%       -13.3%
delta%(p4-m)  -4.5%      -16.4%      -24.3%       -25.5%
delta%(p8-m)  -5.2%      -20.0%      -31.7%       -35.8%

STC: (non-regression test because at STC the effect is smaller than at LTC)
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 22767 W: 5160 L: 5040 D: 12567
http://tests.stockfishchess.org/tests/view/5d00f6040ebc5925cf09c3e2

LTC:
LLR: 2.94 (-2.94,2.94) [0.00,4.00]
Total: 26340 W: 4524 L: 4286 D: 17530
http://tests.stockfishchess.org/tests/view/5d00a3810ebc5925cf09ba16

No functional change.
 2019-06-14 07:36:42 +02:00
VoyagerOne a9cca5c953 No DC prune in QS (#2185) 
Don't prune discover checks in qSearch

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 23176 W: 5320 L: 5039 D: 12817
http://tests.stockfishchess.org/tests/view/5cfbc9350ebc5925cf094ab3

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 128428 W: 22222 L: 21679 D: 84527
http://tests.stockfishchess.org/tests/view/5cfbf0b70ebc5925cf094ebc

Bench: 3883245
 2019-06-10 00:26:47 +02:00
Marco Costalba d39bc2efa1 Assorted trivial cleanups 5/2019 
No functional change.

bench: 4178282
 2019-06-09 14:57:08 +02:00
Stefan Geschwentner 2ead74d1e2 Remove depth condition for ttPv (#2166) 
Currently PV nodes with a depth <= 4 were ignored for ttPv. Now remove this constraint and use all PV nodes.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 52209 W: 11755 L: 11694 D: 28760
http://tests.stockfishchess.org/tests/view/5cebc2d30ebc5925cf07b93a

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20874 W: 3689 L: 3568 D: 13617
http://tests.stockfishchess.org/tests/view/5cec01fc0ebc5925cf07c62d
 2019-06-09 14:34:51 +02:00
protonspring 53d197b841 Simplify passed pawns. (#2159) 
This is a functional simplification.

If all of the stoppers are levers, a simple pawn push passes.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 41768 W: 9360 L: 9278 D: 23130
http://tests.stockfishchess.org/tests/view/5ce82ed60ebc5925cf073a79

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 40463 W: 6964 L: 6875 D: 26624
http://tests.stockfishchess.org/tests/view/5ce87d0b0ebc5925cf07472b
 2019-06-09 14:33:34 +02:00
protonspring 14e23d520f Remove a few file_of's (simplify adjacent_files_bb) #2171 
This is a non-functional simplification that removes two file_of(s).

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 22030 W: 5106 L: 4984 D: 11940
http://tests.stockfishchess.org/tests/view/5cf028de0ebc5925cf0839e7
 2019-06-09 14:31:16 +02:00
protonspring 5935daf8a5 Simplify WeakUnopposedPawn #2181 
This is a functional simplification.

Moves WeakUnopposedPawn to pawns.cpp and remove piece dependency.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 8699 W: 2000 L: 1853 D: 4846
http://tests.stockfishchess.org/tests/view/5cf7721b0ebc5925cf08ee79

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 46605 W: 7969 L: 7890 D: 30746
http://tests.stockfishchess.org/tests/view/5cf7d5f70ebc5925cf08fa96
 2019-06-09 14:28:42 +02:00
VoyagerOne 6ed81f09ff SEE Pruning Tweak (#2183) 
Don't SEE prune any check extensions

STC (yellow):
LLR: -2.96 (-2.94,2.94) [0.50,4.50]
Total: 129934 W: 29390 L: 28905 D: 71639
http://tests.stockfishchess.org/tests/view/5cf6b1a70ebc5925cf08dedb

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 102115 W: 17692 L: 17224 D: 67199
http://tests.stockfishchess.org/tests/view/5cf830710ebc5925cf090331
 2019-06-09 14:27:50 +02:00
Michael Chaly 2d06d659c0 Advanced pawn pushes tweak (#2175) 
passed STC
http://tests.stockfishchess.org/tests/view/5cf586ee0ebc5925cf08c0ed
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 29496 W: 6718 L: 6406 D: 16372

passed LTC
http://tests.stockfishchess.org/tests/view/5cf59b630ebc5925cf08c343
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 40778 W: 7057 L: 6765 D: 26956

original idea from early 2018 by @jerrydonaldwatson
Code slightly rewritten to be shorter and more logical, no functinal changes 
compared to passed patch.
 2019-06-09 14:26:53 +02:00
protonspring 09caea5cab Simplify Outposts #2176 
This is a functional simplification. This is NOT the exact version that was tested. Beyond the testing, an assignment was removed and a piece changes for consistency.

Instead of rewarding ANY square past an opponent pawn as an "outpost," only use squares that are protected by our pawn. I believe this is more consistent with what the chess world calls an "outpost."

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23540 W: 5387 L: 5269 D: 12884
http://tests.stockfishchess.org/tests/view/5cf51e6d0ebc5925cf08b823

LTC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 53085 W: 9271 L: 9204 D: 34610
http://tests.stockfishchess.org/tests/view/5cf5279e0ebc5925cf08b992

bench 3424592
 2019-06-09 14:24:06 +02:00
31m059 434b2c72a4 Simplify k-value for passers. Bench: 3854907 (#2182) 
Stockfish evaluates passed pawns in part based on a variable k, which shapes the passed pawn bonus based on the number of squares between the current square and promotion square that are attacked by enemy pieces, and the number defended by friendly ones. Prior to this commit, we gave a large bonus when all squares between the pawn and the promotion square were defended, and if they were not, a somewhat smaller bonus if at least the pawn's next square was. However, this distinction does not appear to provide any Elo at STC or LTC.

Where do we go from here? Many promising Elo-gaining patches were attempted in the past few months to refine passed pawn calculation, by altering the definitions of unsafe and defended squares. Stockfish uses these definitions to choose the value of k, so those tests interact with this PR. Therefore, it may be worthwhile to retest previously promising but not-quite-passing tests in the vicinity of this patch.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 42344 W: 9455 L: 9374 D: 23515
http://tests.stockfishchess.org/tests/view/5cf83ede0ebc5925cf0904fb

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 69548 W: 11855 L: 11813 D: 45880
http://tests.stockfishchess.org/tests/view/5cf8698f0ebc5925cf0908c8

Bench: 3854907
 2019-06-09 14:19:07 +02:00
protonspring 3edf0e6b37 Scale lazy threshold according to material. (#2170) 
STC
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 58543 W: 13238 L: 12782 D: 32523
http://tests.stockfishchess.org/tests/view/5cef3efa0ebc5925cf081f07

LTC
LLR: 3.70 (-2.94,2.94) [0.00,3.50]
Total: 82232 W: 14281 L: 13825 D: 54126
http://tests.stockfishchess.org/tests/view/5cef595d0ebc5925cf082441

bench 3807737
 2019-05-31 14:35:39 +02:00
protonspring c645587270 Simplify semiopen_file (#2165) 
This is a non-functional simplification. Since our file_bb handles either Files or Squares, using Square here removes some code. Not likely any performance difference despite the test.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 6081 W: 1444 L: 1291 D: 3346
http://tests.stockfishchess.org/tests/view/5ceb3e2e0ebc5925cf07ab03

Non functional change.
 2019-05-29 10:00:32 +02:00
Joost VandeVondele 190f38a7c2 Remove one division. (#2158) 
Can be included in the earlier calculation, with a small rounding difference.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17912 W: 4044 L: 3915 D: 9953
http://tests.stockfishchess.org/tests/view/5ce711f90ebc5925cf070d0e

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 56061 W: 9579 L: 9516 D: 36966
http://tests.stockfishchess.org/tests/view/5ce716820ebc5925cf070e37

Bench: 3817662
 2019-05-25 09:43:52 +02:00
31m059 bf6b647a1a Allow RQ through pieces. Bench: 3415326 (#2153) 
We evaluate defended and unsafe squares for a passed pawn push based on friendly and enemy rooks and queens on the passed pawn's file. Prior to this patch, we further required that these rooks and queens be able to directly attack the passed pawn. However, this restriction appears unnecessary and worth almost exactly 0 Elo at LTC.

The simplified code allows rooks and queens to attack/defend the passed pawn through other pieces of either color.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 29019 W: 6488 L: 6381 D: 16150
http://tests.stockfishchess.org/tests/view/5cdcf7270ebc5925cf05d30c

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 54224 W: 9200 L: 9133 D: 35891
http://tests.stockfishchess.org/tests/view/5cddc6210ebc5925cf05eca3

Bench: 3415326
 2019-05-17 13:38:23 +02:00
svivanov72 2985a6b5d7 Remove unused code (#2150) 
Remove an unused operator in has_game_cycle (thanks @vondele)
and modify its comment to explain other code.

No functional change.
 2019-05-16 14:14:11 +02:00
protonspring 272936eaba Score and Select Best Thread in same loop (#2125) 
This is a non-functional simplification that combines vote counting and thread selecting in the same loop.

It is possible that the best thread would be updated more frequently than master, but I'm not sure it matters here. Perhaps "mostVotes" is a better name than "bestVote?"

STC (stopped early).
LLR: 0.70 (-2.94,2.94) [-3.00,1.00]
Total: 10714 W: 2329 L: 2311 D: 6074
http://tests.stockfishchess.org/tests/view/5ccc71470ebc5925cf03d244

No functional change.
 2019-05-16 14:13:16 +02:00
protonspring 3d076a0c50 Consolidate some code in set_state. (#2151) 
Non functional change.
 2019-05-16 14:11:00 +02:00
xoto10 3a572ffb48 Update failedHighCnt rule #2063 
Treat all threads the same as main thread and increment
failedHighCnt on fail highs. This makes the search try
again at lower depth.

@vondele suggested also changing the reset of failedHighCnt
when there is a fail low. Tests including this passed so the
branch has been updated to include both changes. failedHighCnt
is now handled exactly the same in helper threads and the main
thread. Thanks vondele :-)

STC @ 5+0.05 th 4 :
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 7769 W: 1704 L: 1557 D: 4508
http://tests.stockfishchess.org/tests/view/5c9f19520ebc5925cfffd2a1

LTC @ 20+0.2 th 8 :
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 37888 W: 5983 L: 5889 D: 26016
http://tests.stockfishchess.org/tests/view/5c9f57d10ebc5925cfffd696

Bench 3824325
 2019-05-15 11:23:07 +02:00
Marco Costalba 02708a4a11 Revert "Make rootDepth local to search. (#2077)" 
This reverts commit 44c320a572.

Fix a compile error.

Bench: 3824325
 2019-05-15 10:52:15 +02:00
mstembera 4a7b8180ec Remove per thread instances of Endgames. (#2056) 
Similar to PSQT we only need one instance of the Endgames resource. The current per thread copies are identical and read only(after initialization) so from a design point of view it doesn't make sense to have them.

Tested for no slowdown.
http://tests.stockfishchess.org/tests/view/5c94377a0ebc5925cfff43ca
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17320 W: 3487 L: 3359 D: 10474

No functional change.
 2019-05-15 10:41:58 +02:00
Joost VandeVondele 44c320a572 Make rootDepth local to search. (#2077) 
passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 61869 W: 13668 L: 13626 D: 34575
http://tests.stockfishchess.org/tests/view/5ca660eb0ebc5925cf004f0c

No functional change.
 2019-05-15 10:35:58 +02:00
protonspring 4fcd78bd06 Simplify connected #2114 
This is a functional simplification that simplifies
some of the math for connected pawns. The bench is
different because I moved a /2 from opposed into
the connected array.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 37954 W: 8504 L: 8415 D: 21035
http://tests.stockfishchess.org/tests/view/5cbf599a0ebc5925cf028156

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 27780 W: 4682 L: 4572 D: 18526
http://tests.stockfishchess.org/tests/view/5cbf6a5e0ebc5925cf0284b8

Bench 3824325
 2019-05-15 10:31:21 +02:00
Moez Jellouli 2d9fac1e13 Simplify reduction formula #2122 
Simplify reduction formula

No functional change.
 2019-05-15 10:26:32 +02:00
protonspring 66820a2668 Simplify Thread Voting Scheme #2129 
This is a functional simplification of the math in the voting scheme.

It took a bit longer to pass LTC 8 threads, so perhaps more testing is needed at longer times and/or more threads.

STC 4 threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 22315 W: 4852 L: 4732 D: 12731
http://tests.stockfishchess.org/tests/view/5ccc86280ebc5925cf03d439

STC 8 threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42427 W: 8451 L: 8369 D: 25607
http://tests.stockfishchess.org/tests/view/5cccb67c0ebc5925cf03da90

LTC 4 Threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23513 W: 4208 L: 4092 D: 15213
http://tests.stockfishchess.org/tests/view/5ccce94d0ebc5925cf03e1ec

LTC 8 Threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 70098 W: 11442 L: 11399 D: 47257
http://tests.stockfishchess.org/tests/view/5ccd22aa0ebc5925cf03e463

No functional change (in single thread)
 2019-05-15 10:24:00 +02:00
svivanov72 9c7dc057d1 Precompute repetition info (#2132) 
Store repetition info in StateInfo instead of recomputing it in
three different places. This saves some work in has_game_cycle()
where this info is needed for positions before the root.

Tested for non-regression at STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 34104 W: 7586 L: 7489 D: 19029
http://tests.stockfishchess.org/tests/view/5cd0676e0ebc5925cf044b56

No functional change.
 2019-05-15 10:22:21 +02:00
xoto10 a8abba0b4d Remove pawn count in space() calculation #2139 
Simplification. Various attempts to optimise the pawn
count bonus showed little effect, so remove pawn count
altogether and compensate by subtracting 1 instead of 4.

STC 10+0.1 th 1:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 152244 W: 33709 L: 33847 D: 84688
http://tests.stockfishchess.org/tests/view/5cceed330ebc5925cf04170e

LTC 60+0.6 th 1:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 24100 W: 4079 L: 3964 D: 16057
http://tests.stockfishchess.org/tests/view/5cd5b6b80ebc5925cf04e889

Bench: 3648841
 2019-05-15 10:18:49 +02:00
xoto10 5f4d44fda0 Add eg component to evaluate_shelter() #2137 
Add an endgame component to the blockedstorm penalty
so that the penalty applies more uniformly through the game.

STC 10+0.1 th 1 :
LLR: -2.95 (-2.94,2.94) [0.50,4.50]
Total: 94063 W: 21426 L: 21118 D: 51519
http://tests.stockfishchess.org/tests/view/5cd4605c0ebc5925cf04bf43

LTC 60+0.6 th 1 :
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 188232 W: 32808 L: 32090 D: 123334
http://tests.stockfishchess.org/tests/view/5cd47d0a0ebc5925cf04c4fd

Refactored code with higher constant values gave a more convincing LTC result:
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 30050 W: 5330 L: 5066 D: 19654
http://tests.stockfishchess.org/tests/view/5cd6a0000ebc5925cf050653

Bench: 3687700
 2019-05-15 10:12:38 +02:00
Joost VandeVondele 893a08a8c2 Allow for higher depths. (#2147) 
High rootDepths, selDepths and generally searches are increasingly
common with long time control games, analysis, and improving hardware.
In this case, depths of MAX_DEPTH/MAX_PLY (128) can be reached,
and the search tree is truncated.

In principle MAX_PLY can be easily increased, except for a technicality
of storing depths in a signed 8 bit int in the TT. This patch increases
MAX_PLY by storing the depth in an unsigned 8 bit, after shifting by the
most negative depth stored in TT (DEPTH_NONE).

No regression at STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 42235 W: 9565 L: 9484 D: 23186
http://tests.stockfishchess.org/tests/view/5cdb35360ebc5925cf0595e1

Verified to reach high depths on
k1b5/1p1p4/pP1Pp3/K2pPp2/1P1p1P2/3P1P2/5P2/8 w - -
info depth 142 seldepth 154 multipv 1 score cp 537 nodes 26740713110 ...

No bench change.
 2019-05-15 09:52:27 +02:00
Michael Chaly 7df832fea6 Decrease reduction in case we had singular extension. #2146 
Passed STC http://tests.stockfishchess.org/tests/view/5cda71790ebc5925cf057a84
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 73454 W: 16482 L: 15954 D: 41018

Passed LTC http://tests.stockfishchess.org/tests/view/5cdab17b0ebc5925cf05822f
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 56696 W: 9877 L: 9538 D: 37281

Original idea by @locutus2

bench 3378510
 2019-05-15 09:49:29 +02:00
Miguel Lahoz 8a0af1004a Remove PvNode template from reduction 
This functional simplification removes the PvNode reduction and adjusts
the ttPv lmr condition accordingly. Their definitions only differ by the
inclusions of ttPv. Aside from this, shallow move pruning definition
will be the only other functional difference, but this does not seem to
matter too much.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 58908 W: 12980 L: 12932 D: 32996
http://tests.stockfishchess.org/tests/view/5cd1aaaa0ebc5925cf046c6a

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20351 W: 3521 L: 3399 D: 13431
http://tests.stockfishchess.org/tests/view/5cd23fa70ebc5925cf047cd2

Bench: 3687854
 2019-05-09 18:00:58 +02:00
Sergei Ivanov ad8b78ad52 Fix cycle detection in presence of repetitions 
In master search() may incorrectly return a draw score in the following
corner case: there was a 2-fold repetition during the game, and the
current position can be reached by a move from a repeated one. This case
is treated as an upcoming 3-fold repetition, which it is not.

Here is a testcase demonstrating the issue (note that the moves
after FEN are required). The input:

  position fen 8/8/8/8/8/8/p7/2k4K b - - 0 1 moves c1b1 h1g1 b1c1 g1h1 c1b1 h1g1 b1a1 g1h1
  go movetime 1000

produces the output:

  [...]
  info depth 127 seldepth 2 multipv 1 score cp 0 [...]
  bestmove a1b1

saying that the game will be drawn by repetion. However the other possible
move for black, Kb2, avoids repetitions and wins. The patch fixes this behavior.
In particular it finds mate in 10 in the above position.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 10604 W: 2390 L: 2247 D: 5967
http://tests.stockfishchess.org/tests/view/5cb373e00ebc5925cf0167bf

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 19620 W: 3308 L: 3185 D: 13127
http://tests.stockfishchess.org/tests/view/5cb3822f0ebc5925cf016b2d

Bench is not changed since it does not test positions with history of moves.

Bench: 3184182
 2019-05-09 15:39:57 +02:00
Stefan Geschwentner 368f976fb6 Less LMR at root 
Do no LMR for the first four moves if at root node.

STC:
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 19686 W: 4524 L: 4261 D: 10901
http://tests.stockfishchess.org/tests/view/5cd3577b0ebc5925cf04a089

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 88335 W: 15193 L: 14766 D: 58376
http://tests.stockfishchess.org/tests/view/5cd35e600ebc5925cf04a1c3

Bench: 3184182
 2019-05-09 15:25:39 +02:00
Stefan Geschwentner b6d11028bb LMR for captures not cracking alpha 
Enable LMR for a capture/promotion move which does not seem
to have a good chance to fail high according to static eval
and value of captured piece.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 40477 W: 9158 L: 8792 D: 22527
http://tests.stockfishchess.org/tests/view/5cceedc60ebc5925cf04174f

LTC:
LLR: 2.94 (-2.94,2.94) [0.00,3.50]
Total: 21926 W: 3873 L: 3634 D: 14419
http://tests.stockfishchess.org/tests/view/5ccf04310ebc5925cf041ab0

Bench: 3644175
 2019-05-05 23:18:17 +02:00
VoyagerOne aba906b734 Stat Score reset at rootNode - Bench: 3393330 (#2124) 
At rootNode reset great great grandchildren stat score i.e (ss + 4)->statScore = 0

STC: (yellow)
LLR: -2.96 (-2.94,2.94) [0.50,4.50]
Total: 256079 W: 57423 L: 56315 D: 142341
http://tests.stockfishchess.org/tests/view/5ccb0c420ebc5925cf03a6a5

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 61550 W: 10611 L: 10260 D: 40679
http://tests.stockfishchess.org/tests/view/5ccbf9d00ebc5925cf03c487

Bench: 3393330
 2019-05-04 13:41:53 +02:00
Marco Costalba 4e72e2a964 Assorted trivial cleanups 4/2019 
No functional change.
 2019-05-02 19:30:26 +02:00
Joost VandeVondele 5c4002aa82 Simplified shuffle extension version (#2121) 
only the extension part of the shuffle patch is sufficient to
pass [0,3.5] bounds at VLTC as shown by two more tests.

http://tests.stockfishchess.org/tests/view/5cc168bc0ebc5925cf02bda8
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 120684 W: 17875 L: 17400 D: 85409

http://tests.stockfishchess.org/tests/view/5cc14d510ebc5925cf02bcb5
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 68415 W: 10250 L: 9905 D: 48260

this patch proposes to simplify back to this basic and easier to
understand version. In case there is a need to run a [-3, 1] VLTC on
this one, it can be done, but it is resource intensive, and not needed
IMO.

Bench: 3388643
 2019-05-02 19:22:29 +02:00
Joost VandeVondele 7ede1ed071 Allow for address sanitizer. (#2119) 
Properly allow for sanitize=address (-fsanitize=address) as an argument to the Makefile.

No functional change
 2019-04-27 20:47:06 +02:00
Marco Costalba e4c1f8759d Fix bench number of previous patch 
bench: 3388643
 2019-04-27 11:37:51 +02:00
Michael Chaly 9a11a29194 Include bishop protection in king Danger evaluation. #2118 
Same idea as fisherman's knight protection.

passed STC
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 17133 W: 3952 L: 3701 D: 9480 
http://tests.stockfishchess.org/tests/view/5cc3550b0ebc5925cf02dada

passed LTC
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 37316 W: 6470 L: 6188 D: 24658 
http://tests.stockfishchess.org/tests/view/5cc3721d0ebc5925cf02dc90

Looking at this 2 ideas being recent clean elo gainers I have a feeling that we can add also rook and queen protection bonuses or overall move this stuff in pieces loop in the same way as we do pieces attacking bonuses on their kingring... :) Thx fisherman for original idea.

Bench 3429173
 2019-04-27 11:31:55 +02:00
MJZ1977 e89bc30fdc Shuffle detection #2108 
Bench: 3402947
 2019-04-27 11:25:23 +02:00
Joost VandeVondele 6373fd56e9 Remove useless initializations (#2115) 
Removes two unneeded inits, they are always set before their use later on.

No functional change.
 2019-04-24 19:51:57 +02:00
protonspring a858b5a84e Remove DistanceRing #2107 
Remove the DistanceRing array. This reduces the
memory footprint by about 4kb.

http://tests.stockfishchess.org/tests/view/5cba35350ebc5925cf020d7f
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 101421 W: 22491 L: 22528 D: 56402

No functional change.
 2019-04-20 08:34:14 +02:00
Joost VandeVondele bdeb01dec0 Remove capping in reduction (#2110) 
Saves two std::min.

Bench is unchanged to high depth, but in principle this is a functional change so tested both STC and LTC.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 78193 W: 17220 L: 17210 D: 43763
http://tests.stockfishchess.org/tests/view/5cb789540ebc5925cf01b90b

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 93846 W: 15964 L: 15962 D: 61920
http://tests.stockfishchess.org/tests/view/5cb8066d0ebc5925cf01c72b

Bench: 3402947
 2019-04-19 17:33:26 +02:00
Joost VandeVondele f21b503982 Simplify distance (#2109) 
Only called with Squares as argument, so remove unused variants.

As this is just syntax changes, only verified bench at high depth.

No functional change.
 2019-04-18 16:53:52 +02:00
protonspring c4fc00ec49 Remove Movepick::move (#2085) 
The "move" class variable is Movepick is removed (removes some abstraction) which saves a few assignment operations, and the effects of "filter" is limited to the current move (movePtr). The resulting code is a bit more verbose, but it is also more clear what is going on. This version is NOT tested, but is substantially similar to:

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 29191 W: 6474 L: 6367 D: 16350
http://tests.stockfishchess.org/tests/view/5ca7aab50ebc5925cf006e50

This is a non-functional simplification.
 2019-04-17 21:13:39 +02:00
protonspring 3b46df546d Move pawnsOnSquares to Position (#2100) 
We can remove the values in Pawns if we just use the piece arrays in Position. This reduces the size of a pawn entry. This simplification passed individually, and in concert with ps_passedcount100 (removes passedCount storage in pawns.).

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 19957 W: 4529 L: 4404 D: 11024
http://tests.stockfishchess.org/tests/view/5cb3c2d00ebc5925cf016f0d

Combo STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17368 W: 3925 L: 3795 D: 9648
http://tests.stockfishchess.org/tests/view/5cb3d3510ebc5925cf01709a

This is a non-functional simplification.
 2019-04-16 23:10:53 +02:00
protonspring 76777b663a Calculate passedCount real-time #2099 
This is a non-functional simplification which removes the passedCount variable in pawns.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 27982 W: 6227 L: 6118 D: 15637
http://tests.stockfishchess.org/tests/view/5cb3cdd30ebc5925cf017025

Combo STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17368 W: 3925 L: 3795 D: 9648
http://tests.stockfishchess.org/tests/view/5cb3d3510ebc5925cf01709a

Non functional test.
 2019-04-16 16:12:47 +02:00
protonspring eb07775583 Remove semiopenFiles in pawns and simplify space #2102 
This is a functional simplification.

    1. semiopenFiles is removed in pawns and uses the piece arrays in position instead.

    2. popcount is removed in space calculations and uses pawn piece count instead.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 33327 W: 7423 L: 7324 D: 18580
http://tests.stockfishchess.org/tests/view/5cb4be090ebc5925cf018511

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 10173 W: 1774 L: 1636 D: 6763
http://tests.stockfishchess.org/tests/view/5cb4c5920ebc5925cf018696

bench 3402947
 2019-04-16 16:09:36 +02:00
Joost VandeVondele 1594d15922 Remove two useless assignments (#2093) 
These variables are initialized before their use in the movepicker loop.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 138732 W: 30727 L: 30838 D: 77167
http://tests.stockfishchess.org/tests/view/5cb07af40ebc5925cf012c32

No functional change.
 2019-04-13 17:17:47 +02:00
Joost VandeVondele 42d271f23c Give penalty for all early quiets of prev. ply 
passed STC:
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 32884 W: 7283 L: 7184 D: 18417
http://tests.stockfishchess.org/tests/view/5cacb1b20ebc5925cf00ce97

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 22869 W: 3920 L: 3803 D: 15146
http://tests.stockfishchess.org/tests/view/5cacbd760ebc5925cf00cfce

Bench: 3723099
 2019-04-13 17:15:15 +02:00
protonspring a2cdb6e5d2 Simplify Connected Pawn Scoring #2090 
This is a functional simplification that simplifies
connected scoring of pawns.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 37472 W: 8318 L: 8228 D: 20926
http://tests.stockfishchess.org/tests/view/5cae74ef0ebc5925cf00f8a5

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 43035 W: 7366 L: 7281 D: 28388
http://tests.stockfishchess.org/tests/view/5caea3b50ebc5925cf00fe1e

Bench: 3470173
 2019-04-13 16:58:41 +02:00
Marco Costalba 5928cb2b30 Revert "Shuffle detection #2064" 
It causes a serious regression hanging a simple fixed
depth search. Reproducible with:

position fen q1B5/1P1q4/8/8/8/6R1/8/1K1k4 w - - 0 1
go depth 13

The reason is a search tree explosion due to:

if (... && depth < 3 * ONE_PLY)
      extension = ONE_PLY;

This is very dangerous code by itself because triggers **at the leafs**
and in the above position keeps extending endlessly. In normal games
time deadline makes the search to stop sooner or later, but in fixed
seacrch we just hang possibly for a very long time. This is not acceptable
because 'go depth 13' shall not be a surprise for any position.

This patch reverts commit 76f1807baa.
and fixes the issue https://github.com/official-stockfish/Stockfish/issues/2091

Bench: 3243738
 2019-04-12 13:48:04 +02:00
miguel-l 5b5687d76e Extend dangerous passed pawn moves (#2089) 
Introduce a new search extension when pushing an advanced passed pawn is
also suggested by the first killer move. There have been previous tests
which have similar ideas, mostly about pawn pushes, but it seems to be
overkill to extend too many moves. My idea is to limit the extension to
when a move happens to be noteworthy in some other way as well, such as
in this case, when it is also a killer move.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 19027 W: 4326 L: 4067 D: 10634
http://tests.stockfishchess.org/tests/view/5cac2cde0ebc5925cf00c36d

LTC:
LLR: 2.94 (-2.94,2.94) [0.00,3.50]
Total: 93390 W: 15995 L: 15555 D: 61840
http://tests.stockfishchess.org/tests/view/5cac42270ebc5925cf00c4b9

For future tests, it looks like this will interact heavily with passed
pawn evaluation. It may be good to try more variants of some of the more
promising evaluations tests/tweaks.

Bench: 3666092
 2019-04-10 19:35:47 +02:00
protonspring ec49e676a7 Simplify castlingPath (#2088) 
Instead of looping through kfrom,kto, rfrom, rto, we can use BetweenBB. This is less lines of code and it is more clear what castlingPath actually is. Personal benchmarks are all over the place. However, this code is only executed when loading a position, so performance doesn't seem that relevant.

No functional change.
 2019-04-10 19:33:57 +02:00
31m059 ab4b94e173 Raise kingDanger threshold and adjust constant term #2087 
The kingDanger term is intended to give a penalty which increases rapidly in the middlegame but less so in the endgame. To this end, the middlegame component is quadratic, and the endgame component is linear. However, this produces unintended consequences for relatively small values of kingDanger: the endgame penalty will exceed the middlegame penalty. This remains true up to kingDanger = 256 (a S(16, 16) penalty), so some of these inaccurate penalties are actually rather large.

In this patch, we increase the threshold for applying the kingDanger penalty to eliminate some of this unintended behavior. This was very nearly, but not quite, sufficient to pass on its own. The patch was finally successful by integrating a second kingDanger tweak by @Vizvezdenec, increasing the kingDanger constant term slightly and improving both STC and LTC performance.

Where do we go from here? I propose that in the future, any attempts to tune kingDanger coefficients should also consider tuning the kingDanger threshold. The evidence shows clearly that it should not be automatically taken to be zero.

Special thanks to @Vizvezdenec for the kingDanger constant tweak. Thanks also to all the approvers and CPU donors who made this possible!

STC:
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 141225 W: 31239 L: 30846 D: 79140
http://tests.stockfishchess.org/tests/view/5cabbdb20ebc5925cf00b86c

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 30708 W: 5296 L: 5043 D: 20369
http://tests.stockfishchess.org/tests/view/5cabff760ebc5925cf00c22d

Bench: 3445945
 2019-04-09 19:35:17 +02:00
protonspring f98c77413b Remove BetweenBB Array #2076 
Non functional change.
 2019-04-09 13:46:12 +02:00
Marco Costalba 8fa6273ff6 Fix sed for OS X (#2080) 
The sed command is a bit different in Mac OS X (why not!).

The ‘-i’ option required a parameter to tell what extension to add for the 
backup file. To fix it, just add extension for backup file, for example ‘.bak’ 

Fix broken Trevis CI test

No functional change.
 2019-04-06 12:43:41 +02:00
erbsenzaehler 49a1fdd3fe Make ONE_PLY value independent again 
And a Trevis CI test to catch future issues.

No functional change.
 2019-04-06 11:15:17 +02:00
Marco Costalba fdd799bc16 Fix a missing assignment in previous commit 
While reformatting the patch, I got wrong a statement and converted it badly.
 2019-04-06 02:03:15 +02:00
xoto10 1982fe25f8 Use average bestMoveChanges across all threads #2072 
The current update only by main thread depends on the luck of
whether main thread sees any/many changes to the best move or not.
It then makes large, lumpy changes to the time to be
used (1x, 2x, 3x, etc) depending on that sample of 1.
Use the average across all threads to get a more reliable
number with a smoother distribution.

STC @ 5+0.05 th 4 :
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 51899 W: 11446 L: 11029 D: 29424
http://tests.stockfishchess.org/tests/view/5ca32ff20ebc5925cf0016fb

STC @ 5+0.05 th 8 :
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 13851 W: 2843 L: 2620 D: 8388
http://tests.stockfishchess.org/tests/view/5ca35ae00ebc5925cf001adb

LTC @ 20+0.2 th 8 :
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 48527 W: 7941 L: 7635 D: 32951
http://tests.stockfishchess.org/tests/view/5ca37cb70ebc5925cf001cec

Further work:
Similar changes might be possible for the fallingEval and timeReduction calculations (and elsewhere?), using either the min, average or max values across all threads.

Bench 3506898
 2019-04-05 20:37:16 +02:00
Moez Jellouli 0f63b35120 Remove pureStaticEval #2069 
Remove pureStaticEval variable and keep only one
static evaluation (ss->staticEval).

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 64617 W: 14348 L: 14312 D: 35957 Elo -0.24
http://tests.stockfishchess.org/tests/view/5c9e1ad70ebc5925cfffc106

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 82200 W: 13703 L: 13680 D: 54817 Elo -0.24
http://tests.stockfishchess.org/tests/view/5c9e4efd0ebc5925cfffc68b

Bench : 3506898
 2019-04-04 09:40:34 +02:00
Moez Jellouli aa0166fba6 Add attacked by 2 pawns to attackedBy2 (#2074) 
Add squares attacked by 2 pawns to the attackedBy2 array

STC :
LLR: -2.95 (-2.94,2.94) [0.50,4.50]
Total: 132722 W: 29583 L: 29090 D: 74049
http://tests.stockfishchess.org/tests/view/5ca231ba0ebc5925cf000794

LTC :
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 94589 W: 16161 L: 15718 D: 62710
http://tests.stockfishchess.org/tests/view/5ca25d180ebc5925cf000ba4

Bench: 3337864
 2019-04-04 08:49:35 +02:00
Marco Costalba 82ad9ce9cf Assorted trivial cleanups 3/2019 (#2030) 
No functional change.
 2019-03-31 11:47:36 +02:00
protonspring 95ba7f78d5 Use simple array for Pawns Connected bonus #2061 
Simplification which removes the pawns connected array.
Instead of storing the values in an array, the values are
calculated real-time. This is about 1.6% faster on my machines.

Performance:
master ave nps: 159,248,672
patch ave nps: 161,905,592

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 20363 W: 4579 L: 4455 D: 11329
http://tests.stockfishchess.org/tests/view/5c9925ba0ebc5925cfff79a6

Non functional change.
 2019-03-31 11:28:48 +02:00
Moez Jellouli 76f1807baa Shuffle detection #2064 
Shuffle detection procedure :

Shuffling positions are detected if

    the last 36 moves are reversible (rule50_count() > 36),
    the position have been already in the TT,
    there is a still a pawn on the board (to avoid special endings like KBN vs K).

The position is then judged as a draw.

An extension is realized if we already made 14 successive reversible moves in PV to accelerate the detection of the eventual draw.

To go further : we can still improve the idea. The length of the tests need a lot of ressources.

    the limit of 36 is logic but must be checked again for special zugzwang positions,
    this limit can be decreased in special positions,
    the limit of 14 moves for extension has not been tuned.

STC
LLR: -2.94 (-2.94,2.94) [0.50,4.50]
Total: 32595 W: 7273 L: 7275 D: 18047 Elo +0.43
http://tests.stockfishchess.org/tests/view/5c90aa330ebc5925cfff1768

LTC
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 51249 W: 8807 L: 8486 D: 33956 Elo +1.85
http://tests.stockfishchess.org/tests/view/5c90b2450ebc5925cfff1800

VLTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 137974 W: 20503 L: 19983 D: 97488 Elo +1.05
http://tests.stockfishchess.org/tests/view/5c9243a90ebc5925cfff2a93

Bench: 3548313
 2019-03-31 10:51:08 +02:00
protonspring c858990377 Replace std::mins/max with clamp function (#2062) 
Adding a clamp function makes some of these range limitations a bit prettier and removes some #include's.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 28117 W: 6300 L: 6191 D: 15626
http://tests.stockfishchess.org/tests/view/5c9aa1df0ebc5925cfff8fcc

Non functional change.
 2019-03-31 10:48:27 +02:00
Joost VandeVondele d1f76ebcd8 Remove duplication. (#2068) 
always use the implementation of gives_check in position, no need to
hand-inline part of the implementation in search.

LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 57895 W: 12632 L: 12582 D: 32681
http://tests.stockfishchess.org/tests/view/5c9eaa4b0ebc5925cfffc9e3

No functional change.
 2019-03-31 10:44:55 +02:00
protonspring 796d0ad70e Accessor for SquareBB #2067 
This is a non-functional code style change.

If we add an accessor function for SquareBB we can consolidate all of the asserts. This is also a bit cleaner because all SquareBB accesses go through this method making future changes easier to manage.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 63406 W: 14084 L: 14045 D: 35277
http://tests.stockfishchess.org/tests/view/5c9ea6100ebc5925cfffc9af

No functional change.
 2019-03-31 10:43:20 +02:00
protonspring 7133598a98 Simplify pawn asymmetry (remove use of semiopen files). (#2054) 
This is a functional simplification.

To me, the exclusive OR of semiopenFiles here is quite convoluted. Looks like it can be removed.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 43885 W: 9731 L: 9653 D: 24501
http://tests.stockfishchess.org/tests/view/5c9041680ebc5925cfff10ea

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 68437 W: 11577 L: 11533 D: 45327
http://tests.stockfishchess.org/tests/view/5c9101740ebc5925cfff1cbf

bench 3575627
 2019-03-24 17:41:25 +01:00
Joost VandeVondele 2f11c03bbf Remove unneeded condition. (#2057) 
This is covered by the line just before. If we would like to protect
against the piece value of e.g. a N == B, this could be done by an
assert, no need to do this at runtime.

No functional change.
 2019-03-24 17:40:29 +01:00
protonspring ea5505821d Simplify Passed Pawns (#2058) 
This is a non-functional simplification/speedup.

The truth-table for popcount(support) >= popcount(lever) - 1 is:
------------------lever
------------------0-------1---------2
support--0------X-------X---------0
-----------1------X-------X---------X
-----------2------X-------X---------X

Thus, it is functionally equivalent to just do: support || !more_than_one(lever) which removes the expensive popcounts and the -1.

Result of 20 runs:
base (...h_master.exe) = 1451680 +/- 8202
test (./stockfish ) = 1454781 +/- 8604
diff = +3101 +/- 931

STC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 35424 W: 7768 L: 7674 D: 19982
Http://tests.stockfishchess.org/tests/view/5c970f170ebc5925cfff5e28

No functional change.
 2019-03-24 17:37:38 +01:00
xoto10 d320de7619 Remove !extension check #2045 
While looking at pruning using see_ge() (which is very valuable)
it became apparent that the !extension test is not adding any
value - simplify it away.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 56843 W: 12621 L: 12569 D: 31653
http://tests.stockfishchess.org/tests/view/5c8588cb0ebc5925cffe77f4

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 78622 W: 13223 L: 13195 D: 52204
http://tests.stockfishchess.org/tests/view/5c8611cc0ebc5925cffe7f86

Further work could be to optimize the remaining see_ge() test. The idea of less pruning at higher depths is valuable, but perhaps the test (-PawnValueEg * depth) can be improved.

Bench: 3188688
 2019-03-20 14:57:34 +01:00
CoffeeOne 66818f2e85 Skip skipping thread scheme (#1972) 
Several simplification tests (all with the bounds [-3,1]) were run:
5+0.05 8 threads, failed very quickly:
http://tests.stockfishchess.org/tests/view/5c439a020ebc5902bb5d3970

20+0.2 8 threads, also failed, but needed a lot more games:
http://tests.stockfishchess.org/tests/view/5c44b1b70ebc5902bb5d4e34

60+0.6 8 threads passed:
http://tests.stockfishchess.org/tests/view/5c48bfe40ebc5902bca15325

60+0.6 4 threads passed:
http://tests.stockfishchess.org/tests/view/5c4b71a00ebc593af5d49904

No functional change.
 2019-03-20 14:50:41 +01:00
Marco Costalba bad18bccb6 Increase thread stack for OS X (#2035) 
On OS X threads other than the main thread are created with a reduced stack
size of 512KB by default, this is dangerously low for deep searches, so
adjust it to TH_STACK_SIZE. The implementation calls pthread_create() with
proper stack size parameter.

Verified for no regression at STC enabling the patch on all platforms where
pthread is supported.

LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 50873 W: 9768 L: 9700 D: 31405

No functional change.
 2019-03-12 08:35:10 +01:00
protonspring b8efa0daac Remove popcount16() (#2038) 
This is a non-functional simplification / code-style change.

This popcount16 method does nothing but initialize the PopCnt16 arrays.

This can be done in a single bitset line, which is less lines and more clear. Performance for this code is moot.

No functional change.
 2019-03-10 10:53:39 +01:00
xoto10 acc47e8b79 Simplify failedLow away #1986 
FailedLow doesn't seem to add any value so remove it.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 43915 W: 9682 L: 9604 D: 24629
http://tests.stockfishchess.org/tests/view/5c5339770ebc592fc7baef74

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 58515 W: 9670 L: 9609 D: 39236
http://tests.stockfishchess.org/tests/view/5c53cc840ebc592fc7baf6c1

Ideas for further work:

    Tune the values in the revised fallingEval calculation
    Consider adding a term using delta, e.g. c * (delta - 20) as an indicator of eval instability

Bench: 3318033
 2019-03-10 10:47:42 +01:00
Marco Costalba 4d0981fef3 Revert "Allowing singular extension in mate positions" 
It was causing an assert: value > -VALUE_INFINITE
under some conditions.

See https://github.com/official-stockfish/Stockfish/issues/2036

Bench: 3318033
 2019-03-09 13:28:11 +01:00
protonspring 1aab5b4b05 Remove FutilityMoveCounts array. (#2024) 
This is a functional simplification that removes the FutilityMoveCounts array with a simple equation using only ints.

LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 14175 W: 3123 L: 2987 D: 8065

LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 9900 W: 1735 L: 1597 D: 6568

Bench: 3380343
 2019-03-05 20:48:29 +01:00
protonspring 714e857c24 Shrink Reductions[] array to one dimension 
This is a non-functional patch which shrinks the reductions array.
This saves about 8Kb of memory.

The only slow part of master's reductions array is the calculation
of the log values, so using a separate array for those values and
calculating the rest real-time appears to be just as fast as master.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 63245 W: 13906 L: 13866 D: 35473
http://tests.stockfishchess.org/tests/view/5c7b571f0ebc5925cffdc104

No funcional change.
 2019-03-05 19:02:04 +01:00
SFisGOD 58bbbd176b Pawn value tweak 
STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 47166 W: 10664 L: 10311 D: 26191
http://tests.stockfishchess.org/tests/view/5c7dfc370ebc5925cffdf830

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 35439 W: 6034 L: 5767 D: 23638
http://tests.stockfishchess.org/tests/view/5c7e41020ebc5925cffdfe9b

Bench: 3470519
 2019-03-05 14:54:25 +01:00
Marco Costalba 2bceba7f51 Assorted trivial cleanups 2/2019 
No functional change.
 2019-03-05 11:13:02 +01:00
Vizvezdenec c2fb0ff720 Add continuation history 5 
Original patch passed STC:
http://tests.stockfishchess.org/tests/view/5c7439ff0ebc5925cffd3e64
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 26348 W: 5926 L: 5632 D: 14790

and LTC:
http://tests.stockfishchess.org/tests/view/5c745a8b0ebc5925cffd41a8
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 198411 W: 33238 L: 32510 D: 132663

But had undefined behavior.
After fixing (thx to @vondele )

passed LTC:
http://tests.stockfishchess.org/tests/view/5c763c7c0ebc5925cffd5de2
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 112253 W: 18711 L: 18225 D: 75317

bench 3049229
 2019-03-05 11:10:10 +01:00
Joost VandeVondele 82ff04b992 Remove skipQuiets with mate fix. (#2021) 
This removes the skipQuiets variable, as was done in an earlier round by
@protonspring, but fixes an oversight which led to wrong mate
announcements. Quiets can only be pruned when there is no mate score, so
set moveCountPruning at the right spot.

tested as a fix at STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 66321 W: 14690 L: 14657 D: 36974
http://tests.stockfishchess.org/tests/view/5c74f3170ebc5925cffd4b3c

and as the full patch at LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 25903 W: 4341 L: 4228 D: 17334
http://tests.stockfishchess.org/tests/view/5c7540030ebc5925cffd506f

Bench: 3292342
 2019-02-27 13:36:48 +01:00
Marco Costalba 7c5f5fbada Revert "Remove skipQuiets variable in search()" 
This reverts commit 76d2f5b94a.

Due to a bug, see https://github.com/official-stockfish/Stockfish/issues/2019

Bench: 3516616
 2019-02-26 13:23:09 +01:00
Kurtbusch badb2aca44 Add KNNvKP Endgame Heuristic 
This is a somewhat different patch. It fixes blindspots for
 two knights vs pawn endgame.

With local testing starting from random KNNvKP positions where the
pawn has not advanced beyond the 4th rank (thanks @protonspring !)
at 15+0.15 (4 cores), this went +105=868-27 against master. All except
two losses were won in reverse.

The heuristic is simple but effective - the strategy in these endgames
is to push the opposing king to the corner, then move the knight that's
blocking the pawn in for the checkmate while the pawn is free to move
and prevents stalemate. This patch gives SF the little boost it needs
to search the relevant king-cornering mating lines.

See the discussion in pull request 1939 for some more good results for
this test in independant tests:
https://github.com/official-stockfish/Stockfish/pull/1939

Bench: 3310239
 2019-02-21 19:53:03 +01:00
MJZ1977 e51244cb27 ProbCutCount limit dependancy to cutNode 
Use the ProbCutCount limit `2 + 2 * cutNode` instead of constant 3.

STC
LLR: -2.95 (-2.94,2.94) [0.50,4.50]
Total: 61812 W: 13599 L: 13459 D: 34754
http://tests.stockfishchess.org/tests/view/5c6d19240ebc5925cffca07a

LTC
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 27549 W: 4614 L: 4363 D: 18572
http://tests.stockfishchess.org/tests/view/5c6d45c10ebc5925cffca7a6

Closes https://github.com/official-stockfish/Stockfish/pull/2015

Bench: 3368889
 2019-02-21 19:36:48 +01:00
protonspring 22ef36803e Remove PvNode dimension from Reductions array 
This is a functional simplification: if we simply subtract one to Reductions[]
when PvNode is set, we can remove this dimension of the multidimensional array.
I think this saves about 8K of memory.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 10118 W: 2282 L: 2138 D: 5698
http://tests.stockfishchess.org/tests/view/5c6332b60ebc5925cffbdfed

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 70765 W: 11617 L: 11575 D: 47573
http://tests.stockfishchess.org/tests/view/5c63379e0ebc5925cffbe0de

Closes https://github.com/official-stockfish/Stockfish/pull/2010

Bench 3261078
 2019-02-21 19:24:02 +01:00
protonspring 76d2f5b94a Remove skipQuiets variable in search() 
This is a functional simplification. The moveCountPruning variable and the
skipQuiets variable are similar enough in function that they can be combined.
This removes the skipQuiets variable in search.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 23278 W: 5210 L: 5091 D: 12977
http://tests.stockfishchess.org/tests/view/5c65dc490ebc5925cffc12e9

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 77107 W: 12792 L: 12761 D: 51554
http://tests.stockfishchess.org/tests/view/5c65e4360ebc5925cffc1490

Closes https://github.com/official-stockfish/Stockfish/pull/2011

bench 3640330
 2019-02-21 19:18:02 +01:00
protonspring 3c92f849ab Change outposts to single value #1946 
This is a functional simplification of the Outposts array
moving it to a single value. This is a duplicate PR because
I couldn't figure out how to fix the original one.

The idea is from @31m059 with formatting recommendations by @snicolet.

See #1940 for additional information.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23933 W: 5279 L: 5162 D: 13492
http://tests.stockfishchess.org/tests/view/5c3575800ebc596a450c5ecb

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 41718 W: 6919 L: 6831 D: 27968
http://tests.stockfishchess.org/tests/view/5c358c440ebc596a450c6117

bench 3783543
 2019-02-08 10:31:28 +01:00
Marco Costalba 05f7d59a9a Assorted trivial cleanups 1/2019 
To address #1862

No functional change.
 2019-02-08 10:20:43 +01:00
Marco Costalba 332b90455b Log message of: Less king danger... 
The commit:

Less king danger if we have a knight near by to defend it

went in withouth proper commit message, here below we add it:

STC: LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 113106 W: 25087 L: 24367 D: 63652
http://tests.stockfishchess.org/tests/view/5c5517540ebc592fc7bb0eb4

LTC: LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 96669 W: 16318 L: 15872 D: 64479
http://tests.stockfishchess.org/tests/view/5c55352b0ebc592fc7bb11c8

bench: 3653942
 2019-02-08 10:19:00 +01:00
protonspring dd4796fcd5 Remove Some Bitboard Arrays (#1963) 
This is non-functional. These 5 arrays are simple enough to calculate real-time and maintaining an array for them does not help. Decreases the memory footprint.

This seems a tiny bit slower on my machine, but passed STC well enough. Could someone verify speed?

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 44745 W: 9780 L: 9704 D: 25261
http://tests.stockfishchess.org/tests/view/5c47aa2d0ebc5902bca13fc4

The slowdown is minimal even in 32 bit case (thanks to @mstembera for testing):

Compiled using make build ARCH=x86-32 CXX=i686-w64-mingw32-c++ and benched
This patch only:

```
Results for 40 tests for each version:

            Base      Test      Diff      
    Mean    1455204   1450033   5171      
    StDev   49452     34533     59621     

p-value: 0.465
speedup: -0.004
```

No functional change.
 2019-02-08 09:54:38 +01:00
mstembera 6514500236 Less king danger if we have a knight near by to defend it. (#1987) 
bench: 3653942
 2019-02-03 14:16:34 +01:00
Miguel Lahoz 9050eac595 Extend discovered checks regardless of SEE 
A simple idea, but it makes sense: in current master the search is extended
for checks that are considered somewhat safe, and for for this we use the
static exchange evaluation which only considers the `to_sq` of a move.
This is not reliable for discovered checks, where another piece is giving
the check and is arguably a more dangerous type of check. Thus, if the check
is a discovered check, the result of SEE is not relevant and can be ignored.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 29370 W: 6583 L: 6274 D: 16513
http://tests.stockfishchess.org/tests/view/5c5062950ebc593af5d4d9b5

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 227341 W: 37972 L: 37165 D: 152204
http://tests.stockfishchess.org/tests/view/5c5094fb0ebc593af5d4dc2c

Bench: 3611854
 2019-02-01 16:27:21 +01:00
Stéphane Nicolet ff97a9fdb9 Tweak tropism weight in king danger 
There was a simplification attempt last week for the tropism
term in king danger, which passed STC but failed LTC. This
was an indirect sign that maybe the tropism factor was sightly
untuned in current master, so we tried to change it from 1/4
to 5/16.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 28098 W: 6264 L: 5990 D: 15844
http://tests.stockfishchess.org/tests/view/5c518db60ebc593af5d4e306

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 103709 W: 17387 L: 16923 D: 69399
http://tests.stockfishchess.org/tests/view/5c52a5510ebc592fc7baea8b

Bench: 4016000
 2019-02-01 15:34:46 +01:00
Vizvezdenec 3f7ec977cd More precise checks evaluation in king danger 
Remove overlapping safe checks from kingdanger:
- rook and queen checks from the same square: rook check is preferred
- bishop and queen checks form the same square: queen check is preferred

Increase bishop and rook check values as a compensation.

STC
LLR: 2.95 (-2.94,2.94) [0.50,4.50]
Total: 27480 W: 6111 L: 5813 D: 15556
http://tests.stockfishchess.org/tests/view/5c521d050ebc593af5d4e66a

LTC
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 78500 W: 13145 L: 12752 D: 52603
http://tests.stockfishchess.org/tests/view/5c52b9460ebc592fc7baecc5

Closes https://github.com/official-stockfish/Stockfish/pull/1983

------------------------------------------

I have quite a few ideas of how to improve this patch.

- actually rethinking it now it will maybe be useful to discount
  queen/bishop checks if there is only one square that they can
  give check from and it's "occupied" by more valuable check. Right
  now count of this squares does not really matter.

- maybe some small extra bonus can be given for overlapping checks.

- some ideas about using popcount() on safechecks can be retried.

- tune this safecheck values since they were more or less randomly handcrafted in this patch.

Bench: 3216489
 2019-02-01 12:43:33 +01:00
protonspring d1fd1a96bc Simplify Stat Score bonus 
This is a functional simplification of this statScore bonus.
There seems to be little risk of regression with this one.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 26829 W: 5892 L: 5781 D: 15156
http://tests.stockfishchess.org/tests/view/5c5086bb0ebc593af5d4db75

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 28232 W: 4684 L: 4575 D: 18973
http://tests.stockfishchess.org/tests/view/5c50d7690ebc593af5d4dec9

Closes https://github.com/official-stockfish/Stockfish/pull/1979

Bench: 4001014
 2019-01-31 15:21:24 +01:00
DU-jdto 3302349662 Don't update pvHit after IID 
This patch removes line 875 of search.cpp, which was updating pvHit after IID.
Bench testing at depth 22 shows that line 875 of search.cpp never changes the
value of pvHit at NonPV nodes, while at PV nodes it often changes the value
from true to false (and never the reverse). This is because the definition of
pvHit at line 642 is :

```
pvHit = (ttHit && tte->pv_hit()) || (PvNode && depth > 4 * ONE_PLY);
```

while the assignment after IID omits the ` (PvNode && depth > 4 * ONE_PLY) `
condition. As such, unlike the other two post-IID tte reads, this line of code
does not make SF's state more consistent, but rather introduces an inconsistency
in the definition of pvHit. Indeed, changing line 875 read

```
pvHit = (ttHit && tte->pv_hit()) || (PvNode && depth > 4 * ONE_PLY);
```

to match line 642 is functionally equivalent to removing the line entirely, as
this patch does.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 62756 W: 13787 L: 13746 D: 35223
http://tests.stockfishchess.org/tests/view/5c446c850ebc5902bb5d4b75

LTC
LLR: 3.19 (-2.94,2.94) [-3.00,1.00]
Total: 61900 W: 10179 L: 10111 D: 41610
http://tests.stockfishchess.org/tests/view/5c45bf610ebc5902bb5d5d62

Bench: 3796134
 2019-01-29 17:40:00 +01:00
Miguel Lahoz 242c566c1a Change pinning logic in Static Exchange Evaluation (SEE) 
This changes 2 parts with regards to static exchange evaluation.

Currently, we do not allow pinned pieces to recapture if *all* opponent
pinners are still in their starting squares. This changes that to having
a less strict requirement, checking if *any* pinners are still in their
starting square. This makes our SEE give more respect to the pinning
side with regards to exchanges, which makes sense because it helps our
search explore more tactical options.

Furthermore, we change the logic for saving pinners into our state
variable when computing slider_blockers. We will include double pinners,
where two sliders may be looking at the same blocker, a similar concept
to our mobility calculation for sliders in our evaluation section.
Interestingly, I think SEE is the only place where the pinners bitboard
is actually used, so as far as I know there are no other side effects
to this change.

An example and some insights:

White Bf2, Kg1
Black Qe3, Bc5

The move Qg3 will be given the correct value of 0. (Previously < 0)
The move Qd4 will be incorrectly given a value of 0. (Previously < 0)

It seems the tradeoff in search is worth it. Qd4 will likely be pruned
soon by something like probcut anyway, while Qg3 could help us spot
tactics at an earlier depth.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 62162 W: 13879 L: 13408 D: 34875
http://tests.stockfishchess.org/tests/view/5c4ba1a70ebc593af5d49c55

LTC: (Thanks to @alayant)
LLR: 3.40 (-2.94,2.94) [0.00,3.50]
Total: 140285 W: 23416 L: 22825 D: 94044
http://tests.stockfishchess.org/tests/view/5c4bcfba0ebc593af5d49ea8

Bench: 3937213
 2019-01-29 17:32:41 +01:00
Maciej Żenczykowski 8df1cd10df Use int8_t instead of int for SquareDistance[] 
This patch saves (4-1) * 64 * 64 = 12KiB of cache.

STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 176120 W: 38944 L: 38087 D: 99089
http://tests.stockfishchess.org/tests/view/5c4c9f840ebc593af5d4a7ce

LTC
As a pure speed up, I've been informed it should not require LTC.

No functional change
 2019-01-29 17:26:24 +01:00
protonspring 2d0af36753 Simplify TrappedRook 
Simplified TrappedRook to a single penalty removing the dependency on mobility.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 106718 W: 23530 L: 23577 D: 59611
http://tests.stockfishchess.org/tests/view/5c43f6bd0ebc5902bb5d4131

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 54053 W: 8890 L: 8822 D: 36341
http://tests.stockfishchess.org/tests/view/5c44932a0ebc5902bb5d4d59

bench 3665090
 2019-01-22 09:54:10 +01:00
Joost VandeVondele 58d3ee6175 Simplify pondering time management (#1899) 
stopOnPonderhit is used to stop search quickly on a ponderhit. It is set by mainThread as part of its time management. However, master employs it as a signal between mainThread and the UCI thread. This is not necessary, it is sufficient for the UCI thread to signal that pondering finished, and mainThread should do its usual time-keeping job, and in this case stop immediately.

This patch implements this, removing stopOnPonderHit as an atomic variable from the ThreadPool,
and moving it as a normal variable to mainThread, reducing its scope. In MainThread::check_time() the search is stopped immediately if ponder switches to false, and the variable stopOnPonderHit is set.

Furthermore, ponder has been moved to mainThread, as the variable is only used to exchange signals between the UCI thread and mainThread.

The version has been tested locally (as fishtest doesn't support ponder):

Score of ponderSimp vs master: 2616 - 2528 - 8630 [0.503] 13774
Elo difference: 2.22 +/- 3.54

which indicates no regression.

No functional change.
 2019-01-20 19:14:24 +01:00
marotear 59b2486bc3 Simplify pvHit (#1953) 
Removing unnecessary excludedMove condition (there is not excluded move for PvNodes) and re-ordering computation.

Non functional change.
 2019-01-20 12:24:03 +01:00
protonspring 691a287bfe Clean-up some shifting in space calculation (#1955) 
No functional change.
 2019-01-20 12:21:16 +01:00
Jonathan D 3acacf8471 Tweak initiative and Pawn PSQT (#1957) 
Small changes in initiative(). For Pawn PSQT, endgame values for d6-e6 and d7-e7 are now symmetric. The MG value of d2 is now smaller than e2 (d2=13, e2=21 now compared to d2=19, e2=16 before). The MG values of h5-h6-h7 also increased so this might encourage stockfish for more h-pawn pushes.

STC
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 81141 W: 17933 L: 17777 D: 45431
http://tests.stockfishchess.org/tests/view/5c4017350ebc5902bb5cf237

LTC
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 83078 W: 13883 L: 13466 D: 55729
http://tests.stockfishchess.org/tests/view/5c40763f0ebc5902bb5cff09

Bench: 3266398
 2019-01-20 12:20:21 +01:00
protonspring 3300517ecb Remove AdjacentFiles 
This is a non-functional simplification that removes the AdjacentFiles array.
This array is simple enough to calculate that the pre-calculated array provides
no benefit. Reduces the memory footprint.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 74839 W: 16390 L: 16373 D: 42076
http://tests.stockfishchess.org/tests/view/5c3d75920ebc596a450cfb67

No functionnal change
 2019-01-17 08:11:09 +01:00
protonspring 3732c55c18 Simplify pawn moves (#1900) 
If we define dcCandidates with & pawnsNotOn7, 
we don't have to & it both times.

This seems more clear to me as well.

Tested for no regression.
STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 44042 W: 9663 L: 9585 D: 24794
http://tests.stockfishchess.org/tests/view/5c21d9120ebc5902ba12e84d

No functional change.
 2019-01-14 15:03:31 +01:00
Joost VandeVondele 230fb6e9ad Simplify time management a bit 
The new form is likely to trigger a bit more at LTC. Given that LTC
appears to be an improvement, I think that is fine.

The change is not very invasive: it does the same as before, use
potentially less time for moves that are very stable. Most of the
time, the full bonus was given if the bonus was given, so the gradual
part {3, 4, 5} didn't matter much. Whereas previously 'stable' was
expressed as the last 80% of iterations are the same, now I use a
fixed depth (10 iterations). For TCEC style TC, it will presumably
imply some more moves that are played quicker (and thus more time
on the clock when it potentially matters). Note that 10 iterations
of stability means we've been proposing that move for 99.9% of search
time.

passed STC
http://tests.stockfishchess.org/tests/view/5c30d2290ebc596a450c055b
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 70921 W: 15403 L: 15378 D: 40140

passed LTC
http://tests.stockfishchess.org/tests/view/5c31ae240ebc596a450c1881
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17422 W: 2968 L: 2842 D: 11612

No functional change.
 2019-01-14 09:25:22 +01:00
Joost VandeVondele 5446e6f408 Remove pvExact 
The variable pvExact now overlaps with the pvHit concept. So you simplify
the logic with small code tweaks to have pvHit trigger where pvExact
previously triggered.

passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20558 W: 4497 L: 4373 D: 11688
http://tests.stockfishchess.org/tests/view/5c36e9fd0ebc596a450c7885

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23482 W: 3888 L: 3772 D: 15822
http://tests.stockfishchess.org/tests/view/5c37072d0ebc596a450c7a52

Bench: 3739723
 2019-01-10 16:46:04 +01:00
mstembera d07e782e22 Minor cleanup to recent 'Flag critical search tree in hash table' patch 
No functional change
 2019-01-10 16:36:59 +01:00
Joost VandeVondele d2acdac101 Small improvements to the CI infrastructure 
- avoid inlining for the debug testing so that suppressions work
- provide more output for triggered errors

No functional change.
 2019-01-09 16:57:24 +01:00
MJZ1977 70880b8e24 Flag critical search tree in hash table 
Introducing new concept, saving principal lines into the transposition table
to generate a "critical search tree" which we can reuse later for intelligent
pruning/extension decisions.

For instance in this patch we just reduce reduction for these lines. But a lot
of other ideas are possible.

To go further : tune some parameters, how to add or remove lines from the
critical search tree, how to use these lines in search choices, etc.

STC :
LLR: 2.94 (-2.94,2.94) [0.50,4.50]
Total: 59761 W: 13321 L: 12863 D: 33577 +2.23 ELO
http://tests.stockfishchess.org/tests/view/5c34da5d0ebc596a450c53d3

LTC :
LLR: 2.96 (-2.94,2.94) [0.00,3.50]
Total: 26826 W: 4439 L: 4191 D: 18196 +2.9 ELO
http://tests.stockfishchess.org/tests/view/5c35ceb00ebc596a450c65b2

Special thanks to Miguel Lahoz for his help in transposition table in/out.

Bench: 3399866
 2019-01-09 15:05:33 +01:00
Miguel Lahoz f69106f7bb Introduce Multi-Cut 
This was inspired after reading about
[Multi-Cut](https://www.chessprogramming.org/Multi-Cut).

We now do non-singular cut node pruning. The idea is to prune when we
have a "backup plan" in case our expected fail high node does not fail
high on the ttMove.

For singular extensions, we do a search on all other moves but the
ttMove. If this fails high on our original beta, this means that both
the ttMove, as well as at least one other move was proven to fail high
on a lower depth search. We then assume that one of these moves will
work on a higher depth and prune.

STC:
LLR: 2.96 (-2.94,2.94) [0.50,4.50]
Total: 72952 W: 16104 L: 15583 D: 41265
http://tests.stockfishchess.org/tests/view/5c3119640ebc596a450c0be5

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,3.50]
Total: 27103 W: 4564 L: 4314 D: 18225
http://tests.stockfishchess.org/tests/view/5c3184c00ebc596a450c1662

Bench: 3145487
 2019-01-06 16:02:31 +01:00
Joost VandeVondele bb843a00c1 Check tablebase files 
This addresses partially issue #1911 in that it documents in our
Readme the command that users can use to verifying the md5sum of
their downloaded tablebase files.

Additionally, a quick check of the file size (the size of each
tablebase file modulo 64 is 16 as pointed out by @syzygy1) has been
implemented at launch time in Stockfish.

Closes https://github.com/official-stockfish/Stockfish/pull/1927
and https://github.com/official-stockfish/Stockfish/issues/1911

No functional change.
 2019-01-04 15:36:39 +01:00
Marco Costalba 3c576efa77 Delay castling legality check 
Delay legality check of castling moves at search time,
just before making the move, as is the standard with all
the other move types.

This should avoid an useless and not trivial legality check
when the castling is then not tried later. For instance due
to a previous cut-off.

The patch is also a big simplification and allows to entirely
remove generate_castling()

Bench changes due to a different move sequence out of MovePicker.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 45073 W: 9918 L: 9843 D: 25312
http://tests.stockfishchess.org/tests/view/5c2f176f0ebc596a450bdfb3

LTC:
LLR: 3.15 (-2.94,2.94) [-3.00,1.00]
Total: 10156 W: 1707 L: 1560 D: 6889
http://tests.stockfishchess.org/tests/view/5c2e7dfd0ebc596a450bcdf4

Verified with perft both in standard and Chess960 cases.

Closes https://github.com/official-stockfish/Stockfish/pull/1929

Bench: 3559104
 2019-01-04 14:23:14 +01:00
Marco Costalba eb6d7f537d Assorted trivial cleanups (#1894) 
To address https://github.com/official-stockfish/Stockfish/issues/1862

No functional change.
 2019-01-01 14:10:26 +01:00
protonspring 79c97625a4 Remove openFiles in pawns. (#1917) 
A single popcount in evaluate.cpp replaces all openFiles stuff in pawns. It doesn't seem to affect performance at all.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 28103 W: 6134 L: 6025 D: 15944
http://tests.stockfishchess.org/tests/view/5b7d70a20ebc5902bdbb1999

No functional change.
 2019-01-01 13:38:09 +01:00
protonspring 7accf07c0b Remove "Any" predicate filter (#1914) 
This custom predicate filter creates an unnecessary abstraction layer, but doesn't make the code any more readable. The code is clear enough without it.

No functional change.
 2019-01-01 13:36:56 +01:00
protonspring e2d3c163cb Remove as useless micro-optimization in pawns generation (#1915) 
The extra condition is used as a shortcut to skip the following 3 assignments:

```C++
        Bitboard b1 = shift<UpRight>(pawnsOn7) & enemies;
        Bitboard b2 = shift<UpLeft >(pawnsOn7) & enemies;
        Bitboard b3 = shift<Up     >(pawnsOn7) & emptySquares;
```

In case of EVASION with no target on 8th rank (the common case), we end up performing the 3 statements for nothing because b1 = b2 = b3 = 0.

But this is just a small micro-optimization and the condition is quite confusing, so just remove it and prefer a readable code instead.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 78020 W: 16978 L: 16967 D: 44075
http://tests.stockfishchess.org/tests/view/5c27b4fe0ebc5902ba135bb0

No functional change.
 2019-01-01 13:35:53 +01:00
erbsenzaehler 800031c94c Improve the Readme 
I tried to improve the Readme because many people in my local
chess club do not understand some of the UCO options properly.
Starting point of this was Cfish's Readme by Ronald de Man,
some internet resources and the Stockfish code itself.

Closes https://github.com/official-stockfish/Stockfish/pull/1898

Initial commit by user @erbsenzaehler, with help from users
Adrian Petrescu, @alayan-stk-2 and Elvin Liu.

No functional change

Co-Authored-By: Alayan-stk-2 <alayan-stk-2@users.noreply.github.com>
Co-Authored-By: Adrian Petrescu <apetresc@gmail.com>
Co-Authored-By: Elvin Liu <solarlight2@users.noreply.github.com>
 2018-12-29 11:49:16 +01:00
31m059 69dc5568b3 Always initialize and evaluate king safety 
Recent tests by @xoto10, @Vizvezdenec, and myself seemed to hint that Elo could
be gained by expanding the number of cases where king safety is applied. Several
users (@Spliffjiffer, @Vizvezdenec) have anticipated benefits specifically in
evaluation of tactics. It appears that we actually do not need to restrict the
cases in which we initialize and evaluate king safety at all: initializing and
evaluating it in every position appears roughly Elo-neutral at STC and possibly
a substantial Elo gain at LTC.

Any explanation for this scaling is, at this point, conjecture. Assuming it is
not due to chance, my hypothesis is that initialization of king safety in all
positions is a mild slowdown, offset by an Elo gain of evaluating king safety
in all positions. At STC this produces Elo gains and losses that offset each
other, while at longer time control the slowdown is much less important, leaving
only the Elo gain. It probably helps SF to explore king attacks much earlier in
search with high numbers of enemy pieces concentrating but not essentially attacking
king ring.

Thanks to @xoto10 and @Vizvezdenec for helping run my LTC!

Closes https://github.com/official-stockfish/Stockfish/pull/1906

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 35432 W: 7815 L: 7721 D: 19896
http://tests.stockfishchess.org/tests/view/5c24779d0ebc5902ba131b26

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 12887 W: 2217 L: 2084 D: 8586
http://tests.stockfishchess.org/tests/view/5c25049a0ebc5902ba132586

Bench: 3163951

------------------

How to continue from there?

* Next step will be to tune all the king danger terms once more after that :-)
 2018-12-27 21:38:31 +01:00
noobpwnftw 14c4a40dc7 Simplify SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX loop (#1892) 
When iterating through 'SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX' structure, do not use structure member beyond known size.

API is guaranteed to provide us at lease one element upon successful, and no element in the structure can have a zero size.

No functional change.
 2018-12-24 11:24:29 +01:00
noobpwnftw 0194da0d80 Fix crash in best_group() (#1891) 
This pull request fixes a rare crashing bug on Windows inside our NUMA code, first
reported by Dann Corbit in the following forum thread (thanks!):
https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/gA6aoMEuOwg

The fix is to not use structure member beyond known size when iterating through
'SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX' structure. We note that the Microsoft
API is guaranteed to provide us at least one element upon successful, and no
element in the structure can have a zero size.

No functional change.
 2018-12-24 11:20:14 +01:00
Joost VandeVondele ade87ff8d3 Extend stack to ss-5, and remove conditions 
The `&& (ss-1)->killers[0] ` conditions are there seemingly to protect
accessing ss-5.

This is unneeded and not so intuitive (as the killer is checked for equality
with currentMove, and that one is non-zero once we're high enough in the stack,
this protects access to ss-5). We can just extend the stack from ss-4 to ss-5,
so we can call update_continuation_histories(ss-1, ..) always in search.

This goes a bit further than #1881 and addresses a comment in #1878.

passed STC:
http://tests.stockfishchess.org/tests/view/5c1aa8d50ebc5902ba127ad0
LLR: 3.12 (-2.94,2.94) [-3.00,1.00]
Total: 53515 W: 11734 L: 11666 D: 30115

passed LTC:
http://tests.stockfishchess.org/tests/view/5c1b272c0ebc5902ba12858d
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 140176 W: 23123 L: 23192 D: 93861

Bench: 3451321
 2018-12-24 11:06:47 +01:00
protonspring 96ac85b319 Improve endgame KBN vs K (#1877) 
Even when playing without endgame table bases, this particular endgame should
be a win 100% of the time when Stockfish is given a KRBK position, assuming
there are enough moves remaining in the FEN to finish the game without hitting
the 50 move rule.

PROBLEM: The issue with master here is that the PushClose difference per square
is 20, however, the difference in squares for the PushToCorners array is usually
less. Thus, the engine prefers to move the kings closer together rather than pushing
the weak king to the correct corner.

What happens is if the weak king is in a safe corner, SF still prefers pushing the
kings together. Occasionally, the strong king traps the weak king in the safe corner.
It takes a while for SF to figure it out, but often draws the game by the 50 move rule
(on shorter time controls).

This patch increases the PushToCorners values to correct this problem. We also added
an assert to catch any overflow problem if anybody would want to increase the array
values again in the future.

It was tested in a couple of matches starting with random KRBK positions and showed
increased winning rates, see https://github.com/official-stockfish/Stockfish/pull/1877

No functional change
 2018-12-24 10:44:38 +01:00
erbsenzaehler 2089c414da Update our continuous integration machinery (#1889) 
* Update our continuous integration machinery

Ubuntu 16.04 can now be used with travis. Updating all the other stuff
when there.
Invoking the lld linker seems to save 5 minutes with clang on linux.

No functional change.

* fix
 2018-12-23 18:17:44 +01:00
mstembera 656aad8b0c Use a bit less code to calculate hashfull() (#1830) 
* Use a bit less code to calculate hashfull(). Change post increment to preincrement as is more standard
in the rest of stockfish.  Scale result so we report 100% instead of 99.9% when completely full.

No functional change.
 2018-12-23 16:10:07 +01:00
mstembera ae5d2c38e1 Turn on random access for Syzygy files in Windows (#1840) 
* This is the Windows version of
https://github.com/official-stockfish/Stockfish/pull/1829

No functional change.
 2018-12-23 16:09:03 +01:00
protonspring 59d32f8edd Simplify generate_castling (#1885) 
Although this is a compile-time constant, we stick the castlingSide into a CastlingRight, then pull it out again. This seems unecessarily complex.

No functional change.
 2018-12-23 16:05:24 +01:00
protonspring b54bcfddaa Simplify KBNK endgame implementation 
We do not need to change the winnerKSq variable, so we can simplify
a little bit the logic of the code by changing only the loserKSq
variable when it is necessary. Also consolidate and clarify comments.

See the pull request thread for a proof that the code is correct:
https://github.com/official-stockfish/Stockfish/pull/1854

No functional change
 2018-12-20 10:47:18 +01:00
Guenther Demetz 0f2df4e4af Tweak main killer penalty 
Apply refuted main killer penalty also on early TT cut-offs. This
makes penalty logic more consistent with the logic at normal search.

Failed STC:
http://tests.stockfishchess.org/tests/view/5c121e730ebc5902ba11aad8
LLR: -2.95 (-2.94,2.94) [0.00,5.00]
Total: 72193 W: 15848 L: 15625 D: 40720 Elo +1.07

Passed LTC:
http://tests.stockfishchess.org/tests/view/5c17b1b10ebc5902ba123c24
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 35073 W: 5886 L: 5625 D: 23562 Elo +2.59

Closes https://github.com/official-stockfish/Stockfish/pull/1878

bench: 3393939
 2018-12-18 09:38:06 +01:00
mstembera 67ae53b020 New voting formula for threads 
We now use a quadratic formula during the vote for threads
when deciding on which thread to pick a move from.

time control 5+0.05, with 8 threads:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 20202 W: 4031 L: 3813 D: 12358
http://tests.stockfishchess.org/tests/view/5c16c8e60ebc5902ba1223e2

time control 20+0.2, with 8 threads:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 14330 W: 2290 L: 2115 D: 9925
http://tests.stockfishchess.org/tests/view/5c16efca0ebc5902ba122993

20000 games match at time control 5+0.05, with 31 threads:
ELO: 5.63 +-2.8 (95%) LOS: 100.0%
Total: 20000 W: 3539 L: 3215 D: 13246
http://tests.stockfishchess.org/tests/view/5c16f07a0ebc5902ba122a20

Closes https://github.com/official-stockfish/Stockfish/pull/1876

No functional change (in simple thread mode)
 2018-12-18 08:51:25 +01:00
31m059 7240a90bf9 Use stronglyProtected 
~stronglyProtected is quite similar to ~attackedBy[Them][PAWN] & ~attackedBy2[Them],
the only difference appears to be that the former includes squares attacked twice
by both sides. The resulting logic is simpler, and the change appears to be at least
Elo-neutral at both STC and LTC.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 35924 W: 7978 L: 7885 D: 20061
http://tests.stockfishchess.org/tests/view/5c14a5c00ebc5902ba11ed72

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 37078 W: 6125 L: 6030 D: 24923
http://tests.stockfishchess.org/tests/view/5c14ae880ebc5902ba11eed8

Bench: 3646542
 2018-12-16 10:04:49 +01:00
Alain SAVARD 64a6138d37 Refactor king ring calculation 
Compute the "double protection by pawns" expression only once
in initialize(), instead of once for each piece in the piece loop.

Passed STC
http://tests.stockfishchess.org/tests/view/5c1506380ebc5902ba11f3b4
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 9494 W: 2191 L: 2045 D: 5258

Inspired by Nick Pelling's test
   http://tests.stockfishchess.org/tests/view/5c144d110ebc5902ba11e4af
and an older test of mine
   http://tests.stockfishchess.org/tests/view/5c0402810ebc5902bcee1fc8

Non functional change.
 2018-12-16 09:57:43 +01:00
Joost VandeVondele 4e2bb8fa44 Fix a segfault. 
this patch fixes a rare but reproducible segfault observed playing a
multi-threaded match, it is discussed somewhat in fishcooking.

From the core file, it could be observed that the issue was in qsearch, namely:

````
   ss->pv[0] = MOVE_NONE;
````

and the backtrace shows the it arrives there via razoring, called from the rootNode:

````
    (gdb) bt
    alpha=-19, beta=682, depth=DEPTH_ZERO) at search.cpp:1247
````

Indeed, ss->pv can indeed by a nullptr at the rootNode. However, why is the
segfault so rare ?

The reason is that the condition that guards razoring:

````
   (depth < 2 * ONE_PLY &&  eval <= alpha - RazorMargin)
````

is almost never true, since at the root alpha for depth < 5 is -VALUE_INFINITE.

Nevertheless with the new failHigh scheme, this is not guaranteed, and rootDepth > 5,
can still result in a depth < 2 search at the rootNode. If now another thread,
via the hash, writes a new low eval to the rootPos qsearch can be entered.
Rare but not unseen... I assume that some of the crashes in fishtest recently
might be due to this.

Closes https://github.com/official-stockfish/Stockfish/pull/1860

No functional change
 2018-12-16 09:53:11 +01:00
Joost VandeVondele fda0161e3a Start a TT resize only after search finished. 
As noticed in the forum, a crash in extract_ponder_from_tt could result
if hash size is set before the ponder move is printed. While it is arguably
a GUI issue (but it got me on the cli), it is easy to avoid this issue.

Closes https://github.com/official-stockfish/Stockfish/pull/1856

No functional change.
 2018-12-16 09:41:09 +01:00
31m059 4f3804f3f3 Remove Null Move Pruning material threshold 
On November 30th, @xoto10 experimented with removing this threshold,
but the simplification barely failed LTC. I was inspired to try various
[0, 4] tweaks to increase its value, which would narrow the effects of
this threshold without removing it entirely. Various values repeatedly
led to Elo gains at both STC and LTC, most of which were insufficient
to pass.

After a couple of weeks, I tried again to find an Elo-gaining tweak
but noticed that I could raise the threshold higher and higher without
regression. I decided to try removing it entirely--forgetting that
@xoto10 had already attempted this. However, this now performs much
better at both STC and LTC, producing a STC Elo gain and also potentially
a smaller LTC one.

The reason appears to be a recent change in master (e8ffca3) near
this code, which interacts with this patch. This simplification
governs the conditions under which that patch's effects are applied.
Something non-obvious about that change has significantly improved
the performance of this simplification.

I recognize and thank @xoto10, who originally had this idea. Since
I ran several LTCs recently (to determine whether to open this PR,
or one for a related [0, 4]), I would also like to acknowledge the
other developers and CPU donors for their patience. Thank you all!

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 13445 W: 3000 L: 2862 D: 7583
http://tests.stockfishchess.org/tests/view/5c11f01b0ebc5902ba11a6b8

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 33868 W: 5663 L: 5563 D: 22642
http://tests.stockfishchess.org/tests/view/5c11ffe90ebc5902ba11a8a9

Closes https://github.com/official-stockfish/Stockfish/pull/1870

Bench: 3343286
 2018-12-16 09:32:37 +01:00
SFisGOD 31ac538f96 A combo of parameter tweaks 
Joint work by SFisGOD, xoroshiro and Chess13234.

This combo consists of the following tweaks:
Assorted bonuses and penalties by SFisGOD
Bishop and Rook PSQT by SFisGOD
Tempo Value by xoroshiro
Futility pruning by Chess13234

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 9005 W: 2082 L: 1882 D: 5041
http://tests.stockfishchess.org/tests/view/5c11628c0ebc5902ba119e90

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 44207 W: 7451 L: 7157 D: 29599
http://tests.stockfishchess.org/tests/view/5c1172a40ebc5902ba119fa3

Bench: 3332460
 2018-12-13 13:35:35 +01:00
Kurt 883367d217 Asymmetrical 8x8 Pawn PSQT 
STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 13323 W: 3015 L: 2818 D: 7490
http://tests.stockfishchess.org/tests/view/5c00a2520ebc5902bcedd41b

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 52294 W: 9093 L: 8756 D:34445
http://tests.stockfishchess.org/tests/view/5c00b2c40ebc5902bcedd596

Some obvious followups to this are to further tune this PSQT, or
try 8x8 for other pieces. As of now I don't plan on trying this
for other pieces as I think the majority of the ELO it brings is
for pawns and kings.

Looking at the new values, the differences between kingside and
queenside are quite significant. I am very hopeful that this a
llows SF to understand and plan pawn structures even better than
it already does. Cheers!

Closes https://github.com/official-stockfish/Stockfish/pull/1839

Bench: 3569243
 2018-12-13 13:20:31 +01:00
protonspring e917bd59b1 Changes identified in RENAME/REFORMATTING thread (#1861) 
I've gone through the RENAME/REFORMATTING thread and changed everything I could find, plus a few more. With this, let's close the previous issue and open another.

No functional change.
 2018-12-11 13:47:56 +01:00
VoyagerOne e8ffca3eb4 Tweak CMH pruning 
STC: (yellow)
LLR: -2.94 (-2.94,2.94) [0.00,5.00]
Total: 48919 W: 10625 L: 10517 D: 27777
http://tests.stockfishchess.org/tests/view/5c07e6a20ebc5902bcee7395

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 50360 W: 8424 L: 8102 D: 33834
http://tests.stockfishchess.org/tests/view/5c0812450ebc5902bcee76f4

Bench: 3775064
 2018-12-09 13:11:13 +01:00
protonspring 4e2e4759a1 remove extra line. 2018-12-09 12:59:57 +01:00
protonspring a8e903c33a remove parenthesis. 2018-12-09 12:59:57 +01:00
protonspring 090e49547e add paren. 2018-12-09 12:59:57 +01:00
protonspring fefc0c6789 simplify opposite_colors 2018-12-09 12:59:57 +01:00
Stéphane Nicolet 5c2fbcd09b Revert "pseudo_legal() and MOVE_NONE" 
This reverts commit 33d9548218 ,
which crashed in DEBUG mode because of the following assert in position.h

````
Assertion failed: (is_ok(m)), function capture, file ./position.h, line 369.
````

No functional change
 2018-12-06 15:04:04 +01:00
VoyagerOne 7b4f9c37cb Simplify Killer Move Penalty 
STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20816 W: 4525 L: 4402 D: 11889
http://tests.stockfishchess.org/tests/view/5c017cb90ebc5902bcede5b4

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 39287 W: 6401 L: 6309 D: 26577
http://tests.stockfishchess.org/tests/view/5c01825e0ebc5902bcede686

Bench: 3773021
 2018-12-06 14:40:08 +01:00
xoto10 b19ad4977c Simplify time manager in search() 
Remove the F[] array which I find unhelpful and rename `improvingFactor` to
`fallingEval` since larger values indicate a falling eval and more time use.

I realise a test was not strictly necessary, but I ran STC [-3,1] just to
check there are no foolish errors before creating the pull request:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 35804 W: 7753 L: 7659 D: 20392
http://tests.stockfishchess.org/tests/view/5bef3a0c0ebc595e0ae39c19

It was then suggested to clean the constants around `fallingEval`
to make it more clear this is a factor around ~1 that adjusts time
up or downwards depending on some conditions. We then ran a double
test with this simplification suggestion:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 68435 W: 14936 L: 14906 D: 38593
http://tests.stockfishchess.org/tests/view/5c02c56b0ebc5902bcee0184

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 37258 W: 6324 L: 6230 D: 24704
http://tests.stockfishchess.org/tests/view/5c030a520ebc5902bcee0a32

No functional change
 2018-12-06 14:08:39 +01:00
protonspring 33d9548218 pseudo_legal() and MOVE_NONE 
MOVE_NONE is represented as SQ_A1 to SQ_A1 which is never pseudo_legal.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 38807 W: 8363 L: 8275 D: 22169
http://tests.stockfishchess.org/tests/view/5c05f11d0ebc5902bcee4c86

No functional change
 2018-12-06 14:02:29 +01:00
Vizvezdenec 9dc6d270fc Introduce concept of double pawn protection. 
Exclude doubly protected by pawns squares when calculating attackers on
king ring. Idea of this patch is not to count attackers if they attack
only squares that are protected by two pawns.

STC
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 70040 W: 15476 L: 15002 D: 39562
http://tests.stockfishchess.org/tests/view/5c0354860ebc5902bcee1106

LTC
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 16530 W: 2795 L: 2607 D: 11128
http://tests.stockfishchess.org/tests/view/5c0385080ebc5902bcee14b5

This is third king safety patch in recent times so we probably need
retuning of king safety parameters.

Bench: 3057978
 2018-12-02 20:18:51 +01:00
Miguel Lahoz 982fd9c8bc Penalize refuted killers in continuation history 
Currently we apply a penalty in continuation history for refuted TT moves.
We can use the same idea to also penalize refuted killer moves in continuation
history.

STC:
http://tests.stockfishchess.org/tests/view/5c00ccbd0ebc5902bcedd768
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 54366 W: 12086 L: 11687 D: 30593

LTC:
http://tests.stockfishchess.org/tests/view/5c0107880ebc5902bceddc9c
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 25457 W: 4302 L: 4078 D: 17077

Bench: 3419069
 2018-12-01 11:28:10 +01:00
ElbertoOne 79e3710fd2 Remove Overload bonus 
Compensate by giving the Hanging bonus to weak doubly-attacked
non pawn enemies pieces.

STC: http://tests.stockfishchess.org/tests/view/5bfd53c40ebc5902bced9237
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 62107 W: 13664 L: 13622 D: 34821

LTC: http://tests.stockfishchess.org/tests/view/5bfd74700ebc5902bced9618
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 86406 W: 14381 L: 14365 D: 57660

A possible follow up would be to tune the hanging bonus and/or try to
simplify the hanging bonus condition.

Bench: 3810849
 2018-12-01 10:29:10 +01:00
Stéphane Nicolet 9b276a6596 Restore development version 
No functional change
 2018-11-29 16:17:23 +01:00
Stéphane Nicolet b4c239b625 Stockfish 10 
Official release version of Stockfish 10.

This is also the 10th anniversary version of the Stockfish project, which
started exactly ten years ago! I wish to extend a huge thank you to
all contributors and authors in our amazing community :-)

Bench: 3939338
 2018-11-29 15:45:26 +01:00
Stéphane Nicolet 622360ad66 Update list of authors 
No functional change
 2018-11-29 15:15:43 +01:00
Sebastian Buchwald 340e9ea509 Use emplace_back() in TB code 
The patch was tested for correctness by running bench with and
without the change against current master, and the tablebase hit
numbers were found to be identical in both cases. See the pull
request comments for details:
https://github.com/official-stockfish/Stockfish/pull/1826

No functional change.
 2018-11-29 15:01:54 +01:00
31m059 7b6fa353a3 Simplify casting extension 
On November 16th, before the removal of the depth condition, I tried
revising castling extensions to only handle castling moves, rather than
moves that change castling rights generally. It appeared to be a slight
Elo gain at STC but insufficient to pass [0, 4] (+0.5 Elo), but what I
overlooked was that it made pos.can_castle(us) irrelevant and should
have been a simplification. Recent discussion with @Chess13234 and
Michael Chaly (@Vizvezdenec) inspired me to take a second look, and
the simplification continues to pass when rebased on the current master.

This replaces two conditions with one, because type_of(move) == CASTLING
implies pos.can_castle(Us), allowing us to remove the latter condition.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 110948 W: 24209 L: 24263 D: 62476
http://tests.stockfishchess.org/tests/view/5bf8f65c0ebc5902bced3a63

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 88283 W: 14681 L: 14668 D: 58934
http://tests.stockfishchess.org/tests/view/5bf994a60ebc5902bced4349

Bench: 3939338
 2018-11-27 08:53:14 +01:00
Steinar H. Gunderson de7182f4ee Turn on MADV_RANDOM for Syzygy mmaps (on Unix-like builds) 
When running on a cloud VM (n1-highcpu-96) with several NVMe SSDs and
some non-SSDs for tablebases, I noticed that the average SSD request size was
more than 256 kB. This doesn't make a lot of sense for Syzygy tablebases,
which have a block size of 32 bytes and very low locality.

Seemingly, the tablebase access patterns during probing make the OS,
at least Linux, think that readahead is advantageous; normally, it
gives up doing readahead if there are too many misses, but it doesn't,
perhaps due to the fairly high overall hit rates. (It seems the kernel cannot
distinguish between reading a block that was paged in because the userspace
wanted it explicitly, and one that was read as part of readahead.)

Setting MADV_RANDOM effectively turns off readahead, which causes
the request size to drop to 4 kB. In the aforemented cloud VM test,
this roughly tripled the amount of I/O requests that were able to go
through, while reducing the total traffic from 2.8 GB/sec to 56 MB/sec
(moving the bottleneck to the non-SSDs; it seems the SSDs could have
sustained many more requests).

Closes https://github.com/official-stockfish/Stockfish/pull/1829

No functional change.
 2018-11-27 08:39:23 +01:00
Jörg Oster 6ab92d2e1c Qsearch simplification. (#1828) 
Don't do an extra TT update in case of a fail-high,
but simply break off the moves loop and let the TT update
at the end of qsearch do this job.
Same workflow/logic as in our main search function now.

Tested for no regression to be on the safe side.
STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 30237 W: 6665 L: 6560 D: 17012
http://tests.stockfishchess.org/tests/view/5bf928e80ebc5902bced3f3a

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 51067 W: 8625 L: 8553 D: 33889
http://tests.stockfishchess.org/tests/view/5bf937180ebc5902bced3fdc

No functional change.
 2018-11-25 11:27:40 +01:00
Vizvezdenec bb58bc215c Reintroduce tropism to kingdanger 
Tropism in kingdanger was simplified away in this pull request #1821.
This patch reintroduces tropism in kingdanger with using quadratic scaling.

Passed STC http://tests.stockfishchess.org/tests/view/5bf7c1b10ebc5902bced1f8f
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 52803 W: 11835 L: 11442 D: 29526

Passed LTC http://tests.stockfishchess.org/tests/view/5bf816e90ebc5902bced24f1
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 17204 W: 2988 L: 2795 D: 11421

How do we continue from there?

I've recently tried to introduce tropism difference term in kingdanger which
passed STC 6 times but failed LTC all the time. Maybe using quadratic scaling
for it will also be helpful.

Bench 4041387
 2018-11-24 02:14:18 +01:00
31m059 6e66e7aae2 Remove the tropism term from kingDanger 
A recent LTC tuning session by @candirufish showed this term decreasing significantly. It appears that it can be removed altogether without significant Elo loss.

I also thank @GuardianRM, whose attempt to remove tropism from king danger inspired this one.

After this PR is merged, my next step will be to attempt to tune the coefficients of this new, simplified kingDanger calculation.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 12518 W: 2795 L: 2656 D: 7067
http://tests.stockfishchess.org/tests/view/5befadda0ebc595e0ae3a289

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 164771 W: 26463 L: 26566 D: 111742
http://tests.stockfishchess.org/tests/view/5befcca70ebc595e0ae3a343

LTC 2, rebased on Stockfish 10 beta:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 75226 W: 12563 L: 12529 D: 50134
http://tests.stockfishchess.org/tests/view/5bf2e8910ebc5902bcecb919

Bench: 3412071
 2018-11-24 02:09:35 +01:00
Joost VandeVondele 4b88bea4fc Force time check on TB probe in search. 
Because of aggressive time management and optimistic assumptions
about move overhead, it's still very easy to get Stockfish to forfeit
on time when we hit an endgame and have Syzygy EGTB on a spinning
drive. The latency from serving a few thousand EGTB probes (~10ms each),
of which there can currently be up to 4000 outstanding before a time
check, will easily overwhelm the default Move Overhead of 30ms.

This problem was first raised by Gian-Carlo Pascutto and some solutions
and improvements were discussed in the following pull requests:
https://github.com/official-stockfish/Stockfish/pull/1471
https://github.com/official-stockfish/Stockfish/pull/1623
https://github.com/official-stockfish/Stockfish/pull/1783

This patch is a minimal change proposed by Marco Costalba to lower
the impact of the bug. We now force a check of the clock right after
each tablebase read.

No functional change.
 2018-11-20 08:00:19 +01:00
xoto10 3925750945 Bonus for restricting opponent's piece moves 
STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 51883 W: 11297 L: 10915 D: 29671
http://tests.stockfishchess.org/tests/view/5bf1e2ee0ebc595e0ae3cacd

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 15859 W: 2752 L: 2565 D: 10542
http://tests.stockfishchess.org/tests/view/5bf337980ebc5902bcecbf62

Notes:

(1) The bonus value has not been carefully tested, so it may be possible
to find slightly better values.

(2) Plan is to now try adding similar restriction for pawns. I wanted to
include that as part of this pull request, but I was advised to do it as
two separate pull requests. STC is currently running here, but may not add
enough value to pass green.

Bench: 3679086
 2018-11-20 07:50:12 +01:00
Stéphane Nicolet cf5d683408 Stockfish 10-beta 
Preparation commit for the upcoming Stockfish 10 version, giving a chance to catch last minute feature bugs and evaluation regression during the one-week code freeze period. Also changing the copyright dates to include 2019.

No functional change
 2018-11-19 11:18:21 +01:00
SFisGOD 3f2ec5b3d5 Tweak Queen PSQT based on tuned values 
STC: (Yellow)
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 63140 W: 13433 L: 13353 D: 36354
http://tests.stockfishchess.org/tests/view/5bed42c90ebc595e0ae37cf5

LTC: (Green)
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 47714 W: 7785 L: 7485 D: 32444
http://tests.stockfishchess.org/tests/view/5bec3b8c0ebc595e0ae36dec

Closes https://github.com/official-stockfish/Stockfish/pull/1816

Bench: 3717396
 2018-11-19 10:50:55 +01:00
Kurt b92206305f Tune evaluation scores 
STC:
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 84697 W: 18173 L: 18009 D: 48515
http://tests.stockfishchess.org/tests/view/5bea366f0ebc595e0ae34793

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 157625 W: 25533 L: 24893 D: 107199
http://tests.stockfishchess.org/tests/view/5be8b69e0ebc595e0ae33024

Personally, I feel like SF has been tuned to death recently and that we
need to step away from existing-parameter tunes for a bit and focus more
on new ideas. I don't really think there's much more ELO in these tunes
(for now). For me at least, this was the last existing-parameter tune I'll
be running for quite a while. Cheers!

Bench: 3572567
 2018-11-19 10:42:46 +01:00
protonspring d2274e609c Remove BlockedStorm array 
Apparently, only RANK_3 is relevant. This removes a look-up and the
BlockedStorm array, but adds another conditional.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 84340 W: 18054 L: 18054 D: 48232
http://tests.stockfishchess.org/tests/view/5bea10f40ebc595e0ae3457b

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 31874 W: 5135 L: 5032 D: 21707
http://tests.stockfishchess.org/tests/view/5beadb6a0ebc595e0ae35542

Closes https://github.com/official-stockfish/Stockfish/pull/1814

Bench: 3799443
 2018-11-19 10:37:34 +01:00
VoyagerOne 4111f36f45 Simplify Castle Extension 
Remove depth condition in castle extension, also don't extend if
Singular Extension and Check Extansion fail to extend.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 42070 W: 9118 L: 9036 D: 23916
http://tests.stockfishchess.org/tests/view/5be899cc0ebc595e0ae32f07

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 78278 W: 12490 L: 12458 D: 53330
http://tests.stockfishchess.org/tests/view/5be8ac420ebc595e0ae33010

Bench: 3611041
 2018-11-19 10:28:55 +01:00
protonspring 0e508f30bb Code style in search.cpp 
It does not appear to be not necessary or advantageous to
conditionally initialize kingRing[Us] or kingAttackersCount[Them],
so the 'else' can be removed.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 22873 W: 4923 L: 4804 D: 13146
http://tests.stockfishchess.org/tests/view/5be9a8270ebc595e0ae33c7e

No functional change
 2018-11-19 10:16:07 +01:00
Nikolay Kostov 4350a66ffa Update a comment in the evaluate.cpp file to reflect recent change 
No functional change
 2018-11-19 10:10:47 +01:00
SFisGOD 8a9c298dee Rook PSQT Tuned 
Failed STC (Yellow )
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 56302 W: 12007 L: 11953 D: 32342
http://tests.stockfishchess.org/tests/view/5be69d210ebc595e0ae3185b

Passed 1st LTC (Green)
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 8745 W: 1480 L: 1301 D: 5964
http://tests.stockfishchess.org/tests/view/5be682960ebc595e0ae31818

Failed 2nd LTC (Red)
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 19398 W: 3040 L: 3133 D: 13225
http://tests.stockfishchess.org/tests/view/5be69b840ebc595e0ae31856

Passed 3rd LTC (Green)
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 107516 W: 17342 L: 16858 D: 73316
http://tests.stockfishchess.org/tests/view/5bea879a0ebc595e0ae34d80

Closes https://github.com/official-stockfish/Stockfish/pull/1809

How to continue from there?

The values in the rook table now look a bit strange for a human eye
and are hard to explain, maybe it would be nice to simplify them
by hand and see if we can pass another (clean) double green with a
more regular array.

Bench: 3188070
 2018-11-19 10:02:31 +01:00
Vizvezdenec 2a7213f720 Change default contempt from 21 to 24 centipawns 
To top the rating lists and get more interesting middle play, it
is a good habit to set the default contempt to the highest value
that does not regress against contempt=0. We recently decreased
PawnValueEg it is logical that to raise a little bit the default
higher contempt because of the following internal dependency in
line 334 of search.cpp :

````
int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns
````

STC: contempt=24 passed non-regression vs contempt=0
http://tests.stockfishchess.org/tests/view/5bd6d7f80ebc595e0ae21e14

LTC: contempt=24 passed non-regression LTC vs contempt=0
http://tests.stockfishchess.org/tests/view/5bd6e0980ebc595e0ae21f07

On 2018-11-01, we also tested the effects of contempt=21 and contempt=24
against Stockfish 9, and the net result was neutral:

Contempt 21
ELO: 51.68 +-1.9 (95%) LOS: 100.0%
Total: 40000 W: 9487 L: 3581 D: 26932
http://tests.stockfishchess.org/tests/view/5bdb1a140ebc595e0ae2620a

Contempt 24
ELO: 52.21 +-2.0 (95%) LOS: 100.0%
Total: 40000 W: 9759 L: 3793 D: 26448
http://tests.stockfishchess.org/tests/view/5bdb1b680ebc595e0ae2620d

Bench: 3459874
 2018-11-19 09:47:19 +01:00
Nooby b9f1c9bf3f Clear TableBase mappings in Search::clear() 
This patch will make possible to free mapped TB files with "ucinewgame" command.

We wrote this patch specifically to address a problem that arose while
running Stockfish with 7-piece tablebases as a kibitzer at TCEC for
extended periods of time across multiple games. It was noted that after
some time, the NPS of the kibitzing Stockfish (which is usually 3x faster
than the Stockfish actually competing) would drop precipitously, eventually
falling to preposterously low numbers until restarted.

Their eval bot basically inputs FEN, go infinite, stop and loop, it probably
didn't do ucinewgame either. As time goes it gradually slowed down and OS
starts to use swap, this is not reasonable since the engine only uses 16GB
hash and the machine has 1TB physical RAM and does nothing else.

Author : noobpwnftw

Closes https://github.com/official-stockfish/Stockfish/pull/1790

No functional change.
 2018-11-19 09:40:42 +01:00
protonspring 3cbb05b1b8 Replace the PassedDanger array by an equation 
This equation seems to do as well as the current PassedDanger array.

Master values were: 3, 7, 11, 20
The new values given by the equation are: 3, 6, 11, 18

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 84301 W: 18155 L: 18156 D: 47990
http://tests.stockfishchess.org/tests/view/5bda03180ebc595e0ae2518e

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 7940 W: 1358 L: 1217 D: 5365
http://tests.stockfishchess.org/tests/view/5bdc69880ebc595e0ae27d28

We stopped a LTC run after 70000 games:
LLR: 0.74 (-2.94,2.94) [0.00,4.00]
Total: 70257 W: 11319 L: 11064 D: 47874
http://tests.stockfishchess.org/tests/view/5bdca8420ebc595e0ae281a9

Bench: 3913185
 2018-11-12 20:33:07 +01:00
mstembera 68209c9121 Remove redundant king square parameter 
We don't need to pass the king square as an explicit parameter to the functions
king_safety() and do_king_safety() since we already pass in the position.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 69686 W: 14894 L: 14866 D: 39926
http://tests.stockfishchess.org/tests/view/5be84ac20ebc595e0ae3283c

No functional change.
 2018-11-12 19:45:05 +01:00
31m059 30a905c95d Simplify tropism. (#1807) 
We calculate tropism as a sum of two factors. The first is the number of squares in our kingFlank and Camp that are attacked by the enemy; the second is number of these squares that are attacked twice. Prior to this commit, we excluded squares we defended with pawns from this second value, but this appears unnecessary. (Doubly-attacked squares near our king are still dangerous.) The removal of this exclusion is a possible small Elo gain at STC (estimated +1.59) and almost exactly neutral at LTC (estimated +0.04).

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 20942 W: 4550 L: 4427 D: 11965
http://tests.stockfishchess.org/tests/view/5be4e0ae0ebc595e0ae308a0

LTC:
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 56941 W: 9172 L: 9108 D: 38661
http://tests.stockfishchess.org/tests/view/5be4ec340ebc595e0ae30938

Bench: 3813986
 2018-11-11 22:14:28 +01:00
Stephane Nicolet 05aa34e00e Update list of top CPU contributors 
Contributors with >10,000 CPU hours as of November 4, 2018. Thank you!

No functional change
 2018-11-08 17:09:44 +01:00
SFisGOD cd732c080b Pawn and Piece Values Tuned at LTC 
Failed STC
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 27487 W: 5846 L: 5903 D: 15738
http://tests.stockfishchess.org/tests/view/5be1d3190ebc595e0ae2e5b8

Passed 1st LTC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 38503 W: 6270 L: 5999 D: 26234
http://tests.stockfishchess.org/tests/view/5be1f5ef0ebc595e0ae2e750

Passed 2nd LTC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 34016 W: 5584 L: 5326 D: 23106
http://tests.stockfishchess.org/tests/view/5be2a1970ebc595e0ae2f1b4

This pull request lead to an interesting discussion about testing
methodology for Stockfish:
https://github.com/official-stockfish/Stockfish/pull/1804

Bench: 3647775
 2018-11-08 16:34:10 +01:00
Joost VandeVondele df50ea5dc6 fixup 2018-11-08 16:20:23 +01:00
Joost VandeVondele 9315ba60e6 Extension for king moves changing castling rights 
passed STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 8463 W: 1919 L: 1747 D: 4797
http://tests.stockfishchess.org/tests/view/5be15d510ebc595e0ae2dec6

passed LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 142590 W: 23263 L: 22587 D: 96740
http://tests.stockfishchess.org/tests/view/5be1667b0ebc595e0ae2df2d

Bench: 3607243
 2018-11-08 16:20:23 +01:00
Fabian Fichter a6fe035977 Simplify mobility danger 
Check sign only after adding mobility danger term.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 9090 W: 2001 L: 1856 D: 5233
http://tests.stockfishchess.org/tests/view/5bdc5ee10ebc595e0ae27bc2

LTC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 123466 W: 19766 L: 19805 D: 83895
http://tests.stockfishchess.org/tests/view/5bdc678e0ebc595e0ae27cf3

bench: 3630207
 2018-11-04 21:30:35 +01:00
Stéphane Nicolet 8bb7a73708 Rook tweaks in evaluation 
Some small changes in evaluation to try to convince Stockfish to centralize
her rooks more in middle game and avoid trapping them in the corners. Joint
work by SFisGOD and snicolet.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 99826 W: 21895 L: 21341 D: 56590
http://tests.stockfishchess.org/tests/view/5bdc3e280ebc595e0ae277df

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 21467 W: 3541 L: 3322 D: 14604
http://tests.stockfishchess.org/tests/view/5bdc9ff30ebc595e0ae28119

Bench: 3631608
 2018-11-02 22:08:26 +01:00
Joost VandeVondele 3f1eb85a1c Fix issues from using adjustedDepth too broadly 
The recently committed Fail-High patch (081af90805)
had a number of changes beyond adjusting the depth of search on fail high, with
some undesirable side effects.

1) Decreasing depth on PV output, confusing GUIs and players alike as described in
   issue #1787. The depth printed is anyway a convention, let's consider adjustedDepth
   an implementation detail, and continue to print rootDepth. Depth, nodes, time and
   move quality all increase as we compute more. (fixing this output has no effect on
   play).

2) Fixes go depth output (now based on rootDepth again, no effect on play), also
   reported in issue #1787

3) The depth lastBestDepth is used to compute how long a move is stable, a new move
   found during fail-high is incorrectly considered stable if based on adjustedDepth
   instead of rootDepth (this changes time management). Reverting this passed STC
   and LTC:

   STC
   LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
   Total: 82982 W: 17810 L: 17808 D: 47364
   http://tests.stockfishchess.org/tests/view/5bd391a80ebc595e0ae1e993

   LTC
   LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
   Total: 109083 W: 17602 L: 17619 D: 73862
   http://tests.stockfishchess.org/tests/view/5bd40c820ebc595e0ae1f1fb

4) In the thread voting scheme, the rank of the fail-high thread is now artificially
   low, incorrectly since the quality of the move is much better than what adjustedDepth
   suggests (e.g. if it takes 10 iterations to find VALUE_KNOWN_WIN, it has very low
   depth). Further evidence comes from a test that showed that the move of highest
   depth is not better than that of the last PV (which is potentially of much lower
   adjustedDepth).

   I.e. this test http://tests.stockfishchess.org/tests/view/5bd37a120ebc595e0ae1e7c3
   failed SPRT[0, 5]:

   LLR: -2.95 (-2.94,2.94) [0.00,5.00]
   Total: 10609 W: 2266 L: 2345 D: 5998

   In a running 5+0.05 th 8 test (more than 10000 games) a positive Elo estimate is
   shown (strong enough for a [-3,1], possibly not [0,4]):

   http://tests.stockfishchess.org/tests/view/5bd421be0ebc595e0ae1f315
   LLR: -0.13 (-2.94,2.94) [0.00,4.00]
   Total: 13644 W: 2573 L: 2532 D: 8539
   Elo	1.04 [-2.52,4.61] / LOS 71%

Thus, restore old behavior as a bugfix, keeping the core of the fail-high patch
idea as resolving scheme. This is non-functional for bench, but changes searches
via time management and in the threaded case.

Bench: 3556672
 2018-11-01 16:00:56 +01:00
SFisGOD 4a0db9ea3c Combo 
Combo of two parameter tweaks and tuned values for Queen and ThreatByKing.

STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 20180 W: 4439 L: 4198 D: 11543
http://tests.stockfishchess.org/tests/view/5bd7b8250ebc595e0ae22e97

LTC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 86312 W: 14106 L: 13685 D: 58521
http://tests.stockfishchess.org/tests/view/5bd803560ebc595e0ae23213

This combo consists of the following:

Queen Value (tuned values)
Iter: 72056, A: 5000, alpha 0.602000, gamma 0.101000, clipping old, rounding deterministic
param: QueenValueMg, best: 2528.91, start: 2528.00
param: QueenValueEg, best: 2687.12, start: 2698.00

ThreatByKing (tuned values)
Green STC (50.8k games)
http://tests.stockfishchess.org/tests/view/5bd1d5a00ebc595e0ae1cbec
LTC (I stopped this test at 71.2k games. It's likely yellow.)
http://tests.stockfishchess.org/tests/view/5bd263e70ebc595e0ae1d77e

WeakUnopposedPawn (tweak) by xoto (https://github.com/xoto10)
Green STC (102.8k games)
http://tests.stockfishchess.org/tests/view/5bd306bb0ebc595e0ae1e146
Yellow LTC (90.8k games)
http://tests.stockfishchess.org/tests/view/5bd3ea660ebc595e0ae1f16b

aspiTune1 (tweak) by vondele (https://github.com/vondele)
Green STC (125.9k games)
http://tests.stockfishchess.org/tests/view/5bd2ae100ebc595e0ae1dab0
Yellow LTC (107.9k games)
http://tests.stockfishchess.org/tests/view/5bd3eb700ebc595e0ae1f16f

Thank you @31m059 (Mark Tenzer) for helping me! Also, thank you very much
for recognizing my efforts. I genuinely appreciate it.

Bench: 3556672
 2018-11-01 15:39:19 +01:00
Vizvezdenec 7a61368971 Tweak of knight PSQT and mobility bonuses 
STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 16906 W: 3745 L: 3516 D: 9645
http://tests.stockfishchess.org/tests/view/5bd306a40ebc595e0ae1e144

LTC
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 62779 W: 10249 L: 9901 D: 42629
http://tests.stockfishchess.org/tests/view/5bd3188f0ebc595e0ae1e296

Bench 3166402
 2018-10-27 09:23:11 +02:00
Guenther Demetz 081af90805 On main thread: reduce depth after fail high 
This helps resolving consecutive FH's during aspiration more efficiently

STC:
http://tests.stockfishchess.org/tests/view/5bc857920ebc592439f85765
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 4992 W: 1134 L: 980 D: 2878 Elo +10.72 

LTC:
http://tests.stockfishchess.org/tests/view/5bc868050ebc592439f857ef
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 8123 W: 1363 L: 1210 D: 5550 Elo +6.54

No-Regression test with 8 threads, tc=15+0.15:
http://tests.stockfishchess.org/tests/view/5bc874ca0ebc592439f85938
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 24740 W: 3977 L: 3863 D: 16900 Elo +1.60

This was a cooperation between me and Michael Stembera:
-me recognizing SF having problems with resolving FH's efficiently at
high depths, thus starting some tests based on consecutive FH's.
-mstembera picking up the idea with first success at STC & LTC (so full
credits to him!)
-me suggesting how to resolve the issues pinpointed by S.G on PR #1768
and finally restricting the logic to the main thread so that it don't
regresses at multi-thread.

bench: 3314347
 2018-10-25 23:08:06 +02:00
Peter Zsifkovits bc3b148d57 NUMA for 9 threads or more 
Enable numa machinery only for STRICTLY MORE than 8 threads. Reason for this
change is that nowadays SMP tests are always done with 8 threads. That is a
problem for multi-socket Windows machines running on fishtest.

No functional change
 2018-10-25 23:03:25 +02:00
Günther Demetz 9fff272209 Revert Pull Request #1771, see issue #1785 (#1786) 
no functional change

bench: 4274207
 2018-10-23 18:04:30 +02:00
mstembera 542a2b39ed Small simplification in castling rights 
There is no need for a special struct with a static member
to generate castling rights.

No functional change.
 2018-10-21 08:15:04 +02:00
ElbertoOne 738a6dfd4c Simplify check extensions 
Remove the !moveCountPruning condition for check extensions, which seems not necessary.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 22238 W: 4835 L: 4715 D: 12688
http://tests.stockfishchess.org/tests/view/5bb3241a0ebc592439f6d2ac

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 36593 W: 5898 L: 5802 D: 24893
http://tests.stockfishchess.org/tests/view/5bb34c220ebc592439f6d5dc

Bench: 4274207
 2018-10-14 20:40:57 +02:00
Joost VandeVondele 97d2cc9a9c Randomize draw eval 
The patch adds a small random component (+-1) to VALUE_DRAW for the evaluation
of draw positions (mostly 3folds). This random component is not static, but
potentially different for each visit of the node (hence derived from the node
counter). The effect is that in positions with many 3fold draw lines, different
lines are followed at each iteration. This keeps the search much more dynamic,
as opposed to being locked to one particular 3fold.

An example of a position where master suffers from 3fold-blindness and this patch
solves quickly is the famous TCEC game 53:

FEN: 3r2k1/pr6/1p3q1p/5R2/3P3p/8/5RP1/3Q2K1 b - - 0 51

master doesn't see that this is a lost position (draw eval up to depth 50) as
Qf6-e6 d4-d5 (found by patch at depth 23) leads to a loss.

The 3fold-blindness is more important at longer TC, the patch was yellow STC and
LTC, but passed VLTC:

STC
LLR: -2.95 (-2.94,2.94) [0.00,5.00]
Total: 46328 W: 10048 L: 9953 D: 26327
http://tests.stockfishchess.org/tests/view/5b9c0ca20ebc592cf275f7c7

LTC
LLR: -2.95 (-2.94,2.94) [0.00,5.00]
Total: 54663 W: 8938 L: 8846 D: 36879
http://tests.stockfishchess.org/tests/view/5b9ca1610ebc592cf27601d3

VLTC
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 31789 W: 4512 L: 4284 D: 22993
http://tests.stockfishchess.org/tests/view/5b9d1a670ebc592cf276076d

Credit to @crossbr for pointing to this problem repeatedly, and giving the hint
that many draw lines are typical in those situations.

Bench: 4756639
 2018-10-14 20:33:52 +02:00
Guenther Demetz cb0111d3db Correctly track down pv even in fail-high case 
Currently we update (track up) the pv even in the fail high case.
However most times in such cases the pv in the ply below remains unset
because there we have value == alpha and so finally we see truncated
pv's (=just one move) in fail high cases.
Of course tracking down these pv's (+sending them to the gui) comes at a
certian cost, but no-regression tests passed:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 16300 W: 3556 L: 3424 D: 9320
http://tests.stockfishchess.org/tests/view/5b9b73500ebc592cf275ea92

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 202411 W: 32734 L: 32897 D: 136780
http://tests.stockfishchess.org/tests/view/5b9baed10ebc592cf275ef6d

N.B.: Digging also into qsearch was tried in another version but seemed
not to pass the tests. This means that we don't always will get a pv
until the very tips.

No functional change
 2018-10-14 20:19:46 +02:00
Miguel Lahoz 0370077c37 Simplify evaluation of blockers_for_king 
Currently, we have two evaluation terms which account for pinned pieces.
One is for all pinned pieces in kingDanger computation and another for
just pinned pawns in ThreatByRank. We can increase the relevant bonus
for kingDanger calculation and do away with the ThreatByRank, which
seems to just add more complexity.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 113353 W: 24299 L: 24356 D: 64698
http://tests.stockfishchess.org/tests/view/5ba348c20ebc592cf2766e61

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 96458 W: 15514 L: 15511 D: 65433
http://tests.stockfishchess.org/tests/view/5ba398830ebc592cf2767563

At 100k games, I thought it struggles a bit, but some related [0,4]
tests attempting individual tweaks seem to fail:

I tried directly tweaking ThreatByRank:
http://tests.stockfishchess.org/tests/view/5ba3c6300ebc592cf276791c
http://tests.stockfishchess.org/tests/view/5ba3c6190ebc592cf2767917

@Vizveznedec was also recently trying to tweak the same coeffecients
for kingDanger calculation:
http://tests.stockfishchess.org/tests/view/5ba2c7320ebc592cf27664b2
http://tests.stockfishchess.org/tests/view/5ba2c8220ebc592cf27664b8
http://tests.stockfishchess.org/tests/view/5ba2c7880ebc592cf27664b4
http://tests.stockfishchess.org/tests/view/5ba2c7ce0ebc592cf27664b6

Bench: 4648095
 2018-10-14 20:15:16 +02:00
Joost VandeVondele d615f15fce small ttCapture simplification. 
ttCapture can be assigned to only once outside of the main loop. The patch seems
functional at higher depths (seems possible in the case of non-legal TTmoves that
are captures).

passed STC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 23189 W: 5098 L: 4980 D: 13111
http://tests.stockfishchess.org/tests/view/5bb3822c0ebc592439f6d966

passed LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 10336 W: 1665 L: 1529 D: 7142
http://tests.stockfishchess.org/tests/view/5bb39a190ebc592439f6db8a

unchanged bench: 4312846
 2018-10-14 20:10:47 +02:00
31m059 489357d7b2 Combo 
This PR is a combination of two unrelated [0, 4] patches that appeared promising
but not quite strong enough to pass on their own. The combination initially failed
STC with a positive score after a long run, and the subsequent speculative LTC test
passed.

* tweak_threatOnQueen4 :

Increase the middlegame components of ThreatByMinor[QUEEN]
and ThreatByRook[QUEEN] by 15 each. Bryan's (@crossbr) analysis of CCC Bonus Game 10
inspired several tests on penalizing a queen with limited safe mobility. While
attempting to implement this idea, I noticed that when I did not include the queen's
current square in the calculations, the Elo gains seemed to vanish--and only then did
I have the idea to revisit ThreatByMinor[QUEEN] and ThreatByRook[QUEEN], adding a
corresponding value to each. Without Bryan's work, this test would never have been
submitted. I would also like to recognize the efforts and contributions of @SFisGOD,
who also vigorously worked on this idea.

* Use pure static eval for null move pruning :

This idea was directly re-purposed from a promising test by Jerry Donald Watson
(@jerrydonaldwatson) in August. It was also independently developed and tested by
Stefan Geschwentner (@locutus2) previously.
Thank you all!

STC (failed yellow):
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 83913 W: 17986 L: 17825 D: 48102
http://tests.stockfishchess.org/tests/view/5bbc59300ebc592439f76aa5

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 137198 W: 22351 L: 21772 D: 93075
http://tests.stockfishchess.org/tests/view/5bbce35f0ebc592439f77639

Bench: 4312846
 2018-10-14 20:02:31 +02:00
Eduardo Caceres 8141bdd179 Fix two typos in comments 
Note by snicolet: I use this non-functional change patch
as a pretext to correct the wrong bench number I introduced
in the message of the previous commit.

Bench: 4059356
 2018-09-27 21:39:36 +02:00
Joost VandeVondele bbf9daa175 Remove essentially unused code 
this was added recently as part of a larger commit, but only changes eval of positions at MAX_PLY depth a little. Can be safely removed:

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 7424 W: 1640 L: 1492 D: 4292
http://tests.stockfishchess.org/html/live_elo.html?5ba3bcbe0ebc592cf27677ff

passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 73554 W: 12028 L: 11990 D: 49536
http://tests.stockfishchess.org/html/live_elo.html?5ba397ee0ebc592cf2767556

unchanged Bench: 4248710
 2018-09-27 21:28:38 +02:00
protonspring 13d06edb84 Two simplifications in passed pawns evaluation 
These two simplifications appear to be affecting and/or offsetting each other.
Neither can be removed independently, but in combination they pass -3,1.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 36391 W: 7888 L: 7795 D: 20708
http://tests.stockfishchess.org/tests/view/5b9bce410ebc592cf275f1b2

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 19513 W: 3237 L: 3114 D: 13162
http://tests.stockfishchess.org/tests/view/5b9c0edf0ebc592cf275f80e

Closes https://github.com/official-stockfish/Stockfish/pull/1769

bench 4059356
 2018-09-27 21:18:18 +02:00
Rocky640 49b1591505 Pawn PSQT Tuned 
Tested against master "Tweak opposite color bishops endgame scaling"
using values from a 100K SPSA with ck=10

Passed STC
http://tests.stockfishchess.org/tests/view/5ba7fe7a0ebc592cf276b971
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 27717 W: 6052 L: 5782 D: 15883

Passed LTC
http://tests.stockfishchess.org/tests/view/5ba815790ebc592cf276bb6b
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 17486 W: 2919 L: 2712 D: 11855

bench: 4441247
 2018-09-27 20:58:40 +02:00
Joost VandeVondele 33b2f6398c Remove unneeded branch 
Storing unconditionally the current generation and bound is equivalent to master.
Part of the condition was added as a speed optimization in #429.
Here the branch is fully eliminated.

passed STC single-threaded:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 73515 W: 16378 L: 16359 D: 40778
http://tests.stockfishchess.org/tests/view/5b2fc38c0ebc5902b2e57fd5

passed STC multi-threaded:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 63725 W: 12916 L: 12874 D: 37935
http://tests.stockfishchess.org/tests/view/5b307b8f0ebc5902b2e5895f

The multithreaded test was run after a plausible suggestion by @mstembera that the effect of this could be larger with many cores. The result seems to indicate this doesn't really matter on the 8core architecture abundantly available on fishtest.

No functional change
 2018-09-27 20:48:11 +02:00
Vizvezdenec 0fa957cf66 Tweak opposite colord bishops endgame scaling. 
Make scale factor dependant on asymmetry of pawn structure.

STC http://tests.stockfishchess.org/tests/view/5b92a2a80ebc592cf2753dd4
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 31490 W: 6870 L: 6587 D: 18033

LTC http://tests.stockfishchess.org/tests/view/5b92f8170ebc592cf2754438
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 54928 W: 8988 L: 8653 D: 37287

This patch shows that SF can use some more complicated endgame heuristics to evaluate endgames better from the distance.

Closes https://github.com/official-stockfish/Stockfish/pull/1767

Bench: 4248710
 2018-09-10 12:22:44 +02:00
ElbertoOne 4bef7aa5cd Parameter tweaks in PSQT and NMP 
This patch is a combinaison of two parameters tweaks patches which
have failed as strong yellows at LTC recently, by Alain Savard (Rocky640)
and Fabian Fichter (ianfab):
  http://tests.stockfishchess.org/tests/view/5b8a71e60ebc592cf2749b1d
  http://tests.stockfishchess.org/tests/view/5b81ce3b0ebc5902bdbb6585

Passed STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 57200 W: 12392 L: 12008 D: 32800
http://tests.stockfishchess.org/tests/view/5b8d0a5a0ebc592cf274c48f

And LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 37215 W: 6233 L: 5962 D: 25020
http://tests.stockfishchess.org/tests/view/5b8d56090ebc592cf274cb53

Closes https://github.com/official-stockfish/Stockfish/pull/1764

Bench: 4136116

---------------

How to continue from there?

The null move reduction formula in line 769 of search.cpp is quite convoluted
and full of mysterious magic constants at the moment, it would certainly be
nice to simplify it and/or gain more Elo from it:

```
Depth R = (  (823 + 67 * depth / ONE_PLY) / 256
           + std::min(int(eval - beta) / 200, 3)) * ONE_PLY;
```
 2018-09-04 10:43:02 +02:00
Stéphane Nicolet 767c4ad1fc Update list of authors 
And also fix some spaces and formatting oddities in the code.

No functional change
 2018-09-03 22:11:30 +02:00
Stéphane Nicolet 2bfaf45455 Re-introduce "keep pawns on both flanks" 
Re-introduce the "keep pawns on both flanks" idea.

STC yellow:
LLR: -2.95 (-2.94,2.94) [0.00,5.00]
Total: 93279 W: 20175 L: 19853 D: 53251
http://tests.stockfishchess.org/tests/view/5b8a00370ebc592cf274916a

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 11440 W: 1960 L: 1792 D: 7688
http://tests.stockfishchess.org/tests/view/5b8a329f0ebc592cf2749615

Closes https://github.com/official-stockfish/Stockfish/pull/1761

Bench: 4609645
 2018-09-01 11:30:38 +02:00
Rocky640 f923dc0fe5 Long Diagonal Tweaks 
a) Reduce PSQT values along the long diagonals on non-central squares
and increase the LongDiagonal bonus accordingly. The effect is to penalise
bishops on the long diagonal which can not "see" the 2 central squares.
The "good" bishops still have more or less the same bonus as current master.

b) For a bishop on a central square, because of the "| s" term in the code,
the LongDiagonalBonus was always given. So while being there, remove the "| s"
and compensate the central Bishop PSQT accordingly.

Passed STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 44498 W: 9658 L: 9323 D: 25517
http://tests.stockfishchess.org/tests/view/5b8992770ebc592cf2748942

Passed LTC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 63092 W: 10324 L: 9975 D: 42793
http://tests.stockfishchess.org/tests/view/5b89a17a0ebc592cf2748b59

Closes https://github.com/official-stockfish/Stockfish/pull/1760

bench: 4693901
 2018-09-01 04:33:17 +02:00
protonspring e846a9306d Remove PawnsOnBothFlanks 
It looks like PawnsOnBothFlanks can be removed from initiative().
A barrage of tests seem to confirm that the adjustment to -110
does not gain elo to offset any potential loss by removing
PawnsOnBothFlanks.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 22014 W: 4760 L: 4639 D: 12615
http://tests.stockfishchess.org/tests/view/5b7f50cc0ebc5902bdbb3a3e

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 40561 W: 6667 L: 6577 D: 27317
http://tests.stockfishchess.org/tests/view/5b801f9f0ebc5902bdbb4467

The barrage of 0,4 tests on the -136 value are in my ps_tunetests branch.
http://tests.stockfishchess.org/tests/user/protonspring

Closes https://github.com/official-stockfish/Stockfish/pull/1751

Bench: 4413173

-------------

How to continue from there?

The fact that endgames with all the pawns on only one flank are
drawish is a well-known chess idea, so it seems quite strange that
this can be removed so easily without losing Elo.

In the past there had been attempts to improve on PawnsOnBothFlanks
with similar concepts (for instance using the pawn span value), but
the tests were at best neutral. Maybe Stockfish is now mature enough
that these refined ideas would work to replace PawnsOnBothFlanks?
 2018-08-29 02:49:10 +02:00
MJZ1977 10bb2e6cdb Fix bug with "excludedMove" for probcut 
Bugfix: "excludedMove" has to be skipped in the probcut loop too.
If it is not skipped, the probcut can exit quickly with a wrong return
value corresponding to the excluded move. See the following forum
thread for a discussion:
https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/GGithf_VwSU

STC :
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17130 W: 3747 L: 3617 D: 9766
http://tests.stockfishchess.org/tests/view/5b8460c40ebc5902bdbb999a

LTC :
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 12387 W: 2064 L: 1930 D: 8393
http://tests.stockfishchess.org/tests/view/5b8466f90ebc5902bdbb9a21

To go further : it can be perhaps useful to tune the singular extension
search parameters.

Closes https://github.com/official-stockfish/Stockfish/pull/1754

Bench: 4308541
 2018-08-29 02:28:09 +02:00
Steinar H. Gunderson 166bf90e41 Shrink the hash table of tablebases back to 4096 entries 
There is no need to make this as large as 65536 just for the sake of the
single 7-man tablebase that happens to have the key 0xf9247fff. Idea for the
fix by Ronald de Man, who suggested simply to allow more buckets past the end.

We also implement Robin Hood hashing for the hash table, which takes the worst
-case search for full 7-man tablebases down from 68 to 11 probes (Also takes
the average probe length from 2.06 to 2.05). For a table with 8K entries, the
corresponding numbers would be worst-case from 9 to 4, with average from 1.30
to 1.29.

https://github.com/official-stockfish/Stockfish/pull/1747

No functional change
 2018-08-29 02:00:20 +02:00
Ondrej Mosnacek 4aa091cf44 Refactor pure static eval code 
This commit tries to make the new pure static eval code more readable by
splitting up the nested assignments into separate lines and making a few
more cosmetic tweaks.

No functional change.
 2018-08-29 01:24:45 +02:00
protonspring 8a4821923a make DistanceRing more consistent 
This is a non-functional change. By pre-incrementing minKingPawnDistance
instead of post-incrementing, we can remove this -1.

This also makes DistanceRing more consistent with the rest of stockfish
since it now holds an actual "distance" instead of a less natural distance-1.

In current master, PseudoAttacks[KING][ksq] == DistanceRingBB[ksq][0]
With this patch, it will be PseudoAttacks[KING][ksq] == DistanceRingBB[ksq][1]
ie squares at distance 1 from the king. This is more natural use of distance.

The current array size DistanceRingBB[SQUARE_NB][8] is still OK with the new
definition, because maximum distance between two squares on a chess board is
seven (for example Kh1 and a8).

No functional change.
 2018-08-29 01:07:38 +02:00
Vizvezdenec 6307fd08e6 Tweak stat bonus formula 
Tweak stat bonus formula on top of latest elo gain by @snicolet

STC
http://tests.stockfishchess.org/tests/view/5b830a810ebc5902bdbb7e9c
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 27797 W: 6113 L: 5842 D: 15842

LTC
http://tests.stockfishchess.org/tests/view/5b831f2c0ebc5902bdbb8038
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 13655 W: 2294 L: 2099 D: 9262

I think that more elo can be found in tweaks of this parameters so I plan
to further try some "hand-tuning", including increasing/decreasing ratio of
two constants and making bonus assimetric to 0. Thx to @AndyGrant for helping
with github and @jerrydonaldwatson for original idea.

Closes https://github.com/official-stockfish/Stockfish/pull/1748

Bench: 4172767
 2018-08-29 00:53:31 +02:00
VoyagerOne 3ac3b68540 Don't modify Eval with search stats at ttHits 
STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 28344 W: 6148 L: 6040 D: 16156
http://tests.stockfishchess.org/tests/view/5b7d6b4e0ebc5902bdbb1914

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 41084 W: 6769 L: 6680 D: 27635
http://tests.stockfishchess.org/tests/view/5b7d7f5b0ebc5902bdbb1b85

Bench: 4457440
 2018-08-29 00:41:53 +02:00
Stefan Geschwentner 28543cddc6 Store only unchanged static evaluations in TT 
A recent commit introduced a decrease of the static evaluation of
an inner node dependent on the previous stat score, which finally
was also stored in the transposition table. Now only the unchanged
static evaluation are stored there.

Remark:
For the case that a static evaluation can be retrieved from the
transposition table the value is now used unchanged. Another test
which also applies the modification in this case failed:
http://tests.stockfishchess.org/tests/view/5b7af6df0ebc5902bdbae2f6

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 6707 W: 1547 L: 1383 D: 3777
http://tests.stockfishchess.org/tests/view/5b7a92df0ebc5902bdbadcf3

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 36203 W: 6046 L: 5781 D: 24376
http://tests.stockfishchess.org/tests/view/5b7abaa10ebc5902bdbadfa9

Closes https://github.com/official-stockfish/Stockfish/pull/1742

Bench: 4457440
 2018-08-20 21:52:29 +02:00
Stéphane Nicolet f3b8a69919 Use an affine formula to mix stats and eval 
Follow-up for the previous patch: we use an affine formula to mix stats
and evaluation in search. The idea is to give a bonus if the previous
move of the opponent was historically bad, and a malus if the previous
move of the opponent was historically good.

More precisely, if x is the stat score of the previous move by the opponent,
we implement the following formulas to tweak the evaluation at an internal
node of the tree for our pruning decisions at this node:

if x = 0, use v' = eval(P)
if x > 0, use v' = eval(P) - 5 - x/1024
if x < 0, use v' = eval(P) + 5 - x/1024

For reference, the previous master had this simpler rule:

if x > 0, use v' = eval(P) - 10
if x <= 0, use v' = eval(P)

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 29322 W: 6359 L: 6088 D: 16875
http://tests.stockfishchess.org/tests/view/5b76a5980ebc5902bdba957f

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 30893 W: 5154 L: 4910 D: 20829
http://tests.stockfishchess.org/tests/view/5b76ca6d0ebc5902bdba9914

Closes https://github.com/official-stockfish/Stockfish/pull/1740

Bench: 4592766
 2018-08-18 01:23:36 +02:00
VoyagerOne 96c3a1f2ec Mix search stats with evaluation 
Mix search stats with evaluation: if the opponent's move has a good historyStat,
then decrease the evaluation of the internal node a bit for the pruning decisions
during search.

STC;
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 72083 W: 15683 L: 15203 D: 41197
http://tests.stockfishchess.org/tests/view/5b74c3ea0ebc5902bdba7d41

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 29104 W: 4867 L: 4630 D: 19607
http://tests.stockfishchess.org/tests/view/5b7565000ebc5902bdba851b

Closes https://github.com/official-stockfish/Stockfish/pull/1738

Bench: 4514101

-----------

How to continue from there?

• the use of the previous stat score can probably be simplified in lines 587 and 716
• we could try to use a continuous bonus based on the previous stat score, instead
  of just a fixed offset of -10 when the opponent previous move was good.

----------

Comments by Stefan Geschwentner:

Interesting idea. Because only the eval in search is tweak this should only
influence the eval and static eval used at inner nodes, and not on the return
search value (which comes in the end from quiescence search), except through
saving in TT followed by a TT cutoff.

So essentialy this effects diverse pruning/reduction parts -- eval and static
eval  are lowered for good opponent moves:

• tt cutoff (ttValue)
• improving (static eval)
• more razoring (eval)
• less futility pruning (eval)
• less null move pruning (eval + static eval) (but with little more depth)
• more probcut (static eval)
• more move futility pruning (static eval)
 2018-08-17 11:40:29 +02:00
protonspring d0f09de2d2 Simplify king file dependancy in evaluate_shelter() 
Remove the special value we used for the file of the king in the
evaluate_shelter() function, and compensate by tweaking some of
the ShelterStrength[] array values.

STC
LLR: 2.94 (-2.94,2.94) [-3.00,1.00]
Total: 17069 W: 3782 L: 3652 D: 9635
http://tests.stockfishchess.org/tests/view/5b75eb0d0ebc5902bdba8f3d

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42639 W: 6973 L: 6887 D: 28779
http://tests.stockfishchess.org/tests/view/5b75fd7f0ebc5902bdba906b

Closes https://github.com/official-stockfish/Stockfish/pull/1739

Bench: 4639508
 2018-08-17 10:21:20 +02:00
Stéphane Nicolet 881cab2525 Double weight of capture history 
We double in this patch the weight of the capture history table in the
local scoring of captures for move ordering.

The capture history table is indexed by the triplet (capturing piece,
capture square, captured piece) and gets information like "it seems to
have been historically good in that part of the search tree to capture
a pawn with a rook on g3, even if it seems to lose material", and affect
the normaly pure « Most Valuable Victim » ordering of captures.

Finished yellow at STC after 228842 games (posting a +1.36 Elo gain):
LLR: -2.95 (-2.94,2.94) [0.00,4.00]
Total: 228842 W: 50894 L: 50152 D: 127796
http://tests.stockfishchess.org/tests/view/5b714bb00ebc5902bdba332d

Passed LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 43251 W: 7425 L: 7131 D: 28695
http://tests.stockfishchess.org/tests/view/5b71c7d40ebc5902bdba3e51

Thanks to user Vizvezdenec for running the LTC test.

Closes https://github.com/official-stockfish/Stockfish/pull/1736

Bench: 4272361
 2018-08-14 10:12:31 +02:00
Alain SAVARD 4d22d3e52d Remove pawncount array in imbalance 
This is a natural follow up to last commit where values on the
QuadraticOurs diagonal and some piece value deltas were changed.
@Stefano80 tried to simplify the newly introduced pawncount array
using QuadraticOurs[1][1] =52 and a -30 adjustment on pawn values

His STC [-3,1] was green
http://tests.stockfishchess.org/tests/view/5b707f5b0ebc5902bdba2745
but not his LTC[-3,1]
http://tests.stockfishchess.org/tests/view/5b7095700ebc5902bdba2a49

So I started a 80000 30+0.3 SPSA on the QuadraticOurs diagonal and
on the piece values using @Stefano80 start values.

SPSA gave the new values QuadraticOurs[1][1] =38 and a -33 on pawn
values (the other changes on QuadraticOurs were kept, but were not
ignificant according to this test
http://tests.stockfishchess.org/tests/view/5b710ccb0ebc5902bdba2f27)

STC
http://tests.stockfishchess.org/tests/view/5b710b220ebc5902bdba2f19
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 50902 W: 11214 L: 11150 D: 28538

LTC
http://tests.stockfishchess.org/tests/view/5b7124ef0ebc5902bdba3106
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 34271 W: 5852 L: 5753 D: 22666

Closes https://github.com/official-stockfish/Stockfish/pull/1735

bench: 4738555
 2018-08-14 08:36:27 +02:00
GuardianRM 41cc4eb953 Non-linear bonus for pawn count 
This patch introduces a non-linear bonus for pawns, along with some
(linear) corrections for the other pieces types.

The original values were obtained by a massive non-linear tuning of both
pawns and other pieces by GuardianRM, while Alain Savard and Chris Cain
later simplified the patch by observing that, apart from the pawn case, the
tuned corrections were in fact almost affine and could be incorporated in
our current code base via the piece values in types.h (offset) and the diagonal
of the quadratic matrix (slope). See discussion in PR#1725 :
https://github.com/official-stockfish/Stockfish/pull/1725

STC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 42948 W: 9662 L: 9317 D: 23969
http://tests.stockfishchess.org/tests/view/5b6ff6e60ebc5902bdba1d87

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 19683 W: 3409 L: 3206 D: 13068
http://tests.stockfishchess.org/tests/view/5b702dbd0ebc5902bdba216b

How to continue from there?
- Maybe the non-linearity for the pawn value could be somewhat tempered
  again and a simpler linear correction for pawns would work?

Closes https://github.com/official-stockfish/Stockfish/pull/1734

Bench: 4681496
 2018-08-12 18:40:11 +02:00
Stefano Cardanobile b5581b7779 Combo of several promising parameter tweaks 
Combo of several tuning patches which finished yellow at LTC.

[STC](http://tests.stockfishchess.org/tests/view/5b6ead340ebc5902bdba14ce)
LR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 10668 W: 2445 L: 2239 D: 5984
Elo: 6.25 [1.76,10.69] (95%)

[LTC](http://tests.stockfishchess.org/tests/view/5b6eb50e0ebc5902bdba151f)
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 23761 W: 4155 L: 3923 D: 15683
Elo: 3.02 [0.29,5.67] (95%)

Original patches:
- [Piece values](http://tests.stockfishchess.org/tests/view/5b6d2cc00ebc5902bdba02d5) by Stefano Cardanobile
- [Stat bonus](http://tests.stockfishchess.org/tests/view/5b6adbc90ebc5902bdb9da73) by Stefan Geschwentner
- [Rook on pawn](http://tests.stockfishchess.org/tests/view/5b62a95b0ebc5902bdb961c0) by Mark Tenzer
- [Hanging bonus](http://tests.stockfishchess.org/tests/view/5b5d2fa00ebc5902bdb90855) by Ivan Ilvec
- [ss tweak](http://tests.stockfishchess.org/tests/view/5b58b7240ebc5902bdb89025) by miguel-l

Bench: 4694813
 2018-08-12 10:09:30 +02:00
Jerry Donald Watson 348cd5ed74 Simple razoring: depth 1 only, no distinction between PV / NonPV 
We simplify the razoring logic by applying it to all nodes at depth 1 only.
An added advantage is that only one razor margin is needed now, and we treat
PV and Non-PV nodes in the same manner.

How to continue?
- There may be some conditions in which depth 2 razoring is beneficial.
- We can see whether the razor margin can be tuned, perhaps even with a
  different value for PV nodes.
- Perhaps we can unify the treatment of PV and Non-PV nodes in other parts
  of the search as well.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 5474 W: 1281 L: 1127 D: 3066
http://tests.stockfishchess.org/tests/view/5b6de3b20ebc5902bdba0d1e

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 62670 W: 10749 L: 10697 D: 41224
http://tests.stockfishchess.org/tests/view/5b6dee340ebc5902bdba0eb0

In addition, we ran a fixed LTC test against a similar patch which also
passed SPRT [-3, 1]:

ELO: 0.23 +-2.1 (95%) LOS: 58.6%
Total: 36412 W: 6168 L: 6144 D: 24100
http://tests.stockfishchess.org/tests/view/5b6e83940ebc5902bdba1485

We are opting for this patch as the more logical and simple of the two,
and it appears to be no less strong. Thanks in particular to @DU-jdto
for input into this patch.

Bench: 4476945
 2018-08-12 09:54:16 +02:00
Miguel Lahoz f1088c9822 Remove Condition For Passed Pawns 
Currently, we do not consider pawns passed if there is another pawn of
the same color in front of them. It appears that this condition is not
necessary. The idea is that the doubled pawns are likely to be weak and
one of them will be likely captured anyway. On the other hand, if we do
somehow manage to promote a pawn, then the pawn behind it becomes passed
as well. In any case, the end result is we end up with an extra
potentially passed pawn. The current evaluation for passed pawns already
handles this case by also scaling down this effect.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 28291 W: 6287 L: 6178 D: 15826
http://tests.stockfishchess.org/tests/view/5b6c4b960ebc5902bdb9f256

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 30717 W: 5256 L: 5151 D: 20310
http://tests.stockfishchess.org/tests/view/5b6c82980ebc5902bdb9f863

Bench: 4938285
 2018-08-10 06:16:29 +02:00
Stefan Geschwentner 198418ee67 LMR simplification 
Unify the "quiet" and "non-quiet" reduction rules for use at any kind of moves.
The idea behind it was that both rules reduce at similiar cases in master:
one directly for late previous moves and the other indirectly by using a
bad stat score which is used for most move sorting and so approximates the
late move condition.

For captures/promotions the old rule was triggered in 25% but the new
rule only for 3% of all cases (so now more reductions are done, whereas
for quiet moves reductions keep the same level).

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 162327 W: 35976 L: 36134 D: 90217
http://tests.stockfishchess.org/tests/view/5b6a9a430ebc5902bdb9d5c1

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 29570 W: 5083 L: 4976 D: 19511
http://tests.stockfishchess.org/tests/view/5b6bc5d00ebc5902bdb9e9d6

Bench: 4526980
 2018-08-09 14:45:35 +02:00
Stefano Cardanobile bd4d2b0576 First check threshold in space evaluation 
Currently, we first calculate some bitboards at the top of Evaluation::space()
and then check whether we actually need them. Invert the ordering. Of course this
does not make a difference in current master because the constexpr bitboard
calculations are in fact done at compile time by any decent compiler, but I find
my version a bit healthier since it will always meet or exceed current implementation
even if we eventually change the spaceMask to something not contsexpr.

No functional change.
 2018-08-08 17:58:41 +02:00
FauziAkram c569cf263d King Psqt Tuning 
After a session of tuning for King Psqt I got some new values, which was later
tweaked manually by me Fauzi, to result in an Elo-gain patch which seems to scale
pretty well:

STC: LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 100653 W: 22550 L: 22314 D: 55789 [Yellow patch]

LTC: LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 147079 W: 25584 L: 24947 D: 96548 [Green Patch]

Bench: 4669050
 2018-08-08 17:49:16 +02:00
Stefano Cardanobile d96c1c32a2 Introduce voting system for best move selection 
Introduce voting system for best move selction in multi-threads mode.
Joint work with Stefan Geschwentner, based on ideas introduced by
Michael Stembera.

Moves are upvoted by every thread using the margin to the minimum score
across threads and the completed depth.

First thread voting for the winner move is selected as best thread.

Passed STC, LTC. A further LTC test with only 4 threads failed with positive
score. A LTC with 31 threads was stopped with LLR 0.77 after 25k games to
avoid use of excessive resources (equivalent to 1.5M STC games).

Similar ideas were proposed by Michael Stembera 2 years ago #507, #508.
This implementation seems simpler and more understandable, the results
slightly more promising.

Further possible work:

1) Tweak of the formula using for assigning votes.
2) Use a different baseline for the score dependent part: maximum score
or winning probability could make more sense.
3) Assign votes in `Thread::Search` as iterations are completed and use
voting results to stop search.
4) Select best thread as the threads voting for best move with the highest
completed depth or, alternatively, vote on PV moves.

Link to SPRT tests

[stopped LTC, 31 threads 20+0.02](http://tests.stockfishchess.org/tests/view/5b61dc090ebc5902bdb95192)
LLR: 0.77 (-2.94,2.94) [0.00,5.00]
Total: 25602 W: 3977 L: 3850 D: 17775
Elo: 1.70 [-0.68,4.07] (95%)

[passed LTC, 8 threads 20+0.02](http://tests.stockfishchess.org/tests/view/5b5df5180ebc5902bdb9162d)
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 44478 W: 7602 L: 7300 D: 29576
Elo: 1.92 [-0.29,3.94] (95%)

[failed LTC, 4 threads 20+0.02](http://tests.stockfishchess.org/tests/view/5b5f39ef0ebc5902bdb92792)
LLR: -2.94 (-2.94,2.94) [0.00,5.00]
Total: 29922 W: 5286 L: 5285 D: 19351
Elo: 0.48 [-1.98,3.10] (95%)

[passed STC, 4 threads 5+0.05](http://tests.stockfishchess.org/tests/view/5b5dbf0f0ebc5902bdb9131c)
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 9108 W: 2033 L: 1858 D: 5217
Elo: 6.11 [1.26,10.89] (95%)

No functional change (in simple threat mode)
 2018-08-08 17:34:12 +02:00
Marco Costalba 571f54b176 Improve Stats definition 
Use operator const T&() instead of operator T() to avoid possible
costly hidden copies of non-scalar nested types.

Currently StatsEntry has a single member T, so assuming
sizeof(StatsEntry) == sizeof(T) it happens to work, but it's
better to use the size of the proper entry type in std::fill.
Note that current code works because std::array items are ensured
to be allocated in contiguous memory and there is no padding among
nested arrays. The latter condition does not seem to be strictly
enforced by the standard, so be careful here.

Finally use address-of operator instead of get() to fully hide the
wrapper class StatsEntry at calling sites. For completness add
the arrow operator too and simplify the C++ code a bit more.

Same binary code as previous master under the Clang compiler.

No functional change.
 2018-08-01 12:40:12 +02:00
Marco Costalba fae57273b2 Small tweaks to recent code changes 
As a note, current 2 LMR conditions on stat score
could be simplified in a single line:

r -= ((ss->statScore >= 0) - ((ss-1)->statScore >= 0)) * ONE_PLY;

We keep them splitted in 2 "if" statements because are easier
to (immediately) read.

No functional change.
 2018-07-31 11:56:10 +02:00
noobpwnftw 9afa03b80e 7-pieces Syzygy tablebase support 
This is the first patch teaching Stockfish how to use the 7-pieces
Syzygy tablebase currently calculated by Bujun Guo (@noobpwnftw) and
Ronald de Man (@syzygy1). The 7-pieces database are so big that they
required a change in the internal format of the files (technically,
some DTZ values are 16 bits long, so this had to be stored as wide
integers in the Huffman tree).

Here are the estimated file size for the 7-pieces Syzygy files,
compared to the 151G of the 6-pieces Syzygy:

```
7.1T    ./7men_testing/4v3_pawnful (ongoing, 120 of 325 sets remaining)
2.4T    ./7men_testing/4v3_pawnless
2.3T    ./7men_testing/5v2_pawnful
660G    ./7men_testing/5v2_pawnless
117G    ./7men_testing/6v1_pawnful
87G     ./7men_testing/6v1_pawnless
```
Some pointers to download or recalculate the tables:

Location of original files, by Bujun Guo:
ftp://ftp.chessdb.cn/pub/syzygy/

Mirrors:
http://tablebase.sesse.net/ (partial)
http://tablebase.lichess.ovh/tables/standard/7/

Generator code:
https://github.com/syzygy1/tb/

Closes https://github.com/official-stockfish/Stockfish/pull/1707

Bench: 5591925 (No functional change if SyzygyTB is not used)

----------------------

Comment by Leonardo Ljubičić (@DragonMist)

This is an amazing achievement, generating and being able to use 7 men syzygy
on the fly. Thank you for your efforts @noobpwnftw !! Looking forward how this
will work in real life, and expecting some trade off between gaining perfect
play and slow disc Access, but once the disc speed and space is not a problem,
I expect 7 men to yield something like 30 elo at least.

-----------------------

Comment by Michael Byrne (@MichaelB7)

This definitely has a bright future. I turned off the 50 move rule (ala ICCF
new rules) for the following position:  `[d]8/8/1b6/8/4N2r/1k6/7B/R1K5 w - - 0 1`
This position is a 451 ply win for white (sans the 50 move rule, this position
was identified by the generator as the longest cursed win for white in KRBN v KRB).

Now Stockfish finds it instantly (as it should), nice work 👊👍 .
```
dep score	    nodes	    time
  7	+132.79 	4339    	0:00.00	Rb1+ Kc4 Nd6+ Kc5 Bg1+ Kxd6 Rxb6+ Kc7 Be3 Rh2 Bd4
  6	+132.79 	1652    	0:00.00	Rb1+ Kc4 Nd2+ Kd5 Rxb6 Rxh2 Nf3 Rf2
  5	+132.79 	589      	0:00.00	Rb1+ Kc4 Rxb6 Rxh2 Nf6 Rh1+ Kb2
  4	+132.79 	308      	0:00.00	Rb1+ Kc4 Nd6+ Kc3 Rxb6 Rxh2
  3	+132.79 	88        	0:00.00	Rb1+ Ka4 Nc3+ Ka5 Ra1+ Kb4 Ra4+ Kxc3 Rxh4
  2	+132.79 	54        	0:00.00	Rb1+ Ka4 Nc3+ Ka5 Ra1+ Kb4
  1	+132.7
```
 2018-07-31 11:24:28 +02:00
Stéphane Nicolet ba2a2c34bb Introduce tropism measure in king danger 
This patch adds the tropism measure as a new term in the king danger variable.
Since we then trasform this variable as a Score via a quadratic formula, the
main effect of the patch is the positive correlation of the tropism measure
with some checks and pins information already present in the king danger code.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 6805 W: 1597 L: 1431 D: 3777
http://tests.stockfishchess.org/tests/view/5b5df8d10ebc5902bdb91699

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 32872 W: 5782 L: 5523 D: 21567
http://tests.stockfishchess.org/tests/view/5b5e08d80ebc5902bdb917ee

How to continue from there?

• it may be possible to use CloseEnemies=S(7,0)
• we may want to try incorporating other strategic features in the quadratic
  king danger.

Closes https://github.com/official-stockfish/Stockfish/pull/1717

Bench: 5591925
 2018-07-30 08:26:48 +02:00
Miguel Lahoz c08e05b494 Increase the mg->eg gradient for the PawnlessFlank malus 
Just a change of value to S(19, 84). Also somewhat of a follow up
to the recent tweak in definition of KingFlank.

I tried a lot of other values before this, increasing and decreasing
but with little success, and before giving up I wanted to try tweaking
the middlegame and endgame values in the opposite directions. I guess
this is somewhat lucky.

STC:
LLR: 2.94 (-2.94,2.94) [0.00,4.00]
Total: 67685 W: 15399 L: 14963 D: 37323
http://tests.stockfishchess.org/tests/view/5b5b5ae80ebc5902bdb8e4f8

LTC: (Also thanks to Stephane Nicolet)
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 54635 W: 9505 L: 9172 D: 35958
http://tests.stockfishchess.org/tests/view/5b5b78f20ebc5902bdb8ece5

Closes https://github.com/official-stockfish/Stockfish/pull/1714

Bench: 4883742
 2018-07-28 07:34:37 +02:00
VoyagerOne 6184d2b2ac Simplify cmh pruning 
Simplify cmh pruning by removing PvNode exception

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 9935 W: 2330 L: 2184 D: 5421
http://tests.stockfishchess.org/tests/view/5b587dc00ebc5902bdb88424

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 20635 W: 3585 L: 3464 D: 13586
http://tests.stockfishchess.org/tests/view/5b58910a0ebc5902bdb885b9

Closes https://github.com/official-stockfish/Stockfish/pull/1711

Bench: 4905530
 2018-07-27 16:23:45 +02:00
Stéphane Nicolet 9ca014df49 Fix a compilation error for MSVC 
The previous commit wouldn't compile on the Microsoft Virtual Studio C++ compiler. So use a more compatible style for the same idea (which we already use in numerous places of evaluate.cpp, for instance in line 563).

Under the Clang compiler, both versions generate exactly the same machine code (same md5 signatures for the two binaries).

No functional change.
 2018-07-27 15:46:13 +02:00
Stéphane Nicolet e12fc10b5c Remove a popcount for HinderPassedPawn 
Remove a popcount for HinderPassedPawn, and compensate by doubling
 the bonus from S(4,0) to to S(8,0).

Maybe it was pure luck, but we got the idea of this Elo gaining patch by
seing the simplification attempt by Mike Whiteley in pull request #1703.
This suggests that whenever we have a passed evaluation simplification,
we should consider the possibility that the master bonus has become
slightly out of tune with time, and we should try a few Elo gaining [0..4]
tests by hand-tuning the master bonus.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 19136 W: 4388 L: 4147 D: 10601
http://tests.stockfishchess.org/tests/view/5b59be6f0ebc5902bdb8ac06

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 99382 W: 17324 L: 16843 D: 65215
http://tests.stockfishchess.org/tests/view/5b59d2410ebc5902bdb8afa8

Closes https://github.com/official-stockfish/Stockfish/pull/1710

Bench: 4688817
 2018-07-27 15:23:57 +02:00
Miguel Lahoz 313f403733 Tweak KingFlank when king is on edge files 
This tweak excludes files D and E from the KingFlank bitboard when our
king is on the A or H files respectively. As far as I can tell, this
affects two things: the calculation for CloseEnemies and PawnlessFlank.
Aside from filtering out slightly less relevant attacks in the flank,
I suspect this helps with king prophylaxis, avoiding attacks and moving
towards the center when the pawns start to come off.

STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 56755 W: 12881 L: 12489 D: 31385
http://tests.stockfishchess.org/tests/view/5b58a94c0ebc5902bdb88c72

LTC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 130205 W: 22536 L: 21957 D: 85712
http://tests.stockfishchess.org/tests/view/5b58b7580ebc5902bdb89029

How to continue: Tweaking the two bonuses mentioned might give some
gain, although as far as I can tell, CloseEnemies is very sensitive to
even small changes.

Closes https://github.com/official-stockfish/Stockfish/pull/1705

Bench: 5026009
 2018-07-27 10:38:20 +02:00
Jekaa c9f80660a6 Small reformat in evaluate threats (non functional) 
When evaluating threat by safe pawn and pawn push the same expression is used.

STC
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 19444 W: 4540 L: 4309 D: 10595
http://tests.stockfishchess.org/tests/view/5b5a6e150ebc5902bdb8c5c0

Closes https://github.com/official-stockfish/Stockfish/pull/1709

No functional change.

--------------------

Comments by Stéphane Nicolet:

I don't measure any speed-up on my system, with two parallel benches at depth 22:

Total time (ms) : 74989
Nodes searched : 144830258
Nodes/second : 1931353
master

Total time (ms) : 75341
Nodes searched : 144830258
Nodes/second : 1922329
testedpatch

And anyway, like Stefan Geschwentner, I don't think that a 0.3% speed-up would
be enough to pass a [0..5] LTC test -- as a first approximation, we have this
rule of thumb that 1% speed-up gives about 1 Elo point.

However, considering the facts that the reformatting by itself is interesting,
that this is your first green test and that you played by the rules by running
the SPRT[0..5] test before opening the pull request, I will commit the change.
I will only take the liberty to change the occurrences of safe in lines 590 and
591 to b, to make the code more similar to lines 584 and 585.

So approved, and congrats :-)
 2018-07-27 10:30:53 +02:00
ianfab d44701be4b Fix condition for error message of signature script 
Use obtained bench instead of reference bench when checking for crash.

No functional change.
 2018-07-27 10:16:33 +02:00
protonspring 2660a9145e Remove condition for pawn threats 
It appears as though removing squares that are already attacked
by our pawns can be removed.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 51242 W: 11503 L: 11440 D: 28299
http://tests.stockfishchess.org/tests/view/5b58b5a40ebc5902bdb88f52

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 35246 W: 6063 L: 5966 D: 23217
http://tests.stockfishchess.org/tests/view/5b58f8e20ebc5902bdb8959b

How to continue after this patch: there is now a slight semantic
overlap between the ThreatByPawnPush and the ThreatBySafePawn bonuses,
so hand-tuning either of these, or both at the same time, is natural.

Closes https://github.com/official-stockfish/Stockfish/pull/1702

Bench 4734881
 2018-07-26 09:34:22 +02:00
Stefan Geschwentner a4eda3056e Rank threats on pinned pawns 
Add for pinned pawns half of the standard rank based threat bonus.

STC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 44010 W: 9987 L: 9635 D: 24388
http://tests.stockfishchess.org/tests/view/5b58aa780ebc5902bdb88c7a

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 29475 W: 5089 L: 4847 D: 19539
http://tests.stockfishchess.org/tests/view/5b58b56c0ebc5902bdb88f37

Closes https://github.com/official-stockfish/Stockfish/pull/1701

Bench: 4503866
 2018-07-26 01:29:12 +02:00
Stéphane Nicolet ae98927885 Code clean-up 
This patch implements some idea by Alain Savard and Mike Whiteley taken from the perpertual renaming/reformatting thread.

This is a pure code cleaning patch (so no change in functionality), but I use it as a pretext to correct the bogus bench number that I introduced in the previous commit.

Bench: 4413383
 2018-07-25 18:31:02 +02:00
Stefan Geschwentner c4c2e08f0d Tweak stat bonus 
Increase stat bonus by 1/32 and adjust the divisor of main and capture
history tables to 10692.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 28437 W: 6444 L: 6166 D: 15827
http://tests.stockfishchess.org/tests/view/5b579b4d0ebc5902bdb87139

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 111204 W: 19160 L: 18644 D: 73400
http://tests.stockfishchess.org/tests/view/5b57a7c60ebc5902bdb872d3

Closes https://github.com/official-stockfish/Stockfish/pull/1698

Bench: 4778882
 2018-07-25 18:02:07 +02:00
VoyagerOne 6e36860554 CounterMove History Pruning Tweak 
STC: (Yellow)
LLR: -2.96 (-2.94,2.94) [0.00,5.00]
Total: 40124 W: 8817 L: 8751 D: 22556
http://tests.stockfishchess.org/tests/view/5b5690180ebc5902bdb85c8a

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 21599 W: 3811 L: 3599 D: 14189
http://tests.stockfishchess.org/tests/view/5b5757010ebc5902bdb86b1f

Closes https://github.com/official-stockfish/Stockfish/pull/1697

Bench:  4794161
 2018-07-25 17:55:16 +02:00
Stefan Geschwentner bb56779cb6 Revert "Tweak reductions formula: 0.88 * depth + 0.12" 
This patch reverts the recent commit called "Tweak reductions formula, etc."
The decisions for the revert decision were as follows:

1) The original commit called "Tweak reductions formula: 0.88 * depth + 0.12"
showed bad scaling at in a Very Long Time Control (VLTC) test:

VLTC (180+1.8):
LLR: -1.59 (-2.94,2.94) [0.00,5.00]
Total: 14968 W: 2247 L: 2257 D: 10464
http://tests.stockfishchess.org/tests/view/5b559ffa0ebc5902bdb84f36

2) So there was a suspicion that the original fast passing LTC test which lead
us to accept the patch may have been a statistical accident, so we organized
a match against the previous master at LTC to get an Elo estimate for the
patch:

LTC match:
ELO: -1.83 +-2.1 (95%) LOS: 4.3%
Total: 36018 W: 6018 L: 6208 D: 23792
http://tests.stockfishchess.org/tests/view/5b55f8110ebc5902bdb8526f

3) Based on these results, we ran a simplification test with [-3..1] bounds
for the revert at LTC:

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 41501 W: 7107 L: 7020 D: 27374
http://tests.stockfishchess.org/tests/view/5b5738670ebc5902bdb86932

4) So we revert.

Bench: 4491691
 2018-07-25 07:39:06 +02:00
double-beep 38471697b7 Slight decrease of overload value 
Set overload value to S(13,6)

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 27606 W: 6371 L: 6094 D: 15141
http://tests.stockfishchess.org/tests/view/5b5455840ebc5902bdb82425

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 112435 W: 19442 L: 18921 D: 74072
http://tests.stockfishchess.org/tests/view/5b546d4a0ebc5902bdb82741

Closes https://github.com/official-stockfish/Stockfish/pull/1694

Bench: 4937000
 2018-07-24 08:39:08 +02:00
Stefan Geschwentner 50287a55d3 Tweak reductions formula: 0.88 * depth + 0.12 
Replace the depth part in the reduction formula for higher depths
with a slower growing linear function. So for depth > 3 less reductions
are used.

What we can try next:
- move the break point to even higher depths
- tweak the slope for lower and higher depth
- even possibly use a further higher depth threshold for a another
  slower growing function

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 25317 W: 5763 L: 5505 D: 14049
http://tests.stockfishchess.org/tests/view/5b54f9f70ebc5902bdb840ed

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 7451 W: 1320 L: 1167 D: 4964
http://tests.stockfishchess.org/tests/view/5b54feeb0ebc5902bdb84244

Closes https://github.com/official-stockfish/Stockfish/pull/1692

Bench: 4617359
 2018-07-23 09:16:29 +02:00
Goodkov Vasiliy Aleksandrovich 0d5fe2f156 Simplify condition for ThreatByRook 
Remove stronglyProtected Queen for ThreatByRook. Idea is that in the
current master the  SliderOnQueen bonus and the see_ge() function do
something similar as ThreatByRook for Queen, so this patch removes
some redundancy, in that sense.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 21878 W: 4939 L: 4818 D: 12121
http://tests.stockfishchess.org/tests/view/5b53a83b0ebc5902bdb815d1

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 35307 W: 5979 L: 5882 D: 23446
http://tests.stockfishchess.org/tests/view/5b53b60b0ebc5902bdb8174c

Close https://github.com/official-stockfish/Stockfish/pull/1690

Bench: 4834554
 2018-07-23 00:03:05 +02:00
protonspring af1ddfd83b simplified forward ranks. 
This is a non-functional simplification. We change replaces an 'OR'
and a lookup (rank_bb(ksq)) with a bitwise ~.  This is fewer operations
and is probably faster.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 25441 W: 5689 L: 5575 D: 14177
http://tests.stockfishchess.org/tests/view/5b52d05a0ebc5902bdb8010e

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 26904 W: 4664 L: 4553 D: 17687
http://tests.stockfishchess.org/tests/view/5b543df70ebc5902bdb8212d

No functional change.
 2018-07-22 17:59:39 +02:00
Marco Costalba 4bd24da161 Slight tidy up in endgame machinery 
No functional change.
 2018-07-22 17:55:41 +02:00
Stefan Geschwentner 53c07c34bb Non functional LMR rewrite. 2018-07-22 17:53:31 +02:00
Alain SAVARD 0365b08601 Simplify the "overload" condition 
This is a follow-up of the previous pull request (#1686) by Miguel.
We simplify the "Overload" bonus condition by re-using the "weak"
variable, which captures well the essence of the overload condition.
This may also be a small speed optimization because the weak variable
is in a register at this point of the code.

http://tests.stockfishchess.org/tests/view/5b527b440ebc5902bdb7f7db
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 10925 W: 2517 L: 2374 D: 6034

http://tests.stockfishchess.org/tests/view/5b527f930ebc5902bdb7f883
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 15569 W: 2697 L: 2568 D: 10304

Closes https://github.com/official-stockfish/Stockfish/pull/1687

Bench: 5010472
 2018-07-21 07:05:50 +02:00
Miguel Lahoz 41bc0d5660 Remove connectivity. 
There seems to be some strange interaction between Overload and Connectivity.
Overload encourages us to not have too many defended and attacked pieces,
as this may expose us to various tactics. This feels somewhat like it is in
conflict with Connectivity, where pieces are defended preemptively.

Here I take the "pick one or the other" approach and just remove connectivity,
while strengthening the effect of Overload to compensate. The reasoning is that
if we defend our pieces preemptively, then it does get attacked, we want to do
something about it so we don't get penalized by Overload. On the other
hand, if it doesn't get attacked, then there's no need to defend it.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 27734 W: 6174 L: 6064 D: 15496
http://tests.stockfishchess.org/tests/view/5b5073bd0ebc5902bdb7ba5c

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 51606 W: 8897 L: 8827 D: 33882
http://tests.stockfishchess.org/tests/view/5b50aa900ebc5902bdb7bf29

Bench: 4658006
 2018-07-21 06:56:48 +02:00
Stefan Geschwentner 12e79be910 Better check evasion move sorting 
Use in addition the counter move history table for sorting quiet
check evasion moves in main and quiecence search. Also rename
"contHistory" to "continuationHistory" while there.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 73284 W: 16433 L: 15938 D: 40913
http://tests.stockfishchess.org/tests/view/5b4f526e0ebc5902bdb7a401

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 12135 W: 2171 L: 1997 D: 7967
http://tests.stockfishchess.org/tests/view/5b4fc0ef0ebc5902bdb7ae0e

Closes https://github.com/official-stockfish/Stockfish/pull/1685

Bench 4817583
 2018-07-19 18:27:20 +02:00
Miguel Lahoz 3913726d1c Use single value for KingProtector. 
After some recent big tuning session, the values for King Protector were
simplified to only be used on minor pieces. This patch tries to further
simplify by just using a single value, since current S(6,5) and S(5,6)
are close to each other. The value S(6,6) ended up passing, although
S(5,5) was also tried and failed STC.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 14261 W: 3288 L: 3151 D: 7822
http://tests.stockfishchess.org/tests/view/5b4ccdf50ebc5902bdb77f65

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 19606 W: 3396 L: 3273 D: 12937
http://tests.stockfishchess.org/tests/view/5b4ce4280ebc5902bdb7803b

Bench: 5448998
 2018-07-18 08:44:45 +02:00
ElbertoOne 2ac35027d5 Simplify Overload condition 
Extend the bonus for Overload to cases where our side
 has more than one attacker to a non pawn piece.
Based on an idea by Bryan in the forum. For instance,
 now black gets the overload bonus in this position:
 8/5R1k/6pb/p6p/P1N4P/1Pp5/2K3P1/2N4r b - - 6 46
 because two black pieces are attacking the knight on c1
 that is defended only by the king.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 57446 W: 12762 L: 12711 D: 31973
http://tests.stockfishchess.org/tests/view/5b4ca9970ebc5902bdb77a88

LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 42113 W: 7295 L: 7209 D: 27609
http://tests.stockfishchess.org/tests/view/5b4ccea00ebc5902bdb77f69

Bench: 4667263
 2018-07-18 08:37:13 +02:00
DU-jdto a05793517f Minor code style tweaks 
No functional change.
 2018-07-18 08:26:33 +02:00
ianfab ee0f5cd303 Minor whitespace formatting changes 
No functional change.
 2018-07-18 08:25:08 +02:00
Gian-Carlo Pascutto e0f317afaa Allow Position::init() to be called multiple times. 
For the rationale to allow this, see commit
a66c73deef

This was broken when cuckoo hashing was added, and
subtly broke (for example) lichess' Android application,
thus illustrating the original judgement was sound.

No functional change.
 2018-07-18 08:14:57 +02:00
protonspring a6fa6a9e92 Remove rank limitation for MinorBehindPawn 
This is a functional simplification.  It seems like the rank restriction
for MinorBehindPawn can be removed.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 61195 W: 13404 L: 13360 D: 34431
http://tests.stockfishchess.org/tests/view/5b47e6f00ebc5978f4be3fc0

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 31701 W: 5367 L: 5264 D: 21070
http://tests.stockfishchess.org/tests/view/5b48a2cb0ebc5978f4be4769

Bench: 4938702
 2018-07-14 08:27:33 +02:00
candirufish d2d4e85f25 Tuned Values after 2 million spsa games 
Various king and pawn eval values tuned after 2 million games. Rounding
slightly adjusted.

LTC: http://tests.stockfishchess.org/tests/view/5b477a260ebc5978f4be3ed4
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 32783 W: 5852 L: 5588 D: 21343

STC: http://tests.stockfishchess.org/tests/view/5b472d420ebc5978f4be3e4d
LLR: 3.23 (-2.94,2.94) [0.00,4.00]
Total: 44380 W: 10201 L: 9841 D: 24338

I think I reached the limit of the fishtest framework. It frequently
crashed at 2 million games already. The small values also moved a lot
throughout the entire tuning session though with smaller margin. The
passed danger and close enemies values seems the most sensitive (changing
close enemies alone to 6 failed before but now it passes), whether or not
they are close to optimal I don't know, but it seems some parameters are
also correlated to others.

Closes https://github.com/official-stockfish/Stockfish/pull/1670

bench: 5103722
 2018-07-14 08:13:15 +02:00
Joost VandeVondele d2752fdc15 Remove offset in thread redistribution scheme. 
doesn't have a benefit.

passed STC (8 threads):
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 19574 W: 4028 L: 3904 D: 11642
http://tests.stockfishchess.org/tests/view/5b3e48950ebc5902b9fff080

passed LTC (8 threads):
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21293 W: 3626 L: 3506 D: 14161
http://tests.stockfishchess.org/tests/view/5b3eefd60ebc5902b9fffa81

Closes https://github.com/official-stockfish/Stockfish/pull/1667

No functional change single threaded.
 2018-07-07 10:42:06 +02:00
31m059 0f48095759 Simplify ThreatByKing to be a single Score. 
In the current master, ThreatByKing is an array of two Scores, one for
when we have a single attack and one for when we have many. The latter
case is very rarely called during bench and was recently given a strange
negative value during a tuning run, as pointed out by @candirufish on
commit efd4ca2.  Here, we simplify away this second case entirely, and
increase the remaining ThreatByKing to compensate.

Although I derived the parameter tweak independently, with the goal of
preserving the same average bonus, I later noticed that a very similar
Score had already been derived by an ongoing SPSA tuning session.
I therefore recognize @candirufish for first discovering these values.

I would also like to thank @Rocky640 for valuable feedback that pointed
me in the direction of ThreatByKing.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 7677 W: 1772 L: 1623 D: 4282
http://tests.stockfishchess.org/tests/view/5b3db0320ebc5902b9ffe97a

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 108031 W: 18329 L: 18350 D: 71352
http://tests.stockfishchess.org/tests/view/5b3dbf4b0ebc5902b9ffe9db

Closes https://github.com/official-stockfish/Stockfish/pull/1666

Bench: 4678861
 2018-07-06 01:34:01 +02:00
VoyagerOne 3279655f12 Capture Stat Tweak 
Penalize capture moves that fail to create a cutoff even at quiet move cutoff.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 19004 W: 4284 L: 4059 D: 10661
http://tests.stockfishchess.org/tests/view/5b3a7d4d0ebc5902b9ffb6ea

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 23100 W: 3981 L: 3765 D: 15354
http://tests.stockfishchess.org/tests/view/5b3aa4550ebc5902b9ffb8cf

Closes https://github.com/official-stockfish/Stockfish/pull/1664

Bench: 5232010
 2018-07-04 01:12:16 +02:00
Joost VandeVondele e7cfa5d020 Simplify saving a TT entry. 
Avoid passing TT.generation() to TTEntry::save() at every call,
moving the implementation of TTEntry::save from tt.h to tt.cpp.

tested for no regression:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 53787 W: 11948 L: 11890 D: 29949
http://tests.stockfishchess.org/tests/view/5b2ff37f0ebc5902b2e582fe

Closes https://github.com/official-stockfish/Stockfish/pull/1662

No functional change.
 2018-07-04 00:59:15 +02:00
Joost VandeVondele 8c4f0ffa1d Reduce scope of variables 
Small cleanup TranspositionTable:clear().

Closes https://github.com/official-stockfish/Stockfish/pull/1659

No functional change.
 2018-07-04 00:51:10 +02:00
Ondrej Mosnáček a781535168 Move PSQ score to Position 
This patch simplifies Position::do_move() by moving the PSQ score from
StateInfo to Position and updating it inside the put/remove/move_piece
functions.

The downside is that there is now slightly more computation done in
Position::undo_move(), but the fishtest results are Elo neutral.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 78820 W: 15775 L: 15760 D: 47285
http://tests.stockfishchess.org/tests/view/5b1cd1d00ebc5902ab9c64ab

Passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 32966 W: 5716 L: 5615 D: 21635
http://tests.stockfishchess.org/tests/view/5b31e1230ebc5902b2e5a833

Closes https://github.com/official-stockfish/Stockfish/pull/1647

No functional change.
 2018-06-27 11:42:25 +02:00
protonspring af6072c8b7 Remove make_bitboard() 
In current master, the function make_bitboard() does nothing apart from
helping initialize the SquareBB[] array. This seems like an unnecessary
abstraction layer.

The advantage of make_bitboard() is we can define a bitboard, in a simple
and general way, not only from a single square but also from a list of
squares. It is more elegant, faster and  readable than combining multiple
SquareBB explicitly, but the last complex use case in evaluation was
simplified away a few months ago.

If make_bitboard() becomes useful again to define complicated bitboards,
it will be easy enough to reintroduce it using this pull request as
an implementation reference.

No functional change.
 2018-06-26 09:08:15 +02:00
joergoster 1e9397a2df Simplify KingProtector penalty. 
Recent tuning results implied this penalty is more important for knights
and bishops, and almost negligible for rooks and queen.

Passed as simplification both
STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 20873 W: 4592 L: 4469 D: 11812
http://tests.stockfishchess.org/tests/view/5b2fb4d00ebc5902b2e57e84

and LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 46069 W: 7949 L: 7870 D: 30250
http://tests.stockfishchess.org/tests/view/5b2fcc4b0ebc5902b2e580c5

Closes https://github.com/official-stockfish/Stockfish/pull/1660

Bench: 5487679
 2018-06-26 08:55:35 +02:00
Alain SAVARD f0a7bed6fb Simplify HinderPassedPawn bonus 
Make sure each piece is not scored more than once as a passed pawn "hinderer",
by scoring only the blockers along the passed pawn path. Inspired by TCEC Game 29.

Passed STC as a simplification
http://tests.stockfishchess.org/tests/view/5b3016d00ebc5902b2e58552
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 75388 W: 16656 L: 16641 D: 42091

Passed LTC as a simplification
http://tests.stockfishchess.org/tests/view/5b302ed90ebc5902b2e587fc
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 49157 W: 8460 L: 8386 D: 32311

Current master was also counting the number of attacks along a passed pawn path,
which might be misleading:

a) a defender might be counted many times for the same pawn path. For example a
   White rook on a1 attacking a black pawn on a7 would score the bonus * 6 but
   would be probably better placed on a8

b) a defender might be counted on different pawn paths and might be overloaded. For
   example a Ke4 or Qe4 against pawns on d6  and f6 would score the bonus * 6.

Counting each blocker or attacker only once is more complicated, and does not help
either: http://tests.stockfishchess.org/tests/view/5b2ff1cb0ebc5902b2e582b2

After this small simplification, there might be ways to increase the HinderPassedPawn
penalty.

Closes https://github.com/official-stockfish/Stockfish/pull/1661

Bench: 4520519
 2018-06-26 08:16:37 +02:00
candirufish efd4ca27c4 Another set of tuned values after one million games 
Another set of tuned values, obtained by a long session of one million games.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 15810 W: 3687 L: 3458 D: 8665
http://tests.stockfishchess.org/tests/view/5b2d32f60ebc5902b2e55d9e

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 102118 W: 18146 L: 17651 D: 66321
http://tests.stockfishchess.org/tests/view/5b2d372c0ebc5902b2e55e0a

Closes https://github.com/official-stockfish/Stockfish/pull/1658

Bench: 4557946
 2018-06-23 09:03:58 +02:00
Stéphane Nicolet 34321fcc2d Increase outflanking weight to 12 
Give more incentive to king activity in the endgame by increasing the weight
of the "outflanking" variable from 8 to 12 in the function evaluate_initiative().

Finished yellow after 133102 games at STC:

LLR: -3.07 (-2.94,2.94) [0.00,4.00]
Total: 133102 W: 29535 L: 29179 D: 74388
http://tests.stockfishchess.org/tests/view/5b2b63fe0ebc5902b2e54475

Passed LTC:

LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 28027 W: 4918 L: 4672 D: 18437
http://tests.stockfishchess.org/tests/view/5b2ba39e0ebc5902b2e54a64

Closes https://github.com/official-stockfish/Stockfish/pull/1657

Bench: 4721753
 2018-06-22 01:29:25 +02:00
candirufish 062eb074c8 Tuned values after 505k games 
Various king and pawn tuned eval values after 505k 60 sec 600 nodes time
SPSA games. Adjusted passed rank and file values to be symmetrical.

Passed LTC (after passed rank/file adjustment):
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 37906 W: 6953 L: 6668 D: 24285
http://tests.stockfishchess.org/tests/view/5b2790960ebc5902b8d17ba1

A previous, very similar version with raw tuned values passed STC and LTC:

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 39515 W: 9227 L: 8900 D: 21388
http://tests.stockfishchess.org/tests/view/5b277e3e0ebc5902b8d17ac9

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 14618 W: 2743 L: 2537 D: 9338
http://tests.stockfishchess.org/tests/view/5b2785020ebc5902b8d17b98

Closes https://github.com/official-stockfish/Stockfish/pull/1654

bench: 4777396
 2018-06-21 10:23:05 +02:00
Michael An 06a853eb9c Fix GCC 8 cast warnings 
Silences the following warnings when compiling with GCC 8.
The fix is to use an intermediate pointer to anonymous function:

```
misc.cpp: In function 'int WinProcGroup::get_group(size_t)':
misc.cpp:241:77: warning: cast between incompatible function types from 'FARPROC' {aka 'long long int (*)()'} to 'fun1_t' {aka 'bool (*)(_LOGICAL_PROCESSOR_RELATIONSHIP, _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*, long unsigned int*)'} [-Wcast-function-type]
   auto fun1 = (fun1_t)GetProcAddress(k32, "GetLogicalProcessorInformationEx");
                                                                             ^
misc.cpp: In function 'void WinProcGroup::bindThisThread(size_t)':
misc.cpp:309:71: warning: cast between incompatible function types from 'FARPROC' {aka 'long long int (*)()'} to 'fun2_t' {aka 'bool (*)(short unsigned int, _GROUP_AFFINITY*)'} [-Wcast-function-type]
   auto fun2 = (fun2_t)GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
                                                                       ^
misc.cpp:310:67: warning: cast between incompatible function types from 'FARPROC' {aka 'long long int (*)()'} to 'fun3_t' {aka 'bool (*)(void*, const _GROUP_AFFINITY*, _GROUP_AFFINITY*)'} [-Wcast-function-type]
   auto fun3 = (fun3_t)GetProcAddress(k32, "SetThreadGroupAffinity");
                                                                   ^
```

No functional change.
 2018-06-21 09:51:31 +02:00
mstembera 745160572f Fix MSVC error 
Compiling the current master with MSVC gives the following error:

```
search.cpp(956): error C2660: 'operator *': function does not take 1 arguments
types.h(303): note: see declaration of 'operator *'
```

This was introduced in commit:
https://github.com/official-stockfish/Stockfish/commit/88de112b84a5285c2afb3e075a05c2ab8ad3fd33

We use a suggestion by @vondele to fix the error, thanks!

No functional change.
 2018-06-20 05:43:00 +02:00
Stefano80 9d219c07e4 Slight simplification in scale factor computation 
[STC](http://tests.stockfishchess.org/tests/view/5b2614000ebc5902b8d17193)
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 17733 W: 3996 L: 3866 D: 9871

[LTC](http://tests.stockfishchess.org/tests/view/5b264d0f0ebc5902b8d17206)
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 55524 W: 9535 L: 9471 D: 36518

Use pawn count scaling also for opposite bishops endings with additional material, with a slope of 2 instead of 7. This simplifies slightly the code.

This PR is a functionally equivalent refactoring of the version which was submitted.

Four versions tried, 2 passed both STC and LTC. I picked the one which seemed more promising at LTC.

Slope 4 passed STC (-0.54 Elo), LTC not attempted
Slope 3 passed STC (+2.51 Elo), LTC (-0.44 Elo)
Slope 2 passed STC (+2.09 Elo), LTC (+0.04 Elo)
Slope 1 passed STC (+0.90 Elo), failed LTC (-3.40 Elo)

Bench: 4761613
 2018-06-20 05:27:24 +02:00
DU-jdto a834bfe833 Remove lmrDepth restriction on quiet see pruning 
And tweak the threshold value. With this threshold and the current piece
values, this permits see pruning on quiets to be done up to an lmrDepth
of 9 (beyond that the threshold is below -QueenValueMg and see_ge will
pass unconditionally).

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 110316 W: 24612 L: 24667 D: 61037
http://tests.stockfishchess.org/tests/view/5b20aa760ebc5902ab9c9c1d

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 17352 W: 2968 L: 2842 D: 11542
http://tests.stockfishchess.org/tests/view/5b20cf1e0ebc5902ab9c9fb6

Closes https://github.com/official-stockfish/Stockfish/pull/1651

Bench: 5069074
 2018-06-13 21:52:53 +02:00
Joost VandeVondele 6c36e65193 Remove depth condition for pruning captures. 
The SEE condition alone is sufficient.

passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 109863 W: 24339 L: 24392 D: 61132
http://tests.stockfishchess.org/tests/view/5b1f5b000ebc5902ab9c8668

passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 23390 W: 4020 L: 3903 D: 15467
http://tests.stockfishchess.org/tests/view/5b1f94b40ebc5902ab9c8b5e

Closes https://github.com/official-stockfish/Stockfish/pull/1648

Bench: 4834747
 2018-06-13 21:46:12 +02:00
protonspring fc3af7c4fb Optimize an expression in endgame.cpp 
I believe using foward_file_bb() here is fewer instructions.

a) Fewer instructions and probably more clear (debatable).
b) Possible that a lookup is slower than a few local operations, but the
   forward_file_bb table is probably used often enough that it is always
   cached.

Passed
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21004 W: 4263 L: 4141 D: 12600
http://tests.stockfishchess.org/tests/view/5b1cad830ebc5902ab9c6239

Closes https://github.com/official-stockfish/Stockfish/pull/1644

No functional change.
 2018-06-11 10:22:55 +02:00
candirufish 88de112b84 Simplify capture pruning margin formula 
Using just `PawnValueEg * depth` as Capture Prune Margin. There was a bunch
of patches that passed recently regarding captures, maybe this part of the
master code redundant? The patch was tested as a simplification:

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 20833 W: 4218 L: 4096 D: 12519
http://tests.stockfishchess.org/tests/view/5b1cf2100ebc5902ab9c6651

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 27050 W: 3975 L: 3864 D: 19211
http://tests.stockfishchess.org/tests/view/5b1cfdc80ebc5902ab9c6776

Closes https://github.com/official-stockfish/Stockfish/pull/1643

Bench: 4980482
 2018-06-11 10:03:33 +02:00
Stefan Geschwentner 86e467520f Optimize contempt value (21) 
After several tests it seems best to increase contempt from 12 to 21. This does
not regress against contempt=0 and gives a gain of around 7-8 elo against SF 7
in comparison to current default contempt.

STC: Test for non-regression contempt=21 against contempt=0
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 71250 W: 13956 L: 13926 D: 43368
http://tests.stockfishchess.org/tests/view/5b19a58d0ebc5902ab9c3bfa

STC: Test contempt 21 against SF 7
ELO: 190.06 +-2.8 (95%) LOS: 100.0%
Total: 40000 W: 22608 L: 2676 D: 14716
http://tests.stockfishchess.org/tests/view/5b19a6520ebc5902ab9c3c0e

STC: Test master against SF 7 for comparison
ELO: 182.95 +-2.7 (95%) LOS: 100.0%
Total: 40000 W: 21905 L: 2595 D: 15500
http://tests.stockfishchess.org/tests/view/5b16f5bc0ebc59214346d5ca

LTC: Test for non-regression contempt=21 against contempt=0
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 47666 W: 6914 L: 6832 D: 33920
http://tests.stockfishchess.org/tests/view/5b1a170b0ebc5902ab9c3fde

LTC: Test contempt 21 against SF 7
ELO: 203.92 +-2.6 (95%) LOS: 100.0%
Total: 40000 W: 22447 L: 1340 D: 16213
http://tests.stockfishchess.org/tests/view/5b1a174b0ebc5902ab9c3fe1

LTC: Test master against SF 7 for comparison
ELO: 196.08 +-2.6 (95%) LOS: 100.0%
Total: 40000 W: 21639 L: 1191 D: 17170
http://tests.stockfishchess.org/tests/view/5b1a17e40ebc5902ab9c3fe4

Closes https://github.com/official-stockfish/Stockfish/pull/1646

Bench: 4786912
 2018-06-11 09:54:32 +02:00
Joost VandeVondele 2af2c67650 Remove failedLow from the mainThread struct 
failedLow is in fact a local variable in Thread::search().

Also clean some spaces and tabs in code.

No functional change.
 2018-06-11 09:46:26 +02:00
candirufish 528507b303 Quiet move soft fail high bonus 
Extra bonus for quiet move creating a huge soft fail high (triggered
in 21% of quiet bestmoves on a normal bench run). Pb00067 original idea
using PawnValueMg.

Passed STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 138207 W: 28060 L: 27295 D: 82852
http://tests.stockfishchess.org/tests/view/5b14471b0ebc5902a81689c1

Passe LTC:
LLR: 2.94 (-2.94,2.94) [0.00,5.00]
Total: 157289 W: 23200 L: 22518 D: 111571
http://tests.stockfishchess.org/tests/view/5b149dde0ebc5902a8b41c5a

bench: 4441320
 2018-06-06 10:16:48 +02:00
VoyagerOne 231103d2cf Simplify capture bonus 
Simplify capture bonus by simply adding ONE_DEPTH instead of being
dependent on BestValue.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 24419 W: 4939 L: 4824 D: 14656
http://tests.stockfishchess.org/tests/view/5b16b2040ebc5963ba37e2a5

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 44560 W: 6524 L: 6438 D: 31598
http://tests.stockfishchess.org/tests/view/5b16ccc00ebc59214346d403

Closes https://github.com/official-stockfish/Stockfish/pull/1640

Bench: 4782637
 2018-06-06 09:58:34 +02:00
Stéphane Nicolet e4f8a4fa7f Call cycle detection before qsearch() 
This has the property of raising alpha before calling qsearch(), thus
maybe giving some more cuts during qsearch(). The patch is equivalent
to the use of cycle detection inside qsearch() at depth 0, but is in
fact implemented by re-ordering code inside search(), which explains
the [0..4] bounds in the following tests.

STC (interrupted after 124250 games, with LLR=0.87):
http://tests.stockfishchess.org/tests/view/5b1500bd0ebc5902a8b420bf
LLR: 0.87 (-2.94,2.94) [0.00,4.00]
Total: 124250 W: 24973 L: 24470 D: 74807

LTC:
http://tests.stockfishchess.org/tests/view/5b1590eb0ebc5902a84dcd09
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 74234 W: 11098 L: 10733 D: 52403

Closes https://github.com/official-stockfish/Stockfish/pull/1635

Bench: 4326784
 2018-06-05 18:15:54 +02:00
Joost VandeVondele 9597ad8cab Stabilize AppVeyor CI 
After a helpful suggestion from AppVeyor support staff, moving the Stockfish
execution from ps to cmd seems to work. Alternative to PR #1624 tested in PR #1637.

No functional change.
 2018-06-05 18:06:13 +02:00
Guenther Demetz b939788f9d Remove a superfluous subtrahend 
The '- 1' subtrahend was introduced for guarding against null move
search at root, which would be nonsense. But this is actually already
guaranteed by the !PvNode condition. This followed from the discussion
in pull request 1609: https://github.com/official-stockfish/Stockfish/pull/1609

No functional change
 2018-06-05 10:10:32 +02:00
VoyagerOne 6b5d671cdc Simplify LMR for captures 
Simplify LMR for captures by removing capture's stat score logic for reduction.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 37068 W: 7462 L: 7370 D: 22236
http://tests.stockfishchess.org/tests/view/5b115bc30ebc591af58a6fd2

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 80061 W: 11706 L: 11671 D: 56684
http://tests.stockfishchess.org/tests/view/5b117f590ebc59033d2d5315

Closes https://github.com/official-stockfish/Stockfish/pull/1631

Bench: 4470519
 2018-06-05 09:58:10 +02:00
joergoster f7bae2de82 Bugfix of Position::has_repeated() 
The function Position::has_repeated() is used by Tablebases::root_probe()
to determine whether we can rank all winning moves with the same value, or
if we need to strictly rank by dtz in case the position has already been
repeated once, and we are risking to run into the 50-move rule and thus
losing the win (especially critical in some very complicated endgames).

To check whether the current position or one of the previous positions
after the last zeroing move has already been occured once, we start looking
for a repetition of the current position, and if that is not the case, we
step one position back and repeat the check for that position, and so on.

If you now look at how this was done before the new root ranking patch was
merged two months ago, it seems quite obvious that it is a simple oversight:
https://github.com/official-stockfish/Stockfish/commit/108f0da4d7f993732aa2e854b8f3fa8ca6d3b46c

More specifically, after we stepped one position back with

```
stc = stc->previous;
```

we now have to start checking for a repetition with

```
StateInfo* stp = stc->previous->previous;
```

and not with

```
StateInfo* stp = st->previous->previous;
```

Closes https://github.com/official-stockfish/Stockfish/pull/1625

No functional change
 2018-06-04 07:45:12 +02:00
Stéphane Nicolet 8ef9bc5a95 Fix overload ambiguity 
Fix an error when compiling current master with MSVC due to the
ambiguity of which operator* overload was intended (reported by
Jarrod Torriero).

No functional change.
 2018-06-03 09:19:13 +02:00
pb00068 c5d6ae8c96 Extra bonus for capture creating a huge fail high 
STC:
http://tests.stockfishchess.org/tests/view/5b114f3d0ebc596e9e0881f6
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 13007 W: 2730 L: 2541 D: 7736

LTC:
http://tests.stockfishchess.org/tests/view/5b1176740ebc59033d2d52c6
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 15594 W: 2417 L: 2239 D: 10938

See https://github.com/official-stockfish/Stockfish/pull/1627

Bench: 4790240
 2018-06-02 18:02:35 +02:00
Stéphane Nicolet a0486ecb40 Fix comments, rename variables 
Thanks everybody for the various hints in the perpetual renaming thread:
https://github.com/official-stockfish/Stockfish/issues/1426

No functional change
 2018-06-02 17:41:37 +02:00
Joost VandeVondele 6cc5614124 Reallocate TT on threadpool resize. 
Makes sure the potential benefit of first touch does not depend on
the order of the UCI commands Threads and Hash, by reallocating the
hash if a Threads is issued. The cost is zeroing the TT once more
than needed. In case the prefered order (first Threads than Hash)
is employed, this amounts to zeroing the default sized TT (16Mb),
which is essentially instantaneous.

Follow up for https://github.com/official-stockfish/Stockfish/pull/1601
where additional data and discussion is available.

Closes https://github.com/official-stockfish/Stockfish/pull/1620

No functional change.
 2018-06-02 17:03:01 +02:00
Joost VandeVondele 31b8243272 Simplify depth reduction in IID. 
Use a constant reduction instead of a depth dependent reduction.

passed STC:
http://tests.stockfishchess.org/tests/view/5b06eb600ebc5914abc12ba8
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 58086 W: 11710 L: 11657 D: 34719

passed LTC:
http://tests.stockfishchess.org/tests/view/5b07b25e0ebc5914abc12c6d
LLR: 3.09 (-2.94,2.94) [-3.00,1.00]
Total: 110414 W: 16217 L: 16219 D: 77978

Bench: 4521056
 2018-05-30 13:38:11 +02:00
Rodrigo Exterckötter Tjäder 626d43a329 Use threads to clear the TT faster. 
Stockfish currently takes a while to clear the TT when using larger hash sizes.

On one machine with 128 GB hash it takes about 50 seconds with a single thread,
allowing it to use all allocated cores brought that time down to 4 seconds on
some Linux systems. The patch was further tested on Windows and refined with
NUMA binding of the hash initializing threads (we refer to pull request #1601
for the complete discussion and the speed measurements).

Closes https://github.com/official-stockfish/Stockfish/pull/1601

No functional change
 2018-05-30 13:07:18 +02:00
VoyagerOne 3d6995eae8 LMR Capture Tweak 
Increase capture reduction by comparing opponent's stat score

STC: (Yellow)
LLR: -2.96 (-2.94,2.94) [0.00,5.00]
Total: 92291 W: 18647 L: 18350 D: 55294
http://tests.stockfishchess.org/tests/view/5b04225e0ebc5914abc1291b

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 20176 W: 3061 L: 2868 D: 14247
http://tests.stockfishchess.org/tests/view/5b04bb3f0ebc5914abc129a3

How to continue?
• we could try a different value for the capture history threeshold

Closes https://github.com/official-stockfish/Stockfish/pull/1612

Bench: 5167159
 2018-05-24 19:06:24 +02:00
protonspring d5d23bfd2d Simplify BlockedByPawn to one dimension 
I was able to get this to pass which reduces BlockedByPawn to one dimension
with NO distance from edge offset.

GOOD)  It's more simple and may provide additional clarity for further
simplifications.  Facilitates migrating unblocked to one dimension as well.

BAD) If there is indeed a distance component to BlockedStorm (may or may
not be the case), this obfuscates this component into ShelterStrength and
UnblockedStorm. This may be more convoluted. Also, it may be more convenient
to have each of the three arrays (ShelterStrength, BlockedStorm, and UnBlocked)
be the same size.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 96173 W: 19326 L: 19343 D: 57504
http://tests.stockfishchess.org/tests/view/5b04544d0ebc5914abc12965

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 49818 W: 7441 L: 7363 D: 35014
http://tests.stockfishchess.org/tests/view/5b0487d50ebc5914abc12990

Closes https://github.com/official-stockfish/Stockfish/pull/1611

Bench: 5133208
 2018-05-24 18:46:55 +02:00
Joost VandeVondele beaadd6547 Correctly prevent recursive verification in nmp. 
As discussed with @pb00068, the condition to prevent recursive verification
was not completely correct. This patch corrects that condition, and adds an
assert. In the current implementation, recursive verification needs to be
avoided in order not to break the verification of the move closer to the
root (i.e. to not set thisThread->nmp_min_ply to zero prematurely).

This patch is tested as a bug fix, based on and tested against PR #1609 .

passed STC:
http://tests.stockfishchess.org/tests/view/5b050f170ebc5914abc129c5
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 7875 W: 1669 L: 1523 D: 4683

passed LTC:
http://tests.stockfishchess.org/tests/view/5b0513970ebc5914abc129cd
LLR: 3.00 (-2.94,2.94) [-3.00,1.00]
Total: 24048 W: 3525 L: 3407 D: 17116

Bench changes at high depth.

Closes https://github.com/official-stockfish/Stockfish/pull/1610
and    https://github.com/official-stockfish/Stockfish/pull/1609

Bench: 4484288
 2018-05-24 18:26:34 +02:00
Joost VandeVondele d702203113 Simplify color usage in search. 
define Color us and use this instead of pos.side_to_move() and nmp_odd. The latter allows to clarify the nmp verification criterion.

Tested for no regression:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 76713 W: 15303 L: 15284 D: 46126
http://tests.stockfishchess.org/tests/view/5b046a0d0ebc5914abc12971

No functional change.
 2018-05-22 22:43:17 +02:00
VoyagerOne 04407e35d6 Simply reset StatScore to zero at beta cutoff 
STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 43154 W: 8706 L: 8625 D: 25823
http://tests.stockfishchess.org/tests/view/5b01a7660ebc5914abc1271d

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 48155 W: 7036 L: 6955 D: 34164
http://tests.stockfishchess.org/tests/view/5b01b2e50ebc5914abc1272c

Closes https://github.com/official-stockfish/Stockfish/pull/1608

Bench: 4484288
 2018-05-22 07:23:04 +02:00
protonspring 335dc2d021 Simplify shelter: always do strength and danger 
This check of pawns before subtracting danger can be removed.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21174 W: 4361 L: 4239 D: 12574
http://tests.stockfishchess.org/tests/view/5b00b9f90ebc5914abc12680

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 56980 W: 8377 L: 8309 D: 40294
http://tests.stockfishchess.org/tests/view/5b00ca750ebc5914abc12683

Closes https://github.com/official-stockfish/Stockfish/pull/1607

Bench: 4746692
 2018-05-21 09:51:05 +02:00
Stéphane Nicolet fd4585ef07 Simplifying away the progressKey 
Simplifying away all the progressKey stuff gives exactly the same bench,
without any speed impact. Tested for speed against master with two benches
at depth 22 ran in parallel:

**testedpatch**
Total time (ms) : 92350
Nodes searched : 178962949
Nodes/second : 1937877

**master**
Total time (ms) : 92358
Nodes searched : 178962949
Nodes/second : 1937709

We also tested the patch at STC for no-regression with [-3, 1] bounds:

LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 57299 W: 11529 L: 11474 D: 34296
http://tests.stockfishchess.org/tests/view/5b015a1c0ebc5914abc126e5

Closes https://github.com/official-stockfish/Stockfish/pull/1603

No functional change.
 2018-05-21 09:37:44 +02:00
mstembera e8005ebe56 Fix MSVC errors in tbprobe.cpp 
Default template parameters values and recursive functions do not play well
together. Fix for below errors that showed up after updating to latest MSVC.

````
tbprobe.cpp(1156): error C2672:
    'search': no matching overloaded function found

tbprobe.cpp(1198): error C2783:
  'Tablebases::WDLScore `anonymous-namespace'::search(Position &,Tablebases::ProbeState *)':
could not deduce template argument for 'CheckZeroingMoves'

````

Closes https://github.com/official-stockfish/Stockfish/pull/1594

No functional change.
 2018-05-16 23:40:23 +02:00
Tom Truscott 91a76331ca Use cycle detection to bound search value 
A position which has a move which draws by repetition, or which could have
been reached from an earlier position in the game tree, is considered to be
at least a draw for the side to move.

Cycle detection algorithm by Marcel van Kervink:

       https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf

----------------------------

How does the algorithm work in practice? The algorithm is an efficient
method to detect if the side to move has a drawing move, without doing any
move generation, thus possibly giving a cheap cutoffThe most interesting
conditions are both on line 1195:

```
  if (   originalKey == (progressKey ^ stp->key)
      || progressKey == Zobrist::side)
```

This uses the position keys as a sort-of Bloom filter, to avoid the expensive
checks which follow. For "upcoming repetition" consider the opening Nf3 Nf6 Ng1.
The XOR of this position's key with the starting position gives their difference,
which can be used to look up black's repeating move (Ng8). But that look-up is
expensive, so line 1195 checks that the white pieces are on their original squares.

This is the subtlest part of the algorithm, but the basic idea in the above game
is there are 4 positions (starting position and the one after each move). An XOR
of the first pair (startpos and after Nf3) gives a key matching Nf3. An XOR of
the second pair (after Nf6 and after Ng1) gives a key matching the move Ng1. But
since the difference in each pair is the location of the white knight those keys
are "identical" (not quite because while there are 4 keys the the side to move
changed 3 times, so the keys differ by Zobrist::side). The loop containing line
1195 does this pair-wise XOR-ing.

Continuing the example, after line 1195 determines that the white pieces are
back where they started we still need to make sure the changes in the black
pieces represents a legal move. This is done by looking up the "moveKey" to
see if it corresponds to possible move, and that there are no pieces blocking
its way. There is the additional complication that, to match the behavior of
is_draw(), if the repetition is not inside the search tree then there must be
an additional repetition in the game history. Since a position can have more
than one upcoming repetition a simple count does not suffice. So there is a
search loop ending on line 1215.

On the other hand, the "no-progress' is the same thing but offset by 1 ply.
I like the concept but think it currently has minimal or negative benefit,
and I'd be happy to remove it if that would get the patch accepted. This
will not, however, save many lines of code.

-----------------------------

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 36430 W: 7446 L: 7150 D: 21834
http://tests.stockfishchess.org/tests/view/5afc123f0ebc591fdf408dfc

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 12998 W: 2045 L: 1876 D: 9077
http://tests.stockfishchess.org/tests/view/5afc2c630ebc591fdf408e0c

How could we continue after the patch:

• The code in search() that checks for cycles has numerous possible variants.
  Perhaps the check need could be done in qsearch() too.

• The biggest improvement would be to get "no progress" to be of actual benefit,
  and it would be helpful understand why it (probably) isn't. Perhaps there is an
  interaction with the transposition table or the (fantastically complex) tree
  search. Perhaps this would be hard to fix, but there may be a simple oversight.

Closes https://github.com/official-stockfish/Stockfish/pull/1575

Bench: 4550412
 2018-05-16 22:51:43 +02:00
VoyagerOne aacee91a5a Update search.cpp 
At PvNodes allow bonus for prior counter move that caused a fail low
for depth 1 and 2. Note : I did a speculative LTC on yellow STC patch
since history stats tend to be highly TC sensitive

STC (Yellow):
LLR: -2.96 (-2.94,2.94) [0.00,5.00]
Total: 64295 W: 13042 L: 12873 D: 38380
http://tests.stockfishchess.org/tests/view/5af507c80ebc5968e6524153

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 22407 W: 3413 L: 3211 D: 15783
http://tests.stockfishchess.org/tests/view/5af85dd40ebc591fdf408b87

Also use local variable excludedMove in NMP (marotear)

Bench:  5294316
 2018-05-14 06:52:48 +02:00
Stéphane Nicolet bf01bd0755 Tweak kingAttackersCount and KingAttackWeights 
Use the whole kingRing for pawn attackers instead of only the squares directly
around the king. This tends to give quite a lot more kingAttackersCount, so to
compensate and to avoid raising the  king danger too fast we lower the values
in the KingAttackWeights array a little bit.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 51892 W: 10723 L: 10369 D: 30800
http://tests.stockfishchess.org/tests/view/5af6d4dd0ebc5968e652428e

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 24536 W: 3737 L: 3515 D: 17284
http://tests.stockfishchess.org/tests/view/5af709890ebc5968e65242ac

Credits to user @xoroshiro for the idea of using the kingRing for pawn attackers.

How to continue? It seems that the KingAttackWeights[] array stores values
which are quite Elo-sensitive, yet they have not been tuned with SPSA recently.
There might be easy Elo points to get there.

Closes https://github.com/official-stockfish/Stockfish/pull/1597

Bench: 5282815
 2018-05-13 07:20:39 +02:00
mstembera c163c2fcb0 Include all blockers in king danger 
Simplification: in king danger, include all blockers and not only pinned
pieces, since blockers enemy pieces can result in discovered checks which
are also bad.

STC  http://tests.stockfishchess.org/tests/view/5af35f9f0ebc5968e6523fe9
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 145781 W: 29368 L: 29478 D: 86935

LTC http://tests.stockfishchess.org/tests/view/5af3cb430ebc5968e652401f
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 76398 W: 11272 L: 11232 D: 53894

I also incorrectly scheduled STC with [0,5] which it failed.
http://tests.stockfishchess.org/tests/view/5af283c00ebc5968e6523f33
LLR: -2.94 (-2.94,2.94) [0.00,5.00]
Total: 12338 W: 2451 L: 2522 D: 7365

Closes https://github.com/official-stockfish/Stockfish/pull/1593

bench: 4698290

----------------------------------------

Thanks to @vondele and @Rocky640 for a cleaner version of the patch,
and the following comments!

> Most of the pinned, (or for this pull request, blocking) squares were
> already computed in the unsafeChecks, the only missing squares being:
>
> a) squares attacked by a Queen which are occupied by friendly piece
>    or "unsafe". Note that adding such squares never passed SPRT[0,5].
>
> b) squares not in mobilityArea[Us].
>
> There is a strong relationship between the blockers and the unsafeChecks,
> but the bitboard unsafeChecks is still useful when the checker is not
> aligned with the king, and the checking square is occupied by friendly
> piece or is "unsafe". This is always the case for the Knight.
 2018-05-10 23:36:16 +02:00
protonspring 255df4ffae Consolidate pawn storm types 
Simplification: the Unopposed and Unblocked pawn storm types are mathematically
similar enough to combine with no Elo loss. This reduces the pawn storm types
to BlockedByPawn and UnBlocked.

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 116869 W: 23549 L: 23605 D: 69715
http://tests.stockfishchess.org/tests/view/5af2def90ebc5968e6523f82

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 39912 W: 6090 L: 5998 D: 27824
http://tests.stockfishchess.org/tests/view/5af3b2e20ebc5968e6524013

Closes https://github.com/official-stockfish/Stockfish/pull/1592

Bench: 5244314
 2018-05-10 15:46:32 +02:00
Stefan Geschwentner 76d4a80084 Tune null move pruning 
Use a lower stat score threshold of 22500.

Failed yellow at STC after many games (~0.92 Elo):
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 73978 W: 14947 L: 14834 D: 44197
http://tests.stockfishchess.org/tests/view/5af2deec0ebc5968e6523f80

But scales good and passed LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 23147 W: 3453 L: 3237 D: 16457
http://tests.stockfishchess.org/tests/view/5af3cf820ebc5968e6524022

Closes https://github.com/official-stockfish/Stockfish/pull/1591

Bench: 4777674
 2018-05-10 12:28:18 +02:00
candirufish fc0a1f37cf Tuned some pawns and evaluation constants 
Tuned values in pawns.cpp and evaluate.cpp after a SPSA session:
419k games 60sec 600nodetime.  We have adjusted the PassedRank[]
output of the SPSA session to keep increasing values with rank,
and PassedFile[] output to keep the West <–> East symmetry of
the evaluation.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 58948 W: 12431 L: 12046 D: 34471
http://tests.stockfishchess.org/tests/view/5af2302f0ebc5968e6523f0a

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 22211 W: 3468 L: 3251 D: 15492
http://tests.stockfishchess.org/tests/view/5af264c80ebc5968e6523f1a

See https://github.com/official-stockfish/Stockfish/pull/1587
and https://github.com/official-stockfish/Stockfish/pull/1590

bench: 4437531
 2018-05-09 09:22:11 +02:00
Joost VandeVondele 4d647428d8 Remove goto, limit skipping to NMP 
This patch simplifies the control flow in search(), removing an if
and a goto. A side effect of the patch is that Stockfish is now a
little bit more selective at low depths, because we allow razoring,
futility pruning and probcut pruning after a null move.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 32035 W: 6523 L: 6422 D: 19090
http://tests.stockfishchess.org/tests/view/5af142ca0ebc597fb3d39bb6

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 41431 W: 6187 L: 6097 D: 29147
http://tests.stockfishchess.org/tests/view/5af148770ebc597fb3d39bc1

Ideas for further work:

• Use the nodes credit opened by the patch (the increased selectivity)
  to try somewhat higher razoring, futility or probcut margins at [0..4].

Bench: 4855031
 2018-05-09 01:42:34 +02:00
Stefan Geschwentner de0889612f Tweak null move pruning conditions 
Allow null move pruning only if last stat score < 30000.

Passed STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 12653 W: 2641 L: 2454 D: 7558
http://tests.stockfishchess.org/tests/view/5af1d8830ebc5968e6523edb

Passed LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 19782 W: 3072 L: 2878 D: 13832
http://tests.stockfishchess.org/tests/view/5af1ee8c0ebc5968e6523ee4

Ideas for further work:

• Tune the stat score threshold.
• Try depth based stat score threshold.
• Try stat score condition for other prunings.

Closes https://github.com/official-stockfish/Stockfish/pull/1589

Bench: 5088156
 2018-05-08 23:31:55 +02:00
Alain SAVARD 6634f41ac9 Drop the lever condition for backwards 
We can view the patch version as adding some "undermining bonus" for
level pawns, when the defending side can not easily avoid the exchange
by advancing her pawn.

• Case 1) White b2,c3, Black a3,b3:
          Black is breaking through, b2 deserves a penalty

• Case 2) White b2,c3, Black a3,c4:
          if b2xa3 then White ends up with a weak pawn on a3
          and probably a weak pawn on c3 too.

In either case, White can still not safely play b2-b3 and make a
phalanx with c3, which is the essence of a backward pawn definition.

Passed STC in SPRT[0, 4]:
LLR: -2.96 (-2.94,2.94) [0.00,4.00]
Total: 131169 W: 26523 L: 26199 D: 78447
http://tests.stockfishchess.org/tests/view/5aefa4d50ebc5902a409a151
ELO 1.19 [-0.38,2.88] (95%)

Passed LTC in SPRT[-3, 1]:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 24824 W: 3732 L: 3617 D: 17475
http://tests.stockfishchess.org/tests/view/5af04d3f0ebc5902a88b2e55
ELO 1.27 [-1.21,3.70] (95%)

Closes https://github.com/official-stockfish/Stockfish/pull/1584

How to continue from there?

There were some promising tests a couple of months ago about adding
a lever condition for king danger in evaluate.cpp, maybe it would
be time to re-try this after all the recent changes in pawns.cpp

Bench: 4773882
 2018-05-08 11:14:43 +02:00
Joost VandeVondele 8d1625d6df Remove skipEarlyPruning argument to search() 
Remove nine boolean arguments and the corresponding skipEarlyPruning variable.
Instead, skip early pruning only when there is an excluded move, and try null
move pruning only if the previous move was not itself a null move.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 33623 W: 6853 L: 6755 D: 20015
http://tests.stockfishchess.org/tests/view/5aef462a0ebc5902a409a10e

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 39474 W: 5882 L: 5789 D: 27803
http://tests.stockfishchess.org/tests/view/5aefd4b80ebc5902a409a164

Closes https://github.com/official-stockfish/Stockfish/pull/1585

Bench: 4953556
 2018-05-08 10:43:56 +02:00
Joost VandeVondele 155d5417d9 Improve signature script 
Catch case of missing bench, indicative of a crash or assert.

No functional change
 2018-05-08 10:32:23 +02:00
protonspring cb4bda0f49 Simplify the backward pawns code 
The two lines of code in the patch seem to be just as good as master.

1. We now only look at the current square to see if it is currently backward,
whereas master looks there AND further ahead in the current file (master would
declare a pawn "backward" even though it could still safely advance a little).
This simplification allows us to avoid the use of the difficult logic with
`backmost_sq(Us, neighbours | stoppers)`.

2. The condition `relative_rank(Us,s) < RANK_5` is simplified away.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 68132 W: 14025 L: 13992 D: 40115
http://tests.stockfishchess.org/tests/view/5aedc97a0ebc5902a4099fd6

Passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 23789 W: 3643 L: 3527 D: 16619
http://tests.stockfishchess.org/tests/view/5aee4f970ebc5902a409a03a

Ideas for further work:

• The new code flags some pawns on the 5th rank as backward, which was not the
case in the old master. So maybe we should test a version with that included?

• Further tweaks of the backward condition with [0..5] bounds?

Closes https://github.com/official-stockfish/Stockfish/pull/1583

Bench: 5122789
 2018-05-06 09:44:14 +02:00
Stéphane Nicolet d4cb80b210 Tweak the connected[] array value for pawns on rank 5 
A recent tuning session by Jerry Donald Watson suggested that the
value for the pawns on the fifth rank in the connected[] array were
a little bit too high in master. We lower here this value from 75 to 65.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 27399 W: 5646 L: 5384 D: 16369
http://tests.stockfishchess.org/tests/view/5aea17c50ebc5902a1bed396

LTC:
LLR: 3.66 (-2.94,2.94) [0.00,4.00]
Total: 95590 W: 14529 L: 14062 D: 66999
http://tests.stockfishchess.org/tests/view/5aea34a40ebc5902a104ebe5

Closes https://github.com/official-stockfish/Stockfish/pull/1580

Bench: 5186783
 2018-05-03 22:00:07 +02:00
Stéphane Nicolet 06e0134cbc Correct a bug introduced by Stéphane in the previous patch. 
When we are using the "Bitboard + Square" overloaded operators,
the compiler uses the interpediate SquareBB[s] to transform the
square into a Bitboard, and then calculate the result.

For instance, the following code:

```
   b = pos.pieces(Us, PAWN) & s
```

generates in fact the code:

```
   b = pos.pieces(Us, PAWN) & SquareBB[s]`
```

The bug introduced by Stéphane in the previous patch was the
use of `b = pos.pieces(Us, PAWN) & (s + Up)` which can result
in out-of-bounds errors for the SquareBB[] array if s in the
last rank of the board.

We coorect the bug, and also add some asserts in bitboard.h to
make the code more robust for this particular bug in the future.

Bug report by Joost VandeVondele. Thanks!

Bench: 5512000
 2018-05-02 13:38:00 +02:00
protonspring 12ef8f71a2 Use special rule for BlockedByKing 
Simplification: remove BlockedByKing from storm array and use a special rule.

The BlockedByKing section in the storm array is substantially similar to the
Unopposed section except for two extreme values V(-290), V(-274). Turns out
removing BlockedByKing and using a special rule for these two values shows
no Elo loss. All the other values in the BlockedByKing section are apparently
irrelevant. BlockedByKing now falls under unopposed which (to me) is a bit
more logical since there is no defending pawn on this file. Also, retuning
the Unopposed section may be another improvement.

GOOD) This is a simplification because the entire BlockedByKing section of
the storm array goes away reducing a few lines of code (and less values to
tune). This also brings clarity because the special rule is self documenting.

BAD) It takes execution time to apply the special rule. This should be negli-
gible because it is based on a template parameter and is boiled down to two
bitwise AND's.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 33470 W: 6820 L: 6721 D: 19929
http://tests.stockfishchess.org/tests/view/5ae7b6e60ebc5926dba90e13

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 47627 W: 7045 L: 6963 D: 33619
http://tests.stockfishchess.org/tests/view/5ae859ff0ebc5926dba90e85

Closes https://github.com/official-stockfish/Stockfish/pull/1574

Bench: 5512000

-----------

How to continue after this patch?

This patch may open the possibility to move the special rule to evaluate.cpp
in the evaluate::king() function, where we could refine the rule using king
danger information. For instance, with a king in H2 blocking an opponent pawn
in H3, it may be critical to know that the opponent has no safe check in G2
before giving the bonus :-)
 2018-05-01 23:55:30 +02:00
MJZ1977 5a7cdadfb3 Penalty for bad bishop with blocked central files 
We increase the penalty for bad bishops by a factor proportional
to the number of our blocked pawns in the center files C, D, E or F.

STC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 8868 W: 1870 L: 1700 D: 5298
http://tests.stockfishchess.org/html/live_elo.html?5ae7674f0ebc590e39268b34

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 5813 W: 950 L: 808 D: 4055
http://tests.stockfishchess.org/html/live_elo.html?5ae77bae0ebc5926dba90dd9

Closes https://github.com/official-stockfish/Stockfish/pull/1573

Bench: 5364190
 2018-05-01 07:12:27 +02:00
Stefano80 213166ba22 Always scale using pawn contribution 
This is a further step in the long quest for a simple way of determining
scale factors for the endgame.

Here we remove the artificial restriction in evaluate_scale_factor()
based on endgame score. Also SCALE_FACTOR_ONEPAWN can be simplified
away. The latter is a small non functional simplification with respect
to the version that was testedin the framework, verified on bench with
depth 22 for good measure.

Passed STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 49438 W: 9999 L: 9930 D: 29509
http://tests.stockfishchess.org/tests/view/5ae20c8b0ebc5963175205c8

Passed LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 101445 W: 15113 L: 15110 D: 71222
http://tests.stockfishchess.org/tests/view/5ae2a0560ebc5902a1998986

How to continue from there?

Maybe the general case could be scaled with pawns from both colors
without losing Elo. If that is the case, then this could be merged
somehow with the scaling in evaluate_initiative(), which also uses
a additive malus down when the number of pawns in the position goes
down.

Closes https://github.com/official-stockfish/Stockfish/pull/1570

Bench: 5254862
 2018-04-29 07:26:25 +02:00
Joost VandeVondele d6252ef202 Simplifiy IID condition 
do IID for all sufficiently deep searches without TT move.

passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 25494 W: 5313 L: 5199 D: 14982
http://tests.stockfishchess.org/tests/view/5ae1e8dd0ebc596317520583

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 80582 W: 12162 L: 12130 D: 56290
http://tests.stockfishchess.org/tests/view/5ae1f5ab0ebc5963175205a4

Bench: 4966970
 2018-04-29 06:59:17 +02:00
Joost VandeVondele 3df8cabb84 Fix 'make strip' for mingw. 
Currently the make strip target is broken on mingw as the exe name is wrong (stockfish instead of stockfish.exe).

Needs some testing by mingw users (both profile-build and strip, native and cross).

No functional change.
 2018-04-29 06:53:51 +02:00
Stéphane Nicolet 11967e89cd Update various comments 
Spotted by Alain Savard, Joost VandeVondele, Ronald de Man, Fabian Fichter, Chris Cain, xoto10

No functional change
 2018-04-29 06:48:18 +02:00
Alain SAVARD 45072612d4 No Queen in the MobilityArea 
Queen was recently excluded from the mobility area of friendly minor
pieces. Exclude queen also from the mobility area of friendly majors too.

Run as a simplification:

STC
http://tests.stockfishchess.org/tests/view/5ade396f0ebc59602d053742
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 46972 W: 9511 L: 9437 D: 28024

LTC
http://tests.stockfishchess.org/tests/view/5ade64b50ebc5949f20a24d3
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 66855 W: 10157 L: 10105 D: 46593

How to continue from there?

The mobilityArea is used in various places of the evaluation as a
soft proxy for "not attacked by the opponent pawns". Now that the
mobility area is getting smaller and smaller, it may be worth to
hunt for Elo gains by trying the more direct ~attackedBy[Them][PAWN]
instead of mobilityArea[Us] in these places.

Bench: 4650572
 2018-04-24 14:41:50 +02:00
Stéphane Nicolet c794c8c801 Simplify the ShelterStrength[] array 
Remove the distinction between the king file and the two neighbours
files in the ShelterStrength[] array. Instead we initialize the safety
variable in the evaluate_shelter() function with a -10 penalty if our
king is on a semi-open file (ie. if our king is on a file without a pawn
protection).

Also rename shelter_storm() to evaluate_shelter() while there.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 23153 W: 4795 L: 4677 D: 13681
http://tests.stockfishchess.org/tests/view/5adcb83d0ebc595ec7ff8aa7

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 25728 W: 3934 L: 3821 D: 17973
http://tests.stockfishchess.org/tests/view/5adcdcb60ebc595ec7ff8adb

See the commit history in PR#1559 for the proof that the committed
version is equivalent to the version in the tests above:
https://github.com/official-stockfish/Stockfish/pull/1559

Full credit to @protonspring for the renormalized values of the
ShelterStrength[] array used for the simplification. Thanks!

Bench: 4703935
 2018-04-23 09:49:05 +02:00
ceebo aef7076c34 Alternative formula for dynamic contempt 
Replace the formula involving arctan with something having similar
behaviour that can be implemented using integer-only operations.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 34781 W: 7189 L: 7093 D: 20499
http://tests.stockfishchess.org/tests/view/5ad7c95f0ebc595700526e76

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 39743 W: 5950 L: 5857 D: 27936
http://tests.stockfishchess.org/tests/view/5ad886ee0ebc595700526e9b

Closes https://github.com/official-stockfish/Stockfish/pull/1558

Bench: 5549801
 2018-04-23 09:13:27 +02:00
Joost VandeVondele a64d524d02 Remove template W param 
Different W template parameters for the different statEntries are
not needed, simplify by consistently using 32.

Passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21683 W: 4545 L: 4424 D: 12714
http://tests.stockfishchess.org/tests/view/5ad797550ebc595700526e59

Passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 110391 W: 16551 L: 16562 D: 77278
http://tests.stockfishchess.org/tests/view/5ad7a88f0ebc595700526e61

Closes https://github.com/official-stockfish/Stockfish/pull/1557

Bench: 5120532
 2018-04-23 08:46:32 +02:00
Stéphane Nicolet 82f7d507ea Allow UCI parameters to be double 
Change the operators of the Option type in uci.h to accept floating
point numbers in double precision on input as the numerical type for
the "spin" values of the UCI protocol.

The output of Stockfish after the "uci" command is unaffected.

This change is compatible with all the existing GUI (as they will
continue sending integers that we can interpret as doubles in SF),
and allows us to pass double parameters to Stockfish in the console
via the "setoption" command. This will be useful if we implement
another tuner as an alternative for SPSA.

Closes https://github.com/official-stockfish/Stockfish/pull/1556

No functional change.

---------------------

A example of the new functionality in action in the branch `tune_float2'`:
https://github.com/snicolet/Stockfish/commit/876c322d0f20ee232da977b4d3489c4cc929765e

I have added the following lines in ucioptions.cpp:

```C++

void on_pi(const Option& o)
{
      double x = Options["PI"];  // or double x = o;
      std::cerr << "received value is x = " << x << std::endl;
}

...

o["PI"]   << Option(3.1415926, -10000000, 10000000, on_pi);
```

Then I can change the value of Pi in Stockfish via the command line, and
check that Stockfish understands a floating point:

````
> ./stockfish
> setoption name PI value 2.7182818284

received value is x = 2.71828
````

On output, the default value of Pi is truncated to 3 (to remain compatible
with the UCI protocol and GUIs):

````
> uci

[...]
option name SyzygyProbeLimit type spin default 6 min 0 max 6
option name PI type spin default 3 min -10000000 max 10000000
uciok
````
 2018-04-23 08:08:27 +02:00
protonspring f7cc0026e3 Simplify BlockedByKing in pawn storms 
This patch is non-functional. Current master does four operations to determine
whether an enemy pawn on this file is blocked by the king or not

```
f == file_of(ksq) && rkThem == relative_rank(Us, ksq) + 1 )
```

By adding a direction (based on the template color), this is reduced to two
operations. This works because b is limited to enemy pawns that are ahead of
the king and on the current file.

```
shift<Down>(b) & ksq
```

I've added a line of code, but the number of executing instructions is reduced
(I think). I'm not sure if this counts as a simplification, but it should
theoretically be a little faster (barely). The code line length is also reduced
making it a little easier to read.

Closes https://github.com/official-stockfish/Stockfish/pull/1552

No functional change.
 2018-04-18 20:03:52 +02:00
Stéphane Nicolet 73e8daa150 Simplify the shelter mask 
The line 246 of pawns.cpp is not necessary, because we restrict the bitboards
to file_of(f) in lines 253 and 256 anyway.

No functional change.
 2018-04-18 19:53:39 +02:00
Alain SAVARD 66af80972a Tidy up on Overload 
Move new code in the if (defended | weak) {} section.

No functional change
 2018-04-18 19:44:41 +02:00
Joost VandeVondele 0143c6f0c2 Document Elo impact of the LMR part of search 
Similar to before, document Elo impact of various LMR steps

Tests run by @jerrydonaldwatson

t1 http://tests.stockfishchess.org/tests/view/5abece950ebc591a560aad0b
t2 http://tests.stockfishchess.org/tests/view/5abecf0c0ebc591a560aad0d
t3 http://tests.stockfishchess.org/tests/view/5abecf7b0ebc591a560aad0f
t4 http://tests.stockfishchess.org/tests/view/5abecfe70ebc591a560aad14
t5 http://tests.stockfishchess.org/tests/view/5abed42b0ebc591a560aad33
t6 http://tests.stockfishchess.org/tests/view/5abed0b90ebc591a560aad19
t7 http://tests.stockfishchess.org/tests/view/5abed1240ebc591a560aad1b
t8 http://tests.stockfishchess.org/tests/view/5abed1b90ebc591a560aad1d

No functional change.
 2018-04-18 19:17:37 +02:00
syzygy1 108f0da4d7 Tablebases root ranking 
This patch corrects both MultiPV behaviour and "go searchmoves" behaviour
for tablebases.

We change the logic of table base probing at root positions from filtering
to ranking. The ranking code is much more straightforward than the current
filtering code (this is a simplification), and also more versatile.

If the root is a TB position, each root move is probed and assigned a TB score
and a TB rank. The TB score is the Value to be displayed to the user for that
move (unless the search finds a mate score), while the TB rank determines which
moves should appear higher in a multi-pv search. In game play, the engine will
always pick a move with the highest rank.

Ranks run from -1000 to +1000:

901 to 1000   : TB win
900           : normally a TB win, in rare cases this could be a draw
1 to 899      : cursed TB wins
0             : draw
-1 to -899    : blessed TB losses
-900          : normally a TB loss, in rare cases this could be a draw
-901 to -1000 : TB loss

Normally all winning moves get rank 1000 (to let the search pick the best
among them). The exception is if there has been a first repetition. In that
case, moves are ranked strictly by DTZ so that the engine will play a move
that lowers DTZ (and therefore cannot repeat the position a second time).

Losing moves get rank -1000 unless they have relatively high DTZ, meaning
they have some drawing chances. Those get ranks towards -901 (when they
cross -900 the draw is certain).

Closes https://github.com/official-stockfish/Stockfish/pull/1467

No functional change (without tablebases).
 2018-04-18 18:46:24 +02:00
syzygy1 e9aeaad052 Analysis Contempt combo box 
This patch introduces an Analysis Contempt UCI combo box to control
the behaviour of contempt during analysis. The possible values are
Both, Off, White, Black. Technically, the engine is supposed to be in
analysis mode if UCI_AnalyseMode is set by the graphical user interface
or if the user has chosen infinite analysis mode ("go infinite").

Credits: the idea for the combo box is due to Michel Van den Bergh.

No functional change (outside analysis mode).

-----------------------------------------------------

The so-called "contempt" is an optimism value that the engine adds
to one color to avoid simplifications and keep tension in the position
during its search. It was introduced in Stockfish 9 and seemed to give
good results during the TCEC 11 tournament (Stockfish seemed to play a
little bit more actively than in previous seasons).

The patch does not change the play during match or blitz play, but gives
more options for correspondance players to decide for which color(s) they
would like to use contempt in analysis mode (infinite time). Here is a
description of the various options:

* Both  : in analysis mode, use the contempt for both players (alternating)
* Off   : in analysis mode, use the contempt for none of the players
* White : in analysis mode, White will play actively, Black will play passively
* Black : in analysis mode, Black will play actively, White will play passively
 2018-04-18 17:49:19 +02:00
syzygy1 ae0bb6dc2b Fix reported DTZ for mate-in-1-ply positions 
This corrects a bug in Tablebases::probe_dtz() which sometimes causes
a higher DTZ value to be returned for the position one ply before mate
than for the position two plies before mate.

The problem was reported by Kolja Kühn here:
http://talkchess.com/forum/viewtopic.php?p=757497#757497

It is explained here:
http://talkchess.com/forum/viewtopic.php?p=757506#757506

I have also adjusted some comments to make clear that probe_dtz()
returns -1 for a mate position.

Closes https://github.com/official-stockfish/Stockfish/pull/1546

No functional change
 2018-04-14 08:36:41 +02:00
Marco Costalba 6413d9b1f9 Further documentation and coding style on TB code 
This patch adds some documentation and code cleanup to tablebase code.

It took me some time to understand the relation among the differrent
structs, although I have rewrote them fully in the past. So I wrote
some detailed documentation to avoid the same efforts for future readers.

Also noteworthy is the use a standard hash table implementation with a
more efficient 1D array instead of a 2D array. This reduces the average
lookup steps of 90% (from 343 to 38 in a bench 128 1 16 run) and reduces
also the table from 5K to 4K
entries.

I have tested on 5-men and no functional and no slowdown reported. It
should be verified on 6-men that the new hash does not overflow. It is
enough to run ./stockfish with 6-men available: if it does not assert at
startup it means everything is ok with 6-men too.

EDIT: verified for 6-men tablebase by Jörg Oster. Thanks!

No functional change.
 2018-04-12 09:37:18 +02:00
Jerry Donald Watson 62619fa228 Simplify condition in space definition 
We remove an unnecessary condition in the definition of safe squares
in the space evaluation. Only the squares which are occupied by our
pawns or attacked by our opponent's pawns are now excluded.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21096 W: 4321 L: 4199 D: 12576
http://tests.stockfishchess.org/tests/view/5acbf7510ebc59547e537d4e

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 23437 W: 3577 L: 3460 D: 16400
http://tests.stockfishchess.org/tests/view/5acc0f750ebc59547e537d6a

It may be possible to further refine the definition of such safe squares.

Bench: 5351765
 2018-04-10 17:47:55 +02:00
VoyagerOne b88374b14a Reset negative statScore on fail high 
STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 9073 W: 1937 L: 1766 D: 5370

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 53530 W: 8139 L: 7823 D: 37568

Bench: 5170165
 2018-04-07 20:26:49 +02:00
Mark Tenzer 759d129e47 Introduce Overload 
This patch applies a S(10, 5) bonus for every square that is:

- Occupied by an enemy piece which is not a pawn
- Attacked exactly once by our pieces
- Defended exactly once by enemy pieces

The idea is that these pieces must be defended. Their defenders have
dramatically limited mobility, and they are vulnerable to our future
attack.

As with connectivity, there are probably many more tests to be run in
this area. In particular:

- I believe @snicolet's queen overload tests have demonstrated a potential
  need for a queen overload bonus above and beyond this one; however, the
  conditions for "overload" in this patch are different (excluding pieces
  we attack twice).  My next test after this is (hopefully) merged will be
  to intersect the Bitboard I define here with the enemy's queen attacks and
  attempt to give additional bonus.
- Perhaps we should exclude pieces attacked by pawns--can pawns really be
  overloaded? Should they have the same weight, or less?  This didn't work
  with a previous version, but it could work with this one.
- More generally, different pieces may need more or less bonus. We could
  change bonuses based on what type of enemy piece is being overloaded, what
  type of friendly piece is attacking, and/or what type of piece is being
  defended by the overloaded piece and attacked by us, or any intersection
  of these three.  For example, here attacked/defended pawns are excluded,
  but they're not totally worthless targets, and could be added again with
  a smaller bonus.
- This list is by no means exhaustive.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 17439 W: 3599 L: 3390 D: 10450
http://tests.stockfishchess.org/tests/view/5ac78a2e0ebc59435923735e

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 43304 W: 6533 L: 6256 D: 30515
http://tests.stockfishchess.org/tests/view/5ac7a1d80ebc59435923736f

Closes https://github.com/official-stockfish/Stockfish/pull/1533

Bench: 5248871

----------------

This is my first time opening a PR, so I apologize if there are errors.
There are too many people to thank since I submitted my first test just
over a month ago. Thank you all for the warm welcome and here is to more
green patches!

In particular, I would like to thank:
- @crossbr, whose comment in a FishCooking thread first inspired me to
            consider the overloading of pieces other than queens,
- @snicolet, whose queen overload tests inspired this one and served as
             the base of my first overload attempts,
- @protonspring, whose connectivity tests inspired this one and who provided
                 much of the feedback needed to take this from red to green,
- @vondele, who kindly corrected me when I submitted a bad LTC test,
- @Rocky640, who has helped me over and over again in the past month.

Thank you all!
 2018-04-07 01:31:23 +02:00
Alain SAVARD 04a228f9c8 Remove the Queen from the mobility area of minor pieces 
In master, we already remove the King from the mobility area of minor pieces
because the King simply stands in the way of other pieces, and since opponent
cannot capture the King, any piece which "protects" the King cannot recapture.

Similarly, this patch introduces the idea that it is rarely a need for a Queen
to be "protected" by a minor (unless it is attacked only by a Queen, in fact).
We used to have a LoosePiece bonus, and in a similar vein the Queen was excluded
from that penalty.

Idea came when reviewing an old game of Kholmov. He was a very good midgame
player, but in the opening his misplace his Queen (and won in the end :-) :
     http://www.chessgames.com/perl/chessgame?gid=1134645

Both white queen moves 10.Qd3 and 13.Qb3 are in the way of some minor piece.
I would prefer to not give a bishop mobility bonus at move 10 for the square d3,
or later a knight mobility bonus at move 13 for the square b3. And the textbook
move is 19.Qe3! which prepares 20.Nb3. This short game sample shows how much a
queen can be "in the way" of minor pieces.

STC
http://tests.stockfishchess.org/tests/view/5ac2c15f0ebc591746423fa3
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 22066 W: 4561 L: 4330 D: 13175

LTC
http://tests.stockfishchess.org/tests/view/5ac2d6500ebc591746423faf
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 25871 W: 3953 L: 3738 D: 18180

Closes https://github.com/official-stockfish/Stockfish/pull/1532

Ideas for future work in this area:

• tweak some more mobility areas for other piece type.
• construct a notion of global mobility for the whole piece set.
• bad bishops.

Bench: 4989125
 2018-04-04 00:07:40 +02:00
Torsten Franz 06a8fd2154 Simplify ThreatBySafePawn evaluation 
Simplify ThreatBySafePawn evaluation by removing the 'if (weak)' speed
optimization check from threats evaluation. This is a non functional
change as it removes just a speed optimization conditional which was
probably useful before but does no longer provide benefits. This section
section had a few more lines not long ago, with ThreatByHangingPawn and
a loop through the threatened pieces, but now there is not much left.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 47775 W: 9696 L: 9624 D: 28455
http://tests.stockfishchess.org/tests/view/5ac298910ebc591746423f8b

Closes https://github.com/official-stockfish/Stockfish/pull/1531

Non functional change.
 2018-04-03 23:34:10 +02:00
Joost VandeVondele 0cfb653eec Simplify Singular Extension condition 
Avoid defining a singly used variable, removes one condition.

passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 53489 W: 10814 L: 10752 D: 31923
http://tests.stockfishchess.org/tests/view/5ac08a8d0ebc590e9457cd94

Closes https://github.com/official-stockfish/Stockfish/pull/1530

No functional change.
 2018-04-03 00:13:38 +02:00
Joost VandeVondele e408fd7b10 Document Elo impact of various parts of search 
In order to understand better the impact of various techniques used in search,
Elo estimates have been run at STC for 60000 games (statistical error ~1.8 Elo),
disabling each feature in turn. This should help future improvements and
simplifications to pick suitable targets.

The list of tests is:
step  7 : http://tests.stockfishchess.org/tests/view/5abcbb4b0ebc5902926cf1ca
step  8 : http://tests.stockfishchess.org/tests/view/5abcbb680ebc5902926cf1cc
step  9 : http://tests.stockfishchess.org/tests/view/5abcbb850ebc5902926cf1ce
step 10 : http://tests.stockfishchess.org/tests/view/5abcbbeb0ebc5902926cf1d2
step 11 : http://tests.stockfishchess.org/tests/view/5abcbbbf0ebc5902926cf1d0
step 13 : http://tests.stockfishchess.org/tests/view/5abd03680ebc5902926cf20b
step 13a: http://tests.stockfishchess.org/tests/view/5abd29660ebc5902926cf22a
step 13b: http://tests.stockfishchess.org/tests/view/5abd29820ebc5902926cf22c
step 14 : http://tests.stockfishchess.org/tests/view/5abd03860ebc5902926cf20f
step 14a: http://tests.stockfishchess.org/tests/view/5abd2b6c0ebc5902926cf230
step 14b: http://tests.stockfishchess.org/tests/view/5abd2b8d0ebc5902926cf232
step 14c: http://tests.stockfishchess.org/tests/view/5abd2bad0ebc5902926cf234
step 14d: http://tests.stockfishchess.org/tests/view/5abd2bcf0ebc5902926cf236
step 14e: http://tests.stockfishchess.org/tests/view/5abd2bf10ebc5902926cf238

This patch documents this in the code.

Note that it will be a waste to recompute these estimates often, even a couple
of [0,5] patches are unlikely to change them by more than the error bars. The
interest of the Elo annotations in the code is not in the details, but in high-
lighting trends such as razoring (2 Elo) and singular extensions (60 Elo). These
estimates should be recomputed at most once a year.

Closes https://github.com/official-stockfish/Stockfish/pull/1522

No functional change.
 2018-04-01 03:21:45 +02:00
mstembera 76f9cd4df1 Some small changes 
1) Use make_bitboard() in Bitboards::init()

2) Fix MSVC warning: search.h(85): warning C4244: '=': conversion from
   'TimePoint' to 'int', possible loss of data.

Closes https://github.com/official-stockfish/Stockfish/pull/1524

No functional change.
 2018-04-01 02:32:55 +02:00
Stéphane Nicolet d9cac9a414 Simplify KBPKB endgame with opposite bishops 
When we reach a position with only two opposite colored bishops and
one pawn on the board, current master would give it a scale factor
of 9/64=0.14 in about one position out of 7200, and a scale factor
of 0.0 in the 7199 others. The patch gives a scale factor of 0.0 in
100% of the cases.

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 55845 W: 11467 L: 11410 D: 32968
http://tests.stockfishchess.org/tests/view/5abc585f0ebc5902926cf15e

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 11915 W: 1852 L: 1719 D: 8344
http://tests.stockfishchess.org/tests/view/5abc7f750ebc5902926cf18c

We also have exhaustive coverage analysis of this patch effect by
Alain Savard, comparing the perfect evaluation given by the Syzygy
tablebase with the heuristic play after this patch for the set of
all legal positions of the KBPKP endgame with opposite bishops, in
the comments thread for this pull request:
https://github.com/official-stockfish/Stockfish/pull/1520

Alain's conclusion:
> According to this definition and the data, I consider this PR is
> identical to master to "solve for draw" and slightly better than
> master to solve earlier for "wins".

Note: this patch is a side effect of an ongoing effort to improve
the evaluation of positions involving a pair of opposite bishops.
See the GitHub diff of this LTC test which almost passed at sprt[0..5]
for a discussion:
http://tests.stockfishchess.org/tests/view/5ab9030b0ebc5902932cbf93

No functional change (at small bench depths)
 2018-04-01 02:19:42 +02:00
Joost VandeVondele f2681232e5 Refine SEE threshold for capture pruning. 
eloDoc suggests that this part of search is worth ~18 Elo.
This patch refines the depth dependence of the SEE threshold.

passed STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 21398 W: 4474 L: 4245 D: 12679
http://tests.stockfishchess.org/tests/view/5abfb0630ebc591a560aae07

passed LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 9028 W: 1439 L: 1285 D: 6304
http://tests.stockfishchess.org/tests/view/5abfbff30ebc591a560aae11

Closes https://github.com/official-stockfish/Stockfish/pull/1527

Bench: 6036915
 2018-03-31 23:10:35 +02:00
Alain SAVARD d5e3e7d207 Candidate Passed Pawn 
Include some not fully supported levers in the (candidate) passed pawns
bitboard, if otherwise unblocked. Maybe levers are usually very short
lived, and some inaccuracy in the lever balance for the definition of
candidate passed pawns just triggers a deeper search.

Here is a example of a case where the patch has an effect on the definition
of candidate passers: White c5/e5 pawns, against Black d6 pawn. Let's say
we want to test if e5 is a candidate passer. The previous master looks
only at files d, e and f (which is already very good) and reject e5 as
a candidate. However, the lever d6 is challenged by 2 pawns, so it should
not fully count. Indirectly, this patch will view such case (and a few more)
to be scored as candidates.

STC
http://tests.stockfishchess.org/tests/view/5abcd55d0ebc5902926cf1e1
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 16492 W: 3419 L: 3198 D: 9875

LTC
http://tests.stockfishchess.org/tests/view/5abce1360ebc5902926cf1e6
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 21156 W: 3201 L: 2990 D: 14965

This was inspired by this test of Jerry Donald Watson, except the case of
zero supporting pawns against two levers is excluded, and it seems that
not excluding that case is bad, while excluding is it beneficial. See the
following tests on fishtest:

https://github.com/official-stockfish/Stockfish/pull/1519
http://tests.stockfishchess.org/tests/view/5abccd850ebc5902926cf1dd
http://tests.stockfishchess.org/tests/view/5abcdd490ebc5902926cf1e4

Closes https://github.com/official-stockfish/Stockfish/pull/1521

Bench: 5568461

----

Comments by Jerry Donald Watson:

> My thinking as to why this works:
>
> The evaluation is either called in an interior node or in the qsearch.
> The calls at the end of the qsearch are the more important as they
> ultimately determine the scoring of each move, whereas the internal
> values are mainly used for pruning decisions with a margin. Some strong
> engines don't even call the eval at all nodes. Now the whole point of
> the qsearch is to find quiet positions where captures do not change the
> evaluation of the position with regards to the search bounds - i.e. if
> there were good captures they would be tried.* So when a candidate lever
> appears in the evaluation at the end of the qsearch, the qsearch has
> guaranteed that it cannot just be captured, or if it can, this does not
> take the score past the search bounds. Practically this may mean that
> the side with the candidate lever has the turn, or perhaps the stopping
> lever pawn is pinned, or that side is forced for other reasons to make
> some other move (e.g. d6 can only take one of the pawns in the example
> above).
>
> Hence granting the full score for only one lever defender makes some
> sense, at least, to me.
>
> IMO this is also why huge bonuses for possible captures in the evaluation
> (e.g. threat on queen and our turn), etc. don't tend to work. Such things
> are best left to the search to figure out.
 2018-03-31 01:16:51 +02:00
Ondrej Mosnáček c8ef80f466 Use per-thread dynamic contempt 
We now use per-thread dynamic contempt. This patch has the following
effects:

 * for Threads=1: **non-functional**
 * for Threads>1:
   * with MultiPV=1: **no regression, little to no ELO gain**
   * with MultiPV>1: **clear improvement over master**

First, I tried testing at standard MultiPV=1 play with [0,5] bounds.
This yielded 2 yellow and 1 red test:

5+0.05, Threads=5:
LLR: -2.96 (-2.94,2.94) [0.00,5.00]
Total: 82689 W: 16439 L: 16190 D: 50060
http://tests.stockfishchess.org/tests/view/5aa93a5a0ebc5902952892e6

5+0.05, Threads=8:
LLR: -2.96 (-2.94,2.94) [0.00,5.00]
Total: 27164 W: 4974 L: 4983 D: 17207
http://tests.stockfishchess.org/tests/view/5ab2639b0ebc5902a6fbefd5

5+0.5, Threads=16:
LLR: -2.97 (-2.94,2.94) [0.00,5.00]
Total: 41396 W: 7127 L: 7082 D: 27187
http://tests.stockfishchess.org/tests/view/5ab124220ebc59029516cb62

Then, I tested with Skill Level=17 (implicitly MutliPV=4), showing
a clear improvement:

5+0.05, Threads=5:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 3498 W: 1316 L: 1135 D: 1047
http://tests.stockfishchess.org/tests/view/5ab4b6580ebc5902932aeca2

Next, I tested the patch with MultiPV=1 again, this time checking for
non-regression ([-3, 1]):

5+0.5, Threads=5:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 65575 W: 12786 L: 12745 D: 40044
http://tests.stockfishchess.org/tests/view/5ab4e8500ebc5902932aecb3

Finally, I ran some tests with fixed number of games, checking if
reverting dynamic contempt gains more elo with Skill Level=17 (i.e.
MultiPV) than applying the "prevScore" fix and this patch. These tests
showed, that this patch gains 15 ELO when playing with Skill Level=17:

5+0.05, Threads=3, "revert dynamic contempt" vs. "WITHOUT this patch":
ELO: -11.43 +-4.1 (95%) LOS: 0.0%
Total: 20000 W: 7085 L: 7743 D: 5172
http://tests.stockfishchess.org/tests/view/5ab636450ebc590295d88536

5+0.05, Threads=3, "revert dynamic contempt" vs. "WITH this patch":
ELO: -26.42 +-4.1 (95%) LOS: 0.0%
Total: 20000 W: 6661 L: 8179 D: 5160
http://tests.stockfishchess.org/tests/view/5ab62e680ebc590295d88524

---
***FAQ***

**Why should this be commited?**
I believe that the gain for multi-thread MultiPV search is a sufficient
justification for this otherwise neutral change. I also believe this
implementation of dynamic contempt is more logical, although this may
be just my opinion.

**Why is per-thread contempt better at MultiPV?**
A likely explanation for the gain in MultiPV mode is that during
search each thread independently switches between rootMoves and via
the shared contempt score skews each other's evaluation.

**Why were the tests done with Skill Level=17?**
This was originally suggested by @Hanamuke and the idea is that with
Skill Level Stockfish sometimes plays also moves it thinks are slightly
sub-optimal and thus the quality of all moves offered by the MultiPV
search is checked by the test.

**Why are the ELO differences so huge?**
This is most likely because of the nature of Skill Level mode --
since it slower and weaker than normal mode, bugs in evaluation have
much greater effect.

---

Closes https://github.com/official-stockfish/Stockfish/pull/1515.

No functional change -- in single thread mode.
 2018-03-30 10:48:57 +02:00
Joost VandeVondele c959871a59 Integrate syzygy in automated testing (v2). 
Extends valgrind/sanitizer testing to cover syzygy code.

The script downloads 4 man syzygy as needed. The time needed for the
additional testing is small (in fact hard to see a difference compared
to the large fluctuations in testing time in travis).

Possible follow-ups:

 * include more TB sensitive positions in bench.
 * include the test script of recent commit "Refactor tbprobe.cpp".
 * verify unchanged bench with TB (with a long run).
 * make the TB part of the continuation integration tests optional.

Closes https://github.com/official-stockfish/Stockfish/pull/1518
and    https://github.com/official-stockfish/Stockfish/pull/1490

No functional change.
 2018-03-30 10:23:48 +02:00
Jerry Donald Watson 9953bfff62 Change reduction/improving interaction 
Adjust criterion for applying extra reduction if not improving.
We now add an extra ply of reduction if r > 1.0, instead of the
previous condition Reductions[NonPV][imp][d][mc] >= 2.

Why does this work? Previously, reductions when not improving had
a discontinuity as the depth and/or move count increases due to the
Reductions[NonPV][imp][d][mc] >= 2 condition. Hence, values of r
such that 0.5 < r < 1.5 would be mapped to a reduction of 1, while
1.5 < r < 2.5 would be mapped to a reduction of 3. This patch allows
values of r satisfying 1.0 < r < 1.5 to be mapped to a reduction of 2,
making the reduction formula more continuous.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 35908 W: 7382 L: 7087 D: 21439
http://tests.stockfishchess.org/tests/view/5aba723a0ebc5902a4743e8f

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 23087 W: 3584 L: 3378 D: 16125
http://tests.stockfishchess.org/tests/view/5aba89070ebc5902a4743ea9

Ideas for future work:
- We could look at retuning the LMR formula.
- We could look at adjusting the reductions in PV nodes if not improving.

Bench: 5326261
 2018-03-28 00:31:47 +02:00
Stéphane Nicolet 5ce630584c Tweak queen values for midgame and endgame 
Queen midgame value: -1%
Queen endgame value: +1%

This patch failed STC, but was exceptionally tested at LTC,
where it passed two independant SPRT tests with bounds [0..4]:

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 20651 W: 3191 L: 2980 D: 14480
http://tests.stockfishchess.org/tests/view/5ab73faa0ebc5902932cbdca

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 89111 W: 13647 L: 13233 D: 62231
http://tests.stockfishchess.org/tests/view/5ab8c0e50ebc5902932cbeae

See https://github.com/official-stockfish/Stockfish/pull/1511
for the discussion of this patch.

How to continue from there?
• there is probably some more Elo gains to get from the tuning
of the queen value.

Bench: 5460229
 2018-03-27 17:51:11 +02:00
protonspring 29070bd01a Simplification: remove pawn shelter/storm masks 
Encode the pawn shelter/storm masks into the danger score

This highly specialized rule directly contradicts the VERY high
danger score for blocked pawns. Reducing the danger score for
blocked pawns and removing this rule is apparently an effective
compromise.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 36597 W: 7522 L: 7429 D: 21646
http://tests.stockfishchess.org/tests/view/5ab935f30ebc5902932cc016

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 100690 W: 15373 L: 15372 D: 69945
http://tests.stockfishchess.org/tests/view/5ab9501f0ebc5902932cc042

Closes https://github.com/official-stockfish/Stockfish/pull/1514

Bench: 5980822
 2018-03-27 17:30:52 +02:00
Ondrej Mosnáček 367304e930 Fix dynamic contempt for MultiPV 
Use rootMoves[PVIdx].previousScore instead of bestValue for
dynamic contempt. This is equivalent for MultiPV=1 (bench remained the
same, even for higher depths), but more correct for MultiPV.

STC (MultiPV=3):
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 2657 W: 1079 L: 898 D: 680
http://tests.stockfishchess.org/tests/view/5aaa47cb0ebc590297330403

LTC (MultiPV=3):
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 2390 W: 874 L: 706 D: 810
http://tests.stockfishchess.org/tests/view/5aaa593a0ebc59029733040b

VLTC 240+2.4 (MultiPV=3):
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 2399 W: 861 L: 694 D: 844
http://tests.stockfishchess.org/tests/view/5aaf983e0ebc5902a182131f

LTC (MultiPV=4, Skill Level=17):
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 747 W: 333 L: 175 D: 239
http://tests.stockfishchess.org/tests/view/5aabccee0ebc5902997ff006

Note: although the ELO differences seem huge, they are inflated by the
nature of Skill Level / MultiPV search, so I don't think they can be
reasonably compared with classic ELO strength.

See https://github.com/official-stockfish/Stockfish/pull/1491 for some
verifications searches with MultiPV = 10 at depths 12 and 24 from the
starting position and the position after 1.e4, comparing the outputs
of the full PV by the old master and by this patch.

No functional change for MultiPV=1
 2018-03-27 17:14:55 +02:00
Ondrej Mosnáček 8ff2fcf299 Refactor tbprobe.cpp 
This involves:
 * replacing the union hacks with simply reusing the EntryPiece arrays
   for the no-pawns case
 * merging the PairsData structure with the EntryPiece/-Pawn structs
   (with credit to Marco: @mcostalba)
 * simplifying some HashTable functions
 * thanks to previous changes, removing the ugly memsets
 * simplifying the template logic for WDL/DTZ distinction
   (now we distinguish based on an enum type, not the entry classes)
 * removing the unneeded Atomic wrapper

-----------------------------

For reference, here is a manual way to check that patches concerning
table bases code are non-functional changes:

0) Download the Syzygy table bases (up to 6 men).
1) Make sure you have branches master and the pull request pointing to
   the right commits.
2) Download the bench calculation scripts from the following URL:

        https://gist.github.com/WOnder93/b5fcf9c989b4a1715684d5c82367cdbe

   and copy into src inside your Stockfish repo.
3) Make the scripts executable (chmod +x *.sh).
4) Run the following command to use TBs located at <path>:

       export SYZYGY_PATH='<path>'

5) After that, run this (it will take a long time, this is a deep bench):

       BENCH_ARGS='128 1 22' ./check_benches.sh master tbprobe_cleanup 2>/dev/null`

==> You should see two equal numbers printed.
    (Of course, now we have to trust that the script itself is correct :)

-----------------------------

Closes https://github.com/official-stockfish/Stockfish/pull/1477

No functional change.
 2018-03-27 17:08:08 +02:00
Marco Costalba 280022baf7 Fix indentation in movepicker.cpp 
Fix indentation in movepicker.cpp and evaluate.cpp. Also move
the PickType enum out of global space.

No functional change
 2018-03-27 16:45:12 +02:00
Stéphane Nicolet a03e98dcd3 Switch time management to 64 bits 
This is a patch to fix issue #1498, switching the time management variables
to 64 bits to avoid overflow of time variables after 25 days.

There was a bug in Stockfish 9 causing the output to be wrong after
2^31 milliseconds search. Here is a long run from the starting position:

info depth 64 seldepth 87 multipv 1 score cp 23 nodes 13928920239402
nps 0 tbhits 0 time -504995523 pv g1f3 d7d5 d2d4 g8f6 c2c4 d5c4 e2e3 e7e6 f1c4
c7c5 e1g1 b8c6 d4c5 d8d1 f1d1 f8c5 c4e2 e8g8 a2a3 c5e7 b2b4 f8d8 b1d2 b7b6 c1b2
c8b7 a1c1 a8c8 c1c2 c6e5 d1c1 c8c2 c1c2 e5f3 d2f3 a7a5 b4b5 e7c5 f3d4 d8c8 d4b3
c5d6 c2c8 b7c8 b3d2 c8b7 d2c4 d6c5 e2f3 b7d5 f3d5 e6d5 c4e5 a5a4 e5d3 f6e4 d3c5
e4c5 b2d4 c5e4 d4b6 e4d6 g2g4 d6b5 b6c5 b5c7 g1g2 c7e6 c5d6 g7g6

We check at compile time that the TimePoint type is exactly 64 bits long for
the compiler (TimePoint is our alias in Stockfish for std::chrono::milliseconds
-- it is a signed integer type of at least 45 bits according to the C++ standard,
but will most probably be implemented as a 64 bits signed integer on modern
compilers), and we use this TimePoint type consistently across the code.

Bug report by user "fischerandom" on the TCEC chat (thanks), and the
patch includes code and suggestions by user "WOnder93" and Ronald de Man.

Fixes issue:          https://github.com/official-stockfish/Stockfish/issues/1498
Closes pull request:  https://github.com/official-stockfish/Stockfish/pull/1510

No functional change.
 2018-03-27 16:25:41 +02:00
Jerry Donald Watson f0f6da2d30 Make kingRing always 8 squares 
Make kingRing always eight squares, extending the bitboard to the
F file if the king is on the H file, and to the C file if the king
is on the A file. This may deal with cases where Stockfish (like
many other engines) would shift the king around on the back rank
like g1h1, not because there is some imminent threat, but because
it makes king safety look a little better just because the king ring
had a smaller area.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 34000 W: 7167 L: 6877 D: 19956
http://tests.stockfishchess.org/tests/view/5ab8216d0ebc5902932cbe64

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 22574 W: 3576 L: 3370 D: 15628
http://tests.stockfishchess.org/tests/view/5ab84e6a0ebc5902932cbe72

How to continue from there?

This patch probably makes it easier to tune the king safety evaluation,
because the new regularity of the king ring size will make the king
safety function more continuous.

Closes https://github.com/official-stockfish/Stockfish/pull/1512

Bench: 5934103
 2018-03-26 09:28:37 +02:00
Chess13234 62937d1007 IID margin reduced to 128 
Change the internal iterative deepening margin from +256 to +128.

Passed STC:
LLR: 3.26 (-2.94,2.94) [0.00,5.00]
Total: 22006 W: 4646 L: 4400 D: 12960
http://tests.stockfishchess.org/tests/view/5ab54a240ebc590295d8847d

Passed LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 46665 W: 7187 L: 6898 D: 32580
http://tests.stockfishchess.org/tests/view/5ab5ba690ebc590295d884b4

Possible work in this area after this change:

• Reduce even more the margin?
• Try to do IID for smaller depths too?

Bench: 5851102
 2018-03-24 08:59:48 +01:00
Joost VandeVondele d40e7ee209 Join refutation stages in the movepicker 
Unifies a bit further the three refuation stages in the MovePicker
class. Also treat the skipping of TT move now always via select_move(),
as discussed in pull request #1454.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 16608 W: 3461 L: 3331 D: 9816
http://tests.stockfishchess.org/tests/view/5ab0aaf00ebc59029fb6f6c3

Closes https://github.com/official-stockfish/Stockfish/pull/1502

No functional change.
 2018-03-21 01:48:47 +01:00
DU-jdto ed26d71354 Fix a few minor code style inconsistencies 
No functional change.
 2018-03-21 01:35:05 +01:00
Joost VandeVondele bd59560480 Join common code in the stages of next_move() 
Rewrite the MovePicker class using lambda expressions for move filtering.
Includes code style changes by @mcostalba.

Verified for speed, passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 43191 W: 9391 L: 9312 D: 24488
http://tests.stockfishchess.org/tests/view/5a99b9df0ebc590297cc8f04

This rewrite of MovePicker.cpp seems to trigger less random crashes on Ryzen
machines than the version in previous master (reported by Bojun Guo).

Closes https://github.com/official-stockfish/Stockfish/pull/1454

No functional change.
 2018-03-19 00:59:30 +01:00
Joost VandeVondele 1940485030 Simplify razoring logic 
passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 36574 W: 7523 L: 7430 D: 21621
http://tests.stockfishchess.org/tests/view/5aae11450ebc590299abf52f

No functional change.
 2018-03-19 00:17:08 +01:00
Ronald de Man 759b3c79cf Mark all compile-time constants as constexpr. 
To more clearly distinguish them from "const" local variables, this patch
defines compile-time local constants as constexpr. This is consistent with
the definition of PvNode as constexpr in search() and qsearch(). It also
makes the code more robust, since the compiler will now check that those
constants are indeed compile-time constants.

We can go even one step further and define all the evaluation and search
compile-time constants as constexpr.

In generate_castling() I replaced "K" with "step", since K was incorrectly
capitalised (in the Chess960 case).

In timeman.cpp I had to make the non-local constants MaxRatio and StealRatio
constepxr, since otherwise gcc would complain when calculating TMaxRatio and
TStealRatio. (Strangely, I did not have to make Is64Bit constexpr even though
it is used in ucioption.cpp in the calculation of constexpr MaxHashMB.)

I have renamed PieceCount to pieceCount in material.h, since the values of
the array are not compile-time constants.

Some compile-time constants in tbprobe.cpp were overlooked. Sides and MaxFile
are not compile-time constants, so were renamed to sides and maxFile.

Non-functional change.
 2018-03-18 23:48:16 +01:00
mstembera 350dff4464 Fix an MSVC 2017 error and warnings. 
Improved version by @mcostalba.

No functional change.
 2018-03-16 22:37:03 +01:00
Stéphane Nicolet 96362fe3df Renaming some variables in code 
Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.

Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426

No functional change.
 2018-03-15 10:44:26 +01:00
Joost VandeVondele 8ab12c9012 Make using quiescence search implicit 
If search depth is less than ONE_PLY call qsearch(), no need to check the
depth condition at various call sites of search().

Passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 14568 W: 3011 L: 2877 D: 8680
http://tests.stockfishchess.org/tests/view/5aa846190ebc59029781015b

Also helps gcc to find some optimizations (smaller binary, some speedup).
Thanks to Aram and Stefan for identifying an oversight in an early version.

Closes https://github.com/official-stockfish/Stockfish/pull/1487

No functional change.
 2018-03-15 09:25:59 +01:00
Stéphane Nicolet 8db75dd9ec Check the clock every 1024 nodes 
This patch checks the clock every 1024, instead of 4096 in current master.

This is a step towards a solution to alleviate the problem reported by
Gian-Carlo Pascutto in pull request #1471, about a situation where SF
would sometimes lose on time in endgames at time control 1min+1sec when
using Syzygy EGTB on a spinning drive.

We made four tests called "Estimate the Elo cost of calling now() every
N nodes", with N in {256,1024} and time control in {STC,LTC}. Each test
was 40000 games with auto-purge off, against master branch.

http://tests.stockfishchess.org/tests/view/5aa4f37c0ebc59029780ff2d
http://tests.stockfishchess.org/tests/view/5aa4f3080ebc59029780ff2b
http://tests.stockfishchess.org/tests/view/5aa5cbb50ebc59029780ffce
http://tests.stockfishchess.org/tests/view/5aa5cb730ebc59029780ffcc

Here is a summary of the results (speed-up and Elo gain against master):

|   Time   |       N=256       |      N=1024      |
|:--------:|:-----------------:|:----------------:|
| Speed-up |    0.1% slower    |   0.2% faster    |
|   STC    |  -0.33 +-2.2 Elo  |  1.33 +-2.2 Elo  |
|   LTC    |   1.08 +-2.3 Elo  |  2.34 +-2.2 Elo  |

Based on these results, we tested N=1024 as a non-regression against
master at LTC:

LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 80746 W: 12430 L: 12399 D: 55917
http://tests.stockfishchess.org/tests/view/5aa7ba660ebc590297810116

Closes https://github.com/official-stockfish/Stockfish/pull/1482

No functional change.
 2018-03-14 22:01:58 +01:00
lucasart edf4c07d25 Use intrinsics only for LSB/MSB 
The NO_BSF does not cover any real life use-case today. The only compilers that
can compile SF today, with the current Makefile and no source code changes, are
either GCC compatible (define __GNUC__) or MSVC compatible (define _MSC_VER). So
they all support LSB/MSB intrinsics.

This patch simplifies away the software fall-backs of LSB/MSB that were still
in Stockfish code, but unused in any of the officially supported compilers.

Note the (legacy) MSVC/WIN32 case, where we use a 32-bit BSF/BSR solution, as
64-bit intrinsics aren't available there.

Discussed in: https://github.com/official-stockfish/Stockfish/pull/1447
and:          https://github.com/official-stockfish/Stockfish/pull/1479

No functional change.
 2018-03-14 01:31:21 +01:00
Jerry Donald Watson b605103a34 Simplify condition for ProbCut move count pruning 
We retire depth-dependence in ProbCut move count pruning,
the move count limit condition is now : "probCutCount < 3"

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 33895 W: 6995 L: 6897 D: 20003
http://tests.stockfishchess.org/tests/view/5aa6eaba0ebc59029781009d

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 28959 W: 4441 L: 4333 D: 20185
http://tests.stockfishchess.org/tests/view/5aa73dfa0ebc5902978100be

Ideas for future work:

• Is a flat move count limit in ProbCut ideal? Depth dependence, or
  dependence on some other variable, could possibly be reintroduced.

• The move count limit 3 is untuned and a better value may exist.

Closes https://github.com/official-stockfish/Stockfish/pull/1486

Bench: 5741807
 2018-03-13 23:32:45 +01:00
Jerry Donald Watson c5f6bd517c Tweak probcut margin with 'improving' flag 
Adjust ProbCut rBeta by whether the score is improving, and also
set improving to false when in check. More precisely, this patch
has two parts:

1) the increased beta threshold for ProbCut is now adjusted based
   on whether the score is improving
2) when in check, improving is always set to false.

Co-authored by Joost VandeVondele (@vondele) and Bill Henry (@VoyagerOne).

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 13480 W: 2840 L: 2648 D: 7992
http://tests.stockfishchess.org/tests/view/5aa693fe0ebc59029781004c

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 25895 W: 4099 L: 3880 D: 17916
http://tests.stockfishchess.org/tests/view/5aa6ac940ebc59029781006e

In terms of opportunities for future work opened up by this patch,
the ProbCut rBeta formula could probably be tuned to gain more Elo.

Closes https://github.com/official-stockfish/Stockfish/pull/1485

Bench: 5328254
 2018-03-13 23:21:46 +01:00
VoyagerOne b2961aded6 Use quiescence search for Probcut 
Perform qsearch for the preliminary search in Probcut

Passed STC with sprt[-3..1] bounds:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 31090 W: 6386 L: 6283 D: 18421
http://tests.stockfishchess.org/tests/view/5aa598ed0ebc59029780ff9f

Passed LTC with sprt[0..4] bounds:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 104056 W: 15990 L: 15531 D: 72535
http://tests.stockfishchess.org/tests/view/5aa5b0f30ebc59029780ffa9

Closes https://github.com/official-stockfish/Stockfish/pull/1483

Bench: 5404567
 2018-03-13 08:21:11 +01:00
Joost VandeVondele efe702e9f5 qsearch(): remove inCheck as a template parameter 
Simplifies a bit, and avoids bugs as in #1478

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 104862 W: 21302 L: 21337 D: 62223
http://tests.stockfishchess.org/tests/view/5aa6de1b0ebc590297810097

Closes https://github.com/official-stockfish/Stockfish/pull/1484

No functional change
 2018-03-13 08:13:26 +01:00
Jerry Donald Watson 840605c14e Adjust initiative in pure pawn endgames 
King and pawn endgames are typically decisive, and a small
advantage is often sufficient to win. Therefore we now take
this into account when computing the initiative adjustment.

This idea came from a series of patches by Gian-Carlo Pascutto.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 48770 W: 10203 L: 9845 D: 28722
http://tests.stockfishchess.org/tests/view/5aa58cce0ebc59029780ff8d

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 22252 W: 3572 L: 3366 D: 15314
http://tests.stockfishchess.org/tests/view/5aa5b27c0ebc59029780ffad

Ideas for future developement:

- There have been a number of changes to the initiative
  calculation lately. Perhaps the coefficients could be
  tuned again.

- It may be possible to add special knowledge for other
  endgames in the initiative calculation.

Closes https://github.com/official-stockfish/Stockfish/pull/1481

Bench: 5750110
 2018-03-12 22:57:21 +01:00
protonspring 6e9337b107 MovePicker: combine countermove with killers. 
Handle the countermove in the same way we use stages to progress
through the killer moves, using a common array called "refutations".
Removes some lines of code and simplifies a bit the jump table.

STC: LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 71707 W: 14622 L: 14595 D: 42490
http://tests.stockfishchess.org/tests/view/5aa003cf0ebc590297cb6276

LTC: LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 22320 W: 3470 L: 3352 D: 15498
http://tests.stockfishchess.org/tests/view/5aa051020ebc590297cb62ba

Closes https://github.com/official-stockfish/Stockfish/pull/1468

No functional change.
 2018-03-12 02:49:14 +01:00
protonspring c3af52c43b Connectivity Score S(3,1) is stronger than S(2,2) 
I believe my tests were conclusive enough to demonstrate
that a connectivity score of S(3,1) is stronger than S(2,2).

STC
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 16175 W: 3386 L: 3165 D: 9624
http://tests.stockfishchess.org/tests/view/5aa48b150ebc59029780fef6

LTC
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 98685 W: 15209 L: 14765 D: 68711
http://tests.stockfishchess.org/tests/view/5aa496f50ebc59029780fefa

Bench 5601228
 2018-03-12 01:52:12 +01:00
protonspring 5dc381a566 Implement an old Russian proverb 
"Loose pieces drop, in blitz keep everything protected"

Adding a small S(2,2) bonus for knights, bishops, rooks, and
queens that are "connected" to each other (in the sense that
they are under attack by our own pieces) apparently is a good
thing. It probably helps the pieces work together a bit better.

STC
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 12317 W: 2655 L: 2467 D: 7195
http://tests.stockfishchess.org/tests/view/5aa2d86b0ebc590297cb6474

LTC
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 35725 W: 5516 L: 5263 D: 24946
http://tests.stockfishchess.org/tests/view/5aa2fc6f0ebc590297cb64a8

How to continue from there (by Stefan Geschwentner)?

• First we should identify all other eval terms which have an overlap
  with new connectivity bonus (like the outpost bonus). A simple way
  would be subtract the connectivity bonus from them and look if this
  better, or use a SPSA session for these terms.

• Tuning Connectivity himself with SPSA seems not so promising because
  of the small range which is useful. Here manual testing changes of
  Connectivity like +-1 seems better.

• The eg value is more important because in endgame the position gets
  more open and so attacks on pieces are easier. Another important point
  is that when defending/fortress-like positions each defending piece
  needs a protection, otherwise attacks on them can break defense.

Closes https://github.com/official-stockfish/Stockfish/pull/1474

Bench: 5318575
 2018-03-10 12:04:03 +01:00
Joost VandeVondele 2c5dfb3122 Assign improving only once 
Avoid duplicated code after recent commit "Use evaluation trend
to adjust futility margin". We initialize the improving variable
to true in the check case, which allows to avoid redundant code
in the general case.

Tested for speed by snicolet, patch seems about 0.4% faster.

No functional change.

Note: initializing the improving variable to false in the check
case was tested as a functional change, ending yellow in both STC
and LTC. This change is not included in the commit, but it is an
interesting result that could become part of a future patch about
improving or LMR. Reference of the LTC yellow test:
http://tests.stockfishchess.org/tests/view/5aa131560ebc590297cb636e
 2018-03-10 11:06:53 +01:00
Alain SAVARD 1093047e7d Two steps slider threats on queen 
Allow a potential slider threat from a square currently occupied
by a harmless attacker, just as the recent "knight on queen" patch.
Also from not completely safe squares, use the mobilityArea instead
of excluding all pawns for both SlidersOnQueen and KnightOnQueen

We now compute the potential sliders threat on queen only if opponent
has one queen.

Run as SPRT [0,4] since it is some kind of simplification but maybe
not clearly one.

STC:
http://tests.stockfishchess.org/tests/view/5aa1ddf10ebc590297cb63d8
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 22997 W: 4817 L: 4570 D: 13610

LTC:
http://tests.stockfishchess.org/tests/view/5aa1fe6b0ebc590297cb63e5
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 11926 W: 1891 L: 1705 D: 8330

After this patch is committed, we may try to:

• re-introduce some "threat by queen" bonus to make Stockfish's queen
  more aggressive (attacking aspect)

• introduce a concept of "queen overload" to force the opponent queen
  into passivity and protecting duties (defensive aspect)

• more generally, re-tune the queen mobility array since patches in the
  last three months have affected a lot the location/activity of queens.

Closes https://github.com/official-stockfish/Stockfish/pull/1473

bench: 5788691
 2018-03-09 21:47:44 +01:00
IIvec 82697f1193 Simplification: use Arctan for the optimism S-curve 
This was an idea of Gontran Lemaire (gonlem), but the graphs
he published did not seem accurate to me. I did my own graphs,
got my own constants and here is the result:

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 42179 W: 8704 L: 8622 D: 24853
http://tests.stockfishchess.org/tests/view/5a9db6270ebc590297cb611b

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 17737 W: 2702 L: 2577 D: 12458
http://tests.stockfishchess.org/tests/view/5a9eb5b20ebc590297cb61b2

Note: we are now back to 70% draw rate in selfplay mode!

Bench: 5544908
 2018-03-07 22:51:31 +01:00
Jerry Donald Watson 65c3bb8586 Use evaluation trend to adjust futility margin 
Adjust futility margin in the child node based on whether the
static evaluation is improving.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 15271 W: 3157 L: 2958 D: 9156
http://tests.stockfishchess.org/tests/view/5a9f2f8c0ebc590297cb6216

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 6617 W: 1053 L: 908 D: 4656
http://tests.stockfishchess.org/tests/view/5a9f98390ebc590297cb6241

Ideas for future work:

- Tune the new margins.
- Try to get this idea to work for futility pruning in parent
  nodes as well.

Bench: 5779242
 2018-03-07 22:34:49 +01:00
Stéphane Nicolet 6d8f583af2 Knight threats on Queen 
We give a S(21,11) bonus for knight threats on the next moves
against enemy queen. The threats are from squares which are
"not strongly protected" and which may be empty, contain enemy
pieces or even one of our piece at the moment (N,B,Q,R) -- hence
be two-steps threats in the later case because we will have to
move our piece and *then* attack the enemy queen with the knight.

STC: http://tests.stockfishchess.org/tests/view/5a9e442e0ebc590297cb6162
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 35129 W: 7346 L: 7052 D: 20731

LTC: http://tests.stockfishchess.org/tests/view/5a9e6e620ebc590297cb617f
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 42442 W: 6695 L: 6414 D: 29333

How to continue from there?

• Trying to refine the threat condition ("not strongly protected")
• Trying the two-steps idea for bishops or rooks threats against queen

Bench: 6051247
 2018-03-07 22:12:29 +01:00
Torsten Franz 56a104e2e0 Remove popcount trick from space evaluation 
Similar removal of superposition code trick as in the
"Simplify tropism computation" patch. This simplification
of the space() function will allow us to specify space
masks which can reach into enemy territory.

passed STC:
LLR: 3.38 (-2.94,2.94) [-3.00,1.00]
Total: 184630 W: 40581 L: 40758 D: 103291
http://tests.stockfishchess.org/tests/view/5a8433360ebc590297cc80c5

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 231799 W: 37647 L: 37858 D: 156294
http://tests.stockfishchess.org/tests/view/5a96a34a0ebc590297cc8cfd

No functional change.
 2018-03-07 21:58:16 +01:00
Stéphane Nicolet d42e6338ea Fix a warning in GCC for Windows 
No functional change
 2018-03-06 22:11:45 +01:00
joergoster 43682d08f7 Code style in Razoring and ProbCut 
No functional change.
 2018-03-06 01:54:36 +01:00
Chris Cain 3192b09fe0 Introduce variadic make_bitboard() 
Adds a helper function to make a bitboard from a list of squares.

No functional change
 2018-03-06 01:33:00 +01:00
Stefano Cardanobile 450f04969c Using a S-curve for the optimism measure 
Add a logarithmic term in the optimism computation, increase
the maximal optimism and lower the contempt offset.

This increases the dynamics of the optimism aspects, giving
a boost for balanced positions without skewing too much on
unbalanced positions (but this version will enter panic mode
faster than previous master when behind, trying to draw faster
when slightly behind). This helps, since optimism is in general
a good thing, for instance at LTC, but too high optimism
rapidly contaminates play.

passed STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 159343 W: 34489 L: 33588 D: 91266
http://tests.stockfishchess.org/tests/view/5a8db9340ebc590297cc85b6

passed LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 47491 W: 7825 L: 7517 D: 32149
http://tests.stockfishchess.org/tests/view/5a9456a80ebc590297cc8a89

It must be mentioned that a version of the PR with contempt 0
did not pass STC [0,5]. The version in the patch, which uses
default contempt 12, was found to be as strong as current master
on different matches against SF7 and SF8, both at STC and LTC.

One drawback maybe is that it raises the draw rate in self-play
from 56% to 59%, giving a little bit less sensitivity for SF
developpers to find evaluation improvements by selfplay tests
in fishtest.

Possible further work:

• tune the values accurately, while keeping in mind the drawrate issue
• check whether it is possible to remove linear and offset term
• try to simplify the S-shape curve

Bench: 5934644
 2018-03-04 16:55:58 +01:00
Joost VandeVondele cad300cfab No extra stage for QS recaptures. 
remove the QRECAPTURES and QSEARCH_RECAPTURES stages as they can be
incoorporated in QCAPTURES stage with a simple condition on depth.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 214964 W: 46188 L: 46443 D: 122333
http://tests.stockfishchess.org/tests/view/5a98544b0ebc590297cc8e35

passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 14552 W: 2404 L: 2274 D: 9874
http://tests.stockfishchess.org/tests/view/5a9947b20ebc590297cc8e93

Bench: 6361582
 2018-03-03 12:41:35 +01:00
VoyagerOne b87308692a Do move-count pruning in probcut 
STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 4928 W: 1163 L: 1007 D: 2758

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 20368 W: 3441 L: 3238 D: 13689
http://tests.stockfishchess.org/tests/view/5a98bea40ebc590297cc8e5d

Bench: 6361568
 2018-03-03 12:04:25 +01:00
Marco Costalba f35e52f030 Merge Stats tables 
Use a recursive std::array with variadic template
parameters to get rid of the last redundacy.

The first template T parameter is the base type of
the array, the W parameter is the weight applied to
the bonuses when we update values with the << operator,
the D parameter limits the range of updates (range is
[-W * D, W * D]), and the last parameters (Size and
Sizes) encode the dimensions of the array.

This allows greater flexibility because we can now tweak
the range [-W * D, W * D] for each table.

Patch removes more lines than what adds and streamlines
the Stats soup in movepick.h

Closes PR#1422 and PR#1421

No functional change.
 2018-03-03 11:35:33 +01:00
Stéphane Nicolet 94b3cdd908 Better indentation in Makefile 
No functional change
 2018-03-03 11:07:23 +01:00
Tom Vijlbrief 94abc2a0cf Reintroduce depth 2 razoring (with additional margin) 
The first depth 2 margin triggers the verification quiescence search.
This qsearch() result has to be better then the second lower margin,
so we only skip the razoring when the qsearch gives a significant
improvement.

Passed STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 32133 W: 7395 L: 7101 D: 17637
http://tests.stockfishchess.org/tests/view/5a93198b0ebc590297cc8942

Passed LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 17382 W: 3002 L: 2809 D: 11571
http://tests.stockfishchess.org/tests/view/5a93b18c0ebc590297cc89c2

This Elo-gaining version was further simplified following a suggestion
of Marco Costalba:

STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 15553 W: 3505 L: 3371 D: 8677
http://tests.stockfishchess.org/tests/view/5a964be90ebc590297cc8cc4

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 13253 W: 2270 L: 2137 D: 8846
http://tests.stockfishchess.org/tests/view/5a9658880ebc590297cc8cca

How to continue after this patch?

Reformating the razoring code (step 7 in search()) to unify the
depth 1 and depth 2 treatements seems quite possible, this could
possibly lead to more simplifications.

Bench: 5765806
 2018-02-28 13:42:32 +01:00
Stefan Geschwentner 59d10374ca Blocked pawn storm 
In pawn structures like white pawns f6,h6 against black pawns f7,g6,h7
the attack on the king is blocked by the own pawns. So decrease the
penalty for king safety.

See diagram and discussion in
https://github.com/official-stockfish/Stockfish/pull/1434

A sample position that this patch wants to avoid is the following
1rr2bk1/3q1p1p/2n1bPpP/pp1pP3/2pP4/P1P1B3/1PBQN1P1/1K3R1R w - - 0 1

White pawn storm on the king side was a disaster, it locked the king
side completely. Therefore, all the king tropism bonus that white have
on the king side are useless, and kingadjacent attacks too. Master
gives White a static +4.5 advantage, but White cannot win that game.
The patch is lowering this evaluation artefact.

STC:
LLR: 2.94 (-2.94,2.94) [0.00,5.00]
Total: 16467 W: 3750 L: 3537 D: 9180
http://tests.stockfishchess.org/tests/view/5a92102d0ebc590297cc87d0

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 64242 W: 11130 L: 10745 D: 42367
http://tests.stockfishchess.org/tests/view/5a923dc80ebc590297cc8806

This version includes reformatting and speed optimization by Alain Savard.

Bench: 5643527
 2018-02-28 13:03:35 +01:00
Leonid Pechenik ad5d86c771 Tweak time management 
Using a SPSA tuning session to optimize the time management
parameters.

With SPSA tuning it is not always possible to say where improvements
came from. Maybe some variables changed randomly or because result
was not sensitive enough to them. So my explanation of changes will
not be necessarily correct, but here it is.

• When decrease of thinking time was added by Joost a few months ago
if best move has not changed for several plies, one more competing
indicator  was introduced for the same purpose along with increase
in score and absence of fail low at root. It seems that tuning put
relatively more importance on that new indicator what allowed to save
time.
• Some of this saved time is distributed proportionally between all
moves and some more time were given to moves when score dropped a lot
or best move changed.
• It looks also that SPSA redistributed more time from the beginning to
later stages of game via other changes in variables - maybe because
contempt made game to last longer or for whatever reason.

All of this is just small tweaks here and there (a few percentages changes).

STC (10+0.1):
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 18970 W: 4268 L: 4029 D: 10673
http://tests.stockfishchess.org/tests/view/5a9291a40ebc590297cc8881

LTC (60+0.6):
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 72027 W: 12263 L: 11878 D: 47886
http://tests.stockfishchess.org/tests/view/5a92d7510ebc590297cc88ef

Additional non-regression tests at other time controls

Sudden death 60s:
LLR: 2.95 (-2.94,2.94) [-4.00,0.00]
Total: 14444 W: 2715 L: 2608 D: 9121
http://tests.stockfishchess.org/tests/view/5a9445850ebc590297cc8a65

40 moves repeating at LTC:
LLR: 2.95 (-2.94,2.94) [-4.00,0.00]
Total: 10309 W: 1880 L: 1759 D: 6670
http://tests.stockfishchess.org/tests/view/5a9566ec0ebc590297cc8be1

This is a functional patch only for time management, but the bench
does not reflect this because it uses fixed depth search, so the number
of nodes does not change during bench.

No functional change.
 2018-02-28 12:37:20 +01:00
Stéphane Nicolet de642f16db Simplify tropism computation 
Simplification. Tests show that the "shift-and-superpose" trick is no longer
necessary. The speed benefit of avoiding a popcount is no longer relevant
on modern machines.

Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 41675 W: 9168 L: 9086 D: 23421
http://tests.stockfishchess.org/tests/view/5a840bcc0ebc590297cc80b5

Passed LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 117728 W: 19875 L: 19911 D: 77942
http://tests.stockfishchess.org/tests/view/5a8444800ebc590297cc80ca

No functional change.
 2018-02-27 19:10:40 +01:00
Stefan Geschwentner cccbecb6f8 Stat score initialization: grandchildren 
This is the sequel of the previous patch, we now let the parent node initialize
stat score to zero once for all grandchildren.

Initialize statScore to zero for the grandchildren of the current position.
So statScore is shared between all grandchildren and only the first grandchild
starts with statScore = 0. Later grandchildren start with the last calculated
statScore of the previous grandchild. This influences the reduction rules in
LMR which are based on the statScore of parent position.

Tests results against the previous patch:

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 23676 W: 5417 L: 5157 D: 13102
http://tests.stockfishchess.org/tests/view/5a9423a90ebc590297cc8a46

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 35485 W: 6168 L: 5898 D: 23419
http://tests.stockfishchess.org/tests/view/5a9435550ebc590297cc8a54

Bench: 5643520
 2018-02-27 18:42:59 +01:00
Stefan Geschwentner 1463881153 Stat score initialization: children 
Let the parent node initialize stat score to zero once for all siblings.

Initialize statScore to zero for the children of the current position.
So statScore is shared between sibling positions and only the first sibling
starts with statScore = 0. Later siblings start with the last calculated
statScore of the previous sibling. This influences the reduction rules in
in LMR which are based on the statScore of parent position.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 22683 W: 5202 L: 4946 D: 12535
http://tests.stockfishchess.org/tests/view/5a93315f0ebc590297cc894f

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 48548 W: 8346 L: 8035 D: 32167
http://tests.stockfishchess.org/tests/view/5a933ba90ebc590297cc8962

Bench: 5833683
 2018-02-27 18:18:56 +01:00
Stéphane Nicolet 29bc128384 No Tempo for draw scores given by heuristic functions 
The current master applies Eval::Tempo even to leaves evaluated
as draw by some of the static evaluation functions of endgame.cpp
(for instance KNN vs K or stalemates in KP vs K). This results in
some lines being reported as +0.07 or -0.07 when the terminal
position has reached such endgames (0.07 being about the value
of a tempo for Stockfish).

This patch does not apply Eval::tempo to these positions. This leads
to more nodes being evaluated as VALUE_DRAW during search, giving more
opportunities for cut-offs in alpha-beta.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,4.00]
Total: 52602 W: 11776 L: 11403 D: 29423
http://tests.stockfishchess.org/tests/view/5a8cb8f60ebc590297cc8546

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,4.00]
Total: 156613 W: 26820 L: 26158 D: 103635
http://tests.stockfishchess.org/tests/view/5a8f452d0ebc590297cc865a

Bench: 4924749
 2018-02-27 08:06:46 +01:00
Marco Costalba ad2a0e356e Speedup and simplify pinners and blockers 
To compute dicovered check or pinned pieces we use some bitwise
operators that are not really needed because already accounted for
at the caller site.

For instance in evaluation we compute:

     pos.pinned_pieces(Us) & s

Where pinned_pieces() is:

     st->blockersForKing[c] & pieces(c)

So in this case the & operator with pieces(c) is useless,
given the outer '& s'.

There are many places where we can use the naked blockersForKing[]
instead of the full pinned_pieces() or discovered_check_candidates().

This path is simpler than original and gives around 1% speed up for me.
Also tested for speed by mstembera and snicolet (neutral in both cases).

No functional change.
 2018-02-27 01:19:06 +01:00
erbsenzaehler d438720a1c Unify use of -mdynamic-no-pic 
Apply -mdynamic-no-pic in a single place in the Makefile instead of 5 places.

Verified on three different Macs:
- a MacBook from 2013
- a MacBook running MacOS 10.9.5
- an iMac running MacOS 10.13.3

No functional change.
 2018-02-27 00:30:47 +01:00
AndyGrant 71cc01c2ef Shallow search to verify probcut 
Perform a preliminary shallow search to verify a probcut before doing
the normal "depth - 4 plies" search.

STC:
LLR: 4.73 (-2.94,2.94) [0.00,5.00]
Total: 36281 W: 8221 L: 7830 D: 20230
http://tests.stockfishchess.org/tests/view/5a921cb90ebc590297cc87f6

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 22907 W: 3954 L: 3738 D: 15215
http://tests.stockfishchess.org/tests/view/5a92672b0ebc590297cc8814

Happy to see something from Ethereal work for Stockfish :)

Bench: 5882274
 2018-02-26 03:01:46 +01:00
Stéphane Nicolet 7a03450bd9 Count passed pawns in asymmetry measure 
The previous asymmetry measure of the pawn structure only used to
consider the number of pawns on semi-opened files in the position.
With this patch we also increase the measure by the number of passed
pawns for both players.

Many thanks to the community for the nice feedback on the previous
version, with special mentions to Alain Savard and Marco Costalba
for clarity and speed suggestions.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 13146 W: 3038 L: 2840 D: 7268
http://tests.stockfishchess.org/tests/view/5a91dd0c0ebc590297cc877e

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 27776 W: 4771 L: 4536 D: 18469
http://tests.stockfishchess.org/tests/view/5a91fdd50ebc590297cc879b

How to continue after this patch?

Stockfish will now evaluate more positions with passed pawns, so
tuning the passed pawns values may bring Elo. The patch has also
consequences on the initiative term, where we might want to give
different weights to passed pawns and semi-openfiles (idea by
Stefano Cardanobile).

Bench: 5302866
 2018-02-26 01:06:45 +01:00
Joost VandeVondele ebb3e7df65 Combine killer moves 
Move the first killer move out of the capture stage, combining treatment
of first and second killer move.

passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 55777 W: 12367 L: 12313 D: 31097
http://tests.stockfishchess.org/tests/view/5a88617e0ebc590297cc8351

Similar to an earlier proposition of Günther Demetz, see pull request #1075.
I think it is more robust and readable than master, why hand-unroll the loop
over the killer array, and duplicate code ?

This version includes review comments from Marco Costalba.

Bench: 5227124
 2018-02-25 23:11:56 +01:00
Stéphane Nicolet 2ec36f8ae8 Revert "Count passed pawns in asymmetry measure" 2018-02-25 15:12:19 +01:00
Stéphane Nicolet 2e21aba8d9 Count passed pawns in asymmetry measure 
The previous asymmetry measure of the pawn structure only used to
consider the number of pawns on semi-opened files in the postions.
With this patch we also increase the measure by the number of passed
pawns for both players.

STC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 13146 W: 3038 L: 2840 D: 7268
http://tests.stockfishchess.org/tests/view/5a91dd0c0ebc590297cc877e

LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 27776 W: 4771 L: 4536 D: 18469
http://tests.stockfishchess.org/tests/view/5a91fdd50ebc590297cc879b

How to continue from there: Stockfish will now evaluate more positions
with passed pawns, so tuning the passed pawns values may bring Elo.
The patch also has consequences on the initiative term.

Bench: 5302866
 2018-02-25 13:12:23 +01:00
Joost VandeVondele 8dd6875240 Join all capture init stages in MovePicker 
Passed STC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 16789 W: 3685 L: 3554 D: 9550
http://tests.stockfishchess.org/tests/view/5a91a8bb0ebc590297cc875b

Passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 21293 W: 3527 L: 3407 D: 14359
http://tests.stockfishchess.org/tests/view/5a920a730ebc590297cc87ba

No functional change
 2018-02-25 12:49:51 +01:00
DU-jdto 16b31bb249 More robust interaction of singular search and iid 
When iid (Internal iterative deepening) is invoked, the prior value of ttValue is
not guaranteed to be VALUE_NONE. As such, it is currently possible to enter a state
in which ttValue has a specific value which is inconsistent with tte->bound() and
tte->depth(). Currently, ttValue is only used within the search in a context that
prevents this situation from making a difference (and so this change is non-functional,
but this is not guaranteed to remain the case in the future.

For instance, just changing the tt depth condition in singular extension node to be

    tte->depth() >= depth - 4 * ONE_PLY

instead of

    tte->depth() >= depth - 3 * ONE_PLY

interacts badly with the absence of ttMove in iid. For the ttMove to become a singular
extension candidate, singularExtensionNode needs to be true. With the current master,
this requires that tte->depth() >= depth - 3 * ONE_PLY. This is not currently possible
if tte comes from IID, since the depth 'd' used for the IID search is always less than
depth - 4 * ONE_PLY for depth >= 8 * ONE_PLY (below depth 8 singularExtensionNode can
never be true anyway). However, with DU-jdto/Stockfish@251281a , this condition can be
met, and it is possible for singularExtensionNode to become true after IID. There are
then two mechanisms by which this patch can affect the search:

• If ttValue was VALUE_NONE prior to IID, the fact that this patch sets ttValue allows
  the 'ttValue != VALUE_NONE' condition of singularExtensionNode to be met.

• If ttValue wasn't VALUE_NONE prior to IID, the fact that this patch modifies ttValue's
  value causes a different 'rBeta' to be calculated if the singular extension search is
  performed.

Tested at STC for non-regression:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 76981 W: 17060 L: 17048 D: 42873
http://tests.stockfishchess.org/tests/view/5a7738b70ebc5902971a9868

No functional change
 2018-02-25 01:15:38 +01:00
DU-jdto 5d57bb467a Simplification: do razoring only for depth 1 
The razoring heuristic is quite a drastic pruning technique,
using a depth 0 search at internal nodes of the search tree
to estimate the true value of depth n nodes. This patch limits
this razoring to the case of internal nodes of depth 1.
Author: Jarrod Torriero (DU-jdto)

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 8043 W: 1865 L: 1716 D: 4462
http://tests.stockfishchess.org/tests/view/5a90a9290ebc590297cc86c1

LTC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 32890 W: 5577 L: 5476 D: 21837
http://tests.stockfishchess.org/tests/view/5a90c8510ebc590297cc86d5

Opportunities opened by this patch: it would be interesting to
know if it brings Elo to re-introduce razoring or soft razoring
at depth >= 2, maybe using a larger margin to compensate for the
increased pruning effect.

Bench: 5227124
 2018-02-24 13:12:04 +01:00
Tom Vijlbrief 9246e4a6f9 Lower razor depth to < 3 and adjust margin 
Various margins were tested: 600, 560, 585, 580, 590 and 595.

Only 590 (this patch) passed both STC and LTC.
Higher margins appear to be better for longer time controls.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 24496 W: 5470 L: 5210 D: 13816
http://tests.stockfishchess.org/tests/view/5a8c6d040ebc590297cc8508

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 74540 W: 12888 L: 12491 D: 49161
http://tests.stockfishchess.org/tests/view/5a8d14c70ebc590297cc8566

Bench: 5475941
 2018-02-23 22:13:11 +01:00
Marco Costalba a09eee5798 Reformat SEE to better document the function 
This is one of the most difficult to understand but also
most important and speed critical functions of SF.

This patch rewrites some part of it to hopefully
make it clearer and drop some redundant variables
in the process.

Same speed than master (or even a bit more).

Thanks to Chris Cain for useful feedback.

No functional change.
 2018-02-23 22:02:44 +01:00
Stéphane Nicolet 52f92d05a9 Move pawn_attacks_bb() helper to bitboard.h 
No functional change.
 2018-02-21 22:31:38 +01:00
Mike Whiteley 820c5c25b6 rename shift variables. 
Where variable names are explicitly incorrect, I feel morally obligated to at least
suggest an alternative. There are many, but these two are especially egregious.

No functional change.
 2018-02-21 21:47:04 +01:00
Alain SAVARD 6c898a10be Avoid a compilation warning 
Avoid a warning while compiling with gcc version 4.9.2

No functional change.
 2018-02-21 00:52:59 +01:00
Marco Costalba 67f5f54a29 Code style in evaluate.cpp 
Passed STC
LLR: 2.95 (-2.94,2.94) [-4.00,0.00]
Total: 75666 W: 16482 L: 16616 D: 42568
http://tests.stockfishchess.org/tests/view/5a8953af0ebc590297cc83ab

No functional change.
 2018-02-20 17:11:18 +01:00
Stéphane Nicolet b2b0013d11 Update list of authors after Stockfish 9 
No functional change.
 2018-02-18 01:51:35 +01:00
Mike Whiteley 80ea80e451 Simplify trapped rook 
As far as can tell, semiopenFiles are set if there is a pawn anywhere on
the file. The removed condition would be true even if the pawns were very
advanced, which doesn't make sense if we're looking for a trapped rook.
Seems the engine fairs better with this removed. My guess s that the
condition that mobility is 3 or less does this well enough.

Begs the question whether this is a mobility issue alone... not sure.
Should I do LTC test?

STC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 13377 W: 3009 L: 2871 D: 7497
http://tests.stockfishchess.org/tests/view/5a855be40ebc590297cc8166

Passed LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 16288 W: 2813 L: 2685 D: 10790
http://tests.stockfishchess.org/tests/view/5a8575a80ebc590297cc817e

Bench: 5006365
 2018-02-15 19:38:09 +01:00
Ronald de Man 860223c5e6 Fix gcc PGO build on Windows 
This fixes the issue #1375 of the PGO builds failing under Windows:
https://github.com/official-stockfish/Stockfish/issues/1375

Solution found during this discussion in the fishcooking forum:
https://groups.google.com/forum/?fromgroups=#!topic/fishcooking/RjIPgeFFLPQ

Closes #1408.

No functional change.
 2018-02-12 23:14:33 +01:00
Marco Costalba 4c57cf0ead Code style fixes in search.cpp 
Some code style triviality.

No functional change.
 2018-02-12 22:58:25 +01:00
Marco Costalba baab8be324 Update travis CI to g++7 
Use newer g++ 7 instead of 6 in travis CI tests.

No functional change.
 2018-02-12 22:42:39 +01:00
Stefano Cardanobile cb1324312d Introduce dynamic contempt 
Make contempt dependent on the current score of the root position.

The idea is that we now use a linear formula like the following to decide
on the contempt to use during a search :

    contempt = x + y * eval

where x is the base contempt set by the user in the "Contempt" UCI option,
and y * eval is the dynamic part which adapts itself to the estimation of
the evaluation of the root position returned by the search. In this patch,
we use x = 18 centipawns by default, and the y * eval correction can go
from -20 centipawns if the root eval is less than -2.0 pawns, up to +20
centipawns when the root eval is more than 2.0 pawns.

To summarize, the new contempt goes from -0.02 to 0.38 pawns, depending if
Stockfish is losing or winning, with an average value of 0.18 pawns by default.

STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 110052 W: 24614 L: 23938 D: 61500
http://tests.stockfishchess.org/tests/view/5a72e6020ebc590f2c86ea20

LTC:
LLR: 2.97 (-2.94,2.94) [0.00,5.00]
Total: 16470 W: 2896 L: 2705 D: 10869
http://tests.stockfishchess.org/tests/view/5a76c5b90ebc5902971a9830

A second match at LTC was organised against the current master:

ELO: 1.45 +-2.9 (95%) LOS: 84.0%
Total: 19369 W: 3350 L: 3269 D: 12750
http://tests.stockfishchess.org/tests/view/5a7acf980ebc5902971a9a2e

Finally, we checked that there is no apparent problem with multithreading,
despite the fact that some threads might have a slightly different contempt
level that the main thread.

Match of this version against master, both using 5 threads, time control 30+0.3:
ELO: 2.18 +-3.2 (95%) LOS: 90.8%
Total: 14840 W: 2502 L: 2409 D: 9929
http://tests.stockfishchess.org/tests/view/5a7bf3e80ebc5902971a9aa2

Include suggestions from Marco Costalba, Aram Tumanian, Ronald de Man, etc.

Bench: 5207156
 2018-02-09 19:07:19 +01:00
Leonid Pechenik d71adc5bd9 Retire "Extra thinking before accepting draw PVs" 
This patch simplifies the time management code, removing the extra
thinking time for moves with draw PV and increasing thinking time
for all moves proportionally by around 4%.

Last time when the time management was carefully tuned was 1.5-2 years
ago. As new patches were getting added, time management was drifting out
of optimum. This happens because when search becomes more precise pv and
score are becoming more stable, there are less fail lows, best move is
picked earlier and there are less best move changes. All this factors are
entering in time management, and average time per move is decreasing with
more and more good patches. For individual patches such effect is small
(except some) and may be up or down, but when there are many of them,
effect is more substantial. The same way benchmark with more and more
patches is slowly drifting down on average.

So my understanding that back in October adding more think time for draw
PV showed positive Elo because time management was not well tuned, there
was more time available, and think_hard patch applied this additional time
to moves with draw PV, while just retuning back to optimum would recover Elo
anyway. It is possible that absence of contempt also helped, as SF9 is showing
less 0.0 scores than the October version.

Anyway, to me it seems that proper place to deal with draw PV is search, and
contempt sounds as much better solution. In time management there is little
additional elo, and if some code is not helping like removed here, it is better
to discard it. It is simpler to find genuine improvement if code is clean.

• Passed STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 20487 W: 4558 L: 4434 D: 11495
http://tests.stockfishchess.org/tests/view/5a7706ec0ebc5902971a9854

• Passed LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 41960 W: 7145 L: 7058 D: 27757
http://tests.stockfishchess.org/tests/view/5a778c830ebc5902971a9895

• Passed an additional non-regression [-5..0] test at the time control
of 60sec for the game (sudden death) with disabled draw adjudication:
LLR: 2.95 (-2.94,2.94) [-5.00,0.00]
Total: 8438 W: 1675 L: 1586 D: 5177
http://tests.stockfishchess.org/tests/view/5a7c3d8d0ebc5902971a9ac0

• Passed an additional non-regression [-5..0] test at the time control
of 1sec+1sec per move with disabled draw adjudication:
LLR: 2.97 (-2.94,2.94) [-5.00,0.00]
Total: 27664 W: 5575 L: 5574 D: 16515
http://tests.stockfishchess.org/tests/view/5a7c3e820ebc5902971a9ac3

This is a functional change for the time management code.

Bench: 4983414
 2018-02-09 10:41:32 +01:00
Stéphane Nicolet 211ebc5c7a Fix bug for 'eval' command in terminal 
The 'eval' debugging command in Terminal did not initialize the Eval::Contempt
variable, leading to random output during debugging sessions (normal search
was unaffected by the bug).

Example of session where the two 'eval' commands should give the same output,
but did not:

./stockfish
position startpos
d
eval
go depth 20
d
eval

The bug is fixed by initializing Eval::Contempt to SCORE_ZERO in Eval::trace

No functional change.
 2018-02-09 01:12:08 +01:00
FauziAkram 917fe69f84 A combo of 3 successful tuning patches 
Shelter Weakness by Fauzi Akram Dabat
Threats by Alain Savard
Passed Pawns by Alain Savard

STC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 51378 W: 11592 L: 11223 D: 28563
http://tests.stockfishchess.org/tests/view/5a79e2fe0ebc5902971a99d1

LTC:
LLR: 2.95 (-2.94,2.94) [0.00,4.00]
Total: 21631 W: 3888 L: 3661 D: 14082
http://tests.stockfishchess.org/tests/view/5a7aefe80ebc5902971a9a39

Bench: 4983414
 2018-02-08 15:14:02 +01:00
protonspring 69067e1988 Obey skipQuiets strictly in MovePicker 
The current logic in master is to continue return quiet moves if their
history score is above 0. It appears as though this check can be
removed, which is also more logically consistent with the “skipQuiets”
semantics used in search.cpp.

This patch may open new opportunitiesto get Elo by changing or
tuning the definition of 'moveCountPruning' in line 830 of search.cpp,
because obeying skipQuiets without checking the history scores makes
the search more sensitive to 'moveCountPruning'.

STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 34780 W: 7680 L: 7584 D: 19516
http://tests.stockfishchess.org/tests/view/5a79f8d80ebc5902971a99db

LTC
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 38757 W: 6732 L: 6641 D: 25384
http://tests.stockfishchess.org/tests/view/5a7afebe0ebc5902971a9a46

Bench 4954595
 2018-02-08 10:46:27 +01:00
Joost VandeVondele 312a248fa9 More robust bench extraction 
Allow travis.yml to recognize a variety of bench formats in commit messages, for instance:

Bench: 5023593. (really).
bench: 5023593 (it was 1234567)
bench : 5023593 (blah blah)
Bench:5023593
Bench: 5023593. 567 something (1234567) 563

No functional change.
 2018-02-07 01:29:53 +01:00
syzygy1 ef61886332 Enable LTO for clang 
Enable link-time optimization in the Makefile when compiling with clang.
Also update travis.yml to use clang++-5.0 and llvm-5.0-dev.

No functional change.
 2018-02-06 00:46:50 +01:00
protonspring 414a3e6ee3 Don’t score and sort all captures in RECAPTURES stage. 
For these recaptures, we’re are only considering those captures
    that recapture the recapture square (small portion of all the
    captures). Therefore, scoring all of the captures and pick_besting
    out of the whole group is not necessary.

    STC
    LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
    Total: 85583 W: 18978 L: 18983 D: 47622
    http://tests.stockfishchess.org/tests/view/5a717faa0ebc590f2c86e9a7

    LTC
    LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
    Total: 20231 W: 3533 L: 3411 D: 13287
    http://tests.stockfishchess.org/tests/view/5a73ad330ebc5902971a96ba

    Bench: 5023593
 2018-02-05 17:27:59 +01:00
Stéphane Nicolet e316e432d0 Revert "Implement old 'multipv' search" 
This revert the following commit:
https://github.com/official-stockfish/Stockfish/commit/44a7db0f9ac02d2461aff39e25f1ac9107ffbfac

Bug report by Ronald de Man in issue:
https://github.com/official-stockfish/Stockfish/issues/1392

Bench: 5023629
 2018-02-04 21:42:56 +01:00
protonspring d93baae220 Simplify qsearch stages in MovePicker 
The difference between QCAPTURES_1 and QCAPTURES_2 quiescence search stages
boils down to a simple check of depth. The way it's being done now is
unnecessarily complex.

This patch is simpler, clearer, and easier to understand.

Passed SPRT[-3..1] test at STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 99755 W: 22158 L: 22192 D: 55405
http://tests.stockfishchess.org/tests/view/5a71f41c0ebc590f2c86e9cb

No functional change.
 2018-02-04 14:57:57 +01:00
joergoster 44a7db0f9a Implement 'old' multipv search. 
It seems to be a waste of time to loop through all remaining root moves
after finishing each PV line. This patch skips this until we have reached
the last PV line (this is the way it was done in Glaurung and very early
versions of Stockfish).

No functional change in Single PV mode.

MultiPV=3 STC and LTC tests
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 3113 W: 1248 L: 1064 D: 801

LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 2260 W: 848 L: 679 D: 733

Bench: 5023629
 2018-02-04 13:35:44 +01:00
Stéphane Nicolet 83c828f31e Restore development version 
No functional change.
 2018-02-04 02:08:09 +01:00
Stéphane Nicolet 0f6f42cd83 Improved spelling, grammar and comment 
Author: Ben Koshy

No functional change
 2018-02-04 00:13:56 +01:00
47 changed files with 3823 additions and 3557 deletions
Expand all files Collapse all files
.travis.yml
+14 -14
View File
@@ -1,6 +1,5 @@
language: cpp language: cpp
sudo: required dist: xenial
dist: trusty
matrix: matrix:
include: include:
@@ -9,20 +8,21 @@ matrix:
addons: addons:
apt: apt:
sources: ['ubuntu-toolchain-r-test'] sources: ['ubuntu-toolchain-r-test']
packages: ['g++-6', 'g++-6-multilib', 'g++-multilib', 'valgrind', 'expect'] packages: ['g++-8', 'g++-8-multilib', 'g++-multilib', 'valgrind', 'expect', 'curl']
env: env:
- COMPILER=g++-6 - COMPILER=g++-8
- COMP=gcc - COMP=gcc
- os: linux - os: linux
compiler: clang compiler: clang
addons: addons:
apt: apt:
sources: ['ubuntu-toolchain-r-test'] sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-xenial-6.0']
packages: ['clang', 'g++-multilib', 'valgrind', 'expect'] packages: ['clang-6.0', 'llvm-6.0-dev', 'g++-multilib', 'valgrind', 'expect', 'curl']
env: env:
- COMPILER=clang++ - COMPILER=clang++-6.0
- COMP=clang - COMP=clang
- LDFLAGS=-fuse-ld=lld
- os: osx - os: osx
compiler: gcc compiler: gcc
@@ -33,7 +33,7 @@ matrix:
- os: osx - os: osx
compiler: clang compiler: clang
env: env:
- COMPILER=clang++ V='Apple LLVM 6.0' # Apple LLVM version 6.0 (clang-600.0.54) (based on LLVM 3.5svn) - COMPILER=clang++ V='Apple LLVM 9.4.1' # Apple LLVM version 9.1.0 (clang-902.0.39.2)
- COMP=clang - COMP=clang
branches: branches:
@@ -45,7 +45,7 @@ before_script:
script: script:
# Obtain bench reference from git log # Obtain bench reference from git log
- git log HEAD | grep "\b[Bb]ench[ :]\+[0-9]\{7\}" | head -n 1 | sed "s/[^0-9]*\([0-9][0-9]*\)/\1/g" > git_sig - git log HEAD | grep "\b[Bb]ench[ :]\+[0-9]\{7\}" | head -n 1 | sed "s/[^0-9]*\([0-9]*\).*/\1/g" > git_sig
- export benchref=$(cat git_sig) - export benchref=$(cat git_sig)
- echo "Reference bench:" $benchref - echo "Reference bench:" $benchref
# #
@@ -54,7 +54,7 @@ script:
- make clean && make -j2 ARCH=x86-64 optimize=no debug=yes build && ../tests/signature.sh $benchref - make clean && make -j2 ARCH=x86-64 optimize=no debug=yes build && ../tests/signature.sh $benchref
- make clean && make -j2 ARCH=x86-32 optimize=no debug=yes build && ../tests/signature.sh $benchref - make clean && make -j2 ARCH=x86-32 optimize=no debug=yes build && ../tests/signature.sh $benchref
- make clean && make -j2 ARCH=x86-32 build && ../tests/signature.sh $benchref - make clean && make -j2 ARCH=x86-32 build && ../tests/signature.sh $benchref
- make clean && make -j2 ARCH=x86-64 build && ../tests/signature.sh $benchref
# #
# Check perft and reproducible search # Check perft and reproducible search
- ../tests/perft.sh - ../tests/perft.sh
@@ -62,12 +62,12 @@ script:
# #
# Valgrind # Valgrind
# #
- export CXXFLAGS=-O1 - export CXXFLAGS="-O1 -fno-inline"
- if [ -x "$(command -v valgrind )" ]; then make clean && make -j2 ARCH=x86-64 debug=yes optimize=no build > /dev/null && ../tests/instrumented.sh --valgrind; fi - if [ -x "$(command -v valgrind )" ]; then make clean && make -j2 ARCH=x86-64 debug=yes optimize=no build > /dev/null && ../tests/instrumented.sh --valgrind; fi
- if [ -x "$(command -v valgrind )" ]; then ../tests/instrumented.sh --valgrind-thread; fi - if [ -x "$(command -v valgrind )" ]; then ../tests/instrumented.sh --valgrind-thread; fi
# #
# Sanitizer # Sanitizer
# #
# Use g++-6 as a proxy for having sanitizers, might need revision as they become available for more recent versions of clang/gcc # Use g++-8 as a proxy for having sanitizers, might need revision as they become available for more recent versions of clang/gcc
- if [[ "$COMPILER" == "g++-6" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=undefined optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-undefined; fi - if [[ "$COMPILER" == "g++-8" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=undefined optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-undefined; fi
- if [[ "$COMPILER" == "g++-6" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=thread optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-thread; fi - if [[ "$COMPILER" == "g++-8" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=thread optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-thread; fi
AUTHORS
+145 -80
View File
@@ -1,98 +1,163 @@
# Generated with 'git shortlog -sn | cut -c8-', which sorts by commits, manually ordered the first four authors, merged duplicates # List of authors for Stockfish, as of January 7, 2020
Tord Romstad Tord Romstad (romstad)
Marco Costalba (mcostalba) Marco Costalba (mcostalba)
Joona Kiiski (zamar) Joona Kiiski (zamar)
Gary Linscott (glinscott) Gary Linscott (glinscott)
Lucas Braesch (lucasart)
Bill Henry (VoyagerOne) Aditya (absimaldata)
mstembera Adrian Petrescu (apetresc)
Stéphane Nicolet (Stephane Nicolet, snicolet) Ajith Chandy Jose (ajithcj)
Stefan Geschwentner Alain Savard (Rocky640)
Alain SAVARD (Rocky640) Alayan Feh (Alayan-stk-2)
Jörg Oster (Joerg Oster, joergoster)
Reuven Peleg
Chris Caino (Chris Cain, ceebo)
Jean-Francois Romang
homoSapiensSapiens
Leonid Pechenik
Stefano Cardanobile (Stefano80)
Arjun Temurnikar
Uri Blass (uriblass)
jundery
Ajith (ajithcj)
hxim
Ralph Stößer (Ralph Stoesser)
Guenther Demetz
Jonathan Calovski (Mysseno)
Tom Vijlbrief
mbootsector
Daylen Yang
ElbertoOne
Henri Wiechers
loco-loco
Joost VandeVondele (Joost Vandevondele)
Ronald de Man (syzygy)
DU-jdto
David Zar
Eelco de Groot
Jerry Donald
NicklasPersson
Ryan Schmitt
Alexander Kure Alexander Kure
Dan Schmidt Alexander Pagel (Lolligerhans)
H. Felix Wittmann Ali AlZhrani (Cooffe)
Jacques Andrew Grant (AndyGrant)
Joseph R. Prostko Andrey Neporada (nepal)
Justin Blanchard
Linus Arver
Luca Brivio
Lyudmil Antonov
Rodrigo Exterckötter Tjäder
Ron Britvich
RyanTaker
Vince Negri
erbsenzaehler
Joseph Hellis (jhellis3)
shane31
Andrew Grant
Andy Duplain Andy Duplain
Aram Tumanian (atumanian)
Arjun Temurnikar
Auguste Pop Auguste Pop
Balint Pfliegel Balint Pfliegel
Dariusz Orzechowski Ben Koshy (BKSpurgeon)
DiscanX Bill Henry (VoyagerOne)
Ernesto Gatti Bojun Guo (noobpwnftw, Nooby)
Gregor Cramer
Hiraoka Takuya (HiraokaTakuya)
Hongzhi Cheng
IIvec
Kelly Wilson
Ken T Takusagawa
Kojirion
Krgp
Matt Sullivan
Matthew Lai
Matthew Sullivan
Michel Van den Bergh
Niklas Fiekas
Oskar Werkelin Ahlin
Pablo Vazquez
Pascal Romaret
Raminder Singh
Richard Lloyd
Ryan Takker
Thanar2
absimaldata
atumanian
braich braich
Brian Sheppard (SapphireBrand, briansheppard-toast)
Bryan Cross (crossbr)
candirufish
Chess13234
Chris Cain (ceebo)
Dan Schmidt (dfannius)
Daniel Axtens (daxtens)
Daniel Dugovic (ddugovic)
Dariusz Orzechowski
David Zar
Daylen Yang (daylen)
DiscanX
double-beep
Eduardo Cáceres (eduherminio)
Eelco de Groot (KingDefender)
Elvin Liu (solarlight2)
erbsenzaehler
Ernesto Gatti
Fabian Beuke (madnight)
Fabian Fichter (ianfab)
fanon fanon
Fauzi Akram Dabat (FauziAkram)
Felix Wittmann
gamander gamander
gguliash gguliash
Gian-Carlo Pascutto (gcp)
Gontran Lemaire (gonlem)
Goodkov Vasiliy Aleksandrovich (goodkov)
Gregor Cramer
GuardianRM
Günther Demetz (pb00067, pb00068)
Guy Vreuls (gvreuls)
Henri Wiechers
Hiraoka Takuya (HiraokaTakuya)
homoSapiensSapiens
Hongzhi Cheng
Ivan Ivec (IIvec)
Jacques B. (Timshel)
Jan Ondruš (hxim)
Jared Kish (Kurtbusch)
Jarrod Torriero (DU-jdto)
Jean Gauthier (OuaisBla)
Jean-Francois Romang (jromang)
Jekaa
Jerry Donald Watson (jerrydonaldwatson)
Jonathan Calovski (Mysseno)
Jonathan Dumale (SFisGOD)
Joost VandeVondele (vondele)
Jörg Oster (joergoster)
Joseph Ellis (jhellis3)
Joseph R. Prostko
jundery
Justin Blanchard (UncombedCoconut)
Kelly Wilson
Ken Takusagawa
kinderchocolate kinderchocolate
Kiran Panditrao (Krgp)
Kojirion
Leonardo Ljubičić (ICCF World Champion)
Leonid Pechenik (lp--)
Linus Arver (listx)
loco-loco
Lub van den Berg (ElbertoOne)
Luca Brivio (lucabrivio)
Lucas Braesch (lucasart)
Lyudmil Antonov (lantonov)
Maciej Żenczykowski (zenczykowski)
Malcolm Campbell (xoto10)
Mark Tenzer (31m059)
marotear
Matthew Lai (matthewlai)
Matthew Sullivan (Matt14916)
Michael An (man)
Michael Byrne (MichaelB7)
Michael Chaly (Vizvezdenec)
Michael Stembera (mstembera)
Michael Whiteley (protonspring)
Michel Van den Bergh (vdbergh)
Miguel Lahoz (miguel-l)
Mikael Bäckman (mbootsector)
Mira
Miroslav Fontán (Hexik)
Moez Jellouli (MJZ1977)
Mohammed Li (tthsqe12)
Nathan Rugg (nmrugg)
Nick Pelling (nickpelling)
Nicklas Persson (NicklasPersson)
Niklas Fiekas (niklasf)
Nikolay Kostov (NikolayIT)
Ondrej Mosnáček (WOnder93)
Oskar Werkelin Ahlin
Pablo Vazquez
Panthee
Pascal Romaret
Pasquale Pigazzini (ppigazzini)
Patrick Jansen (mibere)
pellanda pellanda
ppigazzini Peter Zsifkovits (CoffeeOne)
Ralph Stößer (Ralph Stoesser)
Raminder Singh
renouve renouve
Reuven Peleg
Richard Lloyd
Rodrigo Exterckötter Tjäder
Ron Britvich (Britvich)
Ronald de Man (syzygy1, syzygy)
Ryan Schmitt
Ryan Takker
Sami Kiminki (skiminki)
Sebastian Buchwald (UniQP)
Sergei Antonov (saproj)
Sergei Ivanov (svivanov72)
sf-x sf-x
Shane Booth (shane31)
Stefan Geschwentner (locutus2)
Stefano Cardanobile (Stefano80)
Steinar Gunderson (sesse)
Stéphane Nicolet (snicolet)
Thanar2
thaspel thaspel
unknown theo77186
Tom Truscott
Tom Vijlbrief (tomtor)
Torsten Franz (torfranz, tfranzer)
Tracey Emery (basepr1me)
Uri Blass (uriblass)
Vince Negri (cuddlestmonkey)
# Additionally, we acknowledge the authors and maintainers of fishtest,
# an amazing and essential framework for the development of Stockfish!
#
# https://github.com/glinscott/fishtest/blob/master/AUTHORS
Readme.md
+135 -48
View File
@@ -1,66 +1,123 @@
### Overview ## Overview
[![Build Status](https://travis-ci.org/official-stockfish/Stockfish.svg?branch=master)](https://travis-ci.org/official-stockfish/Stockfish) [![Build Status](https://travis-ci.org/official-stockfish/Stockfish.svg?branch=master)](https://travis-ci.org/official-stockfish/Stockfish)
[![Build Status](https://ci.appveyor.com/api/projects/status/github/official-stockfish/Stockfish?svg=true)](https://ci.appveyor.com/project/mcostalba/stockfish) [![Build Status](https://ci.appveyor.com/api/projects/status/github/official-stockfish/Stockfish?branch=master&svg=true)](https://ci.appveyor.com/project/mcostalba/stockfish/branch/master)
Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is [Stockfish](https://stockfishchess.org) is a free, powerful UCI chess engine
not a complete chess program and requires some UCI-compatible GUI derived from Glaurung 2.1. It is not a complete chess program and requires a
(e.g. XBoard with PolyGlot, eboard, Arena, Sigma Chess, Shredder, Chess UCI-compatible GUI (e.g. XBoard with PolyGlot, Scid, Cute Chess, eboard, Arena,
Partner or Fritz) in order to be used comfortably. Read the Sigma Chess, Shredder, Chess Partner or Fritz) in order to be used comfortably.
documentation for your GUI of choice for information about how to use Read the documentation for your GUI of choice for information about how to use
Stockfish with it. Stockfish with it.
This version of Stockfish supports up to 512 cores. The engine defaults
to one search thread, so it is therefore recommended to inspect the value of
the *Threads* UCI parameter, and to make sure it equals the number of CPU
cores on your computer.
This version of Stockfish has support for Syzygybases. ## Files
### Files
This distribution of Stockfish consists of the following files: This distribution of Stockfish consists of the following files:
* Readme.md, the file you are currently reading. * Readme.md, the file you are currently reading.
* Copying.txt, a text file containing the GNU General Public License. * Copying.txt, a text file containing the GNU General Public License version 3.
* src, a subdirectory containing the full source code, including a Makefile * src, a subdirectory containing the full source code, including a Makefile
that can be used to compile Stockfish on Unix-like systems. that can be used to compile Stockfish on Unix-like systems.
### Syzygybases ## UCI parameters
**Configuration** Currently, Stockfish has the following UCI options:
Syzygybases are configured using the UCI options "SyzygyPath", * #### Debug Log File
"SyzygyProbeDepth", "Syzygy50MoveRule" and "SyzygyProbeLimit". Write all communication to and from the engine into a text file.
The option "SyzygyPath" should be set to the directory or directories that * #### Contempt
contain the .rtbw and .rtbz files. Multiple directories should be A positive value for contempt favors middle game positions and avoids draws.
separated by ";" on Windows and by ":" on Unix-based operating systems.
**Do not use spaces around the ";" or ":".**
Example: `C:\tablebases\wdl345;C:\tablebases\wdl6;D:\tablebases\dtz345;D:\tablebases\dtz6` * #### Analysis Contempt
By default, contempt is set to prefer the side to move. Set this option to "White"
or "Black" to analyse with contempt for that side, or "Off" to disable contempt.
It is recommended to store .rtbw files on an SSD. There is no loss in * #### Threads
storing the .rtbz files on a regular HD. The number of CPU threads used for searching a position. For best performance, set
this equal to the number of CPU cores available.
Increasing the "SyzygyProbeDepth" option lets the engine probe less * #### Hash
aggressively. Set this option to a higher value if you experience too much The size of the hash table in MB.
slowdown (in terms of nps) due to TB probing.
Set the "Syzygy50MoveRule" option to false if you want tablebase positions * #### Clear Hash
that are drawn by the 50-move rule to count as win or loss. This may be useful Clear the hash table.
for correspondence games (because of tablebase adjudication).
The "SyzygyProbeLimit" option should normally be left at its default value. * #### Ponder
Let Stockfish ponder its next move while the opponent is thinking.
* #### MultiPV
Output the N best lines (principal variations, PVs) when searching.
Leave at 1 for best performance.
* #### Skill Level
Lower the Skill Level in order to make Stockfish play weaker (see also UCI_LimitStrength).
Internally, MultiPV is enabled, and with a certain probability depending on the Skill Level a
weaker move will be played.
* #### UCI_LimitStrength
Enable weaker play aiming for an Elo rating as set by UCI_Elo. This option overrides Skill Level.
* #### UCI_Elo
If enabled by UCI_LimitStrength, aim for an engine strength of the given Elo.
This Elo rating has been calibrated at a time control of 60s+0.6s and anchored to CCRL 40/4.
* #### Move Overhead
Assume a time delay of x ms due to network and GUI overheads. This is useful to
avoid losses on time in those cases.
* #### Minimum Thinking Time
Search for at least x ms per move.
* #### Slow Mover
Lower values will make Stockfish take less time in games, higher values will
make it think longer.
* #### nodestime
Tells the engine to use nodes searched instead of wall time to account for
elapsed time. Useful for engine testing.
* #### UCI_Chess960
An option handled by your GUI. If true, Stockfish will play Chess960.
* #### UCI_AnalyseMode
An option handled by your GUI.
* #### SyzygyPath
Path to the folders/directories storing the Syzygy tablebase files. Multiple
directories are to be separated by ";" on Windows and by ":" on Unix-based
operating systems. Do not use spaces around the ";" or ":".
Example: `C:\tablebases\wdl345;C:\tablebases\wdl6;D:\tablebases\dtz345;D:\tablebases\dtz6`
It is recommended to store .rtbw files on an SSD. There is no loss in storing
the .rtbz files on a regular HD. It is recommended to verify all md5 checksums
of the downloaded tablebase files (`md5sum -c checksum.md5`) as corruption will
lead to engine crashes.
* #### SyzygyProbeDepth
Minimum remaining search depth for which a position is probed. Set this option
to a higher value to probe less agressively if you experience too much slowdown
(in terms of nps) due to TB probing.
* #### Syzygy50MoveRule
Disable to let fifty-move rule draws detected by Syzygy tablebase probes count
as wins or losses. This is useful for ICCF correspondence games.
* #### SyzygyProbeLimit
Limit Syzygy tablebase probing to positions with at most this many pieces left
(including kings and pawns).
## What to expect from Syzygybases?
**What to expect**
If the engine is searching a position that is not in the tablebases (e.g. If the engine is searching a position that is not in the tablebases (e.g.
a position with 7 pieces), it will access the tablebases during the search. a position with 8 pieces), it will access the tablebases during the search.
If the engine reports a very large score (typically 123.xx), this means If the engine reports a very large score (typically 153.xx), this means
that it has found a winning line into a tablebase position. that it has found a winning line into a tablebase position.
If the engine is given a position to search that is in the tablebases, it If the engine is given a position to search that is in the tablebases, it
@@ -71,7 +128,7 @@ It will then perform a search only on those moves. **The engine will not move
immediately**, unless there is only a single good move. **The engine likely immediately**, unless there is only a single good move. **The engine likely
will not report a mate score even if the position is known to be won.** will not report a mate score even if the position is known to be won.**
It is therefore clear that behaviour is not identical to what one might It is therefore clear that this behaviour is not identical to what one might
be used to with Nalimov tablebases. There are technical reasons for this be used to with Nalimov tablebases. There are technical reasons for this
difference, the main technical reason being that Nalimov tablebases use the difference, the main technical reason being that Nalimov tablebases use the
DTM metric (distance-to-mate), while Syzygybases use a variation of the DTM metric (distance-to-mate), while Syzygybases use a variation of the
@@ -82,7 +139,7 @@ needed for optimal play and in addition being able to take into account
the 50-move rule. the 50-move rule.
### Compiling it yourself ## Compiling Stockfish yourself from the sources
On Unix-like systems, it should be possible to compile Stockfish On Unix-like systems, it should be possible to compile Stockfish
directly from the source code with the included Makefile. directly from the source code with the included Makefile.
@@ -96,19 +153,49 @@ compile (for instance with Microsoft MSVC) you need to manually
set/unset some switches in the compiler command line; see file *types.h* set/unset some switches in the compiler command line; see file *types.h*
for a quick reference. for a quick reference.
### Resource For Understanding the Code Base When reporting an issue or a bug, please tell us which version and
compiler you used to create your executable. These informations can
be found by typing the following commands in a console:
* [Chessprogramingwiki](https://chessprogramming.wikispaces.com) has good overall chess engines explanations ```
(techniques used here are well explained like hash maps etc), it was ./stockfish
also recommended by the [support at stockfish.](http://support.stockfishchess.org/discussions/questions/1132-how-to-understand-stockfish-sources) compiler
```
* [Here](https://chessprogramming.wikispaces.com/Stockfish) you can find a set of features and techniques used by stockfish and each of them is explained at the wiki, however, it's a generic way rather than focusing on stockfish's own implementation, but it will still help you. ## Understanding the code base and participating in the project
Stockfish's improvement over the last couple of years has been a great
community effort. There are a few ways to help contribute to its growth.
### Donating hardware
Improving Stockfish requires a massive amount of testing. You can donate
your hardware resources by installing the [Fishtest Worker](https://github.com/glinscott/fishtest/wiki/Running-the-worker:-overview)
and view the current tests on [Fishtest](https://tests.stockfishchess.org/tests).
### Improving the code
If you want to help improve the code, there are several valuable resources:
* [In this wiki,](https://www.chessprogramming.org) many techniques used in
Stockfish are explained with a lot of background information.
* [The section on Stockfish](https://www.chessprogramming.org/Stockfish)
describes many features and techniques used by Stockfish. However, it is
generic rather than being focused on Stockfish's precise implementation.
Nevertheless, a helpful resource.
* The latest source can always be found on [GitHub](https://github.com/official-stockfish/Stockfish).
Discussions about Stockfish take place in the [FishCooking](https://groups.google.com/forum/#!forum/fishcooking)
group and engine testing is done on [Fishtest](https://tests.stockfishchess.org/tests).
If you want to help improve Stockfish, please read this [guideline](https://github.com/glinscott/fishtest/wiki/Creating-my-first-test)
first, where the basics of Stockfish development are explained.
### Terms of use ## Terms of use
Stockfish is free, and distributed under the **GNU General Public License** Stockfish is free, and distributed under the **GNU General Public License version 3**
(GPL). Essentially, this means that you are free to do almost exactly (GPL v3). Essentially, this means that you are free to do almost exactly
what you want with the program, including distributing it among your what you want with the program, including distributing it among your
friends, making it available for download from your web site, selling friends, making it available for download from your web site, selling
it (either by itself or as part of some bigger software package), or it (either by itself or as part of some bigger software package), or
@@ -119,5 +206,5 @@ 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 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. 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 For full details, read the copy of the GPL v3 found in the file named
*Copying.txt*. *Copying.txt*.
Top CPU Contributors.txt
+152 -130
View File
@@ -1,132 +1,154 @@
Contributors with >10,000 CPU hours as of January 23, 2018 Contributors with >10,000 CPU hours as of January 7, 2020
Thank you! Thank you!
Username CPU Hours Games played Username CPU Hours Games played
mibere 518300 41835669 --------------------------------------------------
crunchy 375564 29121434 noobpwnftw 9305707 695548021
cw 371664 28748719 mlang 780050 61648867
fastgm 299773 20765374 dew 621626 43921547
JojoM 220590 15299913 mibere 524702 42238645
glinscott 204517 13932027 crunchy 354587 27344275
bking_US 187568 12233168 cw 354495 27274181
ctoks 169342 13475495 fastgm 332801 22804359
spams 149531 10940322 JojoM 295750 20437451
Thanar 137015 11714855 CSU_Dynasty 262015 21828122
velislav 127305 10047749 Fisherman 232181 18939229
vdbergh 121741 9056874 ctoks 218866 17622052
malala 117291 8126488 glinscott 201989 13780820
vdv 117218 8289983 tvijlbrief 201204 15337115
leszek 114825 8331897 velislav 188630 14348485
dsmith 114010 7622414 gvreuls 187164 15149976
CSU_Dynasty 113516 9582758 bking_US 180289 11876016
sqrt2 112407 8782694 nordlandia 172076 13467830
marrco 111143 8222921 leszek 157152 11443978
drabel 108168 9061580 Thanar 148021 12365359
BrunoBanani 104938 7448565 spams 141975 10319326
Data 94621 8433010 drabel 138073 11121749
CoffeeOne 90394 3964243 vdv 137850 9394330
BRAVONE 80811 5341681 mgrabiak 133578 10454324
psk 77195 6156031 TueRens 132485 10878471
brabos 70284 5685893 bcross 129683 11557084
Fisherman 66650 5572406 marrco 126078 9356740
nssy 64587 5369140 sqrt2 125830 9724586
Pking_cda 64499 5704075 robal 122873 9593418
sterni1971 63488 5070004 vdbergh 120766 8926915
mgrabiak 62385 5420812 malala 115926 8002293
tvijlbrief 58957 4154234 CoffeeOne 114241 5004100
jromang 58854 4704502 dsmith 113189 7570238
dv8silencer 57421 3961325 BrunoBanani 104644 7436849
sunu 56620 4609155 Data 92328 8220352
tinker 56039 4204914 mhoram 89333 6695109
biffhero 55743 4810039 davar 87924 7009424
teddybaer 52982 4740444 xoto 81094 6869316
bcross 50548 5071599 ElbertoOne 80899 7023771
renouve 50318 3544864 grandphish2 78067 6160199
Freja 50296 3805120 brabos 77212 6186135
robnjr 47504 4131742 psk 75733 5984901
eva42 46542 4044694 BRAVONE 73875 5054681
davar 46538 4030604 sunu 70771 5597972
finfish 46244 3481661 sterni1971 70605 5590573
rap 46201 3219490 MaZePallas 66886 5188978
ttruscott 45037 3645430 Vizvezdenec 63708 4967313
solarlight 44155 4074841 nssy 63462 5259388
TueRens 41372 3891510 jromang 61634 4940891
ElbertoOne 41321 3920894 teddybaer 61231 5407666
Antihistamine 39218 2792761 Pking_cda 60099 5293873
mhunt 38991 2697512 solarlight 57469 5028306
bigpen0r 37820 3149955 dv8silencer 56913 3883992
homyur 35569 3009637 tinker 54936 4086118
VoyagerOne 35137 3302650 renouve 49732 3501516
mhoram 34770 2684128 Freja 49543 3733019
racerschmacer 33022 3231055 robnjr 46972 4053117
speedycpu 32043 2531964 rap 46563 3219146
EthanOConnor 31638 2143255 Bobo1239 46036 3817196
oryx 29574 2767730 ttruscott 45304 3649765
Pyafue 28885 1986098 racerschmacer 44881 3975413
jkiiski 28014 1923255 finfish 44764 3370515
Garf 27579 2770144 eva42 41783 3599691
slakovv 27017 2031279 biffhero 40263 3111352
Bobo1239 27000 2488707 bigpen0r 39817 3291647
pb00067 26817 2306694 mhunt 38871 2691355
robal 26337 2316795 ronaldjerum 38820 3240695
hyperbolic.tom 26248 2200777 Antihistamine 38785 2761312
rkl 24898 2236013 pb00067 38038 3086320
SC 23988 2126825 speedycpu 37591 3003273
nabildanial 23524 1586321 rkl 37207 3289580
achambord 23495 1942546 VoyagerOne 37050 3441673
Sharaf_DG 22975 1790697 jbwiebe 35320 2805433
chriswk 22876 1947731 cuistot 34191 2146279
anst 22568 2013953 homyur 33927 2850481
Patrick_G 22435 1682293 manap 32873 2327384
cuistot 22201 1383031 gri 32538 2515779
gri 21901 1820968 oryx 31267 2899051
Prcuvu 21182 1890546 EthanOConnor 30959 2090311
Zirie 21171 1493227 SC 30832 2730764
JanErik 20596 1791991 csnodgrass 29505 2688994
Isidor 20560 1730290 jmdana 29458 2205261
xor12 20535 1819280 strelock 28219 2067805
team-oh 20364 1653708 jkiiski 27832 1904470
nesoneg 20264 1493435 Pyafue 27533 1902349
rstoesser 19802 1335177 Garf 27515 2747562
grandphish2 19402 1834196 eastorwest 27421 2317535
sg4032 18427 1671742 slakovv 26903 2021889
dew 18263 1423326 Prcuvu 24835 2170122
ianh2105 18133 1668562 anst 24714 2190091
MazeOfGalious 18022 1644593 hyperbolic.tom 24319 2017394
ville 17900 1539130 Patrick_G 23687 1801617
j3corre 17607 975954 Sharaf_DG 22896 1786697
eudhan 17502 1424648 nabildanial 22195 1519409
iisiraider 17175 1118788 chriswk 21931 1868317
jundery 17172 1115855 achambord 21665 1767323
SFTUser 16635 1363975 Zirie 20887 1472937
purplefishies 16621 1106850 team-oh 20217 1636708
DragonLord 16599 1252348 Isidor 20096 1680691
chris 15274 1575333 ncfish1 19931 1520927
xoto 14900 1486261 nesoneg 19875 1463031
dju 14861 901552 Spprtr 19853 1548165
dex 14647 1228763 JanErik 19849 1703875
nordlandia 14551 1369718 agg177 19478 1395014
ronaldjerum 14361 1210607 SFTUser 19231 1567999
OssumOpossum 14149 1029265 xor12 19017 1680165
IgorLeMasson 13844 1228391 sg4032 18431 1641865
enedene 13762 935618 rstoesser 18118 1293588
ako027ako 13442 1250249 MazeOfGalious 17917 1629593
AdrianSA 13324 924980 j3corre 17743 941444
bpfliegel 13318 886523 cisco2015 17725 1690126
ncfish1 13056 932344 ianh2105 17706 1632562
wei 12863 1369596 dex 17678 1467203
jpulman 12776 854815 jundery 17194 1115855
horst.prack 12436 1151505 iisiraider 17019 1101015
joster 12424 986622 horst.prack 17012 1465656
cisco2015 12265 1205019 Adrian.Schmidt123 16563 1281436
fatmurphy 12015 901134 purplefishies 16342 1092533
modolief 11228 926456 wei 16274 1745989
Dark_wizzie 11214 1017910 ville 16144 1384026
mschmidt 10973 818594 eudhan 15712 1283717
eastorwest 10970 1117836 OuaisBla 15581 972000
infinity 10762 746397 DragonLord 15559 1162790
SapphireBrand 10692 1024604 dju 14716 875569
Thomas A. 10553 736094 chris 14479 1487385
pgontarz 10294 878746 0xB00B1ES 14079 1001120
Andrew Grant 10195 922933 OssumOpossum 13776 1007129
stocky 10083 718114 enedene 13460 905279
bpfliegel 13346 884523
Ente 13198 1156722
IgorLeMasson 13087 1147232
jpulman 13000 870599
ako027ako 12775 1173203
Nikolay.IT 12352 1068349
Andrew Grant 12327 895539
joster 12008 950160
AdrianSA 11996 804972
Nesa92 11455 1111993
fatmurphy 11345 853210
Dark_wizzie 11108 1007152
modolief 10869 896470
mschmidt 10757 803401
infinity 10594 727027
mabichito 10524 749391
Thomas A. Anderson 10474 732094
thijsk 10431 719357
Flopzee 10339 894821
crocogoat 10104 1013854
SapphireBrand 10104 969604
stocky 10017 699440
appveyor.yml
+3 -3
View File
@@ -7,7 +7,7 @@ branches:
- appveyor - appveyor
# Operating system (build VM template) # Operating system (build VM template)
os: Visual Studio 2015 os: Visual Studio 2017
# Build platform, i.e. x86, x64, AnyCPU. This setting is optional. # Build platform, i.e. x86, x64, AnyCPU. This setting is optional.
platform: platform:
@@ -51,7 +51,7 @@ before_build:
$b = git log HEAD | sls "\b[Bb]ench[ :]+[0-9]{7}" | select -first 1 $b = git log HEAD | sls "\b[Bb]ench[ :]+[0-9]{7}" | select -first 1
$bench = $b -match '\D+(\d+)' | % { $matches[1] } $bench = $b -match '\D+(\d+)' | % { $matches[1] }
Write-Host "Reference bench:" $bench Write-Host "Reference bench:" $bench
$g = "Visual Studio 14 2015" $g = "Visual Studio 15 2017"
If (${env:PLATFORM} -eq 'x64') { $g = $g + ' Win64' } If (${env:PLATFORM} -eq 'x64') { $g = $g + ' Win64' }
cmake -G "${g}" . cmake -G "${g}" .
Write-Host "Generated files for: " $g Write-Host "Generated files for: " $g
@@ -61,9 +61,9 @@ build_script:
before_test: before_test:
- cd src/%CONFIGURATION% - cd src/%CONFIGURATION%
- stockfish bench 2> out.txt >NUL
- ps: | - ps: |
# Verify bench number # Verify bench number
./stockfish bench 2> out.txt 1> null
$s = (gc "./out.txt" | out-string) $s = (gc "./out.txt" | out-string)
$r = ($s -match 'Nodes searched \D+(\d+)' | % { $matches[1] }) $r = ($s -match 'Nodes searched \D+(\d+)' | % { $matches[1] })
Write-Host "Engine bench:" $r Write-Host "Engine bench:" $r
src/Makefile
+40 -58
View File
@@ -1,7 +1,7 @@
# Stockfish, a UCI chess playing engine derived from Glaurung 2.1 # Stockfish, a UCI chess playing engine derived from Glaurung 2.1
# Copyright (C) 2004-2008 Tord Romstad (Glaurung author) # Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
# Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad # Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
# Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad # Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
# #
# Stockfish is free software: you can redistribute it and/or modify # Stockfish is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by # it under the terms of the GNU General Public License as published by
@@ -21,14 +21,12 @@
### Section 1. General Configuration ### Section 1. General Configuration
### ========================================================================== ### ==========================================================================
### Establish the operating system name
KERNEL = $(shell uname -s)
ifeq ($(KERNEL),Linux)
OS = $(shell uname -o)
endif
### Executable name ### Executable name
ifeq ($(COMP),mingw)
EXE = stockfish.exe
else
EXE = stockfish EXE = stockfish
endif
### Installation dir definitions ### Installation dir definitions
PREFIX = /usr/local PREFIX = /usr/local
@@ -42,6 +40,12 @@ OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \
material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \ material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \
search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o
### Establish the operating system name
KERNEL = $(shell uname -s)
ifeq ($(KERNEL),Linux)
OS = $(shell uname -o)
endif
### ========================================================================== ### ==========================================================================
### Section 2. High-level Configuration ### Section 2. High-level Configuration
### ========================================================================== ### ==========================================================================
@@ -132,6 +136,8 @@ endif
ifeq ($(ARCH),ppc-64) ifeq ($(ARCH),ppc-64)
arch = ppc64 arch = ppc64
bits = 64 bits = 64
popcnt = yes
prefetch = yes
endif endif
@@ -204,11 +210,12 @@ ifeq ($(COMP),clang)
comp=clang comp=clang
CXX=clang++ CXX=clang++
CXXFLAGS += -pedantic -Wextra -Wshadow CXXFLAGS += -pedantic -Wextra -Wshadow
ifneq ($(KERNEL),Darwin)
ifneq ($(KERNEL),OpenBSD) ifneq ($(KERNEL),Darwin)
LDFLAGS += -latomic ifneq ($(KERNEL),OpenBSD)
endif LDFLAGS += -latomic
endif endif
endif
ifeq ($(ARCH),armv7) ifeq ($(ARCH),armv7)
ifeq ($(OS),Android) ifeq ($(OS),Android)
@@ -279,39 +286,16 @@ ifeq ($(optimize),yes)
CXXFLAGS += -O3 CXXFLAGS += -O3
ifeq ($(comp),gcc) ifeq ($(comp),gcc)
ifeq ($(KERNEL),Darwin)
ifeq ($(arch),i386)
CXXFLAGS += -mdynamic-no-pic
endif
ifeq ($(arch),x86_64)
CXXFLAGS += -mdynamic-no-pic
endif
endif
ifeq ($(OS), Android) ifeq ($(OS), Android)
CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp
endif endif
endif endif
ifeq ($(comp),icc) ifeq ($(comp),$(filter $(comp),gcc clang icc))
ifeq ($(KERNEL),Darwin) ifeq ($(KERNEL),Darwin)
CXXFLAGS += -mdynamic-no-pic CXXFLAGS += -mdynamic-no-pic
endif endif
endif endif
ifeq ($(comp),clang)
ifeq ($(KERNEL),Darwin)
CXXFLAGS += -flto
LDFLAGS += $(CXXFLAGS)
ifeq ($(arch),i386)
CXXFLAGS += -mdynamic-no-pic
endif
ifeq ($(arch),x86_64)
CXXFLAGS += -mdynamic-no-pic
endif
endif
endif
endif endif
### 3.4 Bits ### 3.4 Bits
@@ -331,7 +315,9 @@ endif
### 3.6 popcnt ### 3.6 popcnt
ifeq ($(popcnt),yes) ifeq ($(popcnt),yes)
ifeq ($(comp),icc) ifeq ($(arch),ppc64)
CXXFLAGS += -DUSE_POPCNT
else ifeq ($(comp),icc)
CXXFLAGS += -msse3 -DUSE_POPCNT CXXFLAGS += -msse3 -DUSE_POPCNT
else else
CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT
@@ -342,31 +328,27 @@ endif
ifeq ($(pext),yes) ifeq ($(pext),yes)
CXXFLAGS += -DUSE_PEXT CXXFLAGS += -DUSE_PEXT
ifeq ($(comp),$(filter $(comp),gcc clang mingw)) ifeq ($(comp),$(filter $(comp),gcc clang mingw))
CXXFLAGS += -mbmi2 CXXFLAGS += -msse4 -mbmi2
endif endif
endif endif
### 3.8 Link Time Optimization, it works since gcc 4.5 but not on mingw under Windows. ### 3.8 Link Time Optimization, it works since gcc 4.5 but not on mingw under Windows.
### This is a mix of compile and link time options because the lto link phase ### This is a mix of compile and link time options because the lto link phase
### needs access to the optimization flags. ### needs access to the optimization flags.
ifeq ($(comp),gcc) ifeq ($(optimize),yes)
ifeq ($(optimize),yes) ifeq ($(debug), no)
ifeq ($(debug),no) ifeq ($(comp),$(filter $(comp),gcc clang))
CXXFLAGS += -flto
LDFLAGS += $(CXXFLAGS)
endif
ifeq ($(comp),mingw)
ifeq ($(KERNEL),Linux)
CXXFLAGS += -flto CXXFLAGS += -flto
LDFLAGS += $(CXXFLAGS) LDFLAGS += $(CXXFLAGS)
endif endif
endif endif
endif endif
ifeq ($(comp),mingw)
ifeq ($(KERNEL),Linux)
ifeq ($(optimize),yes)
ifeq ($(debug),no)
CXXFLAGS += -flto
LDFLAGS += $(CXXFLAGS)
endif
endif
endif
endif endif
### 3.9 Android 5 can only run position independent executables. Note that this ### 3.9 Android 5 can only run position independent executables. Note that this
@@ -397,10 +379,10 @@ help:
@echo "" @echo ""
@echo "Supported archs:" @echo "Supported archs:"
@echo "" @echo ""
@echo "x86-64 > x86 64-bit" @echo "x86-64-bmi2 > x86 64-bit with pext support (also enables SSE4)"
@echo "x86-64-modern > x86 64-bit with popcnt support" @echo "x86-64-modern > x86 64-bit with popcnt support (also enables SSE3)"
@echo "x86-64-bmi2 > x86 64-bit with pext support" @echo "x86-64 > x86 64-bit generic"
@echo "x86-32 > x86 32-bit with SSE support" @echo "x86-32 > x86 32-bit (also enables SSE)"
@echo "x86-32-old > x86 32-bit fall back for old hardware" @echo "x86-32-old > x86 32-bit fall back for old hardware"
@echo "ppc-64 > PPC 64-bit" @echo "ppc-64 > PPC 64-bit"
@echo "ppc-32 > PPC 32-bit" @echo "ppc-32 > PPC 32-bit"
@@ -423,7 +405,7 @@ help:
@echo "Advanced examples, for experienced users: " @echo "Advanced examples, for experienced users: "
@echo "" @echo ""
@echo "make build ARCH=x86-64 COMP=clang" @echo "make build ARCH=x86-64 COMP=clang"
@echo "make profile-build ARCH=x86-64-modern COMP=gcc COMPCXX=g++-4.8" @echo "make profile-build ARCH=x86-64-bmi2 COMP=gcc COMPCXX=g++-4.8"
@echo "" @echo ""
@@ -463,7 +445,7 @@ clean: objclean profileclean
# clean binaries and objects # clean binaries and objects
objclean: objclean:
@rm -f $(EXE) $(EXE).exe *.o ./syzygy/*.o @rm -f $(EXE) *.o ./syzygy/*.o
# clean auxiliary profiling files # clean auxiliary profiling files
profileclean: profileclean:
@@ -503,7 +485,7 @@ config-sanity:
@echo "Testing config sanity. If this fails, try 'make help' ..." @echo "Testing config sanity. If this fails, try 'make help' ..."
@echo "" @echo ""
@test "$(debug)" = "yes" || test "$(debug)" = "no" @test "$(debug)" = "yes" || test "$(debug)" = "no"
@test "$(sanitize)" = "undefined" || test "$(sanitize)" = "thread" || test "$(sanitize)" = "no" @test "$(sanitize)" = "undefined" || test "$(sanitize)" = "thread" || test "$(sanitize)" = "address" || test "$(sanitize)" = "no"
@test "$(optimize)" = "yes" || test "$(optimize)" = "no" @test "$(optimize)" = "yes" || test "$(optimize)" = "no"
@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \ @test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7" test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7"
src/benchmark.cpp
+7 -3
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -61,6 +61,10 @@ const vector<string> Defaults = {
"1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1", "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1",
"6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1", "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1",
"8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1", "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1",
"5rk1/q6p/2p3bR/1pPp1rP1/1P1Pp3/P3B1Q1/1K3P2/R7 w - - 93 90",
"4rrk1/1p1nq3/p7/2p1P1pp/3P2bp/3Q1Bn1/PPPB4/1K2R1NR w - - 40 21",
"r3k2r/3nnpbp/q2pp1p1/p7/Pp1PPPP1/4BNN1/1P5P/R2Q1RK1 w kq - 0 16",
"3Qb1k1/1r2ppb1/pN1n2q1/Pp1Pp1Pr/4P2p/4BP2/4B1R1/1R5K b - - 11 40",
// 5-man positions // 5-man positions
"8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1", // Kc2 - mate "8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1", // Kc2 - mate
@@ -113,7 +117,7 @@ vector<string> setup_bench(const Position& current, istream& is) {
string fenFile = (is >> token) ? token : "default"; string fenFile = (is >> token) ? token : "default";
string limitType = (is >> token) ? token : "depth"; string limitType = (is >> token) ? token : "depth";
go = "go " + limitType + " " + limit; go = limitType == "eval" ? "eval" : "go " + limitType + " " + limit;
if (fenFile == "default") if (fenFile == "default")
fens = Defaults; fens = Defaults;
@@ -139,9 +143,9 @@ vector<string> setup_bench(const Position& current, istream& is) {
file.close(); file.close();
} }
list.emplace_back("ucinewgame");
list.emplace_back("setoption name Threads value " + threads); list.emplace_back("setoption name Threads value " + threads);
list.emplace_back("setoption name Hash value " + ttSize); list.emplace_back("setoption name Hash value " + ttSize);
list.emplace_back("ucinewgame");
for (const string& fen : fens) for (const string& fen : fens)
if (fen.find("setoption") != string::npos) if (fen.find("setoption") != string::npos)
src/bitbase.cpp
+8 -8
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <algorithm>
#include <cassert> #include <cassert>
#include <numeric> #include <numeric>
#include <vector> #include <vector>
@@ -28,8 +27,9 @@
namespace { namespace {
// There are 24 possible pawn squares: the first 4 files and ranks from 2 to 7 // There are 24 possible pawn squares: files A to D and ranks from 2 to 7.
const unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608 // Positions with the pawn on files E to H will be mirrored before probing.
constexpr unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608
// Each uint32_t stores results of 32 positions, one per bit // Each uint32_t stores results of 32 positions, one per bit
uint32_t KPKBitbase[MAX_INDEX / 32]; uint32_t KPKBitbase[MAX_INDEX / 32];
@@ -44,7 +44,7 @@ namespace {
// bit 13-14: white pawn file (from FILE_A to FILE_D) // bit 13-14: white pawn file (from FILE_A to FILE_D)
// bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2) // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2)
unsigned index(Color us, Square bksq, Square wksq, Square psq) { unsigned index(Color us, Square bksq, Square wksq, Square psq) {
return wksq | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15); return int(wksq) | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15);
} }
enum Result { enum Result {
@@ -152,9 +152,9 @@ namespace {
// as WIN, the position is classified as WIN, otherwise the current position is // as WIN, the position is classified as WIN, otherwise the current position is
// classified as UNKNOWN. // classified as UNKNOWN.
const Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
const Result Good = (Us == WHITE ? WIN : DRAW); constexpr Result Good = (Us == WHITE ? WIN : DRAW);
const Result Bad = (Us == WHITE ? DRAW : WIN); constexpr Result Bad = (Us == WHITE ? DRAW : WIN);
Result r = INVALID; Result r = INVALID;
Bitboard b = PseudoAttacks[KING][ksq[Us]]; Bitboard b = PseudoAttacks[KING][ksq[Us]];
src/bitboard.cpp
+30 -134
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -19,24 +19,16 @@
*/ */
#include <algorithm> #include <algorithm>
#include <bitset>
#include "bitboard.h" #include "bitboard.h"
#include "misc.h" #include "misc.h"
uint8_t PopCnt16[1 << 16]; uint8_t PopCnt16[1 << 16];
int SquareDistance[SQUARE_NB][SQUARE_NB]; uint8_t SquareDistance[SQUARE_NB][SQUARE_NB];
Bitboard SquareBB[SQUARE_NB]; Bitboard SquareBB[SQUARE_NB];
Bitboard FileBB[FILE_NB];
Bitboard RankBB[RANK_NB];
Bitboard AdjacentFilesBB[FILE_NB];
Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
Bitboard LineBB[SQUARE_NB][SQUARE_NB]; Bitboard LineBB[SQUARE_NB][SQUARE_NB];
Bitboard DistanceRingBB[SQUARE_NB][8];
Bitboard ForwardFileBB[COLOR_NB][SQUARE_NB];
Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB]; Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
Bitboard PawnAttacks[COLOR_NB][SQUARE_NB]; Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
@@ -45,77 +37,12 @@ Magic BishopMagics[SQUARE_NB];
namespace { namespace {
// De Bruijn sequences. See chessprogramming.wikispaces.com/BitScan
const uint64_t DeBruijn64 = 0x3F79D71B4CB0A89ULL;
const uint32_t DeBruijn32 = 0x783A9B23;
int MSBTable[256]; // To implement software msb()
Square BSFTable[SQUARE_NB]; // To implement software bitscan
Bitboard RookTable[0x19000]; // To store rook attacks Bitboard RookTable[0x19000]; // To store rook attacks
Bitboard BishopTable[0x1480]; // To store bishop attacks Bitboard BishopTable[0x1480]; // To store bishop attacks
void init_magics(Bitboard table[], Magic magics[], Direction directions[]); void init_magics(Bitboard table[], Magic magics[], Direction directions[]);
// bsf_index() returns the index into BSFTable[] to look up the bitscan. Uses
// Matt Taylor's folding for 32 bit case, extended to 64 bit by Kim Walisch.
unsigned bsf_index(Bitboard b) {
b ^= b - 1;
return Is64Bit ? (b * DeBruijn64) >> 58
: ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn32) >> 26;
}
// popcount16() counts the non-zero bits using SWAR-Popcount algorithm
unsigned popcount16(unsigned u) {
u -= (u >> 1) & 0x5555U;
u = ((u >> 2) & 0x3333U) + (u & 0x3333U);
u = ((u >> 4) + u) & 0x0F0FU;
return (u * 0x0101U) >> 8;
}
} }
#ifdef NO_BSF
/// Software fall-back of lsb() and msb() for CPU lacking hardware support
Square lsb(Bitboard b) {
assert(b);
return BSFTable[bsf_index(b)];
}
Square msb(Bitboard b) {
assert(b);
unsigned b32;
int result = 0;
if (b > 0xFFFFFFFF)
{
b >>= 32;
result = 32;
}
b32 = unsigned(b);
if (b32 > 0xFFFF)
{
b32 >>= 16;
result += 16;
}
if (b32 > 0xFF)
{
b32 >>= 8;
result += 8;
}
return Square(result + MSBTable[b32]);
}
#endif // ifdef NO_BSF
/// Bitboards::pretty() returns an ASCII representation of a bitboard suitable /// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
/// to be printed to standard output. Useful for debugging. /// to be printed to standard output. Useful for debugging.
@@ -142,64 +69,38 @@ const std::string Bitboards::pretty(Bitboard b) {
void Bitboards::init() { void Bitboards::init() {
for (unsigned i = 0; i < (1 << 16); ++i) for (unsigned i = 0; i < (1 << 16); ++i)
PopCnt16[i] = (uint8_t) popcount16(i); PopCnt16[i] = std::bitset<16>(i).count();
for (Square s = SQ_A1; s <= SQ_H8; ++s) for (Square s = SQ_A1; s <= SQ_H8; ++s)
{ SquareBB[s] = (1ULL << s);
SquareBB[s] = 1ULL << s;
BSFTable[bsf_index(SquareBB[s])] = s;
}
for (Bitboard b = 2; b < 256; ++b)
MSBTable[b] = MSBTable[b - 1] + !more_than_one(b);
for (File f = FILE_A; f <= FILE_H; ++f)
FileBB[f] = f > FILE_A ? FileBB[f - 1] << 1 : FileABB;
for (Rank r = RANK_1; r <= RANK_8; ++r)
RankBB[r] = r > RANK_1 ? RankBB[r - 1] << 8 : Rank1BB;
for (File f = FILE_A; f <= FILE_H; ++f)
AdjacentFilesBB[f] = (f > FILE_A ? FileBB[f - 1] : 0) | (f < FILE_H ? FileBB[f + 1] : 0);
for (Rank r = RANK_1; r < RANK_8; ++r)
ForwardRanksBB[WHITE][r] = ~(ForwardRanksBB[BLACK][r + 1] = ForwardRanksBB[BLACK][r] | RankBB[r]);
for (Color c = WHITE; c <= BLACK; ++c)
for (Square s = SQ_A1; s <= SQ_H8; ++s)
{
ForwardFileBB [c][s] = ForwardRanksBB[c][rank_of(s)] & FileBB[file_of(s)];
PawnAttackSpan[c][s] = ForwardRanksBB[c][rank_of(s)] & AdjacentFilesBB[file_of(s)];
PassedPawnMask[c][s] = ForwardFileBB [c][s] | PawnAttackSpan[c][s];
}
for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1) for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
if (s1 != s2) SquareDistance[s1][s2] = std::max(distance<File>(s1, s2), distance<Rank>(s1, s2));
{
SquareDistance[s1][s2] = std::max(distance<File>(s1, s2), distance<Rank>(s1, s2));
DistanceRingBB[s1][SquareDistance[s1][s2] - 1] |= s2;
}
int steps[][5] = { {}, { 7, 9 }, { 6, 10, 15, 17 }, {}, {}, {}, { 1, 7, 8, 9 } }; for (Square s = SQ_A1; s <= SQ_H8; ++s)
{
PawnAttacks[WHITE][s] = pawn_attacks_bb<WHITE>(square_bb(s));
PawnAttacks[BLACK][s] = pawn_attacks_bb<BLACK>(square_bb(s));
}
for (Color c = WHITE; c <= BLACK; ++c) // Helper returning the target bitboard of a step from a square
for (PieceType pt : { PAWN, KNIGHT, KING }) auto landing_square_bb = [&](Square s, int step)
for (Square s = SQ_A1; s <= SQ_H8; ++s) {
for (int i = 0; steps[pt][i]; ++i) Square to = Square(s + step);
{ return is_ok(to) && distance(s, to) <= 2 ? square_bb(to) : Bitboard(0);
Square to = s + Direction(c == WHITE ? steps[pt][i] : -steps[pt][i]); };
if (is_ok(to) && distance(s, to) < 3) for (Square s = SQ_A1; s <= SQ_H8; ++s)
{ {
if (pt == PAWN) for (int step : {-9, -8, -7, -1, 1, 7, 8, 9} )
PawnAttacks[c][s] |= to; PseudoAttacks[KING][s] |= landing_square_bb(s, step);
else
PseudoAttacks[pt][s] |= to;
}
}
Direction RookDirections[] = { NORTH, EAST, SOUTH, WEST }; for (int step : {-17, -15, -10, -6, 6, 10, 15, 17} )
PseudoAttacks[KNIGHT][s] |= landing_square_bb(s, step);
}
Direction RookDirections[] = { NORTH, EAST, SOUTH, WEST };
Direction BishopDirections[] = { NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST }; Direction BishopDirections[] = { NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST };
init_magics(RookTable, RookMagics, RookDirections); init_magics(RookTable, RookMagics, RookDirections);
@@ -212,13 +113,8 @@ void Bitboards::init() {
for (PieceType pt : { BISHOP, ROOK }) for (PieceType pt : { BISHOP, ROOK })
for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2)
{ if (PseudoAttacks[pt][s1] & s2)
if (!(PseudoAttacks[pt][s1] & s2)) LineBB[s1][s2] = (attacks_bb(pt, s1, 0) & attacks_bb(pt, s2, 0)) | s1 | s2;
continue;
LineBB[s1][s2] = (attacks_bb(pt, s1, 0) & attacks_bb(pt, s2, 0)) | s1 | s2;
BetweenBB[s1][s2] = attacks_bb(pt, s1, SquareBB[s2]) & attacks_bb(pt, s2, SquareBB[s1]);
}
} }
} }
@@ -246,8 +142,8 @@ namespace {
// init_magics() computes all rook and bishop attacks at startup. Magic // init_magics() computes all rook and bishop attacks at startup. Magic
// bitboards are used to look up attacks of sliding pieces. As a reference see // bitboards are used to look up attacks of sliding pieces. As a reference see
// chessprogramming.wikispaces.com/Magic+Bitboards. In particular, here we // www.chessprogramming.org/Magic_Bitboards. In particular, here we use the so
// use the so called "fancy" approach. // called "fancy" approach.
void init_magics(Bitboard table[], Magic magics[], Direction directions[]) { void init_magics(Bitboard table[], Magic magics[], Direction directions[]) {
src/bitboard.h
+147 -96
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -39,40 +39,43 @@ const std::string pretty(Bitboard b);
} }
const Bitboard AllSquares = ~Bitboard(0); constexpr Bitboard AllSquares = ~Bitboard(0);
const Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL; constexpr Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL;
const Bitboard FileABB = 0x0101010101010101ULL; constexpr Bitboard FileABB = 0x0101010101010101ULL;
const Bitboard FileBBB = FileABB << 1; constexpr Bitboard FileBBB = FileABB << 1;
const Bitboard FileCBB = FileABB << 2; constexpr Bitboard FileCBB = FileABB << 2;
const Bitboard FileDBB = FileABB << 3; constexpr Bitboard FileDBB = FileABB << 3;
const Bitboard FileEBB = FileABB << 4; constexpr Bitboard FileEBB = FileABB << 4;
const Bitboard FileFBB = FileABB << 5; constexpr Bitboard FileFBB = FileABB << 5;
const Bitboard FileGBB = FileABB << 6; constexpr Bitboard FileGBB = FileABB << 6;
const Bitboard FileHBB = FileABB << 7; constexpr Bitboard FileHBB = FileABB << 7;
const Bitboard Rank1BB = 0xFF; constexpr Bitboard Rank1BB = 0xFF;
const Bitboard Rank2BB = Rank1BB << (8 * 1); constexpr Bitboard Rank2BB = Rank1BB << (8 * 1);
const Bitboard Rank3BB = Rank1BB << (8 * 2); constexpr Bitboard Rank3BB = Rank1BB << (8 * 2);
const Bitboard Rank4BB = Rank1BB << (8 * 3); constexpr Bitboard Rank4BB = Rank1BB << (8 * 3);
const Bitboard Rank5BB = Rank1BB << (8 * 4); constexpr Bitboard Rank5BB = Rank1BB << (8 * 4);
const Bitboard Rank6BB = Rank1BB << (8 * 5); constexpr Bitboard Rank6BB = Rank1BB << (8 * 5);
const Bitboard Rank7BB = Rank1BB << (8 * 6); constexpr Bitboard Rank7BB = Rank1BB << (8 * 6);
const Bitboard Rank8BB = Rank1BB << (8 * 7); constexpr Bitboard Rank8BB = Rank1BB << (8 * 7);
extern int SquareDistance[SQUARE_NB][SQUARE_NB]; constexpr Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB;
constexpr Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB;
constexpr Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB;
constexpr Bitboard Center = (FileDBB | FileEBB) & (Rank4BB | Rank5BB);
constexpr Bitboard KingFlank[FILE_NB] = {
QueenSide ^ FileDBB, QueenSide, QueenSide,
CenterFiles, CenterFiles,
KingSide, KingSide, KingSide ^ FileEBB
};
extern uint8_t PopCnt16[1 << 16];
extern uint8_t SquareDistance[SQUARE_NB][SQUARE_NB];
extern Bitboard SquareBB[SQUARE_NB]; extern Bitboard SquareBB[SQUARE_NB];
extern Bitboard FileBB[FILE_NB];
extern Bitboard RankBB[RANK_NB];
extern Bitboard AdjacentFilesBB[FILE_NB];
extern Bitboard ForwardRanksBB[COLOR_NB][RANK_NB];
extern Bitboard BetweenBB[SQUARE_NB][SQUARE_NB];
extern Bitboard LineBB[SQUARE_NB][SQUARE_NB]; extern Bitboard LineBB[SQUARE_NB][SQUARE_NB];
extern Bitboard DistanceRingBB[SQUARE_NB][8];
extern Bitboard ForwardFileBB[COLOR_NB][SQUARE_NB];
extern Bitboard PassedPawnMask[COLOR_NB][SQUARE_NB];
extern Bitboard PawnAttackSpan[COLOR_NB][SQUARE_NB];
extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB]; extern Bitboard PseudoAttacks[PIECE_TYPE_NB][SQUARE_NB];
extern Bitboard PawnAttacks[COLOR_NB][SQUARE_NB]; extern Bitboard PawnAttacks[COLOR_NB][SQUARE_NB];
@@ -102,117 +105,137 @@ struct Magic {
extern Magic RookMagics[SQUARE_NB]; extern Magic RookMagics[SQUARE_NB];
extern Magic BishopMagics[SQUARE_NB]; extern Magic BishopMagics[SQUARE_NB];
inline Bitboard square_bb(Square s) {
assert(s >= SQ_A1 && s <= SQ_H8);
return SquareBB[s];
}
/// Overloads of bitwise operators between a Bitboard and a Square for testing /// Overloads of bitwise operators between a Bitboard and a Square for testing
/// whether a given bit is set in a bitboard, and for setting and clearing bits. /// whether a given bit is set in a bitboard, and for setting and clearing bits.
inline Bitboard operator&(Bitboard b, Square s) { inline Bitboard operator&( Bitboard b, Square s) { return b & square_bb(s); }
return b & SquareBB[s]; inline Bitboard operator|( Bitboard b, Square s) { return b | square_bb(s); }
} inline Bitboard operator^( Bitboard b, Square s) { return b ^ square_bb(s); }
inline Bitboard& operator|=(Bitboard& b, Square s) { return b |= square_bb(s); }
inline Bitboard& operator^=(Bitboard& b, Square s) { return b ^= square_bb(s); }
inline Bitboard operator|(Bitboard b, Square s) { inline Bitboard operator&(Square s, Bitboard b) { return b & s; }
return b | SquareBB[s]; inline Bitboard operator|(Square s, Bitboard b) { return b | s; }
} inline Bitboard operator^(Square s, Bitboard b) { return b ^ s; }
inline Bitboard operator^(Bitboard b, Square s) { inline Bitboard operator|(Square s, Square s2) { return square_bb(s) | square_bb(s2); }
return b ^ SquareBB[s];
}
inline Bitboard& operator|=(Bitboard& b, Square s) {
return b |= SquareBB[s];
}
inline Bitboard& operator^=(Bitboard& b, Square s) {
return b ^= SquareBB[s];
}
constexpr bool more_than_one(Bitboard b) { constexpr bool more_than_one(Bitboard b) {
return b & (b - 1); return b & (b - 1);
} }
inline bool opposite_colors(Square s1, Square s2) {
return bool(DarkSquares & s1) != bool(DarkSquares & s2);
}
/// rank_bb() and file_bb() return a bitboard representing all the squares on /// rank_bb() and file_bb() return a bitboard representing all the squares on
/// the given file or rank. /// the given file or rank.
inline Bitboard rank_bb(Rank r) { inline Bitboard rank_bb(Rank r) {
return RankBB[r]; return Rank1BB << (8 * r);
} }
inline Bitboard rank_bb(Square s) { inline Bitboard rank_bb(Square s) {
return RankBB[rank_of(s)]; return rank_bb(rank_of(s));
} }
inline Bitboard file_bb(File f) { inline Bitboard file_bb(File f) {
return FileBB[f]; return FileABB << f;
} }
inline Bitboard file_bb(Square s) { inline Bitboard file_bb(Square s) {
return FileBB[file_of(s)]; return file_bb(file_of(s));
} }
/// shift() moves a bitboard one step along direction D. Mainly for pawns /// shift() moves a bitboard one step along direction D
template<Direction D> template<Direction D>
constexpr Bitboard shift(Bitboard b) { constexpr Bitboard shift(Bitboard b) {
return D == NORTH ? b << 8 : D == SOUTH ? b >> 8 return D == NORTH ? b << 8 : D == SOUTH ? b >> 8
: D == NORTH_EAST ? (b & ~FileHBB) << 9 : D == SOUTH_EAST ? (b & ~FileHBB) >> 7 : D == NORTH+NORTH? b <<16 : D == SOUTH+SOUTH? b >>16
: D == NORTH_WEST ? (b & ~FileABB) << 7 : D == SOUTH_WEST ? (b & ~FileABB) >> 9 : D == EAST ? (b & ~FileHBB) << 1 : D == WEST ? (b & ~FileABB) >> 1
: D == NORTH_EAST ? (b & ~FileHBB) << 9 : D == NORTH_WEST ? (b & ~FileABB) << 7
: D == SOUTH_EAST ? (b & ~FileHBB) >> 7 : D == SOUTH_WEST ? (b & ~FileABB) >> 9
: 0; : 0;
} }
/// pawn_attacks_bb() returns the squares attacked by pawns of the given color
/// from the squares in the given bitboard.
template<Color C>
constexpr Bitboard pawn_attacks_bb(Bitboard b) {
return C == WHITE ? shift<NORTH_WEST>(b) | shift<NORTH_EAST>(b)
: shift<SOUTH_WEST>(b) | shift<SOUTH_EAST>(b);
}
/// pawn_double_attacks_bb() returns the squares doubly attacked by pawns of the
/// given color from the squares in the given bitboard.
template<Color C>
constexpr Bitboard pawn_double_attacks_bb(Bitboard b) {
return C == WHITE ? shift<NORTH_WEST>(b) & shift<NORTH_EAST>(b)
: shift<SOUTH_WEST>(b) & shift<SOUTH_EAST>(b);
}
/// adjacent_files_bb() returns a bitboard representing all the squares on the /// adjacent_files_bb() returns a bitboard representing all the squares on the
/// adjacent files of the given one. /// adjacent files of the given one.
inline Bitboard adjacent_files_bb(File f) { inline Bitboard adjacent_files_bb(Square s) {
return AdjacentFilesBB[f]; return shift<EAST>(file_bb(s)) | shift<WEST>(file_bb(s));
} }
/// between_bb() returns a bitboard representing all the squares between the two /// between_bb() returns squares that are linearly between the given squares
/// given ones. For instance, between_bb(SQ_C4, SQ_F7) returns a bitboard with /// If the given squares are not on a same file/rank/diagonal, return 0.
/// the bits for square d5 and e6 set. If s1 and s2 are not on the same rank, file
/// or diagonal, 0 is returned.
inline Bitboard between_bb(Square s1, Square s2) { inline Bitboard between_bb(Square s1, Square s2) {
return BetweenBB[s1][s2]; return LineBB[s1][s2] & ( (AllSquares << (s1 + (s1 < s2)))
^(AllSquares << (s2 + !(s1 < s2))));
} }
/// forward_ranks_bb() returns a bitboard representing all the squares on all the ranks /// forward_ranks_bb() returns a bitboard representing the squares on the ranks
/// in front of the given one, from the point of view of the given color. For /// in front of the given one, from the point of view of the given color. For instance,
/// instance, forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2. /// forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2.
inline Bitboard forward_ranks_bb(Color c, Square s) { inline Bitboard forward_ranks_bb(Color c, Square s) {
return ForwardRanksBB[c][rank_of(s)]; return c == WHITE ? ~Rank1BB << 8 * (rank_of(s) - RANK_1)
: ~Rank8BB >> 8 * (RANK_8 - rank_of(s));
} }
/// forward_file_bb() returns a bitboard representing all the squares along the line /// forward_file_bb() returns a bitboard representing all the squares along the
/// in front of the given one, from the point of view of the given color: /// line in front of the given one, from the point of view of the given color.
/// ForwardFileBB[c][s] = forward_ranks_bb(c, s) & file_bb(s)
inline Bitboard forward_file_bb(Color c, Square s) { inline Bitboard forward_file_bb(Color c, Square s) {
return ForwardFileBB[c][s]; return forward_ranks_bb(c, s) & file_bb(s);
} }
/// pawn_attack_span() returns a bitboard representing all the squares that can be /// pawn_attack_span() returns a bitboard representing all the squares that can
/// attacked by a pawn of the given color when it moves along its file, starting /// be attacked by a pawn of the given color when it moves along its file,
/// from the given square: /// starting from the given square.
/// PawnAttackSpan[c][s] = forward_ranks_bb(c, s) & adjacent_files_bb(file_of(s));
inline Bitboard pawn_attack_span(Color c, Square s) { inline Bitboard pawn_attack_span(Color c, Square s) {
return PawnAttackSpan[c][s]; return forward_ranks_bb(c, s) & adjacent_files_bb(s);
} }
/// passed_pawn_mask() returns a bitboard mask which can be used to test if a /// passed_pawn_span() returns a bitboard which can be used to test if a pawn of
/// pawn of the given color and on the given square is a passed pawn: /// the given color and on the given square is a passed pawn.
/// PassedPawnMask[c][s] = pawn_attack_span(c, s) | forward_file_bb(c, s)
inline Bitboard passed_pawn_mask(Color c, Square s) { inline Bitboard passed_pawn_span(Color c, Square s) {
return PassedPawnMask[c][s]; return forward_ranks_bb(c, s) & (adjacent_files_bb(s) | file_bb(s));
} }
@@ -225,15 +248,16 @@ inline bool aligned(Square s1, Square s2, Square s3) {
/// distance() functions return the distance between x and y, defined as the /// distance() functions return the distance between x and y, defined as the
/// number of steps for a king in x to reach y. Works with squares, ranks, files. /// number of steps for a king in x to reach y.
template<typename T> inline int distance(T x, T y) { return x < y ? y - x : x - y; } template<typename T1 = Square> inline int distance(Square x, Square y);
template<> inline int distance<File>(Square x, Square y) { return std::abs(file_of(x) - file_of(y)); }
template<> inline int distance<Rank>(Square x, Square y) { return std::abs(rank_of(x) - rank_of(y)); }
template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; } template<> inline int distance<Square>(Square x, Square y) { return SquareDistance[x][y]; }
template<typename T1, typename T2> inline int distance(T2 x, T2 y); template<class T> constexpr const T& clamp(const T& v, const T& lo, const T& hi) {
template<> inline int distance<File>(Square x, Square y) { return distance(file_of(x), file_of(y)); } return v < lo ? lo : v > hi ? hi : v;
template<> inline int distance<Rank>(Square x, Square y) { return distance(rank_of(x), rank_of(y)); } }
/// attacks_bb() returns a bitboard representing all the squares attacked by a /// attacks_bb() returns a bitboard representing all the squares attacked by a
/// piece of type Pt (bishop or rook) placed on 's'. /// piece of type Pt (bishop or rook) placed on 's'.
@@ -265,7 +289,6 @@ inline int popcount(Bitboard b) {
#ifndef USE_POPCNT #ifndef USE_POPCNT
extern uint8_t PopCnt16[1 << 16];
union { Bitboard bb; uint16_t u[4]; } v = { b }; union { Bitboard bb; uint16_t u[4]; } v = { b };
return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]]; return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]];
@@ -283,7 +306,7 @@ inline int popcount(Bitboard b) {
/// lsb() and msb() return the least/most significant bit in a non-zero bitboard /// lsb() and msb() return the least/most significant bit in a non-zero bitboard
#if defined(__GNUC__) #if defined(__GNUC__) // GCC, Clang, ICC
inline Square lsb(Bitboard b) { inline Square lsb(Bitboard b) {
assert(b); assert(b);
@@ -295,7 +318,9 @@ inline Square msb(Bitboard b) {
return Square(63 ^ __builtin_clzll(b)); return Square(63 ^ __builtin_clzll(b));
} }
#elif defined(_WIN64) && defined(_MSC_VER) #elif defined(_MSC_VER) // MSVC
#ifdef _WIN64 // MSVC, WIN64
inline Square lsb(Bitboard b) { inline Square lsb(Bitboard b) {
assert(b); assert(b);
@@ -311,12 +336,39 @@ inline Square msb(Bitboard b) {
return (Square) idx; return (Square) idx;
} }
#else #else // MSVC, WIN32
#define NO_BSF // Fallback on software implementation for other cases inline Square lsb(Bitboard b) {
assert(b);
unsigned long idx;
Square lsb(Bitboard b); if (b & 0xffffffff) {
Square msb(Bitboard b); _BitScanForward(&idx, int32_t(b));
return Square(idx);
} else {
_BitScanForward(&idx, int32_t(b >> 32));
return Square(idx + 32);
}
}
inline Square msb(Bitboard b) {
assert(b);
unsigned long idx;
if (b >> 32) {
_BitScanReverse(&idx, int32_t(b >> 32));
return Square(idx + 32);
} else {
_BitScanReverse(&idx, int32_t(b));
return Square(idx);
}
}
#endif
#else // Compiler is neither GCC nor MSVC compatible
#error "Compiler not supported."
#endif #endif
@@ -330,10 +382,9 @@ inline Square pop_lsb(Bitboard* b) {
} }
/// frontmost_sq() and backmost_sq() return the square corresponding to the /// frontmost_sq() returns the most advanced square for the given color
/// most/least advanced bit relative to the given color. inline Square frontmost_sq(Color c, Bitboard b) {
return c == WHITE ? msb(b) : lsb(b);
inline Square frontmost_sq(Color c, Bitboard b) { return c == WHITE ? msb(b) : lsb(b); } }
inline Square backmost_sq(Color c, Bitboard b) { return c == WHITE ? lsb(b) : msb(b); }
#endif // #ifndef BITBOARD_H_INCLUDED #endif // #ifndef BITBOARD_H_INCLUDED
src/endgame.cpp
+67 -77
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <algorithm>
#include <cassert> #include <cassert>
#include "bitboard.h" #include "bitboard.h"
@@ -31,7 +30,7 @@ namespace {
// Table used to drive the king towards the edge of the board // Table used to drive the king towards the edge of the board
// in KX vs K and KQ vs KR endgames. // in KX vs K and KQ vs KR endgames.
const int PushToEdges[SQUARE_NB] = { constexpr int PushToEdges[SQUARE_NB] = {
100, 90, 80, 70, 70, 80, 90, 100, 100, 90, 80, 70, 70, 80, 90, 100,
90, 70, 60, 50, 50, 60, 70, 90, 90, 70, 60, 50, 50, 60, 70, 90,
80, 60, 40, 30, 30, 40, 60, 80, 80, 60, 40, 30, 30, 40, 60, 80,
@@ -44,23 +43,23 @@ namespace {
// Table used to drive the king towards a corner square of the // Table used to drive the king towards a corner square of the
// right color in KBN vs K endgames. // right color in KBN vs K endgames.
const int PushToCorners[SQUARE_NB] = { constexpr int PushToCorners[SQUARE_NB] = {
200, 190, 180, 170, 160, 150, 140, 130, 6400, 6080, 5760, 5440, 5120, 4800, 4480, 4160,
190, 180, 170, 160, 150, 140, 130, 140, 6080, 5760, 5440, 5120, 4800, 4480, 4160, 4480,
180, 170, 155, 140, 140, 125, 140, 150, 5760, 5440, 4960, 4480, 4480, 4000, 4480, 4800,
170, 160, 140, 120, 110, 140, 150, 160, 5440, 5120, 4480, 3840, 3520, 4480, 4800, 5120,
160, 150, 140, 110, 120, 140, 160, 170, 5120, 4800, 4480, 3520, 3840, 4480, 5120, 5440,
150, 140, 125, 140, 140, 155, 170, 180, 4800, 4480, 4000, 4480, 4480, 4960, 5440, 5760,
140, 130, 140, 150, 160, 170, 180, 190, 4480, 4160, 4480, 4800, 5120, 5440, 5760, 6080,
130, 140, 150, 160, 170, 180, 190, 200 4160, 4480, 4800, 5120, 5440, 5760, 6080, 6400
}; };
// Tables used to drive a piece towards or away from another piece // Tables used to drive a piece towards or away from another piece
const int PushClose[8] = { 0, 0, 100, 80, 60, 40, 20, 10 }; constexpr int PushClose[8] = { 0, 0, 100, 80, 60, 40, 20, 10 };
const int PushAway [8] = { 0, 5, 20, 40, 60, 80, 90, 100 }; constexpr int PushAway [8] = { 0, 5, 20, 40, 60, 80, 90, 100 };
// Pawn Rank based scaling factors used in KRPPKRP endgame // Pawn Rank based scaling factors used in KRPPKRP endgame
const int KRPPKRPScaleFactors[RANK_NB] = { 0, 9, 10, 14, 21, 44, 0, 0 }; constexpr int KRPPKRPScaleFactors[RANK_NB] = { 0, 9, 10, 14, 21, 44, 0, 0 };
#ifndef NDEBUG #ifndef NDEBUG
bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) { bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) {
@@ -75,38 +74,39 @@ namespace {
assert(pos.count<PAWN>(strongSide) == 1); assert(pos.count<PAWN>(strongSide) == 1);
if (file_of(pos.square<PAWN>(strongSide)) >= FILE_E) if (file_of(pos.square<PAWN>(strongSide)) >= FILE_E)
sq = Square(sq ^ 7); // Mirror SQ_H1 -> SQ_A1 sq = Square(int(sq) ^ 7); // Mirror SQ_H1 -> SQ_A1
if (strongSide == BLACK) return strongSide == WHITE ? sq : ~sq;
sq = ~sq;
return sq;
} }
} // namespace } // namespace
/// Endgames members definitions namespace Endgames {
Endgames::Endgames() { std::pair<Map<Value>, Map<ScaleFactor>> maps;
add<KPK>("KPK"); void init() {
add<KNNK>("KNNK");
add<KBNK>("KBNK");
add<KRKP>("KRKP");
add<KRKB>("KRKB");
add<KRKN>("KRKN");
add<KQKP>("KQKP");
add<KQKR>("KQKR");
add<KNPK>("KNPK"); add<KPK>("KPK");
add<KNPKB>("KNPKB"); add<KNNK>("KNNK");
add<KRPKR>("KRPKR"); add<KBNK>("KBNK");
add<KRPKB>("KRPKB"); add<KRKP>("KRKP");
add<KBPKB>("KBPKB"); add<KRKB>("KRKB");
add<KBPKN>("KBPKN"); add<KRKN>("KRKN");
add<KBPPKB>("KBPPKB"); add<KQKP>("KQKP");
add<KRPPKRP>("KRPPKRP"); add<KQKR>("KQKR");
add<KNNKP>("KNNKP");
add<KNPK>("KNPK");
add<KNPKB>("KNPKB");
add<KRPKR>("KRPKR");
add<KRPKB>("KRPKB");
add<KBPKB>("KBPKB");
add<KBPKN>("KBPKN");
add<KBPPKB>("KBPPKB");
add<KRPPKRP>("KRPPKRP");
}
} }
@@ -144,7 +144,7 @@ Value Endgame<KXK>::operator()(const Position& pos) const {
/// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the /// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the
/// defending king towards a corner square of the right color. /// defending king towards a corner square that our bishop attacks.
template<> template<>
Value Endgame<KBNK>::operator()(const Position& pos) const { Value Endgame<KBNK>::operator()(const Position& pos) const {
@@ -155,24 +155,19 @@ Value Endgame<KBNK>::operator()(const Position& pos) const {
Square loserKSq = pos.square<KING>(weakSide); Square loserKSq = pos.square<KING>(weakSide);
Square bishopSq = pos.square<BISHOP>(strongSide); Square bishopSq = pos.square<BISHOP>(strongSide);
// kbnk_mate_table() tries to drive toward corners A1 or H8. If we have a // If our bishop does not attack A1/H8, we flip the enemy king square
// bishop that cannot reach the above squares, we flip the kings in order // to drive to opposite corners (A8/H1).
// to drive the enemy toward corners A8 or H1.
if (opposite_colors(bishopSq, SQ_A1))
{
winnerKSq = ~winnerKSq;
loserKSq = ~loserKSq;
}
Value result = VALUE_KNOWN_WIN Value result = VALUE_KNOWN_WIN
+ PushClose[distance(winnerKSq, loserKSq)] + PushClose[distance(winnerKSq, loserKSq)]
+ PushToCorners[loserKSq]; + PushToCorners[opposite_colors(bishopSq, SQ_A1) ? ~loserKSq : loserKSq];
assert(abs(result) < VALUE_MATE_IN_MAX_PLY);
return strongSide == pos.side_to_move() ? result : -result; return strongSide == pos.side_to_move() ? result : -result;
} }
/// KP vs K. This endgame is evaluated with the help of a bitbase. /// KP vs K. This endgame is evaluated with the help of a bitbase
template<> template<>
Value Endgame<KPK>::operator()(const Position& pos) const { Value Endgame<KPK>::operator()(const Position& pos) const {
@@ -214,7 +209,7 @@ Value Endgame<KRKP>::operator()(const Position& pos) const {
Value result; Value result;
// If the stronger side's king is in front of the pawn, it's a win // If the stronger side's king is in front of the pawn, it's a win
if (wksq < psq && file_of(wksq) == file_of(psq)) if (forward_file_bb(WHITE, wksq) & psq)
result = RookValueEg - distance(wksq, psq); result = RookValueEg - distance(wksq, psq);
// If the weaker side's king is too far from the pawn and the rook, // If the weaker side's king is too far from the pawn and the rook,
@@ -240,7 +235,7 @@ Value Endgame<KRKP>::operator()(const Position& pos) const {
} }
/// KR vs KB. This is very simple, and always returns drawish scores. The /// KR vs KB. This is very simple, and always returns drawish scores. The
/// score is slightly bigger when the defending king is close to the edge. /// score is slightly bigger when the defending king is close to the edge.
template<> template<>
Value Endgame<KRKB>::operator()(const Position& pos) const { Value Endgame<KRKB>::operator()(const Position& pos) const {
@@ -315,6 +310,21 @@ Value Endgame<KQKR>::operator()(const Position& pos) const {
} }
/// KNN vs KP. Simply push the opposing king to the corner
template<>
Value Endgame<KNNKP>::operator()(const Position& pos) const {
assert(verify_material(pos, strongSide, 2 * KnightValueMg, 0));
assert(verify_material(pos, weakSide, VALUE_ZERO, 1));
Value result = 2 * KnightValueEg
- PawnValueEg
+ PushToEdges[pos.square<KING>(weakSide)];
return strongSide == pos.side_to_move() ? result : -result;
}
/// Some cases of trivial draws /// Some cases of trivial draws
template<> Value Endgame<KNNK>::operator()(const Position&) const { return VALUE_DRAW; } template<> Value Endgame<KNNK>::operator()(const Position&) const { return VALUE_DRAW; }
@@ -355,7 +365,7 @@ ScaleFactor Endgame<KBPsK>::operator()(const Position& pos) const {
&& pos.count<PAWN>(weakSide) >= 1) && pos.count<PAWN>(weakSide) >= 1)
{ {
// Get weakSide pawn that is closest to the home rank // Get weakSide pawn that is closest to the home rank
Square weakPawnSq = backmost_sq(weakSide, pos.pieces(weakSide, PAWN)); Square weakPawnSq = frontmost_sq(strongSide, pos.pieces(weakSide, PAWN));
Square strongKingSq = pos.square<KING>(strongSide); Square strongKingSq = pos.square<KING>(strongSide);
Square weakKingSq = pos.square<KING>(weakSide); Square weakKingSq = pos.square<KING>(weakSide);
@@ -631,29 +641,8 @@ ScaleFactor Endgame<KBPKB>::operator()(const Position& pos) const {
// Case 2: Opposite colored bishops // Case 2: Opposite colored bishops
if (opposite_colors(strongBishopSq, weakBishopSq)) if (opposite_colors(strongBishopSq, weakBishopSq))
{ return SCALE_FACTOR_DRAW;
// We assume that the position is drawn in the following three situations:
//
// a. The pawn is on rank 5 or further back.
// b. The defending king is somewhere in the pawn's path.
// c. The defending bishop attacks some square along the pawn's path,
// and is at least three squares away from the pawn.
//
// These rules are probably not perfect, but in practice they work
// reasonably well.
if (relative_rank(strongSide, pawnSq) <= RANK_5)
return SCALE_FACTOR_DRAW;
Bitboard path = forward_file_bb(strongSide, pawnSq);
if (path & pos.pieces(weakSide, KING))
return SCALE_FACTOR_DRAW;
if ( (pos.attacks_from<BISHOP>(weakBishopSq) & path)
&& distance(weakBishopSq, pawnSq) >= 3)
return SCALE_FACTOR_DRAW;
}
return SCALE_FACTOR_NONE; return SCALE_FACTOR_NONE;
} }
@@ -674,8 +663,6 @@ ScaleFactor Endgame<KBPPKB>::operator()(const Position& pos) const {
Square ksq = pos.square<KING>(weakSide); Square ksq = pos.square<KING>(weakSide);
Square psq1 = pos.squares<PAWN>(strongSide)[0]; Square psq1 = pos.squares<PAWN>(strongSide)[0];
Square psq2 = pos.squares<PAWN>(strongSide)[1]; Square psq2 = pos.squares<PAWN>(strongSide)[1];
Rank r1 = rank_of(psq1);
Rank r2 = rank_of(psq2);
Square blockSq1, blockSq2; Square blockSq1, blockSq2;
if (relative_rank(strongSide, psq1) > relative_rank(strongSide, psq2)) if (relative_rank(strongSide, psq1) > relative_rank(strongSide, psq2))
@@ -709,7 +696,7 @@ ScaleFactor Endgame<KBPPKB>::operator()(const Position& pos) const {
&& opposite_colors(ksq, wbsq) && opposite_colors(ksq, wbsq)
&& ( bbsq == blockSq2 && ( bbsq == blockSq2
|| (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(weakSide, BISHOP)) || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(weakSide, BISHOP))
|| distance(r1, r2) >= 2)) || distance<Rank>(psq1, psq2) >= 2))
return SCALE_FACTOR_DRAW; return SCALE_FACTOR_DRAW;
else if ( ksq == blockSq2 else if ( ksq == blockSq2
@@ -774,6 +761,9 @@ ScaleFactor Endgame<KNPK>::operator()(const Position& pos) const {
template<> template<>
ScaleFactor Endgame<KNPKB>::operator()(const Position& pos) const { ScaleFactor Endgame<KNPKB>::operator()(const Position& pos) const {
assert(verify_material(pos, strongSide, KnightValueMg, 1));
assert(verify_material(pos, weakSide, BishopValueMg, 0));
Square pawnSq = pos.square<PAWN>(strongSide); Square pawnSq = pos.square<PAWN>(strongSide);
Square bishopSq = pos.square<BISHOP>(weakSide); Square bishopSq = pos.square<BISHOP>(weakSide);
Square weakKingSq = pos.square<KING>(weakSide); Square weakKingSq = pos.square<KING>(weakSide);
src/endgame.h
+18 -16
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@
#ifndef ENDGAME_H_INCLUDED #ifndef ENDGAME_H_INCLUDED
#define ENDGAME_H_INCLUDED #define ENDGAME_H_INCLUDED
#include <map> #include <unordered_map>
#include <memory> #include <memory>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
@@ -37,6 +37,7 @@ enum EndgameCode {
EVALUATION_FUNCTIONS, EVALUATION_FUNCTIONS,
KNNK, // KNN vs K KNNK, // KNN vs K
KNNKP, // KNN vs KP
KXK, // Generic "mate lone king" eval KXK, // Generic "mate lone king" eval
KBNK, // KBN vs K KBNK, // KBN vs K
KPK, // KP vs K KPK, // KP vs K
@@ -64,6 +65,7 @@ enum EndgameCode {
/// Endgame functions can be of two types depending on whether they return a /// Endgame functions can be of two types depending on whether they return a
/// Value or a ScaleFactor. /// Value or a ScaleFactor.
template<EndgameCode E> using template<EndgameCode E> using
eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type; eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type;
@@ -89,37 +91,37 @@ struct Endgame : public EndgameBase<T> {
}; };
/// The Endgames class stores the pointers to endgame evaluation and scaling /// The Endgames namespace handles the pointers to endgame evaluation and scaling
/// base objects in two std::map. We use polymorphism to invoke the actual /// base objects in two std::map. We use polymorphism to invoke the actual
/// endgame function by calling its virtual operator(). /// endgame function by calling its virtual operator().
class Endgames { namespace Endgames {
template<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>; template<typename T> using Ptr = std::unique_ptr<EndgameBase<T>>;
template<typename T> using Map = std::map<Key, Ptr<T>>; template<typename T> using Map = std::unordered_map<Key, Ptr<T>>;
extern std::pair<Map<Value>, Map<ScaleFactor>> maps;
void init();
template<typename T> template<typename T>
Map<T>& map() { Map<T>& map() {
return std::get<std::is_same<T, ScaleFactor>::value>(maps); return std::get<std::is_same<T, ScaleFactor>::value>(maps);
} }
template<EndgameCode E, typename T = eg_type<E>, typename P = Ptr<T>> template<EndgameCode E, typename T = eg_type<E>>
void add(const std::string& code) { void add(const std::string& code) {
StateInfo st; StateInfo st;
map<T>()[Position().set(code, WHITE, &st).material_key()] = P(new Endgame<E>(WHITE)); map<T>()[Position().set(code, WHITE, &st).material_key()] = Ptr<T>(new Endgame<E>(WHITE));
map<T>()[Position().set(code, BLACK, &st).material_key()] = P(new Endgame<E>(BLACK)); map<T>()[Position().set(code, BLACK, &st).material_key()] = Ptr<T>(new Endgame<E>(BLACK));
} }
std::pair<Map<Value>, Map<ScaleFactor>> maps;
public:
Endgames();
template<typename T> template<typename T>
EndgameBase<T>* probe(Key key) { const EndgameBase<T>* probe(Key key) {
return map<T>().count(key) ? map<T>()[key].get() : nullptr; auto it = map<T>().find(key);
return it != map<T>().end() ? it->second.get() : nullptr;
} }
}; }
#endif // #ifndef ENDGAME_H_INCLUDED #endif // #ifndef ENDGAME_H_INCLUDED
src/evaluate.cpp
+527 -591
View File
File diff suppressed because it is too large Load Diff
src/evaluate.h
+2 -4
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -29,9 +29,7 @@ class Position;
namespace Eval { namespace Eval {
const Value Tempo = Value(20); // Must be visible to search constexpr Value Tempo = Value(28); // Must be visible to search
extern Score Contempt;
std::string trace(const Position& pos); std::string trace(const Position& pos);
src/main.cpp
+3 -5
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@
#include "thread.h" #include "thread.h"
#include "tt.h" #include "tt.h"
#include "uci.h" #include "uci.h"
#include "endgame.h"
#include "syzygy/tbprobe.h" #include "syzygy/tbprobe.h"
namespace PSQT { namespace PSQT {
@@ -41,10 +42,7 @@ int main(int argc, char* argv[]) {
Bitboards::init(); Bitboards::init();
Position::init(); Position::init();
Bitbases::init(); Bitbases::init();
Search::init(); Endgames::init();
Pawns::init();
Tablebases::init(Options["SyzygyPath"]);
TT.resize(Options["Hash"]);
Threads.set(Options["Threads"]); Threads.set(Options["Threads"]);
Search::clear(); // After threads are up Search::clear(); // After threads are up
src/material.cpp
+19 -28
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <algorithm> // For std::min
#include <cassert> #include <cassert>
#include <cstring> // For std::memset #include <cstring> // For std::memset
@@ -31,18 +30,18 @@ namespace {
// Polynomial material imbalance parameters // Polynomial material imbalance parameters
const int QuadraticOurs[][PIECE_TYPE_NB] = { constexpr int QuadraticOurs[][PIECE_TYPE_NB] = {
// OUR PIECES // OUR PIECES
// pair pawn knight bishop rook queen // pair pawn knight bishop rook queen
{1667 }, // Bishop pair {1438 }, // Bishop pair
{ 40, 0 }, // Pawn { 40, 38 }, // Pawn
{ 32, 255, -3 }, // Knight OUR PIECES { 32, 255, -62 }, // Knight OUR PIECES
{ 0, 104, 4, 0 }, // Bishop { 0, 104, 4, 0 }, // Bishop
{ -26, -2, 47, 105, -149 }, // Rook { -26, -2, 47, 105, -208 }, // Rook
{-189, 24, 117, 133, -134, -10 } // Queen {-189, 24, 117, 133, -134, -6 } // Queen
}; };
const int QuadraticTheirs[][PIECE_TYPE_NB] = { constexpr int QuadraticTheirs[][PIECE_TYPE_NB] = {
// THEIR PIECES // THEIR PIECES
// pair pawn knight bishop rook queen // pair pawn knight bishop rook queen
{ 0 }, // Bishop pair { 0 }, // Bishop pair
@@ -68,16 +67,14 @@ namespace {
&& pos.non_pawn_material(us) >= RookValueMg; && pos.non_pawn_material(us) >= RookValueMg;
} }
bool is_KBPsKs(const Position& pos, Color us) { bool is_KBPsK(const Position& pos, Color us) {
return pos.non_pawn_material(us) == BishopValueMg return pos.non_pawn_material(us) == BishopValueMg
&& pos.count<BISHOP>(us) == 1
&& pos.count<PAWN >(us) >= 1; && pos.count<PAWN >(us) >= 1;
} }
bool is_KQKRPs(const Position& pos, Color us) { bool is_KQKRPs(const Position& pos, Color us) {
return !pos.count<PAWN>(us) return !pos.count<PAWN>(us)
&& pos.non_pawn_material(us) == QueenValueMg && pos.non_pawn_material(us) == QueenValueMg
&& pos.count<QUEEN>(us) == 1
&& pos.count<ROOK>(~us) == 1 && pos.count<ROOK>(~us) == 1
&& pos.count<PAWN>(~us) >= 1; && pos.count<PAWN>(~us) >= 1;
} }
@@ -87,7 +84,7 @@ namespace {
template<Color Us> template<Color Us>
int imbalance(const int pieceCount[][PIECE_TYPE_NB]) { int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
const Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
int bonus = 0; int bonus = 0;
@@ -132,7 +129,7 @@ Entry* probe(const Position& pos) {
Value npm_w = pos.non_pawn_material(WHITE); Value npm_w = pos.non_pawn_material(WHITE);
Value npm_b = pos.non_pawn_material(BLACK); Value npm_b = pos.non_pawn_material(BLACK);
Value npm = std::max(EndgameLimit, std::min(npm_w + npm_b, MidgameLimit)); Value npm = clamp(npm_w + npm_b, EndgameLimit, MidgameLimit);
// Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME] // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME]
e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit)); e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit));
@@ -140,10 +137,10 @@ Entry* probe(const Position& pos) {
// Let's look if we have a specialized evaluation function for this particular // Let's look if we have a specialized evaluation function for this particular
// material configuration. Firstly we look for a fixed configuration one, then // material configuration. Firstly we look for a fixed configuration one, then
// for a generic one if the previous search failed. // for a generic one if the previous search failed.
if ((e->evaluationFunction = pos.this_thread()->endgames.probe<Value>(key)) != nullptr) if ((e->evaluationFunction = Endgames::probe<Value>(key)) != nullptr)
return e; return e;
for (Color c = WHITE; c <= BLACK; ++c) for (Color c : { WHITE, BLACK })
if (is_KXK(pos, c)) if (is_KXK(pos, c))
{ {
e->evaluationFunction = &EvaluateKXK[c]; e->evaluationFunction = &EvaluateKXK[c];
@@ -152,9 +149,9 @@ Entry* probe(const Position& pos) {
// OK, we didn't find any special evaluation function for the current material // OK, we didn't find any special evaluation function for the current material
// configuration. Is there a suitable specialized scaling function? // configuration. Is there a suitable specialized scaling function?
EndgameBase<ScaleFactor>* sf; const auto* sf = Endgames::probe<ScaleFactor>(key);
if ((sf = pos.this_thread()->endgames.probe<ScaleFactor>(key)) != nullptr) if (sf)
{ {
e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned
return e; return e;
@@ -163,9 +160,9 @@ Entry* probe(const Position& pos) {
// We didn't find any specialized scaling function, so fall back on generic // We didn't find any specialized scaling function, so fall back on generic
// ones that refer to more than one material distribution. Note that in this // ones that refer to more than one material distribution. Note that in this
// case we don't return after setting the function. // case we don't return after setting the function.
for (Color c = WHITE; c <= BLACK; ++c) for (Color c : { WHITE, BLACK })
{ {
if (is_KBPsKs(pos, c)) if (is_KBPsK(pos, c))
e->scalingFunction[c] = &ScaleKBPsK[c]; e->scalingFunction[c] = &ScaleKBPsK[c];
else if (is_KQKRPs(pos, c)) else if (is_KQKRPs(pos, c))
@@ -206,22 +203,16 @@ Entry* probe(const Position& pos) {
e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW :
npm_w <= BishopValueMg ? 4 : 14); npm_w <= BishopValueMg ? 4 : 14);
if (pos.count<PAWN>(WHITE) == 1 && npm_w - npm_b <= BishopValueMg)
e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN;
if (pos.count<PAWN>(BLACK) == 1 && npm_b - npm_w <= BishopValueMg)
e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN;
// Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
// for the bishop pair "extended piece", which allows us to be more flexible // for the bishop pair "extended piece", which allows us to be more flexible
// in defining bishop pair bonuses. // in defining bishop pair bonuses.
const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = { const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
{ pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE), { pos.count<BISHOP>(WHITE) > 1, pos.count<PAWN>(WHITE), pos.count<KNIGHT>(WHITE),
pos.count<BISHOP>(WHITE) , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) }, pos.count<BISHOP>(WHITE) , pos.count<ROOK>(WHITE), pos.count<QUEEN >(WHITE) },
{ pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK), { pos.count<BISHOP>(BLACK) > 1, pos.count<PAWN>(BLACK), pos.count<KNIGHT>(BLACK),
pos.count<BISHOP>(BLACK) , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } }; pos.count<BISHOP>(BLACK) , pos.count<ROOK>(BLACK), pos.count<QUEEN >(BLACK) } };
e->value = int16_t((imbalance<WHITE>(PieceCount) - imbalance<BLACK>(PieceCount)) / 16); e->value = int16_t((imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16);
return e; return e;
} }
src/material.h
+4 -4
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -56,9 +56,9 @@ struct Entry {
} }
Key key; Key key;
EndgameBase<Value>* evaluationFunction; const EndgameBase<Value>* evaluationFunction;
EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each const EndgameBase<ScaleFactor>* scalingFunction[COLOR_NB]; // Could be one for each
// side (e.g. KPKP, KBPsKs) // side (e.g. KPKP, KBPsK)
int16_t value; int16_t value;
uint8_t factor[COLOR_NB]; uint8_t factor[COLOR_NB];
Phase gamePhase; Phase gamePhase;
src/misc.cpp
+95 -17
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -23,6 +23,11 @@
#undef _WIN32_WINNT #undef _WIN32_WINNT
#define _WIN32_WINNT 0x0601 // Force to include needed API prototypes #define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
#endif #endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h> #include <windows.h>
// The needed Windows API for processor groups could be missed from old Windows // The needed Windows API for processor groups could be missed from old Windows
// versions, so instead of calling them directly (forcing the linker to resolve // versions, so instead of calling them directly (forcing the linker to resolve
@@ -51,7 +56,7 @@ namespace {
/// Version number. If Version is left empty, then compile date in the format /// Version number. If Version is left empty, then compile date in the format
/// DD-MM-YY and show in engine_info. /// DD-MM-YY and show in engine_info.
const string Version = "9"; const string Version = "11";
/// Our fancy logging facility. The trick here is to replace cin.rdbuf() and /// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
/// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We /// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
@@ -97,6 +102,13 @@ public:
if (!fname.empty() && !l.file.is_open()) if (!fname.empty() && !l.file.is_open())
{ {
l.file.open(fname, ifstream::out); l.file.open(fname, ifstream::out);
if (!l.file.is_open())
{
cerr << "Unable to open debug log file " << fname << endl;
exit(EXIT_FAILURE);
}
cin.rdbuf(&l.in); cin.rdbuf(&l.in);
cout.rdbuf(&l.out); cout.rdbuf(&l.out);
} }
@@ -139,8 +151,79 @@ const string engine_info(bool to_uci) {
} }
/// compiler_info() returns a string trying to describe the compiler we use
const std::string compiler_info() {
#define STRINGIFY2(x) #x
#define STRINGIFY(x) STRINGIFY2(x)
#define VER_STRING(major, minor, patch) STRINGIFY(major) "." STRINGIFY(minor) "." STRINGIFY(patch)
/// Predefined macros hell:
///
/// __GNUC__ Compiler is gcc, Clang or Intel on Linux
/// __INTEL_COMPILER Compiler is Intel
/// _MSC_VER Compiler is MSVC or Intel on Windows
/// _WIN32 Building on Windows (any)
/// _WIN64 Building on Windows 64 bit
std::string compiler = "\nCompiled by ";
#ifdef __clang__
compiler += "clang++ ";
compiler += VER_STRING(__clang_major__, __clang_minor__, __clang_patchlevel__);
#elif __INTEL_COMPILER
compiler += "Intel compiler ";
compiler += "(version ";
compiler += STRINGIFY(__INTEL_COMPILER) " update " STRINGIFY(__INTEL_COMPILER_UPDATE);
compiler += ")";
#elif _MSC_VER
compiler += "MSVC ";
compiler += "(version ";
compiler += STRINGIFY(_MSC_FULL_VER) "." STRINGIFY(_MSC_BUILD);
compiler += ")";
#elif __GNUC__
compiler += "g++ (GNUC) ";
compiler += VER_STRING(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
#else
compiler += "Unknown compiler ";
compiler += "(unknown version)";
#endif
#if defined(__APPLE__)
compiler += " on Apple";
#elif defined(__CYGWIN__)
compiler += " on Cygwin";
#elif defined(__MINGW64__)
compiler += " on MinGW64";
#elif defined(__MINGW32__)
compiler += " on MinGW32";
#elif defined(__ANDROID__)
compiler += " on Android";
#elif defined(__linux__)
compiler += " on Linux";
#elif defined(_WIN64)
compiler += " on Microsoft Windows 64-bit";
#elif defined(_WIN32)
compiler += " on Microsoft Windows 32-bit";
#else
compiler += " on unknown system";
#endif
compiler += "\n __VERSION__ macro expands to: ";
#ifdef __VERSION__
compiler += __VERSION__;
#else
compiler += "(undefined macro)";
#endif
compiler += "\n";
return compiler;
}
/// Debug functions used mainly to collect run-time statistics /// Debug functions used mainly to collect run-time statistics
static int64_t hits[2], means[2]; static std::atomic<int64_t> hits[2], means[2];
void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; } void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); } void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
@@ -163,7 +246,7 @@ void dbg_print() {
std::ostream& operator<<(std::ostream& os, SyncCout sc) { std::ostream& operator<<(std::ostream& os, SyncCout sc) {
static Mutex m; static std::mutex m;
if (sc == IO_LOCK) if (sc == IO_LOCK)
m.lock(); m.lock();
@@ -205,12 +288,6 @@ void prefetch(void* addr) {
#endif #endif
void prefetch2(void* addr) {
prefetch(addr);
prefetch((uint8_t*)addr + 64);
}
namespace WinProcGroup { namespace WinProcGroup {
#ifndef _WIN32 #ifndef _WIN32
@@ -219,11 +296,11 @@ void bindThisThread(size_t) {}
#else #else
/// get_group() retrieves logical processor information using Windows specific /// best_group() retrieves logical processor information using Windows specific
/// API and returns the best group id for the thread with index idx. Original /// API and returns the best group id for the thread with index idx. Original
/// code from Texel by Peter Österlund. /// code from Texel by Peter Österlund.
int get_group(size_t idx) { int best_group(size_t idx) {
int threads = 0; int threads = 0;
int nodes = 0; int nodes = 0;
@@ -233,7 +310,7 @@ int get_group(size_t idx) {
// Early exit if the needed API is not available at runtime // Early exit if the needed API is not available at runtime
HMODULE k32 = GetModuleHandle("Kernel32.dll"); HMODULE k32 = GetModuleHandle("Kernel32.dll");
auto fun1 = (fun1_t)GetProcAddress(k32, "GetLogicalProcessorInformationEx"); auto fun1 = (fun1_t)(void(*)())GetProcAddress(k32, "GetLogicalProcessorInformationEx");
if (!fun1) if (!fun1)
return -1; return -1;
@@ -252,7 +329,7 @@ int get_group(size_t idx) {
return -1; return -1;
} }
while (ptr->Size > 0 && byteOffset + ptr->Size <= returnLength) while (byteOffset < returnLength)
{ {
if (ptr->Relationship == RelationNumaNode) if (ptr->Relationship == RelationNumaNode)
nodes++; nodes++;
@@ -263,6 +340,7 @@ int get_group(size_t idx) {
threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1; threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
} }
assert(ptr->Size);
byteOffset += ptr->Size; byteOffset += ptr->Size;
ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size); ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
} }
@@ -294,15 +372,15 @@ int get_group(size_t idx) {
void bindThisThread(size_t idx) { void bindThisThread(size_t idx) {
// Use only local variables to be thread-safe // Use only local variables to be thread-safe
int group = get_group(idx); int group = best_group(idx);
if (group == -1) if (group == -1)
return; return;
// Early exit if the needed API are not available at runtime // Early exit if the needed API are not available at runtime
HMODULE k32 = GetModuleHandle("Kernel32.dll"); HMODULE k32 = GetModuleHandle("Kernel32.dll");
auto fun2 = (fun2_t)GetProcAddress(k32, "GetNumaNodeProcessorMaskEx"); auto fun2 = (fun2_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
auto fun3 = (fun3_t)GetProcAddress(k32, "SetThreadGroupAffinity"); auto fun3 = (fun3_t)(void(*)())GetProcAddress(k32, "SetThreadGroupAffinity");
if (!fun2 || !fun3) if (!fun2 || !fun3)
return; return;
src/misc.h
+5 -3
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -30,8 +30,8 @@
#include "types.h" #include "types.h"
const std::string engine_info(bool to_uci = false); const std::string engine_info(bool to_uci = false);
const std::string compiler_info();
void prefetch(void* addr); void prefetch(void* addr);
void prefetch2(void* addr);
void start_logger(const std::string& fname); void start_logger(const std::string& fname);
void dbg_hit_on(bool b); void dbg_hit_on(bool b);
@@ -41,6 +41,8 @@ void dbg_print();
typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds
static_assert(sizeof(TimePoint) == sizeof(int64_t), "TimePoint should be 64 bits");
inline TimePoint now() { inline TimePoint now() {
return std::chrono::duration_cast<std::chrono::milliseconds> return std::chrono::duration_cast<std::chrono::milliseconds>
(std::chrono::steady_clock::now().time_since_epoch()).count(); (std::chrono::steady_clock::now().time_since_epoch()).count();
@@ -51,7 +53,7 @@ struct HashTable {
Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; } Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; }
private: private:
std::vector<Entry> table = std::vector<Entry>(Size); std::vector<Entry> table = std::vector<Entry>(Size); // Allocate on the heap
}; };
src/movegen.cpp
+43 -93
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -25,46 +25,6 @@
namespace { namespace {
template<CastlingRight Cr, bool Checks, bool Chess960>
ExtMove* generate_castling(const Position& pos, ExtMove* moveList, Color us) {
static const bool KingSide = (Cr == WHITE_OO || Cr == BLACK_OO);
if (pos.castling_impeded(Cr) || !pos.can_castle(Cr))
return moveList;
// After castling, the rook and king final positions are the same in Chess960
// as they would be in standard chess.
Square kfrom = pos.square<KING>(us);
Square rfrom = pos.castling_rook_square(Cr);
Square kto = relative_square(us, KingSide ? SQ_G1 : SQ_C1);
Bitboard enemies = pos.pieces(~us);
assert(!pos.checkers());
const Direction K = Chess960 ? kto > kfrom ? WEST : EAST
: KingSide ? WEST : EAST;
for (Square s = kto; s != kfrom; s += K)
if (pos.attackers_to(s) & enemies)
return moveList;
// Because we generate only legal castling moves we need to verify that
// when moving the castling rook we do not discover some hidden checker.
// For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
if (Chess960 && (attacks_bb<ROOK>(kto, pos.pieces() ^ rfrom) & pos.pieces(~us, ROOK, QUEEN)))
return moveList;
Move m = make<CASTLING>(kfrom, rfrom);
if (Checks && !pos.gives_check(m))
return moveList;
*moveList++ = m;
return moveList;
}
template<GenType Type, Direction D> template<GenType Type, Direction D>
ExtMove* make_promotions(ExtMove* moveList, Square to, Square ksq) { ExtMove* make_promotions(ExtMove* moveList, Square to, Square ksq) {
@@ -92,16 +52,15 @@ namespace {
template<Color Us, GenType Type> template<Color Us, GenType Type>
ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) { ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) {
// Compute our parametrized parameters at compile time, named according to // Compute some compile time parameters relative to the white side
// the point of view of white side. constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
const Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB);
const Bitboard TRank8BB = (Us == WHITE ? Rank8BB : Rank1BB); constexpr Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB);
const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB); constexpr Direction Up = pawn_push(Us);
const Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB); constexpr Direction UpRight = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
const Direction Up = (Us == WHITE ? NORTH : SOUTH); constexpr Direction UpLeft = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
const Direction Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
const Direction Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
const Square ksq = pos.square<KING>(Them);
Bitboard emptySquares; Bitboard emptySquares;
Bitboard pawnsOn7 = pos.pieces(Us, PAWN) & TRank7BB; Bitboard pawnsOn7 = pos.pieces(Us, PAWN) & TRank7BB;
@@ -126,8 +85,6 @@ namespace {
if (Type == QUIET_CHECKS) if (Type == QUIET_CHECKS)
{ {
Square ksq = pos.square<KING>(Them);
b1 &= pos.attacks_from<PAWN>(ksq, Them); b1 &= pos.attacks_from<PAWN>(ksq, Them);
b2 &= pos.attacks_from<PAWN>(ksq, Them); b2 &= pos.attacks_from<PAWN>(ksq, Them);
@@ -135,10 +92,10 @@ namespace {
// if the pawn is not on the same file as the enemy king, because we // if the pawn is not on the same file as the enemy king, because we
// don't generate captures. Note that a possible discovery check // don't generate captures. Note that a possible discovery check
// promotion has been already generated amongst the captures. // promotion has been already generated amongst the captures.
Bitboard dcCandidates = pos.discovered_check_candidates(); Bitboard dcCandidateQuiets = pos.blockers_for_king(Them) & pawnsNotOn7;
if (pawnsNotOn7 & dcCandidates) if (dcCandidateQuiets)
{ {
Bitboard dc1 = shift<Up>(pawnsNotOn7 & dcCandidates) & emptySquares & ~file_bb(ksq); Bitboard dc1 = shift<Up>(dcCandidateQuiets) & emptySquares & ~file_bb(ksq);
Bitboard dc2 = shift<Up>(dc1 & TRank3BB) & emptySquares; Bitboard dc2 = shift<Up>(dc1 & TRank3BB) & emptySquares;
b1 |= dc1; b1 |= dc1;
@@ -160,7 +117,7 @@ namespace {
} }
// Promotions and underpromotions // Promotions and underpromotions
if (pawnsOn7 && (Type != EVASIONS || (target & TRank8BB))) if (pawnsOn7)
{ {
if (Type == CAPTURES) if (Type == CAPTURES)
emptySquares = ~pos.pieces(); emptySquares = ~pos.pieces();
@@ -168,38 +125,36 @@ namespace {
if (Type == EVASIONS) if (Type == EVASIONS)
emptySquares &= target; emptySquares &= target;
Bitboard b1 = shift<Right>(pawnsOn7) & enemies; Bitboard b1 = shift<UpRight>(pawnsOn7) & enemies;
Bitboard b2 = shift<Left >(pawnsOn7) & enemies; Bitboard b2 = shift<UpLeft >(pawnsOn7) & enemies;
Bitboard b3 = shift<Up >(pawnsOn7) & emptySquares; Bitboard b3 = shift<Up >(pawnsOn7) & emptySquares;
Square ksq = pos.square<KING>(Them);
while (b1) while (b1)
moveList = make_promotions<Type, Right>(moveList, pop_lsb(&b1), ksq); moveList = make_promotions<Type, UpRight>(moveList, pop_lsb(&b1), ksq);
while (b2) while (b2)
moveList = make_promotions<Type, Left >(moveList, pop_lsb(&b2), ksq); moveList = make_promotions<Type, UpLeft >(moveList, pop_lsb(&b2), ksq);
while (b3) while (b3)
moveList = make_promotions<Type, Up >(moveList, pop_lsb(&b3), ksq); moveList = make_promotions<Type, Up >(moveList, pop_lsb(&b3), ksq);
} }
// Standard and en-passant captures // Standard and en-passant captures
if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS) if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)
{ {
Bitboard b1 = shift<Right>(pawnsNotOn7) & enemies; Bitboard b1 = shift<UpRight>(pawnsNotOn7) & enemies;
Bitboard b2 = shift<Left >(pawnsNotOn7) & enemies; Bitboard b2 = shift<UpLeft >(pawnsNotOn7) & enemies;
while (b1) while (b1)
{ {
Square to = pop_lsb(&b1); Square to = pop_lsb(&b1);
*moveList++ = make_move(to - Right, to); *moveList++ = make_move(to - UpRight, to);
} }
while (b2) while (b2)
{ {
Square to = pop_lsb(&b2); Square to = pop_lsb(&b2);
*moveList++ = make_move(to - Left, to); *moveList++ = make_move(to - UpLeft, to);
} }
if (pos.ep_square() != SQ_NONE) if (pos.ep_square() != SQ_NONE)
@@ -229,7 +184,7 @@ namespace {
ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Color us, ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Color us,
Bitboard target) { Bitboard target) {
assert(Pt != KING && Pt != PAWN); static_assert(Pt != KING && Pt != PAWN, "Unsupported piece type in generate_moves()");
const Square* pl = pos.squares<Pt>(us); const Square* pl = pos.squares<Pt>(us);
@@ -241,7 +196,7 @@ namespace {
&& !(PseudoAttacks[Pt][from] & target & pos.check_squares(Pt))) && !(PseudoAttacks[Pt][from] & target & pos.check_squares(Pt)))
continue; continue;
if (pos.discovered_check_candidates() & from) if (pos.blockers_for_king(~us) & from)
continue; continue;
} }
@@ -261,7 +216,9 @@ namespace {
template<Color Us, GenType Type> template<Color Us, GenType Type>
ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) { ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) {
const bool Checks = Type == QUIET_CHECKS; constexpr CastlingRights OO = Us & KING_SIDE;
constexpr CastlingRights OOO = Us & QUEEN_SIDE;
constexpr bool Checks = Type == QUIET_CHECKS; // Reduce template instantations
moveList = generate_pawn_moves<Us, Type>(pos, moveList, target); moveList = generate_pawn_moves<Us, Type>(pos, moveList, target);
moveList = generate_moves<KNIGHT, Checks>(pos, moveList, Us, target); moveList = generate_moves<KNIGHT, Checks>(pos, moveList, Us, target);
@@ -275,19 +232,14 @@ namespace {
Bitboard b = pos.attacks_from<KING>(ksq) & target; Bitboard b = pos.attacks_from<KING>(ksq) & target;
while (b) while (b)
*moveList++ = make_move(ksq, pop_lsb(&b)); *moveList++ = make_move(ksq, pop_lsb(&b));
}
if (Type != CAPTURES && Type != EVASIONS && pos.can_castle(Us)) if (Type != CAPTURES && pos.can_castle(CastlingRights(OO | OOO)))
{
if (pos.is_chess960())
{ {
moveList = generate_castling<MakeCastling<Us, KING_SIDE>::right, Checks, true>(pos, moveList, Us); if (!pos.castling_impeded(OO) && pos.can_castle(OO))
moveList = generate_castling<MakeCastling<Us, QUEEN_SIDE>::right, Checks, true>(pos, moveList, Us); *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(OO));
}
else if (!pos.castling_impeded(OOO) && pos.can_castle(OOO))
{ *moveList++ = make<CASTLING>(ksq, pos.castling_rook_square(OOO));
moveList = generate_castling<MakeCastling<Us, KING_SIDE>::right, Checks, false>(pos, moveList, Us);
moveList = generate_castling<MakeCastling<Us, QUEEN_SIDE>::right, Checks, false>(pos, moveList, Us);
} }
} }
@@ -297,19 +249,16 @@ namespace {
} // namespace } // namespace
/// generate<CAPTURES> generates all pseudo-legal captures and queen /// <CAPTURES> Generates all pseudo-legal captures and queen promotions
/// promotions. Returns a pointer to the end of the move list. /// <QUIETS> Generates all pseudo-legal non-captures and underpromotions
/// <NON_EVASIONS> Generates all pseudo-legal captures and non-captures
/// ///
/// generate<QUIETS> generates all pseudo-legal non-captures and /// Returns a pointer to the end of the move list.
/// underpromotions. Returns a pointer to the end of the move list.
///
/// generate<NON_EVASIONS> generates all pseudo-legal captures and
/// non-captures. Returns a pointer to the end of the move list.
template<GenType Type> template<GenType Type>
ExtMove* generate(const Position& pos, ExtMove* moveList) { ExtMove* generate(const Position& pos, ExtMove* moveList) {
assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS); static_assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS, "Unsupported type in generate()");
assert(!pos.checkers()); assert(!pos.checkers());
Color us = pos.side_to_move(); Color us = pos.side_to_move();
@@ -336,7 +285,7 @@ ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* moveList) {
assert(!pos.checkers()); assert(!pos.checkers());
Color us = pos.side_to_move(); Color us = pos.side_to_move();
Bitboard dc = pos.discovered_check_candidates(); Bitboard dc = pos.blockers_for_king(~us) & pos.pieces(us);
while (dc) while (dc)
{ {
@@ -403,8 +352,9 @@ ExtMove* generate<EVASIONS>(const Position& pos, ExtMove* moveList) {
template<> template<>
ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) { ExtMove* generate<LEGAL>(const Position& pos, ExtMove* moveList) {
Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); Color us = pos.side_to_move();
Square ksq = pos.square<KING>(pos.side_to_move()); Bitboard pinned = pos.blockers_for_king(us) & pos.pieces(us);
Square ksq = pos.square<KING>(us);
ExtMove* cur = moveList; ExtMove* cur = moveList;
moveList = pos.checkers() ? generate<EVASIONS >(pos, moveList) moveList = pos.checkers() ? generate<EVASIONS >(pos, moveList)
src/movegen.h
+1 -1
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
src/movepick.cpp
+126 -189
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -25,12 +25,10 @@
namespace { namespace {
enum Stages { enum Stages {
MAIN_SEARCH, CAPTURES_INIT, GOOD_CAPTURES, KILLERS, COUNTERMOVE, QUIET_INIT, QUIET, BAD_CAPTURES, MAIN_TT, CAPTURE_INIT, GOOD_CAPTURE, REFUTATION, QUIET_INIT, QUIET, BAD_CAPTURE,
EVASION, EVASIONS_INIT, ALL_EVASIONS, EVASION_TT, EVASION_INIT, EVASION,
PROBCUT, PROBCUT_INIT, PROBCUT_CAPTURES, PROBCUT_TT, PROBCUT_INIT, PROBCUT,
QSEARCH_WITH_CHECKS, QCAPTURES_1_INIT, QCAPTURES_1, QCHECKS, QSEARCH_TT, QCAPTURE_INIT, QCAPTURE, QCHECK_INIT, QCHECK
QSEARCH_NO_CHECKS, QCAPTURES_2_INIT, QCAPTURES_2,
QSEARCH_RECAPTURES, QRECAPTURES
}; };
// partial_insertion_sort() sorts moves in descending order up to and including // partial_insertion_sort() sorts moves in descending order up to and including
@@ -48,15 +46,6 @@ namespace {
} }
} }
// pick_best() finds the best move in the range (begin, end) and moves it to
// the front. It's faster than sorting all the moves in advance when there
// are few moves, e.g., the possible captures.
Move pick_best(ExtMove* begin, ExtMove* end) {
std::swap(*begin, *std::max_element(begin, end));
return *begin;
}
} // namespace } // namespace
@@ -68,62 +57,49 @@ namespace {
/// MovePicker constructor for the main search /// MovePicker constructor for the main search
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,
const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers_p) const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers)
: pos(p), mainHistory(mh), captureHistory(cph), contHistory(ch), countermove(cm), : pos(p), mainHistory(mh), captureHistory(cph), continuationHistory(ch),
killers{killers_p[0], killers_p[1]}, depth(d){ refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d) {
assert(d > DEPTH_ZERO); assert(d > 0);
stage = pos.checkers() ? EVASION : MAIN_SEARCH; stage = pos.checkers() ? EVASION_TT : MAIN_TT;
ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE; ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
stage += (ttMove == MOVE_NONE); stage += (ttMove == MOVE_NONE);
} }
/// MovePicker constructor for quiescence search /// MovePicker constructor for quiescence search
MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const CapturePieceToHistory* cph, Square s) MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh,
: pos(p), mainHistory(mh), captureHistory(cph) { const CapturePieceToHistory* cph, const PieceToHistory** ch, Square rs)
: pos(p), mainHistory(mh), captureHistory(cph), continuationHistory(ch), recaptureSquare(rs), depth(d) {
assert(d <= DEPTH_ZERO); assert(d <= 0);
if (pos.checkers()) stage = pos.checkers() ? EVASION_TT : QSEARCH_TT;
stage = EVASION; ttMove = ttm
&& (depth > DEPTH_QS_RECAPTURES || to_sq(ttm) == recaptureSquare)
else if (d > DEPTH_QS_NO_CHECKS) && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
stage = QSEARCH_WITH_CHECKS;
else if (d > DEPTH_QS_RECAPTURES)
stage = QSEARCH_NO_CHECKS;
else
{
stage = QSEARCH_RECAPTURES;
recaptureSquare = s;
return;
}
ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE;
stage += (ttMove == MOVE_NONE); stage += (ttMove == MOVE_NONE);
} }
/// MovePicker constructor for ProbCut: we generate captures with SEE higher /// MovePicker constructor for ProbCut: we generate captures with SEE greater
/// than or equal to the given threshold. /// than or equal to the given threshold.
MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph) MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph)
: pos(p), captureHistory(cph), threshold(th) { : pos(p), captureHistory(cph), threshold(th) {
assert(!pos.checkers()); assert(!pos.checkers());
stage = PROBCUT; stage = PROBCUT_TT;
ttMove = ttm ttMove = ttm
&& pos.pseudo_legal(ttm)
&& pos.capture(ttm) && pos.capture(ttm)
&& pos.pseudo_legal(ttm)
&& pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE; && pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE;
stage += (ttMove == MOVE_NONE); stage += (ttMove == MOVE_NONE);
} }
/// score() assigns a numerical value to each move in a list, used for sorting. /// MovePicker::score() assigns a numerical value to each move in a list, used
/// Captures are ordered by Most Valuable Victim (MVV), preferring captures /// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
/// with a good history. Quiets are ordered using the histories. /// captures with a good history. Quiets moves are ordered using the histories.
template<GenType Type> template<GenType Type>
void MovePicker::score() { void MovePicker::score() {
@@ -131,14 +107,15 @@ void MovePicker::score() {
for (auto& m : *this) for (auto& m : *this)
if (Type == CAPTURES) if (Type == CAPTURES)
m.value = PieceValue[MG][pos.piece_on(to_sq(m))] m.value = int(PieceValue[MG][pos.piece_on(to_sq(m))]) * 6
+ Value((*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))]); + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))];
else if (Type == QUIETS) else if (Type == QUIETS)
m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] m.value = (*mainHistory)[pos.side_to_move()][from_to(m)]
+ (*contHistory[0])[pos.moved_piece(m)][to_sq(m)] + 2 * (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
+ (*contHistory[1])[pos.moved_piece(m)][to_sq(m)] + 2 * (*continuationHistory[1])[pos.moved_piece(m)][to_sq(m)]
+ (*contHistory[3])[pos.moved_piece(m)][to_sq(m)]; + 2 * (*continuationHistory[3])[pos.moved_piece(m)][to_sq(m)]
+ (*continuationHistory[5])[pos.moved_piece(m)][to_sq(m)];
else // Type == EVASIONS else // Type == EVASIONS
{ {
@@ -146,189 +123,149 @@ void MovePicker::score() {
m.value = PieceValue[MG][pos.piece_on(to_sq(m))] m.value = PieceValue[MG][pos.piece_on(to_sq(m))]
- Value(type_of(pos.moved_piece(m))); - Value(type_of(pos.moved_piece(m)));
else else
m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] - (1 << 28); m.value = (*mainHistory)[pos.side_to_move()][from_to(m)]
+ (*continuationHistory[0])[pos.moved_piece(m)][to_sq(m)]
- (1 << 28);
} }
} }
/// next_move() is the most important method of the MovePicker class. It returns /// MovePicker::select() returns the next move satisfying a predicate function.
/// a new pseudo legal move every time it is called, until there are no more moves /// It never returns the TT move.
/// left. It picks the move with the biggest value from a list of generated moves template<MovePicker::PickType T, typename Pred>
/// taking care not to return the ttMove if it has already been searched. Move MovePicker::select(Pred filter) {
while (cur < endMoves)
{
if (T == Best)
std::swap(*cur, *std::max_element(cur, endMoves));
if (*cur != ttMove && filter())
return *cur++;
cur++;
}
return MOVE_NONE;
}
/// MovePicker::next_move() is the most important method of the MovePicker class. It
/// returns a new pseudo legal move every time it is called until there are no more
/// moves left, picking the move with the highest score from a list of generated moves.
Move MovePicker::next_move(bool skipQuiets) { Move MovePicker::next_move(bool skipQuiets) {
Move move; top:
switch (stage) { switch (stage) {
case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS: case MAIN_TT:
case QSEARCH_NO_CHECKS: case PROBCUT: case EVASION_TT:
case QSEARCH_TT:
case PROBCUT_TT:
++stage; ++stage;
return ttMove; return ttMove;
case CAPTURES_INIT: case CAPTURE_INIT:
endBadCaptures = cur = moves; case PROBCUT_INIT:
case QCAPTURE_INIT:
cur = endBadCaptures = moves;
endMoves = generate<CAPTURES>(pos, cur); endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>(); score<CAPTURES>();
++stage; ++stage;
/* fallthrough */ goto top;
case GOOD_CAPTURES: case GOOD_CAPTURE:
while (cur < endMoves) if (select<Best>([&](){
{ return pos.see_ge(*cur, Value(-55 * cur->value / 1024)) ?
move = pick_best(cur++, endMoves); // Move losing capture to endBadCaptures to be tried later
if (move != ttMove) true : (*endBadCaptures++ = *cur, false); }))
{ return *(cur - 1);
if (pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)))
return move;
// Losing capture, move it to the beginning of the array // Prepare the pointers to loop over the refutations array
*endBadCaptures++ = move; cur = std::begin(refutations);
} endMoves = std::end(refutations);
}
// If the countermove is the same as a killer, skip it
if ( refutations[0].move == refutations[2].move
|| refutations[1].move == refutations[2].move)
--endMoves;
++stage; ++stage;
move = killers[0]; // First killer move
if ( move != MOVE_NONE
&& move != ttMove
&& pos.pseudo_legal(move)
&& !pos.capture(move))
return move;
/* fallthrough */ /* fallthrough */
case KILLERS: case REFUTATION:
if (select<Next>([&](){ return *cur != MOVE_NONE
&& !pos.capture(*cur)
&& pos.pseudo_legal(*cur); }))
return *(cur - 1);
++stage; ++stage;
move = killers[1]; // Second killer move
if ( move != MOVE_NONE
&& move != ttMove
&& pos.pseudo_legal(move)
&& !pos.capture(move))
return move;
/* fallthrough */
case COUNTERMOVE:
++stage;
move = countermove;
if ( move != MOVE_NONE
&& move != ttMove
&& move != killers[0]
&& move != killers[1]
&& pos.pseudo_legal(move)
&& !pos.capture(move))
return move;
/* fallthrough */ /* fallthrough */
case QUIET_INIT: case QUIET_INIT:
cur = endBadCaptures; if (!skipQuiets)
endMoves = generate<QUIETS>(pos, cur); {
score<QUIETS>(); cur = endBadCaptures;
partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY); endMoves = generate<QUIETS>(pos, cur);
score<QUIETS>();
partial_insertion_sort(cur, endMoves, -3000 * depth);
}
++stage; ++stage;
/* fallthrough */ /* fallthrough */
case QUIET: case QUIET:
while ( cur < endMoves if ( !skipQuiets
&& (!skipQuiets || cur->value >= VALUE_ZERO)) && select<Next>([&](){return *cur != refutations[0].move
{ && *cur != refutations[1].move
move = *cur++; && *cur != refutations[2].move;}))
return *(cur - 1);
// Prepare the pointers to loop over the bad captures
cur = moves;
endMoves = endBadCaptures;
if ( move != ttMove
&& move != killers[0]
&& move != killers[1]
&& move != countermove)
return move;
}
++stage; ++stage;
cur = moves; // Point to beginning of bad captures
/* fallthrough */ /* fallthrough */
case BAD_CAPTURES: case BAD_CAPTURE:
if (cur < endBadCaptures) return select<Next>([](){ return true; });
return *cur++;
break;
case EVASIONS_INIT: case EVASION_INIT:
cur = moves; cur = moves;
endMoves = generate<EVASIONS>(pos, cur); endMoves = generate<EVASIONS>(pos, cur);
score<EVASIONS>(); score<EVASIONS>();
++stage; ++stage;
/* fallthrough */ /* fallthrough */
case ALL_EVASIONS: case EVASION:
while (cur < endMoves) return select<Best>([](){ return true; });
{
move = pick_best(cur++, endMoves); case PROBCUT:
if (move != ttMove) return select<Best>([&](){ return pos.see_ge(*cur, threshold); });
return move;
} case QCAPTURE:
break; if (select<Best>([&](){ return depth > DEPTH_QS_RECAPTURES
|| to_sq(*cur) == recaptureSquare; }))
return *(cur - 1);
// If we did not find any move and we do not try checks, we have finished
if (depth != DEPTH_QS_CHECKS)
return MOVE_NONE;
case PROBCUT_INIT:
cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
++stage; ++stage;
/* fallthrough */ /* fallthrough */
case PROBCUT_CAPTURES: case QCHECK_INIT:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
if ( move != ttMove
&& pos.see_ge(move, threshold))
return move;
}
break;
case QCAPTURES_1_INIT: case QCAPTURES_2_INIT:
cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
++stage;
/* fallthrough */
case QCAPTURES_1: case QCAPTURES_2:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
if (move != ttMove)
return move;
}
if (stage == QCAPTURES_2)
break;
cur = moves; cur = moves;
endMoves = generate<QUIET_CHECKS>(pos, cur); endMoves = generate<QUIET_CHECKS>(pos, cur);
++stage; ++stage;
/* fallthrough */ /* fallthrough */
case QCHECKS: case QCHECK:
while (cur < endMoves) return select<Next>([](){ return true; });
{
move = cur++->move;
if (move != ttMove)
return move;
}
break;
case QSEARCH_RECAPTURES:
cur = moves;
endMoves = generate<CAPTURES>(pos, cur);
score<CAPTURES>();
++stage;
/* fallthrough */
case QRECAPTURES:
while (cur < endMoves)
{
move = pick_best(cur++, endMoves);
if (to_sq(move) == recaptureSquare)
return move;
}
break;
default:
assert(false);
} }
return MOVE_NONE; assert(false);
return MOVE_NONE; // Silence warning
} }
src/movepick.h
+69 -69
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -23,95 +23,85 @@
#include <array> #include <array>
#include <limits> #include <limits>
#include <type_traits>
#include "movegen.h" #include "movegen.h"
#include "position.h" #include "position.h"
#include "types.h" #include "types.h"
/// StatBoards is a generic 2-dimensional array used to store various statistics /// StatsEntry stores the stat table value. It is usually a number but could
template<int Size1, int Size2, typename T = int16_t> /// be a move or even a nested history. We use a class instead of naked value
struct StatBoards : public std::array<std::array<T, Size2>, Size1> { /// to directly call history update operator<<() on the entry so to use stats
/// tables at caller sites as simple multi-dim arrays.
template<typename T, int D>
class StatsEntry {
void fill(const T& v) { T entry;
T* p = &(*this)[0][0];
std::fill(p, p + sizeof(*this) / sizeof(*p), v);
}
void update(T& entry, int bonus, const int D) { public:
void operator=(const T& v) { entry = v; }
T* operator&() { return &entry; }
T* operator->() { return &entry; }
operator const T&() const { return entry; }
assert(abs(bonus) <= D); // Ensure range is [-32 * D, 32 * D] void operator<<(int bonus) {
assert(abs(32 * D) < (std::numeric_limits<T>::max)()); // Ensure we don't overflow assert(abs(bonus) <= D); // Ensure range is [-D, D]
static_assert(D <= std::numeric_limits<T>::max(), "D overflows T");
entry += bonus * 32 - entry * abs(bonus) / D; entry += bonus - entry * abs(bonus) / D;
assert(abs(entry) <= 32 * D); assert(abs(entry) <= D);
} }
}; };
/// StatCubes is a generic 3-dimensional array used to store various statistics /// Stats is a generic N-dimensional array used to store various statistics.
template<int Size1, int Size2, int Size3, typename T = int16_t> /// The first template parameter T is the base type of the array, the second
struct StatCubes : public std::array<std::array<std::array<T, Size3>, Size2>, Size1> { /// template parameter D limits the range of updates in [-D, D] when we update
/// values with the << operator, while the last parameters (Size and Sizes)
/// encode the dimensions of the array.
template <typename T, int D, int Size, int... Sizes>
struct Stats : public std::array<Stats<T, D, Sizes...>, Size>
{
typedef Stats<T, D, Size, Sizes...> stats;
void fill(const T& v) { void fill(const T& v) {
T* p = &(*this)[0][0][0];
std::fill(p, p + sizeof(*this) / sizeof(*p), v);
}
void update(T& entry, int bonus, const int D, const int W) { // For standard-layout 'this' points to first struct member
assert(std::is_standard_layout<stats>::value);
assert(abs(bonus) <= D); // Ensure range is [-W * D, W * D] typedef StatsEntry<T, D> entry;
assert(abs(W * D) < (std::numeric_limits<T>::max)()); // Ensure we don't overflow entry* p = reinterpret_cast<entry*>(this);
std::fill(p, p + sizeof(*this) / sizeof(entry), v);
entry += bonus * W - entry * abs(bonus) / D;
assert(abs(entry) <= W * D);
} }
}; };
/// ButterflyBoards are 2 tables (one for each color) indexed by the move's from template <typename T, int D, int Size>
/// and to squares, see chessprogramming.wikispaces.com/Butterfly+Boards struct Stats<T, D, Size> : public std::array<StatsEntry<T, D>, Size> {};
typedef StatBoards<COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)> ButterflyBoards;
/// PieceToBoards are addressed by a move's [piece][to] information /// In stats table, D=0 means that the template parameter is not used
typedef StatBoards<PIECE_NB, SQUARE_NB> PieceToBoards; enum StatsParams { NOT_USED = 0 };
enum StatsType { NoCaptures, Captures };
/// CapturePieceToBoards are addressed by a move's [piece][to][captured piece type] information
typedef StatCubes<PIECE_NB, SQUARE_NB, PIECE_TYPE_NB> CapturePieceToBoards;
/// ButterflyHistory records how often quiet moves have been successful or /// ButterflyHistory records how often quiet moves have been successful or
/// unsuccessful during the current search, and is used for reduction and move /// unsuccessful during the current search, and is used for reduction and move
/// ordering decisions. It uses ButterflyBoards as backing store. /// ordering decisions. It uses 2 tables (one for each color) indexed by
struct ButterflyHistory : public ButterflyBoards { /// the move's from and to squares, see www.chessprogramming.org/Butterfly_Boards
typedef Stats<int16_t, 10692, COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)> ButterflyHistory;
void update(Color c, Move m, int bonus) {
StatBoards::update((*this)[c][from_to(m)], bonus, 324);
}
};
/// PieceToHistory is like ButterflyHistory, but is based on PieceToBoards
struct PieceToHistory : public PieceToBoards {
void update(Piece pc, Square to, int bonus) {
StatBoards::update((*this)[pc][to], bonus, 936);
}
};
/// CapturePieceToHistory is like PieceToHistory, but is based on CapturePieceToBoards
struct CapturePieceToHistory : public CapturePieceToBoards {
void update(Piece pc, Square to, PieceType captured, int bonus) {
StatCubes::update((*this)[pc][to][captured], bonus, 324, 2);
}
};
/// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous /// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous
/// move, see chessprogramming.wikispaces.com/Countermove+Heuristic /// move, see www.chessprogramming.org/Countermove_Heuristic
typedef StatBoards<PIECE_NB, SQUARE_NB, Move> CounterMoveHistory; typedef Stats<Move, NOT_USED, PIECE_NB, SQUARE_NB> CounterMoveHistory;
/// ContinuationHistory is the history of a given pair of moves, usually the /// CapturePieceToHistory is addressed by a move's [piece][to][captured piece type]
/// current one given a previous one. History table is based on PieceToBoards typedef Stats<int16_t, 10692, PIECE_NB, SQUARE_NB, PIECE_TYPE_NB> CapturePieceToHistory;
/// instead of ButterflyBoards.
typedef StatBoards<PIECE_NB, SQUARE_NB, PieceToHistory> ContinuationHistory; /// PieceToHistory is like ButterflyHistory but is addressed by a move's [piece][to]
typedef Stats<int16_t, 29952, PIECE_NB, SQUARE_NB> PieceToHistory;
/// ContinuationHistory is the combined history of a given pair of moves, usually
/// the current one given a previous one. The nested history table is based on
/// PieceToHistory instead of ButterflyBoards.
typedef Stats<PieceToHistory, NOT_USED, PIECE_NB, SQUARE_NB> ContinuationHistory;
/// MovePicker class is used to pick one pseudo legal move at a time from the /// MovePicker class is used to pick one pseudo legal move at a time from the
@@ -120,17 +110,27 @@ typedef StatBoards<PIECE_NB, SQUARE_NB, PieceToHistory> ContinuationHistory;
/// when MOVE_NONE is returned. In order to improve the efficiency of the alpha /// 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 /// beta algorithm, MovePicker attempts to return the moves which are most likely
/// to get a cut-off first. /// to get a cut-off first.
class MovePicker { class MovePicker {
enum PickType { Next, Best };
public: public:
MovePicker(const MovePicker&) = delete; MovePicker(const MovePicker&) = delete;
MovePicker& operator=(const MovePicker&) = delete; MovePicker& operator=(const MovePicker&) = delete;
MovePicker(const Position&, Move, Value, const CapturePieceToHistory*); MovePicker(const Position&, Move, Value, const CapturePieceToHistory*);
MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, Square); MovePicker(const Position&, Move, Depth, const ButterflyHistory*,
MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, Move, Move*); const CapturePieceToHistory*,
const PieceToHistory**,
Square);
MovePicker(const Position&, Move, Depth, const ButterflyHistory*,
const CapturePieceToHistory*,
const PieceToHistory**,
Move,
Move*);
Move next_move(bool skipQuiets = false); Move next_move(bool skipQuiets = false);
private: private:
template<PickType T, typename Pred> Move select(Pred);
template<GenType> void score(); template<GenType> void score();
ExtMove* begin() { return cur; } ExtMove* begin() { return cur; }
ExtMove* end() { return endMoves; } ExtMove* end() { return endMoves; }
@@ -138,9 +138,9 @@ private:
const Position& pos; const Position& pos;
const ButterflyHistory* mainHistory; const ButterflyHistory* mainHistory;
const CapturePieceToHistory* captureHistory; const CapturePieceToHistory* captureHistory;
const PieceToHistory** contHistory; const PieceToHistory** continuationHistory;
Move ttMove, countermove, killers[2]; Move ttMove;
ExtMove *cur, *endMoves, *endBadCaptures; ExtMove refutations[3], *cur, *endMoves, *endBadCaptures;
int stage; int stage;
Square recaptureSquare; Square recaptureSquare;
Value threshold; Value threshold;
src/pawns.cpp
+117 -161
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -31,153 +31,124 @@ namespace {
#define V Value #define V Value
#define S(mg, eg) make_score(mg, eg) #define S(mg, eg) make_score(mg, eg)
// Isolated pawn penalty // Pawn penalties
const Score Isolated = S(13, 18); constexpr Score Backward = S( 9, 24);
constexpr Score BlockedStorm = S(82, 82);
constexpr Score Doubled = S(11, 56);
constexpr Score Isolated = S( 5, 15);
constexpr Score WeakLever = S( 0, 56);
constexpr Score WeakUnopposed = S(13, 27);
// Backward pawn penalty // Connected pawn bonus
const Score Backward = S(24, 12); constexpr int Connected[RANK_NB] = { 0, 7, 8, 12, 29, 48, 86 };
// Connected pawn bonus by opposed, phalanx, #support and rank // Strength of pawn shelter for our king by [distance from edge][rank].
Score Connected[2][2][3][RANK_NB]; // RANK_1 = 0 is used for files where we have no pawn, or pawn is behind our king.
constexpr Value ShelterStrength[int(FILE_NB) / 2][RANK_NB] = {
// Doubled pawn penalty { V( -6), V( 81), V( 93), V( 58), V( 39), V( 18), V( 25) },
const Score Doubled = S(18, 38); { V(-43), V( 61), V( 35), V(-49), V(-29), V(-11), V( -63) },
{ V(-10), V( 75), V( 23), V( -2), V( 32), V( 3), V( -45) },
// Weakness of our pawn shelter in front of the king by [isKingFile][distance from edge][rank]. { V(-39), V(-13), V(-29), V(-52), V(-48), V(-67), V(-166) }
// RANK_1 = 0 is used for files where we have no pawns or our pawn is behind our king.
const Value ShelterWeakness[][int(FILE_NB) / 2][RANK_NB] = {
{ { V( 97), V(17), V( 9), V(44), V( 84), V( 87), V( 99) }, // Not On King file
{ V(106), V( 6), V(33), V(86), V( 87), V(104), V(112) },
{ V(101), V( 2), V(65), V(98), V( 58), V( 89), V(115) },
{ V( 73), V( 7), V(54), V(73), V( 84), V( 83), V(111) } },
{ { V(104), V(20), V( 6), V(27), V( 86), V( 93), V( 82) }, // On King file
{ V(123), V( 9), V(34), V(96), V(112), V( 88), V( 75) },
{ V(120), V(25), V(65), V(91), V( 66), V( 78), V(117) },
{ V( 81), V( 2), V(47), V(63), V( 94), V( 93), V(104) } }
}; };
// Danger of enemy pawns moving toward our king by [type][distance from edge][rank]. // Danger of enemy pawns moving toward our king by [distance from edge][rank].
// For the unopposed and unblocked cases, RANK_1 = 0 is used when opponent has // RANK_1 = 0 is used for files where the enemy has no pawn, or their pawn
// no pawn on the given file, or their pawn is behind our king. // is behind our king. Note that UnblockedStorm[0][1-2] accommodate opponent pawn
const Value StormDanger[][4][RANK_NB] = { // on edge, likely blocked by our king.
{ { V( 0), V(-290), V(-274), V(57), V(41) }, // BlockedByKing constexpr Value UnblockedStorm[int(FILE_NB) / 2][RANK_NB] = {
{ V( 0), V( 60), V( 144), V(39), V(13) }, { V( 85), V(-289), V(-166), V(97), V(50), V( 45), V( 50) },
{ V( 0), V( 65), V( 141), V(41), V(34) }, { V( 46), V( -25), V( 122), V(45), V(37), V(-10), V( 20) },
{ V( 0), V( 53), V( 127), V(56), V(14) } }, { V( -6), V( 51), V( 168), V(34), V(-2), V(-22), V(-14) },
{ { V( 4), V( 73), V( 132), V(46), V(31) }, // Unopposed { V(-15), V( -11), V( 101), V( 4), V(11), V(-15), V(-29) }
{ V( 1), V( 64), V( 143), V(26), V(13) },
{ V( 1), V( 47), V( 110), V(44), V(24) },
{ V( 0), V( 72), V( 127), V(50), V(31) } },
{ { V( 0), V( 0), V( 79), V(23), V( 1) }, // BlockedByPawn
{ V( 0), V( 0), V( 148), V(27), V( 2) },
{ V( 0), V( 0), V( 161), V(16), V( 1) },
{ V( 0), V( 0), V( 171), V(22), V(15) } },
{ { V(22), V( 45), V( 104), V(62), V( 6) }, // Unblocked
{ V(31), V( 30), V( 99), V(39), V(19) },
{ V(23), V( 29), V( 96), V(41), V(15) },
{ V(21), V( 23), V( 116), V(41), V(15) } }
}; };
// Max bonus for king safety. Corresponds to start position with all the pawns
// in front of the king and no enemy pawn on the horizon.
const Value MaxSafetyBonus = V(258);
#undef S #undef S
#undef V #undef V
template<Color Us> template<Color Us>
Score evaluate(const Position& pos, Pawns::Entry* e) { Score evaluate(const Position& pos, Pawns::Entry* e) {
const Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
const Direction Up = (Us == WHITE ? NORTH : SOUTH); constexpr Direction Up = pawn_push(Us);
const Direction Right = (Us == WHITE ? NORTH_EAST : SOUTH_WEST);
const Direction Left = (Us == WHITE ? NORTH_WEST : SOUTH_EAST);
Bitboard b, neighbours, stoppers, doubled, supported, phalanx; Bitboard neighbours, stoppers, support, phalanx, opposed;
Bitboard lever, leverPush; Bitboard lever, leverPush, blocked;
Square s; Square s;
bool opposed, backward; bool backward, passed, doubled;
Score score = SCORE_ZERO; Score score = SCORE_ZERO;
const Square* pl = pos.squares<PAWN>(Us); const Square* pl = pos.squares<PAWN>(Us);
Bitboard ourPawns = pos.pieces( Us, PAWN); Bitboard ourPawns = pos.pieces( Us, PAWN);
Bitboard theirPawns = pos.pieces(Them, PAWN); Bitboard theirPawns = pos.pieces(Them, PAWN);
e->passedPawns[Us] = e->pawnAttacksSpan[Us] = e->weakUnopposed[Us] = 0; Bitboard doubleAttackThem = pawn_double_attacks_bb<Them>(theirPawns);
e->semiopenFiles[Us] = 0xFF;
e->kingSquares[Us] = SQ_NONE; e->passedPawns[Us] = 0;
e->pawnAttacks[Us] = shift<Right>(ourPawns) | shift<Left>(ourPawns); e->kingSquares[Us] = SQ_NONE;
e->pawnsOnSquares[Us][BLACK] = popcount(ourPawns & DarkSquares); e->pawnAttacks[Us] = e->pawnAttacksSpan[Us] = pawn_attacks_bb<Us>(ourPawns);
e->pawnsOnSquares[Us][WHITE] = pos.count<PAWN>(Us) - e->pawnsOnSquares[Us][BLACK];
// Loop through all pawns of the current color and score each pawn // Loop through all pawns of the current color and score each pawn
while ((s = *pl++) != SQ_NONE) while ((s = *pl++) != SQ_NONE)
{ {
assert(pos.piece_on(s) == make_piece(Us, PAWN)); assert(pos.piece_on(s) == make_piece(Us, PAWN));
File f = file_of(s); Rank r = relative_rank(Us, s);
e->semiopenFiles[Us] &= ~(1 << f);
e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s);
// Flag the pawn // Flag the pawn
opposed = theirPawns & forward_file_bb(Us, s); opposed = theirPawns & forward_file_bb(Us, s);
stoppers = theirPawns & passed_pawn_mask(Us, s); blocked = theirPawns & (s + Up);
stoppers = theirPawns & passed_pawn_span(Us, s);
lever = theirPawns & PawnAttacks[Us][s]; lever = theirPawns & PawnAttacks[Us][s];
leverPush = theirPawns & PawnAttacks[Us][s + Up]; leverPush = theirPawns & PawnAttacks[Us][s + Up];
doubled = ourPawns & (s - Up); doubled = ourPawns & (s - Up);
neighbours = ourPawns & adjacent_files_bb(f); neighbours = ourPawns & adjacent_files_bb(s);
phalanx = neighbours & rank_bb(s); phalanx = neighbours & rank_bb(s);
supported = neighbours & rank_bb(s - Up); support = neighbours & rank_bb(s - Up);
// A pawn is backward when it is behind all pawns of the same color on the // A pawn is backward when it is behind all pawns of the same color on
// adjacent files and cannot be safely advanced. // the adjacent files and cannot safely advance.
if (!neighbours || lever || relative_rank(Us, s) >= RANK_5) backward = !(neighbours & forward_ranks_bb(Them, s + Up))
backward = false; && (leverPush | blocked);
else
{
// Find the backmost rank with neighbours or stoppers
b = rank_bb(backmost_sq(Us, neighbours | stoppers));
// The pawn is backward when it cannot safely progress to that rank: // Compute additional span if pawn is not backward nor blocked
// either there is a stopper in the way on this rank, or there is a if (!backward && !blocked)
// stopper on adjacent file which controls the way to that rank. e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s);
backward = (b | shift<Up>(b & adjacent_files_bb(f))) & stoppers;
assert(!(backward && (forward_ranks_bb(Them, s + Up) & neighbours))); // A pawn is passed if one of the three following conditions is true:
} // (a) there is no stoppers except some levers
// (b) the only stoppers are the leverPush, but we outnumber them
// (c) there is only one front stopper which can be levered.
passed = !(stoppers ^ lever)
|| ( !(stoppers ^ leverPush)
&& popcount(phalanx) >= popcount(leverPush))
|| ( stoppers == blocked && r >= RANK_5
&& (shift<Up>(support) & ~(theirPawns | doubleAttackThem)));
// Passed pawns will be properly scored in evaluation because we need // Passed pawns will be properly scored later in evaluation when we have
// full attack info to evaluate them. Include also not passed pawns // full attack info.
// which could become passed after one or two pawn pushes when are if (passed)
// not attacked more times than defended.
if ( !(stoppers ^ lever ^ leverPush)
&& !(ourPawns & forward_file_bb(Us, s))
&& popcount(supported) >= popcount(lever)
&& popcount(phalanx) >= popcount(leverPush))
e->passedPawns[Us] |= s; e->passedPawns[Us] |= s;
else if ( stoppers == SquareBB[s + Up] // Score this pawn
&& relative_rank(Us, s) >= RANK_5) if (support | phalanx)
{ {
b = shift<Up>(supported) & ~theirPawns; int v = Connected[r] * (2 + bool(phalanx) - bool(opposed))
while (b) + 21 * popcount(support);
if (!more_than_one(theirPawns & PawnAttacks[Us][pop_lsb(&b)]))
e->passedPawns[Us] |= s; score += make_score(v, v * (r - 2) / 4);
} }
// Score this pawn
if (supported | phalanx)
score += Connected[opposed][bool(phalanx)][popcount(supported)][relative_rank(Us, s)];
else if (!neighbours) else if (!neighbours)
score -= Isolated, e->weakUnopposed[Us] += !opposed; score -= Isolated
+ WeakUnopposed * !opposed;
else if (backward) else if (backward)
score -= Backward, e->weakUnopposed[Us] += !opposed; score -= Backward
+ WeakUnopposed * !opposed;
if (doubled && !supported) if (!support)
score -= Doubled; score -= Doubled * doubled
+ WeakLever * more_than_one(lever);
} }
return score; return score;
@@ -187,27 +158,6 @@ namespace {
namespace Pawns { namespace Pawns {
/// Pawns::init() initializes some tables needed by evaluation. Instead of using
/// hard-coded tables, when makes sense, we prefer to calculate them with a formula
/// to reduce independent parameters and to allow easier tuning and better insight.
void init() {
static const int Seed[RANK_NB] = { 0, 13, 24, 18, 76, 100, 175, 330 };
for (int opposed = 0; opposed <= 1; ++opposed)
for (int phalanx = 0; phalanx <= 1; ++phalanx)
for (int support = 0; support <= 2; ++support)
for (Rank r = RANK_2; r < RANK_8; ++r)
{
int v = 17 * support;
v += (Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0)) >> opposed;
Connected[opposed][phalanx][support][r] = make_score(v, v * (r - 2) / 4);
}
}
/// Pawns::probe() looks up the current position's pawns configuration in /// Pawns::probe() looks up the current position's pawns configuration in
/// the pawns hash table. It returns a pointer to the Entry if the position /// the pawns hash table. It returns a pointer to the Entry if the position
/// is found. Otherwise a new Entry is computed and stored there, so we don't /// is found. Otherwise a new Entry is computed and stored there, so we don't
@@ -222,47 +172,46 @@ Entry* probe(const Position& pos) {
return e; return e;
e->key = key; e->key = key;
e->score = evaluate<WHITE>(pos, e) - evaluate<BLACK>(pos, e); e->scores[WHITE] = evaluate<WHITE>(pos, e);
e->asymmetry = popcount(e->semiopenFiles[WHITE] ^ e->semiopenFiles[BLACK]); e->scores[BLACK] = evaluate<BLACK>(pos, e);
e->openFiles = popcount(e->semiopenFiles[WHITE] & e->semiopenFiles[BLACK]);
return e; return e;
} }
/// Entry::shelter_storm() calculates shelter and storm penalties for the file /// Entry::evaluate_shelter() calculates the shelter bonus and the storm
/// the king is on, as well as the two closest files. /// penalty for a king, looking at the king file and the two closest files.
template<Color Us> template<Color Us>
Value Entry::shelter_storm(const Position& pos, Square ksq) { Score Entry::evaluate_shelter(const Position& pos, Square ksq) {
const Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Color Them = (Us == WHITE ? BLACK : WHITE);
enum { BlockedByKing, Unopposed, BlockedByPawn, Unblocked }; Bitboard b = pos.pieces(PAWN) & ~forward_ranks_bb(Them, ksq);
Bitboard b = pos.pieces(PAWN) & (forward_ranks_bb(Us, ksq) | rank_bb(ksq));
Bitboard ourPawns = b & pos.pieces(Us); Bitboard ourPawns = b & pos.pieces(Us);
Bitboard theirPawns = b & pos.pieces(Them); Bitboard theirPawns = b & pos.pieces(Them);
Value safety = MaxSafetyBonus;
File center = std::max(FILE_B, std::min(FILE_G, file_of(ksq)));
Score bonus = make_score(5, 5);
File center = clamp(file_of(ksq), FILE_B, FILE_G);
for (File f = File(center - 1); f <= File(center + 1); ++f) for (File f = File(center - 1); f <= File(center + 1); ++f)
{ {
b = ourPawns & file_bb(f); b = ourPawns & file_bb(f);
Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1; int ourRank = b ? relative_rank(Us, frontmost_sq(Them, b)) : 0;
b = theirPawns & file_bb(f); b = theirPawns & file_bb(f);
Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1; int theirRank = b ? relative_rank(Us, frontmost_sq(Them, b)) : 0;
int d = std::min(f, ~f); File d = map_to_queenside(f);
safety -= ShelterWeakness[f == file_of(ksq)][d][rkUs] bonus += make_score(ShelterStrength[d][ourRank], 0);
+ StormDanger
[f == file_of(ksq) && rkThem == relative_rank(Us, ksq) + 1 ? BlockedByKing : if (ourRank && (ourRank == theirRank - 1))
rkUs == RANK_1 ? Unopposed : bonus -= BlockedStorm * int(theirRank == RANK_3);
rkThem == rkUs + 1 ? BlockedByPawn : Unblocked] else
[d][rkThem]; bonus -= make_score(UnblockedStorm[d][theirRank], 0);
} }
return safety; return bonus;
} }
@@ -270,30 +219,37 @@ Value Entry::shelter_storm(const Position& pos, Square ksq) {
/// when king square changes, which is about 20% of total king_safety() calls. /// when king square changes, which is about 20% of total king_safety() calls.
template<Color Us> template<Color Us>
Score Entry::do_king_safety(const Position& pos, Square ksq) { Score Entry::do_king_safety(const Position& pos) {
Square ksq = pos.square<KING>(Us);
kingSquares[Us] = ksq; kingSquares[Us] = ksq;
castlingRights[Us] = pos.can_castle(Us); castlingRights[Us] = pos.castling_rights(Us);
int minKingPawnDistance = 0; auto compare = [](Score a, Score b) { return mg_value(a) < mg_value(b); };
Score shelter = evaluate_shelter<Us>(pos, ksq);
// If we can castle use the bonus after castling if it is bigger
if (pos.can_castle(Us & KING_SIDE))
shelter = std::max(shelter, evaluate_shelter<Us>(pos, relative_square(Us, SQ_G1)), compare);
if (pos.can_castle(Us & QUEEN_SIDE))
shelter = std::max(shelter, evaluate_shelter<Us>(pos, relative_square(Us, SQ_C1)), compare);
// In endgame we like to bring our king near our closest pawn
Bitboard pawns = pos.pieces(Us, PAWN); Bitboard pawns = pos.pieces(Us, PAWN);
if (pawns) int minPawnDist = pawns ? 8 : 0;
while (!(DistanceRingBB[ksq][minKingPawnDistance++] & pawns)) {}
Value bonus = shelter_storm<Us>(pos, ksq); if (pawns & PseudoAttacks[KING][ksq])
minPawnDist = 1;
else while (pawns)
minPawnDist = std::min(minPawnDist, distance(ksq, pop_lsb(&pawns)));
// If we can castle use the bonus after the castling if it is bigger return shelter - make_score(0, 16 * minPawnDist);
if (pos.can_castle(MakeCastling<Us, KING_SIDE>::right))
bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_G1)));
if (pos.can_castle(MakeCastling<Us, QUEEN_SIDE>::right))
bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
return make_score(bonus, -16 * minKingPawnDistance);
} }
// Explicit template instantiation // Explicit template instantiation
template Score Entry::do_king_safety<WHITE>(const Position& pos, Square ksq); template Score Entry::do_king_safety<WHITE>(const Position& pos);
template Score Entry::do_king_safety<BLACK>(const Position& pos, Square ksq); template Score Entry::do_king_safety<BLACK>(const Position& pos);
} // namespace Pawns } // namespace Pawns
src/pawns.h
+11 -31
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -33,56 +33,36 @@ namespace Pawns {
struct Entry { struct Entry {
Score pawns_score() const { return score; } Score pawn_score(Color c) const { return scores[c]; }
Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; } Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
Bitboard passed_pawns(Color c) const { return passedPawns[c]; } Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; } Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; }
int weak_unopposed(Color c) const { return weakUnopposed[c]; } int passed_count() const { return popcount(passedPawns[WHITE] | passedPawns[BLACK]); }
int pawn_asymmetry() const { return asymmetry; }
int open_files() const { return openFiles; }
int semiopen_file(Color c, File f) const { template<Color Us>
return semiopenFiles[c] & (1 << f); Score king_safety(const Position& pos) {
} return kingSquares[Us] == pos.square<KING>(Us) && castlingRights[Us] == pos.castling_rights(Us)
? kingSafety[Us] : (kingSafety[Us] = do_king_safety<Us>(pos));
int semiopen_side(Color c, File f, bool leftSide) const {
return semiopenFiles[c] & (leftSide ? (1 << f) - 1 : ~((1 << (f + 1)) - 1));
}
int pawns_on_same_color_squares(Color c, Square s) const {
return pawnsOnSquares[c][bool(DarkSquares & s)];
} }
template<Color Us> template<Color Us>
Score king_safety(const Position& pos, Square ksq) { Score do_king_safety(const Position& pos);
return kingSquares[Us] == ksq && castlingRights[Us] == pos.can_castle(Us)
? kingSafety[Us] : (kingSafety[Us] = do_king_safety<Us>(pos, ksq));
}
template<Color Us> template<Color Us>
Score do_king_safety(const Position& pos, Square ksq); Score evaluate_shelter(const Position& pos, Square ksq);
template<Color Us>
Value shelter_storm(const Position& pos, Square ksq);
Key key; Key key;
Score score; Score scores[COLOR_NB];
Bitboard passedPawns[COLOR_NB]; Bitboard passedPawns[COLOR_NB];
Bitboard pawnAttacks[COLOR_NB]; Bitboard pawnAttacks[COLOR_NB];
Bitboard pawnAttacksSpan[COLOR_NB]; Bitboard pawnAttacksSpan[COLOR_NB];
Square kingSquares[COLOR_NB]; Square kingSquares[COLOR_NB];
Score kingSafety[COLOR_NB]; Score kingSafety[COLOR_NB];
int weakUnopposed[COLOR_NB];
int castlingRights[COLOR_NB]; int castlingRights[COLOR_NB];
int semiopenFiles[COLOR_NB];
int pawnsOnSquares[COLOR_NB][COLOR_NB]; // [color][light/dark squares]
int asymmetry;
int openFiles;
}; };
typedef HashTable<Entry, 16384> Table; typedef HashTable<Entry, 131072> Table;
void init();
Entry* probe(const Position& pos); Entry* probe(const Position& pos);
} // namespace Pawns } // namespace Pawns
src/position.cpp
+251 -166
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -36,10 +36,6 @@
using std::string; using std::string;
namespace PSQT {
extern Score psq[PIECE_NB][SQUARE_NB];
}
namespace Zobrist { namespace Zobrist {
Key psq[PIECE_NB][SQUARE_NB]; Key psq[PIECE_NB][SQUARE_NB];
@@ -52,38 +48,8 @@ namespace {
const string PieceToChar(" PNBRQK pnbrqk"); const string PieceToChar(" PNBRQK pnbrqk");
const Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING, constexpr Piece Pieces[] = { W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING }; B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING };
// min_attacker() is a helper function used by see_ge() to locate the least
// valuable attacker for the side to move, remove the attacker we just found
// from the bitboards and scan for new X-ray attacks behind it.
template<int Pt>
PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers,
Bitboard& occupied, Bitboard& attackers) {
Bitboard b = stmAttackers & bb[Pt];
if (!b)
return min_attacker<Pt + 1>(bb, to, stmAttackers, occupied, attackers);
occupied ^= b & ~(b - 1);
if (Pt == PAWN || Pt == BISHOP || Pt == QUEEN)
attackers |= attacks_bb<BISHOP>(to, occupied) & (bb[BISHOP] | bb[QUEEN]);
if (Pt == ROOK || Pt == QUEEN)
attackers |= attacks_bb<ROOK>(to, occupied) & (bb[ROOK] | bb[QUEEN]);
attackers &= occupied; // After X-ray that may add already processed pieces
return (PieceType)Pt;
}
template<>
PieceType min_attacker<KING>(const Bitboard*, Square, Bitboard, Bitboard&, Bitboard&) {
return KING; // No need to update bitboards: it is the last cycle
}
} // namespace } // namespace
@@ -125,6 +91,19 @@ std::ostream& operator<<(std::ostream& os, const Position& pos) {
} }
// Marcel van Kervinck's cuckoo algorithm for fast detection of "upcoming repetition"
// situations. Description of the algorithm in the following paper:
// https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf
// First and second hash functions for indexing the cuckoo tables
inline int H1(Key h) { return h & 0x1fff; }
inline int H2(Key h) { return (h >> 16) & 0x1fff; }
// Cuckoo tables with Zobrist hashes of valid reversible moves, and the moves themselves
Key cuckoo[8192];
Move cuckooMove[8192];
/// Position::init() initializes at startup the various arrays used to compute /// Position::init() initializes at startup the various arrays used to compute
/// hash keys. /// hash keys.
@@ -152,6 +131,30 @@ void Position::init() {
Zobrist::side = rng.rand<Key>(); Zobrist::side = rng.rand<Key>();
Zobrist::noPawns = rng.rand<Key>(); Zobrist::noPawns = rng.rand<Key>();
// Prepare the cuckoo tables
std::memset(cuckoo, 0, sizeof(cuckoo));
std::memset(cuckooMove, 0, sizeof(cuckooMove));
int count = 0;
for (Piece pc : Pieces)
for (Square s1 = SQ_A1; s1 <= SQ_H8; ++s1)
for (Square s2 = Square(s1 + 1); s2 <= SQ_H8; ++s2)
if (PseudoAttacks[type_of(pc)][s1] & s2)
{
Move move = make_move(s1, s2);
Key key = Zobrist::psq[pc][s1] ^ Zobrist::psq[pc][s2] ^ Zobrist::side;
int i = H1(key);
while (true)
{
std::swap(cuckoo[i], key);
std::swap(cuckooMove[i], move);
if (move == MOVE_NONE) // Arrived at empty slot?
break;
i = (i == H1(key)) ? H2(key) : H1(key); // Push victim to alternative slot
}
count++;
}
assert(count == 3668);
} }
@@ -292,24 +295,18 @@ Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Th
void Position::set_castling_right(Color c, Square rfrom) { void Position::set_castling_right(Color c, Square rfrom) {
Square kfrom = square<KING>(c); Square kfrom = square<KING>(c);
CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; CastlingRights cr = c & (kfrom < rfrom ? KING_SIDE: QUEEN_SIDE);
CastlingRight cr = (c | cs);
st->castlingRights |= cr; st->castlingRights |= cr;
castlingRightsMask[kfrom] |= cr; castlingRightsMask[kfrom] |= cr;
castlingRightsMask[rfrom] |= cr; castlingRightsMask[rfrom] |= cr;
castlingRookSquare[cr] = rfrom; castlingRookSquare[cr] = rfrom;
Square kto = relative_square(c, cs == KING_SIDE ? SQ_G1 : SQ_C1); Square kto = relative_square(c, cr & KING_SIDE ? SQ_G1 : SQ_C1);
Square rto = relative_square(c, cs == KING_SIDE ? SQ_F1 : SQ_D1); Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);
for (Square s = std::min(rfrom, rto); s <= std::max(rfrom, rto); ++s) castlingPath[cr] = (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto)
if (s != kfrom && s != rfrom) & ~(square_bb(kfrom) | rfrom);
castlingPath[cr] |= s;
for (Square s = std::min(kfrom, kto); s <= std::max(kfrom, kto); ++s)
if (s != kfrom && s != rfrom)
castlingPath[cr] |= s;
} }
@@ -317,8 +314,8 @@ void Position::set_castling_right(Color c, Square rfrom) {
void Position::set_check_info(StateInfo* si) const { void Position::set_check_info(StateInfo* si) const {
si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]); si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]); si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);
Square ksq = square<KING>(~sideToMove); Square ksq = square<KING>(~sideToMove);
@@ -341,7 +338,6 @@ void Position::set_state(StateInfo* si) const {
si->key = si->materialKey = 0; si->key = si->materialKey = 0;
si->pawnKey = Zobrist::noPawns; si->pawnKey = Zobrist::noPawns;
si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO; si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO;
si->psq = SCORE_ZERO;
si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove); si->checkersBB = attackers_to(square<KING>(sideToMove)) & pieces(~sideToMove);
set_check_info(si); set_check_info(si);
@@ -351,7 +347,12 @@ void Position::set_state(StateInfo* si) const {
Square s = pop_lsb(&b); Square s = pop_lsb(&b);
Piece pc = piece_on(s); Piece pc = piece_on(s);
si->key ^= Zobrist::psq[pc][s]; si->key ^= Zobrist::psq[pc][s];
si->psq += PSQT::psq[pc][s];
if (type_of(pc) == PAWN)
si->pawnKey ^= Zobrist::psq[pc][s];
else if (type_of(pc) != KING)
si->nonPawnMaterial[color_of(pc)] += PieceValue[MG][pc];
} }
if (si->epSquare != SQ_NONE) if (si->epSquare != SQ_NONE)
@@ -362,20 +363,9 @@ void Position::set_state(StateInfo* si) const {
si->key ^= Zobrist::castling[si->castlingRights]; si->key ^= Zobrist::castling[si->castlingRights];
for (Bitboard b = pieces(PAWN); b; )
{
Square s = pop_lsb(&b);
si->pawnKey ^= Zobrist::psq[piece_on(s)][s];
}
for (Piece pc : Pieces) for (Piece pc : Pieces)
{
if (type_of(pc) != PAWN && type_of(pc) != KING)
si->nonPawnMaterial[color_of(pc)] += pieceCount[pc] * PieceValue[MG][pc];
for (int cnt = 0; cnt < pieceCount[pc]; ++cnt) for (int cnt = 0; cnt < pieceCount[pc]; ++cnt)
si->materialKey ^= Zobrist::psq[pc][cnt]; si->materialKey ^= Zobrist::psq[pc][cnt];
}
} }
@@ -429,18 +419,18 @@ const string Position::fen() const {
ss << (sideToMove == WHITE ? " w " : " b "); ss << (sideToMove == WHITE ? " w " : " b ");
if (can_castle(WHITE_OO)) if (can_castle(WHITE_OO))
ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | KING_SIDE))) : 'K'); ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO ))) : 'K');
if (can_castle(WHITE_OOO)) if (can_castle(WHITE_OOO))
ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE | QUEEN_SIDE))) : 'Q'); ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q');
if (can_castle(BLACK_OO)) if (can_castle(BLACK_OO))
ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | KING_SIDE))) : 'k'); ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO ))) : 'k');
if (can_castle(BLACK_OOO)) if (can_castle(BLACK_OOO))
ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK | QUEEN_SIDE))) : 'q'); ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q');
if (!can_castle(WHITE) && !can_castle(BLACK)) if (!can_castle(ANY_CASTLING))
ss << '-'; ss << '-';
ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ") ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(ep_square()) + " ")
@@ -459,26 +449,27 @@ const string Position::fen() const {
Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const { Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const {
Bitboard result = 0; Bitboard blockers = 0;
pinners = 0; pinners = 0;
// Snipers are sliders that attack 's' when a piece is removed // Snipers are sliders that attack 's' when a piece and other snipers are removed
Bitboard snipers = ( (PseudoAttacks[ ROOK][s] & pieces(QUEEN, ROOK)) Bitboard snipers = ( (PseudoAttacks[ ROOK][s] & pieces(QUEEN, ROOK))
| (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders; | (PseudoAttacks[BISHOP][s] & pieces(QUEEN, BISHOP))) & sliders;
Bitboard occupancy = pieces() ^ snipers;
while (snipers) while (snipers)
{ {
Square sniperSq = pop_lsb(&snipers); Square sniperSq = pop_lsb(&snipers);
Bitboard b = between_bb(s, sniperSq) & pieces(); Bitboard b = between_bb(s, sniperSq) & occupancy;
if (!more_than_one(b)) if (b && !more_than_one(b))
{ {
result |= b; blockers |= b;
if (b & pieces(color_of(piece_on(s)))) if (b & pieces(color_of(piece_on(s))))
pinners |= sniperSq; pinners |= sniperSq;
} }
} }
return result; return blockers;
} }
@@ -504,6 +495,7 @@ bool Position::legal(Move m) const {
Color us = sideToMove; Color us = sideToMove;
Square from = from_sq(m); Square from = from_sq(m);
Square to = to_sq(m);
assert(color_of(moved_piece(m)) == us); assert(color_of(moved_piece(m)) == us);
assert(piece_on(square<KING>(us)) == make_piece(us, KING)); assert(piece_on(square<KING>(us)) == make_piece(us, KING));
@@ -514,7 +506,6 @@ bool Position::legal(Move m) const {
if (type_of(m) == ENPASSANT) if (type_of(m) == ENPASSANT)
{ {
Square ksq = square<KING>(us); Square ksq = square<KING>(us);
Square to = to_sq(m);
Square capsq = to - pawn_push(us); Square capsq = to - pawn_push(us);
Bitboard occupied = (pieces() ^ from ^ capsq) | to; Bitboard occupied = (pieces() ^ from ^ capsq) | to;
@@ -527,16 +518,35 @@ bool Position::legal(Move m) const {
&& !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP)); && !(attacks_bb<BISHOP>(ksq, occupied) & pieces(~us, QUEEN, BISHOP));
} }
// If the moving piece is a king, check whether the destination // Castling moves generation does not check if the castling path is clear of
// square is attacked by the opponent. Castling moves are checked // enemy attacks, it is delayed at a later time: now!
// for legality during move generation. if (type_of(m) == CASTLING)
{
// After castling, the rook and king final positions are the same in
// Chess960 as they would be in standard chess.
to = relative_square(us, to > from ? SQ_G1 : SQ_C1);
Direction step = to > from ? WEST : EAST;
for (Square s = to; s != from; s += step)
if (attackers_to(s) & pieces(~us))
return false;
// In case of Chess960, verify that when moving the castling rook we do
// not discover some hidden checker.
// For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1.
return !chess960
|| !(attacks_bb<ROOK>(to, pieces() ^ to_sq(m)) & pieces(~us, ROOK, QUEEN));
}
// If the moving piece is a king, check whether the destination square is
// attacked by the opponent.
if (type_of(piece_on(from)) == KING) if (type_of(piece_on(from)) == KING)
return type_of(m) == CASTLING || !(attackers_to(to_sq(m)) & pieces(~us)); return !(attackers_to(to) & pieces(~us));
// A non-king move is legal if and only if it is not pinned or it // A non-king move is legal if and only if it is not pinned or it
// is moving along the ray towards or away from the king. // is moving along the ray towards or away from the king.
return !(pinned_pieces(us) & from) return !(blockers_for_king(us) & from)
|| aligned(from, to_sq(m), square<KING>(us)); || aligned(from, to, square<KING>(us));
} }
@@ -573,7 +583,7 @@ bool Position::pseudo_legal(const Move m) const {
{ {
// We have already handled promotion moves, so destination // We have already handled promotion moves, so destination
// cannot be on the 8th/1st rank. // cannot be on the 8th/1st rank.
if (rank_of(to) == relative_rank(us, RANK_8)) if ((Rank8BB | Rank1BB) & to)
return false; return false;
if ( !(attacks_from<PAWN>(from, us) & pieces(~us) & to) // Not a capture if ( !(attacks_from<PAWN>(from, us) & pieces(~us) & to) // Not a capture
@@ -627,7 +637,7 @@ bool Position::gives_check(Move m) const {
return true; return true;
// Is there a discovered check? // Is there a discovered check?
if ( (discovered_check_candidates() & from) if ( (st->blockersForKing[~sideToMove] & from)
&& !aligned(from, to, square<KING>(~sideToMove))) && !aligned(from, to, square<KING>(~sideToMove)))
return true; return true;
@@ -712,7 +722,6 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
Square rfrom, rto; Square rfrom, rto;
do_castling<true>(us, from, to, rfrom, rto); do_castling<true>(us, from, to, rfrom, rto);
st->psq += PSQT::psq[captured][rto] - PSQT::psq[captured][rfrom];
k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto]; k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto];
captured = NO_PIECE; captured = NO_PIECE;
} }
@@ -751,9 +760,6 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]]; st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]];
prefetch(thisThread->materialTable[st->materialKey]); prefetch(thisThread->materialTable[st->materialKey]);
// Update incremental scores
st->psq -= PSQT::psq[captured][capsq];
// Reset rule 50 counter // Reset rule 50 counter
st->rule50 = 0; st->rule50 = 0;
} }
@@ -807,24 +813,17 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1] st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1]
^ Zobrist::psq[pc][pieceCount[pc]]; ^ Zobrist::psq[pc][pieceCount[pc]];
// Update incremental score
st->psq += PSQT::psq[promotion][to] - PSQT::psq[pc][to];
// Update material // Update material
st->nonPawnMaterial[us] += PieceValue[MG][promotion]; st->nonPawnMaterial[us] += PieceValue[MG][promotion];
} }
// Update pawn hash key and prefetch access to pawnsTable // Update pawn hash key
st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to]; st->pawnKey ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to];
prefetch2(thisThread->pawnsTable[st->pawnKey]);
// Reset rule 50 draw counter // Reset rule 50 draw counter
st->rule50 = 0; st->rule50 = 0;
} }
// Update incremental scores
st->psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
// Set capture piece // Set capture piece
st->capturedPiece = captured; st->capturedPiece = captured;
@@ -839,6 +838,25 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) {
// Update king attacks used for fast check detection // Update king attacks used for fast check detection
set_check_info(st); set_check_info(st);
// Calculate the repetition info. It is the ply distance from the previous
// occurrence of the same position, negative in the 3-fold case, or zero
// if the position was not repeated.
st->repetition = 0;
int end = std::min(st->rule50, st->pliesFromNull);
if (end >= 4)
{
StateInfo* stp = st->previous->previous;
for (int i = 4; i <= end; i += 2)
{
stp = stp->previous->previous;
if (stp->key == st->key)
{
st->repetition = stp->repetition ? -i : i;
break;
}
}
}
assert(pos_is_ok()); assert(pos_is_ok());
} }
@@ -926,7 +944,7 @@ void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Squ
} }
/// Position::do(undo)_null_move() is used to do(undo) a "null move": It flips /// Position::do(undo)_null_move() is used to do(undo) a "null move": it flips
/// the side to move without executing any move on the board. /// the side to move without executing any move on the board.
void Position::do_null_move(StateInfo& newSt) { void Position::do_null_move(StateInfo& newSt) {
@@ -954,6 +972,8 @@ void Position::do_null_move(StateInfo& newSt) {
set_check_info(st); set_check_info(st);
st->repetition = 0;
assert(pos_is_ok()); assert(pos_is_ok());
} }
@@ -998,84 +1018,96 @@ bool Position::see_ge(Move m, Value threshold) const {
return VALUE_ZERO >= threshold; return VALUE_ZERO >= threshold;
Square from = from_sq(m), to = to_sq(m); Square from = from_sq(m), to = to_sq(m);
PieceType nextVictim = type_of(piece_on(from));
Color stm = ~color_of(piece_on(from)); // First consider opponent's move
Value balance; // Values of the pieces taken by us minus opponent's ones
Bitboard occupied, stmAttackers;
// The opponent may be able to recapture so this is the best result int swap = PieceValue[MG][piece_on(to)] - threshold;
// we can hope for. if (swap < 0)
balance = PieceValue[MG][piece_on(to)] - threshold;
if (balance < VALUE_ZERO)
return false; return false;
// Now assume the worst possible result: that the opponent can swap = PieceValue[MG][piece_on(from)] - swap;
// capture our piece for free. if (swap <= 0)
balance -= PieceValue[MG][nextVictim];
if (balance >= VALUE_ZERO) // Always true if nextVictim == KING
return true; return true;
bool opponentToMove = true; Bitboard occupied = pieces() ^ from ^ to;
occupied = pieces() ^ from ^ to; Color stm = color_of(piece_on(from));
Bitboard attackers = attackers_to(to, occupied);
// Find all attackers to the destination square, with the moving piece removed, Bitboard stmAttackers, bb;
// but possibly an X-ray attacker added behind it. int res = 1;
Bitboard attackers = attackers_to(to, occupied) & occupied;
while (true) while (true)
{ {
// The balance is negative only because we assumed we could win stm = ~stm;
// the last piece for free. We are truly winning only if we can attackers &= occupied;
// win the last piece _cheaply enough_. Test if we can actually
// do this otherwise "give up".
assert(balance < VALUE_ZERO);
stmAttackers = attackers & pieces(stm); // If stm has no more attackers then give up: stm loses
if (!(stmAttackers = attackers & pieces(stm)))
break;
// Don't allow pinned pieces to attack pieces except the king as long all // Don't allow pinned pieces to attack (except the king) as long as
// pinners are on their original square. // there are pinners on their original square.
if (!(st->pinnersForKing[stm] & ~occupied)) if (st->pinners[~stm] & occupied)
stmAttackers &= ~st->blockersForKing[stm]; stmAttackers &= ~st->blockersForKing[stm];
// If we have no more attackers we must give up
if (!stmAttackers) if (!stmAttackers)
break; break;
// Locate and remove the next least valuable attacker res ^= 1;
nextVictim = min_attacker<PAWN>(byTypeBB, to, stmAttackers, occupied, attackers);
if (nextVictim == KING) // Locate and remove the next least valuable attacker, and add to
// the bitboard 'attackers' any X-ray attackers behind it.
if ((bb = stmAttackers & pieces(PAWN)))
{ {
// Our only attacker is the king. If the opponent still has if ((swap = PawnValueMg - swap) < res)
// attackers we must give up. Otherwise we make the move and break;
// (having no more attackers) the opponent must give up.
if (!(attackers & pieces(~stm))) occupied ^= lsb(bb);
opponentToMove = !opponentToMove; attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
break;
} }
// Assume the opponent can win the next piece for free and switch sides else if ((bb = stmAttackers & pieces(KNIGHT)))
balance += PieceValue[MG][nextVictim]; {
opponentToMove = !opponentToMove; if ((swap = KnightValueMg - swap) < res)
break;
// If balance is negative after receiving a free piece then give up occupied ^= lsb(bb);
if (balance < VALUE_ZERO) }
break;
// Complete the process of switching sides. The first line swaps else if ((bb = stmAttackers & pieces(BISHOP)))
// all negative numbers with non-negative numbers. The compiler {
// probably knows that it is just the bitwise negation ~balance. if ((swap = BishopValueMg - swap) < res)
balance = -balance-1; break;
stm = ~stm;
occupied ^= lsb(bb);
attackers |= attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN);
}
else if ((bb = stmAttackers & pieces(ROOK)))
{
if ((swap = RookValueMg - swap) < res)
break;
occupied ^= lsb(bb);
attackers |= attacks_bb<ROOK>(to, occupied) & pieces(ROOK, QUEEN);
}
else if ((bb = stmAttackers & pieces(QUEEN)))
{
if ((swap = QueenValueMg - swap) < res)
break;
occupied ^= lsb(bb);
attackers |= (attacks_bb<BISHOP>(to, occupied) & pieces(BISHOP, QUEEN))
| (attacks_bb<ROOK >(to, occupied) & pieces(ROOK , QUEEN));
}
else // KING
// If we "capture" with the king but opponent still has attackers,
// reverse the result.
return (attackers & ~pieces(stm)) ? res ^ 1 : res;
} }
// If the opponent gave up we win, otherwise we lose. return bool(res);
return opponentToMove;
} }
/// Position::is_draw() tests whether the position is drawn by 50-move rule /// Position::is_draw() tests whether the position is drawn by 50-move rule
/// or by repetition. It does not detect stalemates. /// or by repetition. It does not detect stalemates.
@@ -1084,25 +1116,78 @@ bool Position::is_draw(int ply) const {
if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size())) if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
return true; return true;
// Return a draw score if a position repeats once earlier but strictly
// after the root, or repeats twice before or at the root.
if (st->repetition && st->repetition < ply)
return true;
return false;
}
// Position::has_repeated() tests whether there has been at least one repetition
// of positions since the last capture or pawn move.
bool Position::has_repeated() const {
StateInfo* stc = st;
int end = std::min(st->rule50, st->pliesFromNull);
while (end-- >= 4)
{
if (stc->repetition)
return true;
stc = stc->previous;
}
return false;
}
/// Position::has_game_cycle() tests if the position has a move which draws by repetition,
/// or an earlier position has a move that directly reaches the current position.
bool Position::has_game_cycle(int ply) const {
int j;
int end = std::min(st->rule50, st->pliesFromNull); int end = std::min(st->rule50, st->pliesFromNull);
if (end < 4) if (end < 3)
return false; return false;
StateInfo* stp = st->previous->previous; Key originalKey = st->key;
int cnt = 0; StateInfo* stp = st->previous;
for (int i = 4; i <= end; i += 2) for (int i = 3; i <= end; i += 2)
{ {
stp = stp->previous->previous; stp = stp->previous->previous;
// Return a draw score if a position repeats once earlier but strictly Key moveKey = originalKey ^ stp->key;
// after the root, or repeats twice before or at the root. if ( (j = H1(moveKey), cuckoo[j] == moveKey)
if ( stp->key == st->key || (j = H2(moveKey), cuckoo[j] == moveKey))
&& ++cnt + (ply > i) == 2) {
return true; Move move = cuckooMove[j];
} Square s1 = from_sq(move);
Square s2 = to_sq(move);
if (!(between_bb(s1, s2) & pieces()))
{
if (ply > i)
return true;
// For nodes before or at the root, check that the move is a
// repetition rather than a move to the current position.
// In the cuckoo table, both moves Rc1c5 and Rc5c1 are stored in
// the same location, so we have to select which square to check.
if (color_of(piece_on(empty(s1) ? s2 : s1)) != side_to_move())
continue;
// For repetitions before or at the root, require one more
if (stp->repetition)
return true;
}
}
}
return false; return false;
} }
@@ -1148,7 +1233,7 @@ void Position::flip() {
bool Position::pos_is_ok() const { bool Position::pos_is_ok() const {
const bool Fast = true; // Quick (default) or full check? constexpr bool Fast = true; // Quick (default) or full check?
if ( (sideToMove != WHITE && sideToMove != BLACK) if ( (sideToMove != WHITE && sideToMove != BLACK)
|| piece_on(square<KING>(WHITE)) != W_KING || piece_on(square<KING>(WHITE)) != W_KING
@@ -1197,15 +1282,15 @@ bool Position::pos_is_ok() const {
assert(0 && "pos_is_ok: Index"); assert(0 && "pos_is_ok: Index");
} }
for (Color c = WHITE; c <= BLACK; ++c) for (Color c : { WHITE, BLACK })
for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) for (CastlingRights cr : {c & KING_SIDE, c & QUEEN_SIDE})
{ {
if (!can_castle(c | s)) if (!can_castle(cr))
continue; continue;
if ( piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) if ( piece_on(castlingRookSquare[cr]) != make_piece(c, ROOK)
|| castlingRightsMask[castlingRookSquare[c | s]] != (c | s) || castlingRightsMask[castlingRookSquare[cr]] != cr
|| (castlingRightsMask[square<KING>(c)] & (c | s)) != (c | s)) || (castlingRightsMask[square<KING>(c)] & cr) != cr)
assert(0 && "pos_is_ok: Castling"); assert(0 && "pos_is_ok: Castling");
} }
src/position.h
+53 -28
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -43,7 +43,6 @@ struct StateInfo {
int castlingRights; int castlingRights;
int rule50; int rule50;
int pliesFromNull; int pliesFromNull;
Score psq;
Square epSquare; Square epSquare;
// Not copied when making a move (will be recomputed anyhow) // Not copied when making a move (will be recomputed anyhow)
@@ -52,8 +51,9 @@ struct StateInfo {
Piece capturedPiece; Piece capturedPiece;
StateInfo* previous; StateInfo* previous;
Bitboard blockersForKing[COLOR_NB]; Bitboard blockersForKing[COLOR_NB];
Bitboard pinnersForKing[COLOR_NB]; Bitboard pinners[COLOR_NB];
Bitboard checkSquares[PIECE_TYPE_NB]; Bitboard checkSquares[PIECE_TYPE_NB];
int repetition;
}; };
/// A list to keep track of the position states along the setup moves (from the /// A list to keep track of the position states along the setup moves (from the
@@ -96,18 +96,19 @@ public:
template<PieceType Pt> int count() const; template<PieceType Pt> int count() const;
template<PieceType Pt> const Square* squares(Color c) const; template<PieceType Pt> const Square* squares(Color c) const;
template<PieceType Pt> Square square(Color c) const; template<PieceType Pt> Square square(Color c) const;
bool is_on_semiopen_file(Color c, Square s) const;
// Castling // Castling
int can_castle(Color c) const; int castling_rights(Color c) const;
int can_castle(CastlingRight cr) const; bool can_castle(CastlingRights cr) const;
bool castling_impeded(CastlingRight cr) const; bool castling_impeded(CastlingRights cr) const;
Square castling_rook_square(CastlingRight cr) const; Square castling_rook_square(CastlingRights cr) const;
// Checking // Checking
Bitboard checkers() const; Bitboard checkers() const;
Bitboard discovered_check_candidates() const; Bitboard blockers_for_king(Color c) const;
Bitboard pinned_pieces(Color c) const;
Bitboard check_squares(PieceType pt) const; Bitboard check_squares(PieceType pt) const;
bool is_discovery_check_on_king(Color c, Move m) const;
// Attacks to/from a given square // Attacks to/from a given square
Bitboard attackers_to(Square s) const; Bitboard attackers_to(Square s) const;
@@ -130,6 +131,7 @@ public:
// Piece specific // Piece specific
bool pawn_passed(Color c, Square s) const; bool pawn_passed(Color c, Square s) const;
bool opposite_bishops() const; bool opposite_bishops() const;
int pawns_on_same_color_squares(Color c, Square s) const;
// Doing and undoing moves // Doing and undoing moves
void do_move(Move m, StateInfo& newSt); void do_move(Move m, StateInfo& newSt);
@@ -153,6 +155,8 @@ public:
bool is_chess960() const; bool is_chess960() const;
Thread* this_thread() const; Thread* this_thread() const;
bool is_draw(int ply) const; bool is_draw(int ply) const;
bool has_game_cycle(int ply) const;
bool has_repeated() const;
int rule50_count() const; int rule50_count() const;
Score psq_score() const; Score psq_score() const;
Value non_pawn_material(Color c) const; Value non_pawn_material(Color c) const;
@@ -187,11 +191,16 @@ private:
Bitboard castlingPath[CASTLING_RIGHT_NB]; Bitboard castlingPath[CASTLING_RIGHT_NB];
int gamePly; int gamePly;
Color sideToMove; Color sideToMove;
Score psq;
Thread* thisThread; Thread* thisThread;
StateInfo* st; StateInfo* st;
bool chess960; bool chess960;
}; };
namespace PSQT {
extern Score psq[PIECE_NB][SQUARE_NB];
}
extern std::ostream& operator<<(std::ostream& os, const Position& pos); extern std::ostream& operator<<(std::ostream& os, const Position& pos);
inline Color Position::side_to_move() const { inline Color Position::side_to_move() const {
@@ -255,25 +264,34 @@ inline Square Position::ep_square() const {
return st->epSquare; return st->epSquare;
} }
inline int Position::can_castle(CastlingRight cr) const { inline bool Position::is_on_semiopen_file(Color c, Square s) const {
return !(pieces(c, PAWN) & file_bb(s));
}
inline bool Position::can_castle(CastlingRights cr) const {
return st->castlingRights & cr; return st->castlingRights & cr;
} }
inline int Position::can_castle(Color c) const { inline int Position::castling_rights(Color c) const {
return st->castlingRights & ((WHITE_OO | WHITE_OOO) << (2 * c)); return st->castlingRights & (c == WHITE ? WHITE_CASTLING : BLACK_CASTLING);
} }
inline bool Position::castling_impeded(CastlingRight cr) const { inline bool Position::castling_impeded(CastlingRights cr) const {
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
return byTypeBB[ALL_PIECES] & castlingPath[cr]; return byTypeBB[ALL_PIECES] & castlingPath[cr];
} }
inline Square Position::castling_rook_square(CastlingRight cr) const { inline Square Position::castling_rook_square(CastlingRights cr) const {
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
return castlingRookSquare[cr]; return castlingRookSquare[cr];
} }
template<PieceType Pt> template<PieceType Pt>
inline Bitboard Position::attacks_from(Square s) const { inline Bitboard Position::attacks_from(Square s) const {
assert(Pt != PAWN); static_assert(Pt != PAWN, "Pawn attacks need color");
return Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_PIECES]) return Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_PIECES])
: Pt == QUEEN ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s) : Pt == QUEEN ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
: PseudoAttacks[Pt][s]; : PseudoAttacks[Pt][s];
@@ -296,25 +314,29 @@ inline Bitboard Position::checkers() const {
return st->checkersBB; return st->checkersBB;
} }
inline Bitboard Position::discovered_check_candidates() const { inline Bitboard Position::blockers_for_king(Color c) const {
return st->blockersForKing[~sideToMove] & pieces(sideToMove); return st->blockersForKing[c];
}
inline Bitboard Position::pinned_pieces(Color c) const {
return st->blockersForKing[c] & pieces(c);
} }
inline Bitboard Position::check_squares(PieceType pt) const { inline Bitboard Position::check_squares(PieceType pt) const {
return st->checkSquares[pt]; return st->checkSquares[pt];
} }
inline bool Position::is_discovery_check_on_king(Color c, Move m) const {
return st->blockersForKing[c] & from_sq(m);
}
inline bool Position::pawn_passed(Color c, Square s) const { inline bool Position::pawn_passed(Color c, Square s) const {
return !(pieces(~c, PAWN) & passed_pawn_mask(c, s)); return !(pieces(~c, PAWN) & passed_pawn_span(c, s));
} }
inline bool Position::advanced_pawn_push(Move m) const { inline bool Position::advanced_pawn_push(Move m) const {
return type_of(moved_piece(m)) == PAWN return type_of(moved_piece(m)) == PAWN
&& relative_rank(sideToMove, from_sq(m)) > RANK_4; && relative_rank(sideToMove, to_sq(m)) > RANK_5;
}
inline int Position::pawns_on_same_color_squares(Color c, Square s) const {
return popcount(pieces(c, PAWN) & ((DarkSquares & s) ? DarkSquares : ~DarkSquares));
} }
inline Key Position::key() const { inline Key Position::key() const {
@@ -330,7 +352,7 @@ inline Key Position::material_key() const {
} }
inline Score Position::psq_score() const { inline Score Position::psq_score() const {
return st->psq; return psq;
} }
inline Value Position::non_pawn_material(Color c) const { inline Value Position::non_pawn_material(Color c) const {
@@ -387,6 +409,7 @@ inline void Position::put_piece(Piece pc, Square s) {
index[s] = pieceCount[pc]++; index[s] = pieceCount[pc]++;
pieceList[pc][index[s]] = s; pieceList[pc][index[s]] = s;
pieceCount[make_piece(color_of(pc), ALL_PIECES)]++; pieceCount[make_piece(color_of(pc), ALL_PIECES)]++;
psq += PSQT::psq[pc][s];
} }
inline void Position::remove_piece(Piece pc, Square s) { inline void Position::remove_piece(Piece pc, Square s) {
@@ -404,20 +427,22 @@ inline void Position::remove_piece(Piece pc, Square s) {
pieceList[pc][index[lastSquare]] = lastSquare; pieceList[pc][index[lastSquare]] = lastSquare;
pieceList[pc][pieceCount[pc]] = SQ_NONE; pieceList[pc][pieceCount[pc]] = SQ_NONE;
pieceCount[make_piece(color_of(pc), ALL_PIECES)]--; pieceCount[make_piece(color_of(pc), ALL_PIECES)]--;
psq -= PSQT::psq[pc][s];
} }
inline void Position::move_piece(Piece pc, Square from, Square to) { inline void Position::move_piece(Piece pc, Square from, Square to) {
// index[from] is not updated and becomes stale. This works as long as index[] // index[from] is not updated and becomes stale. This works as long as index[]
// is accessed just by known occupied squares. // is accessed just by known occupied squares.
Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; Bitboard fromTo = from | to;
byTypeBB[ALL_PIECES] ^= from_to_bb; byTypeBB[ALL_PIECES] ^= fromTo;
byTypeBB[type_of(pc)] ^= from_to_bb; byTypeBB[type_of(pc)] ^= fromTo;
byColorBB[color_of(pc)] ^= from_to_bb; byColorBB[color_of(pc)] ^= fromTo;
board[from] = NO_PIECE; board[from] = NO_PIECE;
board[to] = pc; board[to] = pc;
index[to] = index[from]; index[to] = index[from];
pieceList[pc][index[to]] = to; pieceList[pc][index[to]] = to;
psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
} }
inline void Position::do_move(Move m, StateInfo& newSt) { inline void Position::do_move(Move m, StateInfo& newSt) {
src/psqt.cpp
+58 -54
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -35,69 +35,72 @@ namespace PSQT {
// type on a given square a (middlegame, endgame) score pair is assigned. Table // type on a given square a (middlegame, endgame) score pair is assigned. Table
// is defined for files A..D and white side: it is symmetric for black side and // is defined for files A..D and white side: it is symmetric for black side and
// second half of the files. // second half of the files.
const Score Bonus[][RANK_NB][int(FILE_NB) / 2] = { constexpr Score Bonus[][RANK_NB][int(FILE_NB) / 2] = {
{ },
{ }, { },
{ // Pawn
{ S( 0, 0), S( 0, 0), S( 0, 0), S( 0, 0) },
{ S(-11, 7), S( 6,-4), S( 7, 8), S( 3,-2) },
{ S(-18,-4), S( -2,-5), S( 19, 5), S(24, 4) },
{ S(-17, 3), S( -9, 3), S( 20,-8), S(35,-3) },
{ S( -6, 8), S( 5, 9), S( 3, 7), S(21,-6) },
{ S( -6, 8), S( -8,-5), S( -6, 2), S(-2, 4) },
{ S( -4, 3), S( 20,-9), S( -8, 1), S(-4,18) }
},
{ // Knight { // Knight
{ S(-161,-105), S(-96,-82), S(-80,-46), S(-73,-14) }, { S(-175, -96), S(-92,-65), S(-74,-49), S(-73,-21) },
{ S( -83, -69), S(-43,-54), S(-21,-17), S(-10, 9) }, { S( -77, -67), S(-41,-54), S(-27,-18), S(-15, 8) },
{ S( -71, -50), S(-22,-39), S( 0, -7), S( 9, 28) }, { S( -61, -40), S(-17,-27), S( 6, -8), S( 12, 29) },
{ S( -25, -41), S( 18,-25), S( 43, 6), S( 47, 38) }, { S( -35, -35), S( 8, -2), S( 40, 13), S( 49, 28) },
{ S( -26, -46), S( 16,-25), S( 38, 3), S( 50, 40) }, { S( -34, -45), S( 13,-16), S( 44, 9), S( 51, 39) },
{ S( -11, -54), S( 37,-38), S( 56, -7), S( 65, 27) }, { S( -9, -51), S( 22,-44), S( 58,-16), S( 53, 17) },
{ S( -63, -65), S(-19,-50), S( 5,-24), S( 14, 13) }, { S( -67, -69), S(-27,-50), S( 4,-51), S( 37, 12) },
{ S(-195,-109), S(-67,-89), S(-42,-50), S(-29,-13) } { S(-201,-100), S(-83,-88), S(-56,-56), S(-26,-17) }
}, },
{ // Bishop { // Bishop
{ S(-44,-58), S(-13,-31), S(-25,-37), S(-34,-19) }, { S(-53,-57), S( -5,-30), S( -8,-37), S(-23,-12) },
{ S(-20,-34), S( 20, -9), S( 12,-14), S( 1, 4) }, { S(-15,-37), S( 8,-13), S( 19,-17), S( 4, 1) },
{ S( -9,-23), S( 27, 0), S( 21, -3), S( 11, 16) }, { S( -7,-16), S( 21, -1), S( -5, -2), S( 17, 10) },
{ S(-11,-26), S( 28, -3), S( 21, -5), S( 10, 16) }, { S( -5,-20), S( 11, -6), S( 25, 0), S( 39, 17) },
{ S(-11,-26), S( 27, -4), S( 16, -7), S( 9, 14) }, { S(-12,-17), S( 29, -1), S( 22,-14), S( 31, 15) },
{ S(-17,-24), S( 16, -2), S( 12, 0), S( 2, 13) }, { S(-16,-30), S( 6, 6), S( 1, 4), S( 11, 6) },
{ S(-23,-34), S( 17,-10), S( 6,-12), S( -2, 6) }, { S(-17,-31), S(-14,-20), S( 5, -1), S( 0, 1) },
{ S(-35,-55), S(-11,-32), S(-19,-36), S(-29,-17) } { S(-48,-46), S( 1,-42), S(-14,-37), S(-23,-24) }
}, },
{ // Rook { // Rook
{ S(-25, 0), S(-16, 0), S(-16, 0), S(-9, 0) }, { S(-31, -9), S(-20,-13), S(-14,-10), S(-5, -9) },
{ S(-21, 0), S( -8, 0), S( -3, 0), S( 0, 0) }, { S(-21,-12), S(-13, -9), S( -8, -1), S( 6, -2) },
{ S(-21, 0), S( -9, 0), S( -4, 0), S( 2, 0) }, { S(-25, 6), S(-11, -8), S( -1, -2), S( 3, -6) },
{ S(-22, 0), S( -6, 0), S( -1, 0), S( 2, 0) }, { S(-13, -6), S( -5, 1), S( -4, -9), S(-6, 7) },
{ S(-22, 0), S( -7, 0), S( 0, 0), S( 1, 0) }, { S(-27, -5), S(-15, 8), S( -4, 7), S( 3, -6) },
{ S(-21, 0), S( -7, 0), S( 0, 0), S( 2, 0) }, { S(-22, 6), S( -2, 1), S( 6, -7), S(12, 10) },
{ S(-12, 0), S( 4, 0), S( 8, 0), S(12, 0) }, { S( -2, 4), S( 12, 5), S( 16, 20), S(18, -5) },
{ S(-23, 0), S(-15, 0), S(-11, 0), S(-5, 0) } { S(-17, 18), S(-19, 0), S( -1, 19), S( 9, 13) }
}, },
{ // Queen { // Queen
{ S( 0,-71), S(-4,-56), S(-3,-42), S(-1,-29) }, { S( 3,-69), S(-5,-57), S(-5,-47), S( 4,-26) },
{ S(-4,-56), S( 6,-30), S( 9,-21), S( 8, -5) }, { S(-3,-55), S( 5,-31), S( 8,-22), S(12, -4) },
{ S(-2,-39), S( 6,-17), S( 9, -8), S( 9, 5) }, { S(-3,-39), S( 6,-18), S(13, -9), S( 7, 3) },
{ S(-1,-29), S( 8, -5), S(10, 9), S( 7, 19) }, { S( 4,-23), S( 5, -3), S( 9, 13), S( 8, 24) },
{ S(-3,-27), S( 9, -5), S( 8, 10), S( 7, 21) }, { S( 0,-29), S(14, -6), S(12, 9), S( 5, 21) },
{ S(-2,-40), S( 6,-16), S( 8,-10), S(10, 3) }, { S(-4,-38), S(10,-18), S( 6,-12), S( 8, 1) },
{ S(-2,-55), S( 7,-30), S( 7,-21), S( 6, -6) }, { S(-5,-50), S( 6,-27), S(10,-24), S( 8, -8) },
{ S(-1,-74), S(-4,-55), S(-1,-43), S( 0,-30) } { S(-2,-75), S(-2,-52), S( 1,-43), S(-2,-36) }
}, },
{ // King { // King
{ S(267, 0), S(320, 48), S(270, 75), S(195, 84) }, { S(271, 1), S(327, 45), S(271, 85), S(198, 76) },
{ S(264, 43), S(304, 92), S(238,143), S(180,132) }, { S(278, 53), S(303,100), S(234,133), S(179,135) },
{ S(200, 83), S(245,138), S(176,167), S(110,165) }, { S(195, 88), S(258,130), S(169,169), S(120,175) },
{ S(177,106), S(185,169), S(148,169), S(110,179) }, { S(164,103), S(190,156), S(138,172), S( 98,172) },
{ S(149,108), S(177,163), S(115,200), S( 66,203) }, { S(154, 96), S(179,166), S(105,199), S( 70,199) },
{ S(118, 95), S(159,155), S( 84,176), S( 41,174) }, { S(123, 92), S(145,172), S( 81,184), S( 31,191) },
{ S( 87, 50), S(128, 99), S( 63,122), S( 20,139) }, { S( 88, 47), S(120,121), S( 65,116), S( 33,131) },
{ S( 63, 9), S( 88, 55), S( 47, 80), S( 0, 90) } { S( 59, 11), S( 89, 59), S( 45, 73), S( -1, 78) }
} }
}; };
constexpr Score PBonus[RANK_NB][FILE_NB] =
{ // Pawn (asymmetric distribution)
{ },
{ S( 3,-10), S( 3, -6), S( 10, 10), S( 19, 0), S( 16, 14), S( 19, 7), S( 7, -5), S( -5,-19) },
{ S( -9,-10), S(-15,-10), S( 11,-10), S( 15, 4), S( 32, 4), S( 22, 3), S( 5, -6), S(-22, -4) },
{ S( -8, 6), S(-23, -2), S( 6, -8), S( 20, -4), S( 40,-13), S( 17,-12), S( 4,-10), S(-12, -9) },
{ S( 13, 9), S( 0, 4), S(-13, 3), S( 1,-12), S( 11,-12), S( -2, -6), S(-13, 13), S( 5, 8) },
{ S( -5, 28), S(-12, 20), S( -7, 21), S( 22, 28), S( -8, 30), S( -5, 7), S(-15, 6), S(-18, 13) },
{ S( -7, 0), S( 7,-11), S( -3, 12), S(-13, 21), S( 5, 25), S(-16, 19), S( 10, 4), S( -8, 7) }
};
#undef S #undef S
Score psq[PIECE_NB][SQUARE_NB]; Score psq[PIECE_NB][SQUARE_NB];
@@ -112,12 +115,13 @@ void init() {
PieceValue[MG][~pc] = PieceValue[MG][pc]; PieceValue[MG][~pc] = PieceValue[MG][pc];
PieceValue[EG][~pc] = PieceValue[EG][pc]; PieceValue[EG][~pc] = PieceValue[EG][pc];
Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]); Score score = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
for (Square s = SQ_A1; s <= SQ_H8; ++s) for (Square s = SQ_A1; s <= SQ_H8; ++s)
{ {
File f = std::min(file_of(s), ~file_of(s)); File f = map_to_queenside(file_of(s));
psq[ pc][ s] = v + Bonus[pc][rank_of(s)][f]; psq[ pc][ s] = score + (type_of(pc) == PAWN ? PBonus[rank_of(s)][file_of(s)]
: Bonus[pc][rank_of(s)][f]);
psq[~pc][~s] = -psq[pc][s]; psq[~pc][~s] = -psq[pc][s];
} }
} }
src/search.cpp
+784 -560
View File
File diff suppressed because it is too large Load Diff
src/search.h
+11 -8
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@ class Position;
namespace Search { namespace Search {
/// Threshold used for countermoves based pruning /// Threshold used for countermoves based pruning
const int CounterMovePruneThreshold = 0; constexpr int CounterMovePruneThreshold = 0;
/// Stack struct keeps track of the information we need to remember from nodes /// Stack struct keeps track of the information we need to remember from nodes
@@ -41,7 +41,7 @@ const int CounterMovePruneThreshold = 0;
struct Stack { struct Stack {
Move* pv; Move* pv;
PieceToHistory* contHistory; PieceToHistory* continuationHistory;
int ply; int ply;
Move currentMove; Move currentMove;
Move excludedMove; Move excludedMove;
@@ -69,6 +69,9 @@ struct RootMove {
Value score = -VALUE_INFINITE; Value score = -VALUE_INFINITE;
Value previousScore = -VALUE_INFINITE; Value previousScore = -VALUE_INFINITE;
int selDepth = 0; int selDepth = 0;
int tbRank = 0;
int bestMoveCount = 0;
Value tbScore;
std::vector<Move> pv; std::vector<Move> pv;
}; };
@@ -81,8 +84,9 @@ typedef std::vector<RootMove> RootMoves;
struct LimitsType { struct LimitsType {
LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movetime = TimePoint(0);
npmsec = movestogo = depth = movetime = mate = perft = infinite = 0; movestogo = depth = mate = perft = infinite = 0;
nodes = 0;
} }
bool use_time_management() const { bool use_time_management() const {
@@ -90,10 +94,9 @@ struct LimitsType {
} }
std::vector<Move> searchmoves; std::vector<Move> searchmoves;
int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, TimePoint time[COLOR_NB], inc[COLOR_NB], npmsec, movetime, startTime;
movetime, mate, perft, infinite; int movestogo, depth, mate, perft, infinite;
int64_t nodes; int64_t nodes;
TimePoint startTime;
}; };
extern LimitsType Limits; extern LimitsType Limits;
src/syzygy/tbprobe.cpp
+471 -571
View File
File diff suppressed because it is too large Load Diff
src/syzygy/tbprobe.h
+4 -4
View File
@@ -1,7 +1,7 @@
/* /*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (c) 2013 Ronald de Man Copyright (c) 2013 Ronald de Man
Copyright (C) 2016-2018 Marco Costalba, Lucas Braesch Copyright (C) 2016-2020 Marco Costalba, Lucas Braesch
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -49,9 +49,9 @@ extern int MaxCardinality;
void init(const std::string& paths); void init(const std::string& paths);
WDLScore probe_wdl(Position& pos, ProbeState* result); WDLScore probe_wdl(Position& pos, ProbeState* result);
int probe_dtz(Position& pos, ProbeState* result); int probe_dtz(Position& pos, ProbeState* result);
bool root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score); bool root_probe(Position& pos, Search::RootMoves& rootMoves);
bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Value& score); bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves);
void filter_root_moves(Position& pos, Search::RootMoves& rootMoves); void rank_root_moves(Position& pos, Search::RootMoves& rootMoves);
inline std::ostream& operator<<(std::ostream& os, const WDLScore v) { inline std::ostream& operator<<(std::ostream& os, const WDLScore v) {
src/thread.cpp
+39 -18
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -18,20 +18,21 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <algorithm> // For std::count
#include <cassert> #include <cassert>
#include <algorithm> // For std::count
#include "movegen.h" #include "movegen.h"
#include "search.h" #include "search.h"
#include "thread.h" #include "thread.h"
#include "uci.h" #include "uci.h"
#include "syzygy/tbprobe.h" #include "syzygy/tbprobe.h"
#include "tt.h"
ThreadPool Threads; // Global object ThreadPool Threads; // Global object
/// Thread constructor launches the thread and waits until it goes to sleep /// Thread constructor launches the thread and waits until it goes to sleep
/// in idle_loop(). Note that 'searching' and 'exit' should be alredy set. /// in idle_loop(). Note that 'searching' and 'exit' should be already set.
Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) { Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) {
@@ -51,6 +52,15 @@ Thread::~Thread() {
stdThread.join(); stdThread.join();
} }
/// Thread::bestMoveCount(Move move) return best move counter for the given root move
int Thread::best_move_count(Move move) {
auto rm = std::find(rootMoves.begin() + pvIdx,
rootMoves.begin() + pvLast, move);
return rm != rootMoves.begin() + pvLast ? rm->bestMoveCount : 0;
}
/// Thread::clear() reset histories, usually before a new game /// Thread::clear() reset histories, usually before a new game
@@ -60,18 +70,22 @@ void Thread::clear() {
mainHistory.fill(0); mainHistory.fill(0);
captureHistory.fill(0); captureHistory.fill(0);
for (auto& to : contHistory) for (bool inCheck : { false, true })
for (auto& h : to) for (StatsType c : { NoCaptures, Captures })
h.fill(0); for (auto& to : continuationHistory[inCheck][c])
for (auto& h : to)
h->fill(0);
contHistory[NO_PIECE][0].fill(Search::CounterMovePruneThreshold - 1); for (bool inCheck : { false, true })
for (StatsType c : { NoCaptures, Captures })
continuationHistory[inCheck][c][NO_PIECE][0]->fill(Search::CounterMovePruneThreshold - 1);
} }
/// Thread::start_searching() wakes up the thread that will start the search /// Thread::start_searching() wakes up the thread that will start the search
void Thread::start_searching() { void Thread::start_searching() {
std::lock_guard<Mutex> lk(mutex); std::lock_guard<std::mutex> lk(mutex);
searching = true; searching = true;
cv.notify_one(); // Wake up the thread in idle_loop() cv.notify_one(); // Wake up the thread in idle_loop()
} }
@@ -82,7 +96,7 @@ void Thread::start_searching() {
void Thread::wait_for_search_finished() { void Thread::wait_for_search_finished() {
std::unique_lock<Mutex> lk(mutex); std::unique_lock<std::mutex> lk(mutex);
cv.wait(lk, [&]{ return !searching; }); cv.wait(lk, [&]{ return !searching; });
} }
@@ -97,12 +111,12 @@ void Thread::idle_loop() {
// some Windows NUMA hardware, for instance in fishtest. To make it simple, // some Windows NUMA hardware, for instance in fishtest. To make it simple,
// just check if running threads are below a threshold, in this case all this // just check if running threads are below a threshold, in this case all this
// NUMA machinery is not needed. // NUMA machinery is not needed.
if (Options["Threads"] >= 8) if (Options["Threads"] > 8)
WinProcGroup::bindThisThread(idx); WinProcGroup::bindThisThread(idx);
while (true) while (true)
{ {
std::unique_lock<Mutex> lk(mutex); std::unique_lock<std::mutex> lk(mutex);
searching = false; searching = false;
cv.notify_one(); // Wake up anyone waiting for search finished cv.notify_one(); // Wake up anyone waiting for search finished
cv.wait(lk, [&]{ return searching; }); cv.wait(lk, [&]{ return searching; });
@@ -117,7 +131,7 @@ void Thread::idle_loop() {
} }
/// ThreadPool::set() creates/destroys threads to match the requested number. /// ThreadPool::set() creates/destroys threads to match the requested number.
/// Created and launced threads wil go immediately to sleep in idle_loop. /// Created and launched threads will immediately go to sleep in idle_loop.
/// Upon resizing, threads are recreated to allow for binding if necessary. /// Upon resizing, threads are recreated to allow for binding if necessary.
void ThreadPool::set(size_t requested) { void ThreadPool::set(size_t requested) {
@@ -135,6 +149,12 @@ void ThreadPool::set(size_t requested) {
while (size() < requested) while (size() < requested)
push_back(new Thread(size())); push_back(new Thread(size()));
clear(); clear();
// Reallocate the hash with the new threadpool size
TT.resize(Options["Hash"]);
// Init thread number dependent search params.
Search::init();
} }
} }
@@ -147,7 +167,7 @@ void ThreadPool::clear() {
main()->callsCnt = 0; main()->callsCnt = 0;
main()->previousScore = VALUE_INFINITE; main()->previousScore = VALUE_INFINITE;
main()->previousTimeReduction = 1; main()->previousTimeReduction = 1.0;
} }
/// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and /// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and
@@ -158,8 +178,9 @@ void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
main()->wait_for_search_finished(); main()->wait_for_search_finished();
stopOnPonderhit = stop = false; main()->stopOnPonderhit = stop = false;
ponder = ponderMode; increaseDepth = true;
main()->ponder = ponderMode;
Search::Limits = limits; Search::Limits = limits;
Search::RootMoves rootMoves; Search::RootMoves rootMoves;
@@ -169,7 +190,7 @@ void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
rootMoves.emplace_back(m); rootMoves.emplace_back(m);
if (!rootMoves.empty()) if (!rootMoves.empty())
Tablebases::filter_root_moves(pos, rootMoves); Tablebases::rank_root_moves(pos, rootMoves);
// After ownership transfer 'states' becomes empty, so if we stop the search // After ownership transfer 'states' becomes empty, so if we stop the search
// and call 'go' again without setting a new position states.get() == NULL. // and call 'go' again without setting a new position states.get() == NULL.
@@ -187,8 +208,8 @@ void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
for (Thread* th : *this) for (Thread* th : *this)
{ {
th->nodes = th->tbHits = th->nmp_ply = th->nmp_odd = 0; th->nodes = th->tbHits = th->nmpMinPly = 0;
th->rootDepth = th->completedDepth = DEPTH_ZERO; th->rootDepth = th->completedDepth = 0;
th->rootMoves = rootMoves; th->rootMoves = rootMoves;
th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th); th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th);
} }
src/thread.h
+18 -13
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -32,7 +32,7 @@
#include "pawns.h" #include "pawns.h"
#include "position.h" #include "position.h"
#include "search.h" #include "search.h"
#include "thread_win32.h" #include "thread_win32_osx.h"
/// Thread class keeps together all the thread-related stuff. We use /// Thread class keeps together all the thread-related stuff. We use
@@ -42,11 +42,11 @@
class Thread { class Thread {
Mutex mutex; std::mutex mutex;
ConditionVariable cv; std::condition_variable cv;
size_t idx; size_t idx;
bool exit = false, searching = true; // Set before starting std::thread bool exit = false, searching = true; // Set before starting std::thread
std::thread stdThread; NativeThread stdThread;
public: public:
explicit Thread(size_t); explicit Thread(size_t);
@@ -56,13 +56,15 @@ public:
void idle_loop(); void idle_loop();
void start_searching(); void start_searching();
void wait_for_search_finished(); void wait_for_search_finished();
int best_move_count(Move move);
Pawns::Table pawnsTable; Pawns::Table pawnsTable;
Material::Table materialTable; Material::Table materialTable;
Endgames endgames; size_t pvIdx, pvLast;
size_t PVIdx; uint64_t ttHitAverage;
int selDepth, nmp_ply, nmp_odd; int selDepth, nmpMinPly;
std::atomic<uint64_t> nodes, tbHits; Color nmpColor;
std::atomic<uint64_t> nodes, tbHits, bestMoveChanges;
Position rootPos; Position rootPos;
Search::RootMoves rootMoves; Search::RootMoves rootMoves;
@@ -70,7 +72,8 @@ public:
CounterMoveHistory counterMoves; CounterMoveHistory counterMoves;
ButterflyHistory mainHistory; ButterflyHistory mainHistory;
CapturePieceToHistory captureHistory; CapturePieceToHistory captureHistory;
ContinuationHistory contHistory; ContinuationHistory continuationHistory[2][2];
Score contempt;
}; };
@@ -83,10 +86,12 @@ struct MainThread : public Thread {
void search() override; void search() override;
void check_time(); void check_time();
bool failedLow; double previousTimeReduction;
double bestMoveChanges, previousTimeReduction;
Value previousScore; Value previousScore;
Value iterValue[4];
int callsCnt; int callsCnt;
bool stopOnPonderhit;
std::atomic_bool ponder;
}; };
@@ -104,7 +109,7 @@ struct ThreadPool : public std::vector<Thread*> {
uint64_t nodes_searched() const { return accumulate(&Thread::nodes); } uint64_t nodes_searched() const { return accumulate(&Thread::nodes); }
uint64_t tb_hits() const { return accumulate(&Thread::tbHits); } uint64_t tb_hits() const { return accumulate(&Thread::tbHits); }
std::atomic_bool stop, ponder, stopOnPonderhit; std::atomic_bool stop, increaseDepth;
private: private:
StateListPtr setupStates; StateListPtr setupStates;
src/thread_win32.h
-70
View File
@@ -1,70 +0,0 @@
/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef THREAD_WIN32_H_INCLUDED
#define THREAD_WIN32_H_INCLUDED
/// STL thread library used by mingw and gcc when cross compiling for Windows
/// relies on libwinpthread. Currently libwinpthread implements mutexes directly
/// on top of Windows semaphores. Semaphores, being kernel objects, require kernel
/// mode transition in order to lock or unlock, which is very slow compared to
/// interlocked operations (about 30% slower on bench test). To work around this
/// issue, we define our wrappers to the low level Win32 calls. We use critical
/// sections to support Windows XP and older versions. Unfortunately, cond_wait()
/// is racy between unlock() and WaitForSingleObject() but they have the same
/// speed performance as the SRW locks.
#include <condition_variable>
#include <mutex>
#if defined(_WIN32) && !defined(_MSC_VER)
#ifndef NOMINMAX
# define NOMINMAX // Disable macros min() and max()
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#undef WIN32_LEAN_AND_MEAN
#undef NOMINMAX
/// Mutex and ConditionVariable struct are wrappers of the low level locking
/// machinery and are modeled after the corresponding C++11 classes.
struct Mutex {
Mutex() { InitializeCriticalSection(&cs); }
~Mutex() { DeleteCriticalSection(&cs); }
void lock() { EnterCriticalSection(&cs); }
void unlock() { LeaveCriticalSection(&cs); }
private:
CRITICAL_SECTION cs;
};
typedef std::condition_variable_any ConditionVariable;
#else // Default case: use STL classes
typedef std::mutex Mutex;
typedef std::condition_variable ConditionVariable;
#endif
#endif // #ifndef THREAD_WIN32_H_INCLUDED
src/thread_win32_osx.h
+68
View File
@@ -0,0 +1,68 @@
/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef THREAD_WIN32_OSX_H_INCLUDED
#define THREAD_WIN32_OSX_H_INCLUDED
#include <thread>
/// On OSX threads other than the main thread are created with a reduced stack
/// size of 512KB by default, this is too low for deep searches, which require
/// somewhat more than 1MB stack, so adjust it to TH_STACK_SIZE.
/// The implementation calls pthread_create() with the stack size parameter
/// equal to the linux 8MB default, on platforms that support it.
#if defined(__APPLE__) || defined(__MINGW32__) || defined(__MINGW64__)
#include <pthread.h>
static const size_t TH_STACK_SIZE = 8 * 1024 * 1024;
template <class T, class P = std::pair<T*, void(T::*)()>>
void* start_routine(void* ptr)
{
P* p = reinterpret_cast<P*>(ptr);
(p->first->*(p->second))(); // Call member function pointer
delete p;
return NULL;
}
class NativeThread {
pthread_t thread;
public:
template<class T, class P = std::pair<T*, void(T::*)()>>
explicit NativeThread(void(T::*fun)(), T* obj) {
pthread_attr_t attr_storage, *attr = &attr_storage;
pthread_attr_init(attr);
pthread_attr_setstacksize(attr, TH_STACK_SIZE);
pthread_create(&thread, attr, start_routine<T>, new P(obj, fun));
}
void join() { pthread_join(thread, NULL); }
};
#else // Default case: use STL classes
typedef std::thread NativeThread;
#endif
#endif // #ifndef THREAD_WIN32_OSX_H_INCLUDED
src/timeman.cpp
+31 -30
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -32,9 +32,9 @@ namespace {
enum TimeType { OptimumTime, MaxTime }; enum TimeType { OptimumTime, MaxTime };
const int MoveHorizon = 50; // Plan time management at most this many moves ahead constexpr int MoveHorizon = 50; // Plan time management at most this many moves ahead
const double MaxRatio = 7.09; // When in trouble, we can step over reserved time with this ratio constexpr double MaxRatio = 7.3; // When in trouble, we can step over reserved time with this ratio
const double StealRatio = 0.35; // However we must not steal time from remaining moves over this ratio constexpr double StealRatio = 0.34; // However we must not steal time from remaining moves over this ratio
// move_importance() is a skew-logistic function based on naive statistical // move_importance() is a skew-logistic function based on naive statistical
@@ -44,21 +44,21 @@ namespace {
double move_importance(int ply) { double move_importance(int ply) {
const double XScale = 7.64; constexpr double XScale = 6.85;
const double XShift = 58.4; constexpr double XShift = 64.5;
const double Skew = 0.183; constexpr double Skew = 0.171;
return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero
} }
template<TimeType T> template<TimeType T>
int remaining(int myTime, int movesToGo, int ply, int slowMover) { TimePoint remaining(TimePoint myTime, int movesToGo, int ply, TimePoint slowMover) {
const double TMaxRatio = (T == OptimumTime ? 1 : MaxRatio); constexpr double TMaxRatio = (T == OptimumTime ? 1.0 : MaxRatio);
const double TStealRatio = (T == OptimumTime ? 0 : StealRatio); constexpr double TStealRatio = (T == OptimumTime ? 0.0 : StealRatio);
double moveImportance = (move_importance(ply) * slowMover) / 100; double moveImportance = (move_importance(ply) * slowMover) / 100.0;
double otherMovesImportance = 0; double otherMovesImportance = 0.0;
for (int i = 1; i < movesToGo; ++i) for (int i = 1; i < movesToGo; ++i)
otherMovesImportance += move_importance(ply + 2 * i); otherMovesImportance += move_importance(ply + 2 * i);
@@ -66,7 +66,7 @@ namespace {
double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance); double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance);
double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance); double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance);
return int(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast return TimePoint(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast
} }
} // namespace } // namespace
@@ -83,22 +83,23 @@ namespace {
void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) { void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
int minThinkingTime = Options["Minimum Thinking Time"]; TimePoint minThinkingTime = Options["Minimum Thinking Time"];
int moveOverhead = Options["Move Overhead"]; TimePoint moveOverhead = Options["Move Overhead"];
int slowMover = Options["Slow Mover"]; TimePoint slowMover = Options["Slow Mover"];
int npmsec = Options["nodestime"]; TimePoint npmsec = Options["nodestime"];
TimePoint hypMyTime;
// If we have to play in 'nodes as time' mode, then convert from time // If we have to play in 'nodes as time' mode, then convert from time
// to nodes, and use resulting values in time management formulas. // to nodes, and use resulting values in time management formulas.
// WARNING: Given npms (nodes per millisecond) must be much lower then // WARNING: to avoid time losses, the given npmsec (nodes per millisecond)
// the real engine speed to avoid time losses. // must be much lower than the real engine speed.
if (npmsec) if (npmsec)
{ {
if (!availableNodes) // Only once at game start if (!availableNodes) // Only once at game start
availableNodes = npmsec * limits.time[us]; // Time is in msec availableNodes = npmsec * limits.time[us]; // Time is in msec
// Convert from millisecs to nodes // Convert from milliseconds to nodes
limits.time[us] = (int)availableNodes; limits.time[us] = TimePoint(availableNodes);
limits.inc[us] *= npmsec; limits.inc[us] *= npmsec;
limits.npmsec = npmsec; limits.npmsec = npmsec;
} }
@@ -106,22 +107,22 @@ void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
startTime = limits.startTime; startTime = limits.startTime;
optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime); optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime);
const int MaxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon; const int maxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon;
// We calculate optimum time usage for different hypothetical "moves to go"-values // We calculate optimum time usage for different hypothetical "moves to go" values
// and choose the minimum of calculated search time values. Usually the greatest // and choose the minimum of calculated search time values. Usually the greatest
// hypMTG gives the minimum values. // hypMTG gives the minimum values.
for (int hypMTG = 1; hypMTG <= MaxMTG; ++hypMTG) for (int hypMTG = 1; hypMTG <= maxMTG; ++hypMTG)
{ {
// Calculate thinking time for hypothetical "moves to go"-value // Calculate thinking time for hypothetical "moves to go"-value
int hypMyTime = limits.time[us] hypMyTime = limits.time[us]
+ limits.inc[us] * (hypMTG - 1) + limits.inc[us] * (hypMTG - 1)
- moveOverhead * (2 + std::min(hypMTG, 40)); - moveOverhead * (2 + std::min(hypMTG, 40));
hypMyTime = std::max(hypMyTime, 0); hypMyTime = std::max(hypMyTime, TimePoint(0));
int t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover); TimePoint t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, ply, slowMover);
int t2 = minThinkingTime + remaining<MaxTime >(hypMyTime, hypMTG, ply, slowMover); TimePoint t2 = minThinkingTime + remaining<MaxTime >(hypMyTime, hypMTG, ply, slowMover);
optimumTime = std::min(t1, optimumTime); optimumTime = std::min(t1, optimumTime);
maximumTime = std::min(t2, maximumTime); maximumTime = std::min(t2, maximumTime);
src/timeman.h
+7 -6
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -31,16 +31,17 @@
class TimeManagement { class TimeManagement {
public: public:
void init(Search::LimitsType& limits, Color us, int ply); void init(Search::LimitsType& limits, Color us, int ply);
int optimum() const { return optimumTime; } TimePoint optimum() const { return optimumTime; }
int maximum() const { return maximumTime; } TimePoint maximum() const { return maximumTime; }
int elapsed() const { return int(Search::Limits.npmsec ? Threads.nodes_searched() : now() - startTime); } TimePoint elapsed() const { return Search::Limits.npmsec ?
TimePoint(Threads.nodes_searched()) : now() - startTime; }
int64_t availableNodes; // When in 'nodes as time' mode int64_t availableNodes; // When in 'nodes as time' mode
private: private:
TimePoint startTime; TimePoint startTime;
int optimumTime; TimePoint optimumTime;
int maximumTime; TimePoint maximumTime;
}; };
extern TimeManagement Time; extern TimeManagement Time;
src/tt.cpp
+65 -25
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -20,12 +20,40 @@
#include <cstring> // For std::memset #include <cstring> // For std::memset
#include <iostream> #include <iostream>
#include <thread>
#include "bitboard.h" #include "bitboard.h"
#include "misc.h"
#include "thread.h"
#include "tt.h" #include "tt.h"
#include "uci.h"
TranspositionTable TT; // Our global transposition table TranspositionTable TT; // Our global transposition table
/// TTEntry::save populates the TTEntry with a new node's data, possibly
/// overwriting an old position. Update is not atomic and can be racy.
void TTEntry::save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev) {
// Preserve any existing move for the same position
if (m || (k >> 48) != key16)
move16 = (uint16_t)m;
// Overwrite less valuable entries
if ( (k >> 48) != key16
|| d - DEPTH_OFFSET > depth8 - 4
|| b == BOUND_EXACT)
{
assert(d >= DEPTH_OFFSET);
key16 = (uint16_t)(k >> 48);
value16 = (int16_t)v;
eval16 = (int16_t)ev;
genBound8 = (uint8_t)(TT.generation8 | uint8_t(pv) << 2 | b);
depth8 = (uint8_t)(d - DEPTH_OFFSET);
}
}
/// TranspositionTable::resize() sets the size of the transposition table, /// TranspositionTable::resize() sets the size of the transposition table,
/// measured in megabytes. Transposition table consists of a power of 2 number /// measured in megabytes. Transposition table consists of a power of 2 number
@@ -33,12 +61,9 @@ TranspositionTable TT; // Our global transposition table
void TranspositionTable::resize(size_t mbSize) { void TranspositionTable::resize(size_t mbSize) {
size_t newClusterCount = mbSize * 1024 * 1024 / sizeof(Cluster); Threads.main()->wait_for_search_finished();
if (newClusterCount == clusterCount) clusterCount = mbSize * 1024 * 1024 / sizeof(Cluster);
return;
clusterCount = newClusterCount;
free(mem); free(mem);
mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1); mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1);
@@ -55,15 +80,34 @@ void TranspositionTable::resize(size_t mbSize) {
} }
/// TranspositionTable::clear() overwrites the entire transposition table /// TranspositionTable::clear() initializes the entire transposition table to zero,
/// with zeros. It is called whenever the table is resized, or when the // in a multi-threaded way.
/// user asks the program to clear the table (from the UCI interface).
void TranspositionTable::clear() { void TranspositionTable::clear() {
std::memset(table, 0, clusterCount * sizeof(Cluster)); std::vector<std::thread> threads;
}
for (size_t idx = 0; idx < Options["Threads"]; ++idx)
{
threads.emplace_back([this, idx]() {
// Thread binding gives faster search on systems with a first-touch policy
if (Options["Threads"] > 8)
WinProcGroup::bindThisThread(idx);
// Each thread will zero its part of the hash table
const size_t stride = clusterCount / Options["Threads"],
start = stride * idx,
len = idx != Options["Threads"] - 1 ?
stride : clusterCount - start;
std::memset(&table[start], 0, len * sizeof(Cluster));
});
}
for (std::thread& th: threads)
th.join();
}
/// TranspositionTable::probe() looks up the current position in the transposition /// TranspositionTable::probe() looks up the current position in the transposition
/// table. It returns true and a pointer to the TTEntry if the position is found. /// table. It returns true and a pointer to the TTEntry if the position is found.
@@ -80,8 +124,7 @@ TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
for (int i = 0; i < ClusterSize; ++i) for (int i = 0; i < ClusterSize; ++i)
if (!tte[i].key16 || tte[i].key16 == key16) if (!tte[i].key16 || tte[i].key16 == key16)
{ {
if ((tte[i].genBound8 & 0xFC) != generation8 && tte[i].key16) tte[i].genBound8 = uint8_t(generation8 | (tte[i].genBound8 & 0x7)); // Refresh
tte[i].genBound8 = uint8_t(generation8 | tte[i].bound()); // Refresh
return found = (bool)tte[i].key16, &tte[i]; return found = (bool)tte[i].key16, &tte[i];
} }
@@ -90,11 +133,11 @@ TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
TTEntry* replace = tte; TTEntry* replace = tte;
for (int i = 1; i < ClusterSize; ++i) for (int i = 1; i < ClusterSize; ++i)
// Due to our packed storage format for generation and its cyclic // Due to our packed storage format for generation and its cyclic
// nature we add 259 (256 is the modulus plus 3 to keep the lowest // nature we add 263 (256 is the modulus plus 7 to keep the unrelated
// two bound bits from affecting the result) to calculate the entry // lowest three bits from affecting the result) to calculate the entry
// age correctly even after generation8 overflows into the next cycle. // age correctly even after generation8 overflows into the next cycle.
if ( replace->depth8 - ((259 + generation8 - replace->genBound8) & 0xFC) * 2 if ( replace->depth8 - ((263 + generation8 - replace->genBound8) & 0xF8)
> tte[i].depth8 - ((259 + generation8 - tte[i].genBound8) & 0xFC) * 2) > tte[i].depth8 - ((263 + generation8 - tte[i].genBound8) & 0xF8))
replace = &tte[i]; replace = &tte[i];
return found = false, replace; return found = false, replace;
@@ -107,12 +150,9 @@ TTEntry* TranspositionTable::probe(const Key key, bool& found) const {
int TranspositionTable::hashfull() const { int TranspositionTable::hashfull() const {
int cnt = 0; int cnt = 0;
for (int i = 0; i < 1000 / ClusterSize; i++) for (int i = 0; i < 1000 / ClusterSize; ++i)
{ for (int j = 0; j < ClusterSize; ++j)
const TTEntry* tte = &table[i].entry[0]; cnt += (table[i].entry[j].genBound8 & 0xF8) == generation8;
for (int j = 0; j < ClusterSize; j++)
if ((tte[j].genBound8 & 0xFC) == generation8) return cnt * 1000 / (ClusterSize * (1000 / ClusterSize));
cnt++;
}
return cnt;
} }
src/tt.h
+12 -30
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -30,7 +30,8 @@
/// move 16 bit /// move 16 bit
/// value 16 bit /// value 16 bit
/// eval value 16 bit /// eval value 16 bit
/// generation 6 bit /// generation 5 bit
/// pv node 1 bit
/// bound type 2 bit /// bound type 2 bit
/// depth 8 bit /// depth 8 bit
@@ -39,30 +40,10 @@ struct TTEntry {
Move move() const { return (Move )move16; } Move move() const { return (Move )move16; }
Value value() const { return (Value)value16; } Value value() const { return (Value)value16; }
Value eval() const { return (Value)eval16; } Value eval() const { return (Value)eval16; }
Depth depth() const { return (Depth)(depth8 * int(ONE_PLY)); } Depth depth() const { return (Depth)depth8 + DEPTH_OFFSET; }
bool is_pv() const { return (bool)(genBound8 & 0x4); }
Bound bound() const { return (Bound)(genBound8 & 0x3); } Bound bound() const { return (Bound)(genBound8 & 0x3); }
void save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev);
void save(Key k, Value v, Bound b, Depth d, Move m, Value ev, uint8_t g) {
assert(d / ONE_PLY * ONE_PLY == d);
// Preserve any existing move for the same position
if (m || (k >> 48) != key16)
move16 = (uint16_t)m;
// Don't overwrite more valuable entries
if ( (k >> 48) != key16
|| d / ONE_PLY > depth8 - 4
/* || g != (genBound8 & 0xFC) // Matching non-zero keys are already refreshed by probe() */
|| b == BOUND_EXACT)
{
key16 = (uint16_t)(k >> 48);
value16 = (int16_t)v;
eval16 = (int16_t)ev;
genBound8 = (uint8_t)(g | b);
depth8 = (int8_t)(d / ONE_PLY);
}
}
private: private:
friend class TranspositionTable; friend class TranspositionTable;
@@ -72,7 +53,7 @@ private:
int16_t value16; int16_t value16;
int16_t eval16; int16_t eval16;
uint8_t genBound8; uint8_t genBound8;
int8_t depth8; uint8_t depth8;
}; };
@@ -85,8 +66,8 @@ private:
class TranspositionTable { class TranspositionTable {
static const int CacheLineSize = 64; static constexpr int CacheLineSize = 64;
static const int ClusterSize = 3; static constexpr int ClusterSize = 3;
struct Cluster { struct Cluster {
TTEntry entry[ClusterSize]; TTEntry entry[ClusterSize];
@@ -97,8 +78,7 @@ class TranspositionTable {
public: public:
~TranspositionTable() { free(mem); } ~TranspositionTable() { free(mem); }
void new_search() { generation8 += 4; } // Lower 2 bits are used by Bound void new_search() { generation8 += 8; } // Lower 3 bits are used by PV flag and Bound
uint8_t generation() const { return generation8; }
TTEntry* probe(const Key key, bool& found) const; TTEntry* probe(const Key key, bool& found) const;
int hashfull() const; int hashfull() const;
void resize(size_t mbSize); void resize(size_t mbSize);
@@ -110,6 +90,8 @@ public:
} }
private: private:
friend struct TTEntry;
size_t clusterCount; size_t clusterCount;
Cluster* table; Cluster* table;
void* mem; void* mem;
src/types.h
+55 -62
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -43,6 +43,7 @@
#include <climits> #include <climits>
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
#include <algorithm>
#if defined(_MSC_VER) #if defined(_MSC_VER)
// Disable some silly and noisy warning from MSVC compiler // Disable some silly and noisy warning from MSVC compiler
@@ -80,28 +81,28 @@
#endif #endif
#ifdef USE_POPCNT #ifdef USE_POPCNT
const bool HasPopCnt = true; constexpr bool HasPopCnt = true;
#else #else
const bool HasPopCnt = false; constexpr bool HasPopCnt = false;
#endif #endif
#ifdef USE_PEXT #ifdef USE_PEXT
const bool HasPext = true; constexpr bool HasPext = true;
#else #else
const bool HasPext = false; constexpr bool HasPext = false;
#endif #endif
#ifdef IS_64BIT #ifdef IS_64BIT
const bool Is64Bit = true; constexpr bool Is64Bit = true;
#else #else
const bool Is64Bit = false; constexpr bool Is64Bit = false;
#endif #endif
typedef uint64_t Key; typedef uint64_t Key;
typedef uint64_t Bitboard; typedef uint64_t Bitboard;
const int MAX_MOVES = 256; constexpr int MAX_MOVES = 256;
const int MAX_PLY = 128; constexpr int MAX_PLY = 246;
/// A move needs 16 bits to be stored /// A move needs 16 bits to be stored
/// ///
@@ -131,24 +132,20 @@ enum Color {
WHITE, BLACK, COLOR_NB = 2 WHITE, BLACK, COLOR_NB = 2
}; };
enum CastlingSide { enum CastlingRights {
KING_SIDE, QUEEN_SIDE, CASTLING_SIDE_NB = 2
};
enum CastlingRight {
NO_CASTLING, NO_CASTLING,
WHITE_OO, WHITE_OO,
WHITE_OOO = WHITE_OO << 1, WHITE_OOO = WHITE_OO << 1,
BLACK_OO = WHITE_OO << 2, BLACK_OO = WHITE_OO << 2,
BLACK_OOO = WHITE_OO << 3, BLACK_OOO = WHITE_OO << 3,
ANY_CASTLING = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
CASTLING_RIGHT_NB = 16
};
template<Color C, CastlingSide S> struct MakeCastling { KING_SIDE = WHITE_OO | BLACK_OO,
static constexpr CastlingRight QUEEN_SIDE = WHITE_OOO | BLACK_OOO,
right = C == WHITE ? S == QUEEN_SIDE ? WHITE_OOO : WHITE_OO WHITE_CASTLING = WHITE_OO | WHITE_OOO,
: S == QUEEN_SIDE ? BLACK_OOO : BLACK_OO; BLACK_CASTLING = BLACK_OO | BLACK_OOO,
ANY_CASTLING = WHITE_CASTLING | BLACK_CASTLING,
CASTLING_RIGHT_NB = 16
}; };
enum Phase { enum Phase {
@@ -159,7 +156,6 @@ enum Phase {
enum ScaleFactor { enum ScaleFactor {
SCALE_FACTOR_DRAW = 0, SCALE_FACTOR_DRAW = 0,
SCALE_FACTOR_ONEPAWN = 48,
SCALE_FACTOR_NORMAL = 64, SCALE_FACTOR_NORMAL = 64,
SCALE_FACTOR_MAX = 128, SCALE_FACTOR_MAX = 128,
SCALE_FACTOR_NONE = 255 SCALE_FACTOR_NONE = 255
@@ -183,11 +179,11 @@ enum Value : int {
VALUE_MATE_IN_MAX_PLY = VALUE_MATE - 2 * MAX_PLY, VALUE_MATE_IN_MAX_PLY = VALUE_MATE - 2 * MAX_PLY,
VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY, VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY,
PawnValueMg = 171, PawnValueEg = 240, PawnValueMg = 128, PawnValueEg = 213,
KnightValueMg = 764, KnightValueEg = 848, KnightValueMg = 781, KnightValueEg = 854,
BishopValueMg = 826, BishopValueEg = 891, BishopValueMg = 825, BishopValueEg = 915,
RookValueMg = 1282, RookValueEg = 1373, RookValueMg = 1276, RookValueEg = 1380,
QueenValueMg = 2526, QueenValueEg = 2646, QueenValueMg = 2538, QueenValueEg = 2682,
MidgameLimit = 15258, EndgameLimit = 3915 MidgameLimit = 15258, EndgameLimit = 3915
}; };
@@ -195,7 +191,6 @@ enum Value : int {
enum PieceType { enum PieceType {
NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
ALL_PIECES = 0, ALL_PIECES = 0,
QUEEN_DIAGONAL = 7,
PIECE_TYPE_NB = 8 PIECE_TYPE_NB = 8
}; };
@@ -208,21 +203,18 @@ enum Piece {
extern Value PieceValue[PHASE_NB][PIECE_NB]; extern Value PieceValue[PHASE_NB][PIECE_NB];
enum Depth : int { typedef int Depth;
ONE_PLY = 1, enum : int {
DEPTH_ZERO = 0 * ONE_PLY, DEPTH_QS_CHECKS = 0,
DEPTH_QS_CHECKS = 0 * ONE_PLY, DEPTH_QS_NO_CHECKS = -1,
DEPTH_QS_NO_CHECKS = -1 * ONE_PLY, DEPTH_QS_RECAPTURES = -5,
DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
DEPTH_NONE = -6 * ONE_PLY, DEPTH_NONE = -6,
DEPTH_MAX = MAX_PLY * ONE_PLY DEPTH_OFFSET = DEPTH_NONE,
}; };
static_assert(!(ONE_PLY & (ONE_PLY - 1)), "ONE_PLY is not a power of 2");
enum Square : int { enum Square : int {
SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1, 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_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
@@ -258,10 +250,10 @@ enum Rank : int {
}; };
/// Score enum stores a middlegame and an endgame value in a single integer /// Score enum stores a middlegame and an endgame value in a single integer (enum).
/// (enum). The least significant 16 bits are used to store the endgame value /// The least significant 16 bits are used to store the middlegame value and the
/// and the upper 16 bits are used to store the middlegame value. Take some /// upper 16 bits are used to store the endgame value. We have to take care to
/// care to avoid left-shifting a signed int to avoid undefined behavior. /// avoid left-shifting a signed int to avoid undefined behavior.
enum Score : int { SCORE_ZERO }; enum Score : int { SCORE_ZERO };
constexpr Score make_score(int mg, int eg) { constexpr Score make_score(int mg, int eg) {
@@ -294,7 +286,6 @@ inline T& operator--(T& d) { return d = T(int(d) - 1); }
#define ENABLE_FULL_OPERATORS_ON(T) \ #define ENABLE_FULL_OPERATORS_ON(T) \
ENABLE_BASE_OPERATORS_ON(T) \ ENABLE_BASE_OPERATORS_ON(T) \
ENABLE_INCR_OPERATORS_ON(T) \
constexpr T operator*(int i, T d) { return T(i * int(d)); } \ constexpr T operator*(int i, T d) { return T(i * int(d)); } \
constexpr T operator*(T d, int i) { return T(int(d) * i); } \ constexpr T operator*(T d, int i) { return T(int(d) * i); } \
constexpr T operator/(T d, int i) { return T(int(d) / i); } \ constexpr T operator/(T d, int i) { return T(int(d) / i); } \
@@ -303,12 +294,10 @@ inline T& operator*=(T& d, int i) { return d = T(int(d) * i); } \
inline T& operator/=(T& d, int i) { return d = T(int(d) / i); } inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
ENABLE_FULL_OPERATORS_ON(Value) ENABLE_FULL_OPERATORS_ON(Value)
ENABLE_FULL_OPERATORS_ON(Depth)
ENABLE_FULL_OPERATORS_ON(Direction) ENABLE_FULL_OPERATORS_ON(Direction)
ENABLE_INCR_OPERATORS_ON(PieceType) ENABLE_INCR_OPERATORS_ON(PieceType)
ENABLE_INCR_OPERATORS_ON(Piece) ENABLE_INCR_OPERATORS_ON(Piece)
ENABLE_INCR_OPERATORS_ON(Color)
ENABLE_INCR_OPERATORS_ON(Square) ENABLE_INCR_OPERATORS_ON(Square)
ENABLE_INCR_OPERATORS_ON(File) ENABLE_INCR_OPERATORS_ON(File)
ENABLE_INCR_OPERATORS_ON(Rank) ENABLE_INCR_OPERATORS_ON(Rank)
@@ -326,10 +315,10 @@ inline Value& operator+=(Value& v, int i) { return v = v + i; }
inline Value& operator-=(Value& v, int i) { return v = v - i; } inline Value& operator-=(Value& v, int i) { return v = v - i; }
/// Additional operators to add a Direction to a Square /// Additional operators to add a Direction to a Square
inline Square operator+(Square s, Direction d) { return Square(int(s) + int(d)); } constexpr Square operator+(Square s, Direction d) { return Square(int(s) + int(d)); }
inline Square operator-(Square s, Direction d) { return Square(int(s) - int(d)); } constexpr Square operator-(Square s, Direction d) { return Square(int(s) - int(d)); }
inline Square& operator+=(Square &s, Direction d) { return s = s + d; } inline Square& operator+=(Square& s, Direction d) { return s = s + d; }
inline Square& operator-=(Square &s, Direction d) { return s = s - d; } inline Square& operator-=(Square& s, Direction d) { return s = s - d; }
/// Only declared but not defined. We don't want to multiply two scores due to /// 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. /// a very high risk of overflow. So user should explicitly convert to integer.
@@ -347,11 +336,16 @@ inline Score operator*(Score s, int i) {
assert(eg_value(result) == (i * eg_value(s))); assert(eg_value(result) == (i * eg_value(s)));
assert(mg_value(result) == (i * mg_value(s))); assert(mg_value(result) == (i * mg_value(s)));
assert((i == 0) || (result / i) == s ); assert((i == 0) || (result / i) == s);
return result; return result;
} }
/// Multiplication of a Score by a boolean
inline Score operator*(Score s, bool b) {
return Score(int(s) * int(b));
}
constexpr Color operator~(Color c) { constexpr Color operator~(Color c) {
return Color(c ^ BLACK); // Toggle color return Color(c ^ BLACK); // Toggle color
} }
@@ -360,16 +354,16 @@ constexpr Square operator~(Square s) {
return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8 return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8
} }
constexpr File operator~(File f) {
return File(f ^ FILE_H); // Horizontal flip FILE_A -> FILE_H
}
constexpr Piece operator~(Piece pc) { constexpr Piece operator~(Piece pc) {
return Piece(pc ^ 8); // Swap color of piece B_KNIGHT -> W_KNIGHT return Piece(pc ^ 8); // Swap color of piece B_KNIGHT -> W_KNIGHT
} }
constexpr CastlingRight operator|(Color c, CastlingSide s) { inline File map_to_queenside(File f) {
return CastlingRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c)); return std::min(f, File(FILE_H - f)); // Map files ABCDEFGH to files ABCDDCBA
}
constexpr CastlingRights operator&(Color c, CastlingRights cr) {
return CastlingRights((c == WHITE ? WHITE_CASTLING : BLACK_CASTLING) & cr);
} }
constexpr Value mate_in(int ply) { constexpr Value mate_in(int ply) {
@@ -421,11 +415,6 @@ constexpr Rank relative_rank(Color c, Square s) {
return relative_rank(c, rank_of(s)); return relative_rank(c, rank_of(s));
} }
inline bool opposite_colors(Square s1, Square s2) {
int s = int(s1) ^ int(s2);
return ((s >> 3) ^ s) & 1;
}
constexpr Direction pawn_push(Color c) { constexpr Direction pawn_push(Color c) {
return c == WHITE ? NORTH : SOUTH; return c == WHITE ? NORTH : SOUTH;
} }
@@ -450,10 +439,14 @@ constexpr PieceType promotion_type(Move m) {
return PieceType(((m >> 12) & 3) + KNIGHT); return PieceType(((m >> 12) & 3) + KNIGHT);
} }
inline Move make_move(Square from, Square to) { constexpr Move make_move(Square from, Square to) {
return Move((from << 6) + to); return Move((from << 6) + to);
} }
constexpr Move reverse_move(Move m) {
return make_move(to_sq(m), from_sq(m));
}
template<MoveType T> template<MoveType T>
constexpr Move make(Square from, Square to, PieceType pt = KNIGHT) { constexpr Move make(Square from, Square to, PieceType pt = KNIGHT) {
return Move(T + ((pt - KNIGHT) << 12) + (from << 6) + to); return Move(T + ((pt - KNIGHT) << 12) + (from << 6) + to);
src/uci.cpp
+29 -25
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -28,8 +28,8 @@
#include "position.h" #include "position.h"
#include "search.h" #include "search.h"
#include "thread.h" #include "thread.h"
#include "tt.h"
#include "timeman.h" #include "timeman.h"
#include "tt.h"
#include "uci.h" #include "uci.h"
#include "syzygy/tbprobe.h" #include "syzygy/tbprobe.h"
@@ -89,11 +89,11 @@ namespace {
// Read option name (can contain spaces) // Read option name (can contain spaces)
while (is >> token && token != "value") while (is >> token && token != "value")
name += string(" ", name.empty() ? 0 : 1) + token; name += (name.empty() ? "" : " ") + token;
// Read option value (can contain spaces) // Read option value (can contain spaces)
while (is >> token) while (is >> token)
value += string(" ", value.empty() ? 0 : 1) + token; value += (value.empty() ? "" : " ") + token;
if (Options.count(name)) if (Options.count(name))
Options[name] = value; Options[name] = value;
@@ -146,7 +146,7 @@ namespace {
uint64_t num, nodes = 0, cnt = 1; uint64_t num, nodes = 0, cnt = 1;
vector<string> list = setup_bench(pos, args); vector<string> list = setup_bench(pos, args);
num = count_if(list.begin(), list.end(), [](string s) { return s.find("go ") == 0; }); num = count_if(list.begin(), list.end(), [](string s) { return s.find("go ") == 0 || s.find("eval") == 0; });
TimePoint elapsed = now(); TimePoint elapsed = now();
@@ -155,16 +155,21 @@ namespace {
istringstream is(cmd); istringstream is(cmd);
is >> skipws >> token; is >> skipws >> token;
if (token == "go") if (token == "go" || token == "eval")
{ {
cerr << "\nPosition: " << cnt++ << '/' << num << endl; cerr << "\nPosition: " << cnt++ << '/' << num << endl;
go(pos, is, states); if (token == "go")
Threads.main()->wait_for_search_finished(); {
nodes += Threads.nodes_searched(); go(pos, is, states);
Threads.main()->wait_for_search_finished();
nodes += Threads.nodes_searched();
}
else
sync_cout << "\n" << Eval::trace(pos) << sync_endl;
} }
else if (token == "setoption") setoption(is); else if (token == "setoption") setoption(is);
else if (token == "position") position(pos, is, states); else if (token == "position") position(pos, is, states);
else if (token == "ucinewgame") Search::clear(); else if (token == "ucinewgame") { Search::clear(); elapsed = now(); } // Search::clear() may take some while
} }
elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero' elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero'
@@ -191,9 +196,8 @@ void UCI::loop(int argc, char* argv[]) {
Position pos; Position pos;
string token, cmd; string token, cmd;
StateListPtr states(new std::deque<StateInfo>(1)); StateListPtr states(new std::deque<StateInfo>(1));
auto uiThread = std::make_shared<Thread>(0);
pos.set(StartFEN, false, &states->back(), uiThread.get()); pos.set(StartFEN, false, &states->back(), Threads.main());
for (int i = 1; i < argc; ++i) for (int i = 1; i < argc; ++i)
cmd += std::string(argv[i]) + " "; cmd += std::string(argv[i]) + " ";
@@ -207,18 +211,16 @@ void UCI::loop(int argc, char* argv[]) {
token.clear(); // Avoid a stale if getline() returns empty or blank line token.clear(); // Avoid a stale if getline() returns empty or blank line
is >> skipws >> token; is >> skipws >> token;
if ( token == "quit"
|| token == "stop")
Threads.stop = true;
// The GUI sends 'ponderhit' to tell us the user has played the expected move. // The GUI sends 'ponderhit' to tell us the user has played the expected move.
// So 'ponderhit' will be sent if we were told to ponder on the same move the // So 'ponderhit' will be sent if we were told to ponder on the same move the
// user has played. We should continue searching but switch from pondering to // user has played. We should continue searching but switch from pondering to
// normal search. In case Threads.stopOnPonderhit is set we are waiting for // normal search.
// 'ponderhit' to stop the search, for instance if max search depth is reached.
if ( token == "quit"
|| token == "stop"
|| (token == "ponderhit" && Threads.stopOnPonderhit))
Threads.stop = true;
else if (token == "ponderhit") else if (token == "ponderhit")
Threads.ponder = false; // Switch to normal search Threads.main()->ponder = false; // Switch to normal search
else if (token == "uci") else if (token == "uci")
sync_cout << "id name " << engine_info(true) sync_cout << "id name " << engine_info(true)
@@ -231,11 +233,13 @@ void UCI::loop(int argc, char* argv[]) {
else if (token == "ucinewgame") Search::clear(); else if (token == "ucinewgame") Search::clear();
else if (token == "isready") sync_cout << "readyok" << sync_endl; else if (token == "isready") sync_cout << "readyok" << sync_endl;
// Additional custom non-UCI commands, mainly for debugging // Additional custom non-UCI commands, mainly for debugging.
else if (token == "flip") pos.flip(); // Do not use these commands during a search!
else if (token == "bench") bench(pos, is, states); else if (token == "flip") pos.flip();
else if (token == "d") sync_cout << pos << sync_endl; else if (token == "bench") bench(pos, is, states);
else if (token == "eval") sync_cout << Eval::trace(pos) << sync_endl; else if (token == "d") sync_cout << pos << sync_endl;
else if (token == "eval") sync_cout << Eval::trace(pos) << sync_endl;
else if (token == "compiler") sync_cout << compiler_info() << sync_endl;
else else
sync_cout << "Unknown command: " << cmd << sync_endl; sync_cout << "Unknown command: " << cmd << sync_endl;
src/uci.h
+5 -3
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -49,12 +49,14 @@ public:
Option(OnChange = nullptr); Option(OnChange = nullptr);
Option(bool v, OnChange = nullptr); Option(bool v, OnChange = nullptr);
Option(const char* v, OnChange = nullptr); Option(const char* v, OnChange = nullptr);
Option(int v, int minv, int maxv, OnChange = nullptr); Option(double v, int minv, int maxv, OnChange = nullptr);
Option(const char* v, const char* cur, OnChange = nullptr);
Option& operator=(const std::string&); Option& operator=(const std::string&);
void operator<<(const Option&); void operator<<(const Option&);
operator int() const; operator double() const;
operator std::string() const; operator std::string() const;
bool operator==(const char*) const;
private: private:
friend std::ostream& operator<<(std::ostream&, const OptionsMap&); friend std::ostream& operator<<(std::ostream&, const OptionsMap&);
src/ucioption.cpp
+40 -13
View File
@@ -2,7 +2,7 @@
Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <ostream> #include <ostream>
#include <sstream>
#include "misc.h" #include "misc.h"
#include "search.h" #include "search.h"
@@ -56,10 +57,11 @@ bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const
void init(OptionsMap& o) { void init(OptionsMap& o) {
// at most 2^32 clusters. // at most 2^32 clusters.
const int MaxHashMB = Is64Bit ? 131072 : 2048; constexpr int MaxHashMB = Is64Bit ? 131072 : 2048;
o["Debug Log File"] << Option("", on_logger); o["Debug Log File"] << Option("", on_logger);
o["Contempt"] << Option(20, -100, 100); o["Contempt"] << Option(24, -100, 100);
o["Analysis Contempt"] << Option("Both var Off var White var Black var Both", "Both");
o["Threads"] << Option(1, 1, 512, on_threads); o["Threads"] << Option(1, 1, 512, on_threads);
o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size); o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size);
o["Clear Hash"] << Option(on_clear_hash); o["Clear Hash"] << Option(on_clear_hash);
@@ -68,13 +70,16 @@ void init(OptionsMap& o) {
o["Skill Level"] << Option(20, 0, 20); o["Skill Level"] << Option(20, 0, 20);
o["Move Overhead"] << Option(30, 0, 5000); o["Move Overhead"] << Option(30, 0, 5000);
o["Minimum Thinking Time"] << Option(20, 0, 5000); o["Minimum Thinking Time"] << Option(20, 0, 5000);
o["Slow Mover"] << Option(89, 10, 1000); o["Slow Mover"] << Option(84, 10, 1000);
o["nodestime"] << Option(0, 0, 10000); o["nodestime"] << Option(0, 0, 10000);
o["UCI_Chess960"] << Option(false); o["UCI_Chess960"] << Option(false);
o["UCI_AnalyseMode"] << Option(false);
o["UCI_LimitStrength"] << Option(false);
o["UCI_Elo"] << Option(1350, 1350, 2850);
o["SyzygyPath"] << Option("<empty>", on_tb_path); o["SyzygyPath"] << Option("<empty>", on_tb_path);
o["SyzygyProbeDepth"] << Option(1, 1, 100); o["SyzygyProbeDepth"] << Option(1, 1, 100);
o["Syzygy50MoveRule"] << Option(true); o["Syzygy50MoveRule"] << Option(true);
o["SyzygyProbeLimit"] << Option(6, 0, 6); o["SyzygyProbeLimit"] << Option(7, 0, 7);
} }
@@ -90,11 +95,13 @@ std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
const Option& o = it.second; const Option& o = it.second;
os << "\noption name " << it.first << " type " << o.type; os << "\noption name " << it.first << " type " << o.type;
if (o.type != "button") if (o.type == "string" || o.type == "check" || o.type == "combo")
os << " default " << o.defaultValue; os << " default " << o.defaultValue;
if (o.type == "spin") if (o.type == "spin")
os << " min " << o.min << " max " << o.max; os << " default " << int(stof(o.defaultValue))
<< " min " << o.min
<< " max " << o.max;
break; break;
} }
@@ -114,12 +121,15 @@ Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f) Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
{} {}
Option::Option(int v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f) Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
{ defaultValue = currentValue = std::to_string(v); } { defaultValue = currentValue = std::to_string(v); }
Option::operator int() const { Option::Option(const char* v, const char* cur, OnChange f) : type("combo"), min(0), max(0), on_change(f)
{ defaultValue = v; currentValue = cur; }
Option::operator double() const {
assert(type == "check" || type == "spin"); assert(type == "check" || type == "spin");
return (type == "spin" ? stoi(currentValue) : currentValue == "true"); return (type == "spin" ? stof(currentValue) : currentValue == "true");
} }
Option::operator std::string() const { Option::operator std::string() const {
@@ -127,6 +137,12 @@ Option::operator std::string() const {
return currentValue; return currentValue;
} }
bool Option::operator==(const char* s) const {
assert(type == "combo");
return !CaseInsensitiveLess()(currentValue, s)
&& !CaseInsensitiveLess()(s, currentValue);
}
/// operator<<() inits options and assigns idx in the correct printing order /// operator<<() inits options and assigns idx in the correct printing order
@@ -140,8 +156,8 @@ void Option::operator<<(const Option& o) {
/// operator=() updates currentValue and triggers on_change() action. It's up to /// operator=() updates currentValue and triggers on_change() action. It's up to
/// the GUI to check for option's limits, but we could receive the new value from /// the GUI to check for option's limits, but we could receive the new value
/// the user by console window, so let's check the bounds anyway. /// from the user by console window, so let's check the bounds anyway.
Option& Option::operator=(const string& v) { Option& Option::operator=(const string& v) {
@@ -149,9 +165,20 @@ Option& Option::operator=(const string& v) {
if ( (type != "button" && v.empty()) if ( (type != "button" && v.empty())
|| (type == "check" && v != "true" && v != "false") || (type == "check" && v != "true" && v != "false")
|| (type == "spin" && (stoi(v) < min || stoi(v) > max))) || (type == "spin" && (stof(v) < min || stof(v) > max)))
return *this; return *this;
if (type == "combo")
{
OptionsMap comboMap; // To have case insensitive compare
string token;
std::istringstream ss(defaultValue);
while (ss >> token)
comboMap[token] << Option();
if (!comboMap.count(v) || v == "var")
return *this;
}
if (type != "button") if (type != "button")
currentValue = v; currentValue = v;
tests/instrumented.sh
+28 -6
View File
@@ -28,14 +28,14 @@ case $1 in
echo "sanitizer-undefined testing started" echo "sanitizer-undefined testing started"
prefix='!' prefix='!'
exeprefix='' exeprefix=''
postfix='2>&1 | grep "runtime error:"' postfix='2>&1 | grep -A50 "runtime error:"'
threads="1" threads="1"
;; ;;
--sanitizer-thread) --sanitizer-thread)
echo "sanitizer-thread testing started" echo "sanitizer-thread testing started"
prefix='!' prefix='!'
exeprefix='' exeprefix=''
postfix='2>&1 | grep "WARNING: ThreadSanitizer:"' postfix='2>&1 | grep -A50 "WARNING: ThreadSanitizer:"'
threads="2" threads="2"
cat << EOF > tsan.supp cat << EOF > tsan.supp
@@ -45,6 +45,7 @@ race:TTEntry::bound
race:TTEntry::save race:TTEntry::save
race:TTEntry::value race:TTEntry::value
race:TTEntry::eval race:TTEntry::eval
race:TTEntry::is_pv
race:TranspositionTable::probe race:TranspositionTable::probe
race:TranspositionTable::hashfull race:TranspositionTable::hashfull
@@ -108,13 +109,34 @@ cat << EOF > game.exp
exit \$value exit \$value
EOF EOF
for exps in game.exp #download TB as needed
if [ ! -d ../tests/syzygy ]; then
curl -sL https://api.github.com/repos/niklasf/python-chess/tarball/9b9aa13f9f36d08aadfabff872882f4ab1494e95 | tar -xzf -
mv niklasf-python-chess-9b9aa13 ../tests/syzygy
fi
cat << EOF > syzygy.exp
set timeout 240
spawn $exeprefix ./stockfish
send "uci\n"
send "setoption name SyzygyPath value ../tests/syzygy/\n"
expect "info string Found 35 tablebases" {} timeout {exit 1}
send "bench 128 1 10 default depth\n"
send "quit\n"
expect eof
# return error code of the spawned program, useful for valgrind
lassign [wait] pid spawnid os_error_flag value
exit \$value
EOF
for exp in game.exp syzygy.exp
do do
echo "$prefix expect $exps $postfix" echo "$prefix expect $exp $postfix"
eval "$prefix expect $exps $postfix" eval "$prefix expect $exp $postfix"
rm $exps rm $exp
done done
tests/perft.sh
+1 -1
View File
@@ -1,5 +1,5 @@
#!/bin/bash #!/bin/bash
# verify perft numbers (positions from https://chessprogramming.wikispaces.com/Perft+Results) # verify perft numbers (positions from www.chessprogramming.org/Perft_Results)
error() error()
{ {
tests/signature.sh
+5 -1
View File
@@ -16,7 +16,11 @@ signature=`./stockfish bench 2>&1 | grep "Nodes searched : " | awk '{print $4}'
if [ $# -gt 0 ]; then if [ $# -gt 0 ]; then
# compare to given reference # compare to given reference
if [ "$1" != "$signature" ]; then if [ "$1" != "$signature" ]; then
echo "signature mismatch: reference $1 obtained $signature" if [ -z "$signature" ]; then
echo "No signature obtained from bench. Code crashed or assert triggered ?"
else
echo "signature mismatch: reference $1 obtained: $signature ."
fi
exit 1 exit 1
else else
echo "signature OK: $signature" echo "signature OK: $signature"