Capping stat bonus at 2000

[snicolet]

This patch updates the stat_bonus() function (used in the history tables to
help move ordering), keeping the same quadratic for small depths but changing
the values for depth >= 9:

The old bonus formula was increasing from zero at depth 1 to 4100 at depth 14,
then used the strange, small value of 73 for all depths >= 15.

The new bonus formula increases from 0 at depth 1 to 2000 at depth 8, then
keep 2000 for all depths >= 8.

passed STC:
LLR: 2.94 (-2.94,2.94) <-0.50,2.50>
Total: 169624 W: 42875 L: 42454 D: 84295
Ptnml(0-2): 585, 19340, 44557, 19729, 601
https://tests.stockfishchess.org/tests/view/615bd69e9d256038a969b97c

passed LTC:
LLR: 3.07 (-2.94,2.94) <0.50,3.50>
Total: 37336 W: 9456 L: 9191 D: 18689
Ptnml(0-2): 20, 3810, 10747, 4067, 24
https://tests.stockfishchess.org/tests/view/615c75d99d256038a969b9b2

closes #3731

Bench: 6261865

[mstembera]

Congrats! One multiply could be removed with

 return std::min((6  * d + 229) * d - 215 , 2000);

[Vizvezdenec]

Congrats!
I propose testless removal of this https://github.com/official-stockfish/Stockfish/blob/master/src/search.cpp#L1711
and making it bonus1 : stat_bonus(depth) instead - since bonus1 now is always >= stat_bonus(depth) with this patch.

[silversolver1]

isn't this about equivalent to:

  int stat_bonus(Depth d) {
    return d > 7 ? 2000 : 6 * d * d + 229 * d - 215;
  }

as value of d=8 is 2001 (and all values larger will be pushed to 2000 anyways). no real point in doing the calculations and the comparison every time (only necessary for values 0 to 7 or 1 to 7)

or to use mstembera's calculation which is indeed a bit shorter

  int stat_bonus(Depth d) {
    return d > 7 ? 2000 : (6 * d + 229) * d - 215;
  }

edit: d > 8 should maintain bench (untested but basically means depth 9 or above would be automatic 2000 without having to obtain a number for comparison while depth 1 to 8 would be calculated as normal, including d = 8, 2001)

[snicolet]

@vondele I can squash the change proposed by @Vizvezdenec in the PR, if you wish. That is, instead of

bonus2 = bestValue > beta + PawnValueMg ? bonus1                                 // larger bonus
                                        : std::min(bonus1, stat_bonus(depth));   // smaller bonus

we would use this expression, which would keep the same bench:

bonus2 = bestValue > beta + PawnValueMg ? bonus1               // larger bonus
                                        : stat_bonus(depth);   // smaller bonus

[vondele]

@snicolet yes please squash the change. I won't be able to commit patches before tonight.

[snicolet]

@silversolver1

Thanks for the suggestion. I have measured the speed of these two versions (running two benches at depth 20 in parallel):

version A   :   return std::min((6 * d + 229) * d - 215 , 2000);
version B   :   return d > 7 ? 2000 : (6 * d + 229) * d - 215;

Version B is 0.3% slower than version A.

I suspect that in both cases the time is dominated by the test, instead of the polynomial evaluation. However version A may use an optimized implementation for std::min while version B cannot avoid the branch.