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

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

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.

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.

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

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.

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,..)

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

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.

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)

Make the debug counters thread safe.

needed to use them in a threaded run.

No functional change.

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

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

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

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

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

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

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

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.

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.

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

Assorted trivial cleanups 5/2019

No functional change.

bench: 4178282

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

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

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

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

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

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.

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

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

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

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.

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

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

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.

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.

Consolidate some code in set_state. (#2151)

Non functional change.

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

Revert "Make rootDepth local to search. (#2077)"

This reverts commit 44c320a572188b5875291103edb344c584b91d19.

Fix a compile error.

Bench: 3824325

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.

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.

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

Simplify reduction formula #2122

Simplify reduction formula

No functional change.

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)

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.

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

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

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.

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

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

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

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

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

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

Assorted trivial cleanups 4/2019

No functional change.

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

Allow for address sanitizer. (#2119)

Properly allow for sanitize=address (-fsanitize=address) as an argument to the Makefile.

No functional change

Fix bench number of previous patch

bench: 3388643

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

Shuffle detection #2108

Bench: 3402947

Remove useless initializations (#2115)

Removes two unneeded inits, they are always set before their use later on.

No functional change.

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.

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

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.

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.

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.

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.

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

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.

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

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

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 76f1807baa90eb69f66001d25df2a28533f9406f.
and fixes the issue https://github.com/official-stockfish/Stockfish/issues/2091

Bench: 3243738

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

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.

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

Remove BetweenBB Array #2076

Non functional change.

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.

Make ONE_PLY value independent again

And a Trevis CI test to catch future issues.

No functional change.

Fix a missing assignment in previous commit

While reformatting the patch, I got wrong a statement and converted it badly.

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

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

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

Assorted trivial cleanups 3/2019 (#2030)

No functional change.

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.

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

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.

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.

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.

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

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.

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.

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

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.

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.

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.

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

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

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

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.

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