Lazy SMP ideas

Discussion of chess software programming and technical issues.

Moderators: bob, hgm, Harvey Williamson

Forum rules
This textbox is used to restore diagrams posted with the [d] tag before the upgrade.
User avatar
lucasart
Posts: 3066
Joined: Mon May 31, 2010 11:29 am
Full name: lucasart
Contact:

Re: Lazy SMP ideas

Post by lucasart » Sun Sep 30, 2018 9:33 am

Edsel Apostol wrote:
Sat Sep 01, 2018 4:57 am
So here are the test results from my implementation of ABDADA and Lazy SMP from the new engine and the modified YBWC from Hannibal.

I'm using the following set of positions (from Hannibal games and from some positions posted here in CCC):

Code: Select all

"r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq - 2 12",
"2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - - 4 22",
"r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - - 0 17",
"1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - - 1 32",
"1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - - 1 32",
"1r1r1qk1/pn1p2p1/1pp1npBp/8/2PB2QP/4R1P1/P4PK1/3R4 w - - 0 1",
"3rr1k1/1b2nnpp/1p1q1p2/pP1p1P2/P1pP2P1/2N1P1QP/3N1RB1/2R3K1 w - - 0 1",
"rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - 0 1",
"1r3rk1/3bb1pp/1qn1p3/3pP3/3P1N2/2Q2N2/2P3PP/R1BR3K w - - 0 1",
"rn1q1rk1/2pbb3/pn2p3/1p1pPpp1/3P4/1PNBBN2/P1P1Q1PP/R4R1K w - - 0 1"
The positions are chosen based on their complexity where the engine would need at least a minute or two to complete the depth 20 iteration on single core.

Results are from a dual Intel Xeon E5-2698V3 https://ark.intel.com/products/81060/In ... e-2_30-GHz
The machine is 32 cores with 64 threads.

Hannibal modified YBWC searched with hash size of 512MB and fixed depth of 25 for thread values, 1,2,4,8,16,32,64. Values are summed and divided by the number of positions and then divided by the result of the single thread search. This doesn't take into account the turbo boost from the single core run, so the result is probably a bit lower than the correct value. Every start of the test ucinewgame is being issued, so the search is being started from scratch as hashes are cleared. The result for the Threads: 1 has average time spent in seconds and nodes in kNPS. The succeeding values for higher thread counts are multipliers for nodes, and the inverse for time.

Code: Select all

Threads: 1 time: 74.990600 nodes: 937.200000
Threads: 2 time: 2.149378 nodes: 1.942089
Threads: 4 time: 3.346066 nodes: 3.753011
Threads: 8 time: 5.226519 nodes: 6.973204
Threads: 16 time: 6.626765 nodes: 12.046264
Threads: 32 time: 8.139148 nodes: 16.006453
Threads: 64 time: 4.880303 nodes: 13.368858
As can be seen Hannibal NPS scaling is only good up to 16 cores. Maybe due to the machine being dual CPUs the engine struggled with NUMA due to Hannibal internal design of handling split points and repetition detection. Hannibal was only tested in an 8 core machine before this.

This is the result for the new chess engine with the modified ABDADA as implemented by Tom Kerrigan. http://www.tckerrigan.com/Chess/Paralle ... ed_ABDADA/
Searched with 512MB hash and fixed depth of 20.

Code: Select all

Threads: 1 time: 108.299200 nodes: 3127.100000
Threads: 2 time: 2.168862 nodes: 1.787663
Threads: 4 time: 3.603405 nodes: 3.492227
Threads: 8 time: 6.197661 nodes: 6.876950
Threads: 16 time: 8.440115 nodes: 13.613154
Threads: 32 time: 10.724592 nodes: 26.575884
Threads: 64 time: 11.759754 nodes: 31.082229
NPS scaling is not perfect due probably to turbo boost in single core and the signalling to the threads to quit current iteration upon one thread completing that iteration. This is to synchronize and focus the effort into the next iteration. This is done without waiting for any threads.

This is the result for the LazySMP:

Code: Select all

Threads: 1 time: 109.826200 nodes: 3084.100000
Threads: 2 time: 3.847632 nodes: 1.844580
Threads: 4 time: 6.209981 nodes: 3.616316
Threads: 8 time: 6.069562 nodes: 7.212488
Threads: 16 time: 7.001232 nodes: 14.255216
Threads: 32 time: 13.694476 nodes: 27.848897
Threads: 64 time: 10.592256 nodes: 31.428827
LazySMP is implemented with 50% of the threads searching depth and another 50% on depth+1. As can be seen there is some kind of super linear speedup in Threads 2 and 4. This is probably why Lazy is so strong in 4 cores which is currently the standard with the rating lists.

Invictus chess engine source code can be found here:
ABDADA https://github.com/ed-apostol/InvictusChess
LazySMP https://github.com/ed-apostol/InvictusC ... ee/LazySMP
Good luck with your new engine. Looks like you've done a lot of work on the subject.

In your experience, does ABDADA gain any elo ? (not time to depth, I'm not interested in that metric)

For me, ABDADA is a regression compared to standard lazy SMP, including Tom K's form of it. So messing up the coding base to lose elo, no thanks...

What worked best for me is:
* work balancing: 1/2 workers at depth d, 1/2 workers at depth d+1.
* stop useless iterations: when (any) worker completes a given depth d, signal all other workers running depth <= d to stop immediately, and report back to base, where they can be assigned useful work (ie. >= d+1).
Theory and practice sometimes clash. And when that happens, theory loses. Every single time.

Edsel Apostol
Posts: 770
Joined: Mon Jul 17, 2006 3:53 am
Full name: Edsel Apostol
Contact:

Re: Lazy SMP ideas

Post by Edsel Apostol » Mon Oct 01, 2018 1:10 am

lucasart wrote:
Sun Sep 30, 2018 9:33 am
Edsel Apostol wrote:
Sat Sep 01, 2018 4:57 am
So here are the test results from my implementation of ABDADA and Lazy SMP from the new engine and the modified YBWC from Hannibal.

I'm using the following set of positions (from Hannibal games and from some positions posted here in CCC):

Code: Select all

"r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq - 2 12",
"2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - - 4 22",
"r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - - 0 17",
"1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - - 1 32",
"1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - - 1 32",
"1r1r1qk1/pn1p2p1/1pp1npBp/8/2PB2QP/4R1P1/P4PK1/3R4 w - - 0 1",
"3rr1k1/1b2nnpp/1p1q1p2/pP1p1P2/P1pP2P1/2N1P1QP/3N1RB1/2R3K1 w - - 0 1",
"rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - 0 1",
"1r3rk1/3bb1pp/1qn1p3/3pP3/3P1N2/2Q2N2/2P3PP/R1BR3K w - - 0 1",
"rn1q1rk1/2pbb3/pn2p3/1p1pPpp1/3P4/1PNBBN2/P1P1Q1PP/R4R1K w - - 0 1"
The positions are chosen based on their complexity where the engine would need at least a minute or two to complete the depth 20 iteration on single core.

Results are from a dual Intel Xeon E5-2698V3 https://ark.intel.com/products/81060/In ... e-2_30-GHz
The machine is 32 cores with 64 threads.

Hannibal modified YBWC searched with hash size of 512MB and fixed depth of 25 for thread values, 1,2,4,8,16,32,64. Values are summed and divided by the number of positions and then divided by the result of the single thread search. This doesn't take into account the turbo boost from the single core run, so the result is probably a bit lower than the correct value. Every start of the test ucinewgame is being issued, so the search is being started from scratch as hashes are cleared. The result for the Threads: 1 has average time spent in seconds and nodes in kNPS. The succeeding values for higher thread counts are multipliers for nodes, and the inverse for time.

Code: Select all

Threads: 1 time: 74.990600 nodes: 937.200000
Threads: 2 time: 2.149378 nodes: 1.942089
Threads: 4 time: 3.346066 nodes: 3.753011
Threads: 8 time: 5.226519 nodes: 6.973204
Threads: 16 time: 6.626765 nodes: 12.046264
Threads: 32 time: 8.139148 nodes: 16.006453
Threads: 64 time: 4.880303 nodes: 13.368858
As can be seen Hannibal NPS scaling is only good up to 16 cores. Maybe due to the machine being dual CPUs the engine struggled with NUMA due to Hannibal internal design of handling split points and repetition detection. Hannibal was only tested in an 8 core machine before this.

This is the result for the new chess engine with the modified ABDADA as implemented by Tom Kerrigan. http://www.tckerrigan.com/Chess/Paralle ... ed_ABDADA/
Searched with 512MB hash and fixed depth of 20.

Code: Select all

Threads: 1 time: 108.299200 nodes: 3127.100000
Threads: 2 time: 2.168862 nodes: 1.787663
Threads: 4 time: 3.603405 nodes: 3.492227
Threads: 8 time: 6.197661 nodes: 6.876950
Threads: 16 time: 8.440115 nodes: 13.613154
Threads: 32 time: 10.724592 nodes: 26.575884
Threads: 64 time: 11.759754 nodes: 31.082229
NPS scaling is not perfect due probably to turbo boost in single core and the signalling to the threads to quit current iteration upon one thread completing that iteration. This is to synchronize and focus the effort into the next iteration. This is done without waiting for any threads.

This is the result for the LazySMP:

Code: Select all

Threads: 1 time: 109.826200 nodes: 3084.100000
Threads: 2 time: 3.847632 nodes: 1.844580
Threads: 4 time: 6.209981 nodes: 3.616316
Threads: 8 time: 6.069562 nodes: 7.212488
Threads: 16 time: 7.001232 nodes: 14.255216
Threads: 32 time: 13.694476 nodes: 27.848897
Threads: 64 time: 10.592256 nodes: 31.428827
LazySMP is implemented with 50% of the threads searching depth and another 50% on depth+1. As can be seen there is some kind of super linear speedup in Threads 2 and 4. This is probably why Lazy is so strong in 4 cores which is currently the standard with the rating lists.

Invictus chess engine source code can be found here:
ABDADA https://github.com/ed-apostol/InvictusChess
LazySMP https://github.com/ed-apostol/InvictusC ... ee/LazySMP
Good luck with your new engine. Looks like you've done a lot of work on the subject.

In your experience, does ABDADA gain any elo ? (not time to depth, I'm not interested in that metric)

For me, ABDADA is a regression compared to standard lazy SMP, including Tom K's form of it. So messing up the coding base to lose elo, no thanks...

What worked best for me is:
* work balancing: 1/2 workers at depth d, 1/2 workers at depth d+1.
* stop useless iterations: when (any) worker completes a given depth d, signal all other workers running depth <= d to stop immediately, and report back to base, where they can be assigned useful work (ie. >= d+1).
I've implemented Lazy SMP the same as what you've described and it is about the same strength as my ABDADA. When deferring moves in ABDADA you should also take note of the move order for correct LMR/P but you probably already know that. Texel I think is also ABDADA but it doesn't create new hash entries for a new position being tagged as busy so it doesn't take advantage of the full capability of the algo. I have a separate hash table for just that purpose and have a replacement scheme based on depth, unlike Tom's where he just replace the first entry always. I will stick with ABDADA for now. I think that I can still improve it further along the way, the same as what I did in Hannibal with a DTS like YBWC.

Dann Corbit
Posts: 10244
Joined: Wed Mar 08, 2006 7:57 pm
Location: Redmond, WA USA
Contact:

Re: Lazy SMP ideas

Post by Dann Corbit » Mon Oct 01, 2018 7:33 pm

Edsel Apostol wrote:
Sat Sep 01, 2018 4:57 am
So here are the test results from my implementation of ABDADA and Lazy SMP from the new engine and the modified YBWC from Hannibal.

I'm using the following set of positions (from Hannibal games and from some positions posted here in CCC):

Code: Select all

"r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq - 2 12",
"2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - - 4 22",
"r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - - 0 17",
"1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - - 1 32",
"1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - - 1 32",
"1r1r1qk1/pn1p2p1/1pp1npBp/8/2PB2QP/4R1P1/P4PK1/3R4 w - - 0 1",
"3rr1k1/1b2nnpp/1p1q1p2/pP1p1P2/P1pP2P1/2N1P1QP/3N1RB1/2R3K1 w - - 0 1",
"rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - 0 1",
"1r3rk1/3bb1pp/1qn1p3/3pP3/3P1N2/2Q2N2/2P3PP/R1BR3K w - - 0 1",
"rn1q1rk1/2pbb3/pn2p3/1p1pPpp1/3P4/1PNBBN2/P1P1Q1PP/R4R1K w - - 0 1"
{snip}
I guess that these are from Hannibal games:
2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - -
r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq -
1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - -
1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - -
r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - -
Can you give more information (e.g. date, opponent, correct move, that sort of thing?)

I already have references for the other 5.
Taking ideas is not a vice, it is a virtue. We have another word for this. It is called learning.
But sharing ideas is an even greater virtue. We have another word for this. It is called teaching.

Edsel Apostol
Posts: 770
Joined: Mon Jul 17, 2006 3:53 am
Full name: Edsel Apostol
Contact:

Re: Lazy SMP ideas

Post by Edsel Apostol » Mon Oct 01, 2018 8:22 pm

Dann Corbit wrote:
Mon Oct 01, 2018 7:33 pm
Edsel Apostol wrote:
Sat Sep 01, 2018 4:57 am
So here are the test results from my implementation of ABDADA and Lazy SMP from the new engine and the modified YBWC from Hannibal.

I'm using the following set of positions (from Hannibal games and from some positions posted here in CCC):

Code: Select all

"r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq - 2 12",
"2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - - 4 22",
"r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - - 0 17",
"1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - - 1 32",
"1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - - 1 32",
"1r1r1qk1/pn1p2p1/1pp1npBp/8/2PB2QP/4R1P1/P4PK1/3R4 w - - 0 1",
"3rr1k1/1b2nnpp/1p1q1p2/pP1p1P2/P1pP2P1/2N1P1QP/3N1RB1/2R3K1 w - - 0 1",
"rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - 0 1",
"1r3rk1/3bb1pp/1qn1p3/3pP3/3P1N2/2Q2N2/2P3PP/R1BR3K w - - 0 1",
"rn1q1rk1/2pbb3/pn2p3/1p1pPpp1/3P4/1PNBBN2/P1P1Q1PP/R4R1K w - - 0 1"
{snip}
I guess that these are from Hannibal games:
2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - -
r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq -
1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - -
1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - -
r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - -
Can you give more information (e.g. date, opponent, correct move, that sort of thing?)

I already have references for the other 5.
Hi Dann,

I don't remember the exact game details anymore but it's from previous seasons of TCEC where Hannibal have a hard time searching the position. I just scanned Hannibal games and choose those with lower depth searched.

By the way, I replaced this position:

"rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - 0 1"

as it causes superlinear speedup and it affects the averages.

Dann Corbit
Posts: 10244
Joined: Wed Mar 08, 2006 7:57 pm
Location: Redmond, WA USA
Contact:

Re: Lazy SMP ideas

Post by Dann Corbit » Mon Oct 01, 2018 9:38 pm

Here are my Epd records for those positions.
Thanks the the TCEC reference.
r3k2r/pbpnqp2/1p1ppn1p/6p1/2PP4/2PBPNB1/P4PPP/R2Q1RK1 w kq - acd 40; acs 239; bm Qa4; c0 "TCEC Season 7 - Stage 1a; 2014.09.24; Round 4; Hannibal 1.5x5 vs Spike 1.4; 12.Nd2 was played in the game (same move played by Houdini in another game)"; cce -187; ce 0; pm Qa4; pv Qa4 Nh5 c5 bxc5 Rfb1 Bxf3 gxf3 O-O Rb7 Rfc8 Qc6 Nxg3 hxg3 Nb8 Qa4 Nd7; white_wins 4; black_wins 12; draws 3;
1r2r2k/1p4qp/p3bp2/4p2R/n3P3/2PB4/2PB1QPK/1R6 w - - acd 40; acs 294; bm Rh1; c0 "TCEC Season 7 - Stage 1a; 2014.09.27; Round 6; Hannibal 1.5x5 verses Alfil 14.1; Move played was 32.Rh1"; ce 71; pm Rh1; pv Rh1 Rbc8 Kg1 Bg8 Qh4 Nc5 Bc4 Ne6 Bd5 Nf4 Bxf4 exf4 Bxg8 Kxg8 Rh3 Rc7 Qxf4 Re5 Rxh7 Qxh7 Qxf6 Ree7 Rg3+ Qg7 Rxg7+ Rxg7 c4 Rgf7 Qg6+ Kf8 Qh6+ Ke7 Qh4+ Kd7 Qh5 Ke7 Qe5+ Kf8 Qh8+ Ke7 Qd4 Rc6 g4 Kf8 Qh8+ Ke7 Qb8 Kf6 Qg8 Rc5 Kf2 Re5;
2kr3r/pbpn1pq1/1p3n2/3p1R2/3P3p/2P2Q2/P1BN2PP/R3B2K w - - acd 40; acs 306; bm h3; c0 "TCEC Season 7 - Stage 1a; 2014.09.24; Round 4; Hannibal 1.5x5 vs Spike 1.4; move played was 22.Bf2"; ce 0; pm h3; pv h3 Kb8 Nf1 Rde8 Ne3 Re6 Rf4 Rhe8 Bf2 Ne4 Rxf7 Nxf2+ Qxf2 Qg5 Ng4 Re2 Qf5 Qd2 Bd3 Re1+ Rxe1 Qxe1+ Kh2 Qg3+ Kg1 Bc8 Rxd7 Re1+ Bf1 Rxf1+ Kxf1 Ba6+ Kg1 Qe1+ Kh2 Qg3+;
r2n1rk1/1pq2ppp/p2pbn2/8/P3Pp2/2PBB2P/2PNQ1P1/1R3RK1 w - - acd 40; acs 515; bm Rxf4; c0 "TCEC Season 7 - Stage 1a; 2014.09.27; Round 6; Hannibal 1.5x5 verses Alfil 14.1; Move played was 17.Rxf4"; ce -10; pm Rxf4; pv Rxf4 Nd7 Bd4 Nc6 Nf1 Nc5 Ne3 Rae8 Qd2 Rb8 Nd5 Bxd5 exd5 Nxd4 cxd4 Nxd3 Qxd3 Qa5 c4 Qxa4 Rb6 Rbc8 Rxb7 Qxc4 Qxc4 Rxc4 Rb6 Ra4 Rxd6 f5 h4 g6 Rb6 Rd8 d6 h5 Kf2 Kf7 Kg3 a5 d5 Ra2 Rf2 Rxf2 Kxf2 Ke8 Ra6 a4 Rxa4 Rxd6 Ra7;
rn1q1rk1/2pbb3/pn2p3/1p1pPpp1/3P4/1PNBBN2/P1P1Q1PP/R4R1K w - - acd 41; acs 2169; bm Nxg5; c0 "Dann Corbit, CCC 2015"; c3 "Nxg5"; c4 "arasan19.16"; ce 303; id "arasan19.16"; pm Nxg5; pv Nxg5 Bxg5 Rf3 Bxe3 Rg3+ Bg5 Qh5 Rf7 Rxg5+ Rg7 Rxg7+ Kxg7 g4 Qh8 Qg5+ Kf7 gxf5 exf5 Bxf5 Bxf5 Qxf5+ Ke7 Rg1 N8d7 Rg6 Rg8 Qg5+ Nf6 exf6+ Kf7 Rxg8 Qxg8 Qe5 Qd8 Qh5+ Ke6 Qg4+ Kd6 Qg7 Nd7 f7 Ke6 Qh6+ Kxf7 Nxd5 Nf6 Qxf6+ Qxf6 Nxf6 Kxf6 Kg2 Kg6 Kg3 Kg5 h4+ Kf5 c;
1r1r1qk1/pn1p2p1/1pp1npBp/8/2PB2QP/4R1P1/P4PK1/3R4 w - - acd 43; acs 1800; bm Bc3; c3 "Bc3"; c4 "AlphaZero - Stockfish8"; ce 113; id "AlphaZero - Stockfish8"; pm Bc3; pv Bc3;
1r3rk1/3bb1pp/1qn1p3/3pP3/3P1N2/2Q2N2/2P3PP/R1BR3K w - - acd 45; acs 5100; bm h4; c0 "AlphaZero - Stockfish8"; c1 "Hard"; c3 "h4"; c4 "AlphaZero - Stockfish8"; ce 93; id "AlphaZero - Stockfish8"; pm h4; pv h4 Qb4 Qd3 Qb5 Qxb5 Rxb5 Kh2 Ra5 Bd2 Rxa1 Rxa1 Rb8 c3 Rb2 g4 Rb3 Ra8+ Rb8 Ra2 Rb3 Ng5 Bxg5 hxg5 Rb7 Nd3 Ra7 Rb2 Bc8 Nc5 Rc7 Rb5 Ra7 Rb6 Rc7 Bf4 Kf7 Kg3 Na5 Kf3 Nb7 Be3 Nxc5 dxc5 Bb7 Ke2 Bc6 Kd3 Rc8 Kd4;
1b3r1k/rb1q3p/pp2pppP/3n1n2/1P2N3/P2B1NPQ/1B3P2/2R1R1K1 b - - acd 47; acs 3306; bm e5; c0 "TCEC Season 7 - Stage 1a; 2014.10.01; Round 9; Gull 3 verses Hannibal 1.5x5; e5 was played in the game."; c1 "All moves lose."; ce -231; pm e5; pv e5 Bc4 Bc6 Rcd1 Nd4 Nxd4 Qxh3 Nxc6 Nf4 gxf4 Qg4+ Ng3 g5 fxe5 Qxc4 exf6 Kg8 Nxa7 Bxg3 fxg3 Qb3 Be5 Rxf6 Nc8 Re6 Rd8+ Kf7 Nd6+ Ke7 Re8+ Kd7 Rxe6 Qxe6 Ne4 Kc6 Nxg5 Qxh6 Nf3 Kb5 Kf2 Qg6 Bf4 Ka4 Bd2 Qf7 Re3 Qg6 Kg2 Qg4 Be1 Qc4 Kg1 Qg4 Kf2 Qf5 Rc3 Qg6 Kg2 Qe6 Bd2 Qe4 Kf2 Qg6 Rc1 Qe4 Re1 Qb7 Re3 Qf7 Kg1 Qg6 Kf2;
3rr1k1/1b2nnpp/1p1q1p2/pP1p1P2/P1pP2P1/2N1P1QP/3N1RB1/2R3K1 w - - acd 52; acs 7263; bm Nf1; c3 "Nf1"; c4 "AlphaZero - Stockfish8"; ce 36; id "AlphaZero - Stockfish8"; pm Nf1; pv Nf1 h5 Qxd6 Nxd6 Ng3 h4 Nh5 Nf7 Re1 Ng5 Rfe2 Kf7 Nf4 Rd7 Kf1 Rb8 Rd1 Rh8 Red2 Re8 Ra1 Rc8 Kf2 Rb8 Rdd1 Rh8 Re1 Rhd8 Ke2 Re8 Kd2 Rdd8 Kc2 Rh8 Kb2 Rhe8;
rn3rq1/p5k1/2p2bp1/1p4p1/8/2P1B1PQ/5PK1/3R3R w - - acd 53; acs 14400; bm c4; c0 "AlphaZero - Stockfish8"; c1 "Hard"; c3 "c4"; c4 "AlphaZero - Stockfish8"; ce 234; id "AlphaZero - Stockfish8"; pm c4; pv c4 Re8;
Taking ideas is not a vice, it is a virtue. We have another word for this. It is called learning.
But sharing ideas is an even greater virtue. We have another word for this. It is called teaching.

Michael Sherwin
Posts: 3046
Joined: Fri May 26, 2006 1:00 am
Location: WY, USA
Full name: Michael Sherwin

Re: Lazy SMP ideas

Post by Michael Sherwin » Tue Oct 02, 2018 3:36 am

I'll check out your new engine and run a match against RomiChess and report the results.

Yes, my idea has some thin resemblance to NN engines in the sense that the ratio or difference becomes a measure of probability! :D
I hate if statements. Pawns demand if statements. Therefore I hate pawns.

User avatar
flok
Posts: 204
Joined: Tue Jul 03, 2018 8:19 am
Full name: Folkert van Heusden
Contact:

Re: Lazy SMP ideas

Post by flok » Wed Oct 03, 2018 7:59 pm

I've put embla 2.0.1 on github (https://github.com/flok99/Embla).
What I added was random aspiration window size for the lazy-smp threads. That gave me ~15 elo in the +.
www.vanheusden.com: Micah / Embla / PuppetMaster / DeepBrutePos / Pos / Feeks

Post Reply