Act 3 Threadripper Results

[MikeB]

RUN COMPLETED - 78 out of 100 solved (78.0%)
engine: Black-Diamond-122619
cores: 64
total time used: 3600.0 seconds
toal nodes searched: 487638.241 million
nps: 135.451 million
hash size: 32768
search time: 36 seconds
...and BD did not get credit for finding this alternative mate-in-27 score on #60

[d]6bk/8/5R2/8/7p/5NpP/4p1P1/5rBK b - - bm Kh7 Kg7; id "ACT3.060";

depth 30 seldepth 46 multipv 1 score #+27 nodes 6028410461 nps 167451194 hashfull 111 tbhits 0 time 36.001 pv Bd5 Rf8+ Kg7 Re8 Bxf3 gxf3 e1=Q Rxe1 Rxe1 Kg2 Kf6 Bc5 Kf5 Bd6 Re2+ Kf1 Rh2 f4 Rc2 Bb8 Rc1+ Ke2 g2 Ba7 g1=Q Bxg1 Rxg1 Kd3 Rg3+ Kd4 Kxf4 Kc4 Kf5 Kb4 Rxh3 Kc5 Rf3 Kc4 h3 Kc5 h2 Kd5 h1=Q Kc5 Qc1+ Kb4
-- not solved (45 out of 60 solved, 75.0%)

BD also shows the provided solution is also at least a mate-in-27
info depth 37 seldepth 53 multipv 1 score mate 27 nodes 38783422392 nps 145201337 hashfull 176 tbhits 0 time 267101 pv h8h7 f6f5 e2e1q f3e1 f1f5 e1f3 g8d5 g1b6 d5f3 g2f3 f5d5 h1g2 h7g6 g2f1 d5d2 b6e3 d2a2 e3c5 g6f5 c5e3 a2c2 f3f4 c2a2 f1e1 g3g2 e3g1 f5f4 g1c5 f4f3 e1d1 a2f2 c5f2 f3f2 d1c2 g2g1q c2c3 f2f3 c3c4 g1b6 c4d5 f3f4 d5c4 f4e4 c4c3 b6c5 c3b2 e4d3 b2b3 c5b6 b3a2 d3c3 a2a3 b6b3
bestmove h8h7 ponder f6f5

[Dann Corbit]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

[MikeB]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

When you do get it, you will want to set up

HUGE PAGES

as it is a

HUGE GAIN

in speed in certain positions. My SF Github fork has the code for it.
Thjs is the PR that was submitted:
https://github.com/official-stockfish/S ... /pull/2463
Transition to Linux has gone surprisingly well - I have xBoard, compiling LcO is no issue , both cuteches GUI and client are working well, python-chess is working. Better than I anticipated - Ubuntu is very very good. Very similar to the Pi OS.

[MikeB]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

When you do get it, you will want to set up

HUGE PAGES

as it is a

HUGE GAIN

in speed in certain positions. My SF Github fork has the code for it.
Thjs is the PR that was submitted:
https://github.com/official-stockfish/S ... /pull/2463
Transition to Linux has gone surprisingly well - I have xBoard, compiling LcO is no issue , both cuteches GUI and client are working well, python-chess is working. Better than I anticipated - Ubuntu is very very good. Very similar to the Pi OS.

Also here is my modified version of Jon Dart's 'analyse.py' script to include total nodes searched, total time searched and cumulative nps .

Code: Select all

#!/usr/bin/python3
# -*- coding: utf-8 -*-

# Copyright 2017-2019 by Jon Dart. All Rights Reserved.
#
import re, sys, subprocess, time, chess, chess.engine, traceback

class Options:
   engine_name = 'Black-Diamond-122719'
   multi_pv_value = 1
   search_time = 15
   cores = 64
   hash_size = 8192
   syzygy = '/Volumes/OWC960/syzygy'

class Results:
   # the current position's results indexed by multipv index
   infos = {}
   bestmove = None

class Position:
   # the current position's EPD operators
   ops = {}
   board = chess.Board()

options = Options()

results = Results()

position = Position()

done = False

solved = 0
tried = 0

def correct(bestmove,position):
    if not ('bm' in position.ops) and not ('am' in position.ops):
       print("error: missing target move(s) in line: " + line,file=sys.stderr)
       return False
    else:
       san = position.board.san(bestmove)
       if 'bm' in position.ops and san in position.ops['bm']:
          return True
       elif 'am' in position.ops and not (san in position.ops['am']):
          return True
       return False

def process_info(info,results):
   multipv = None
   if "multipv" in info:
      multipv = int(info["multipv"])
      results.infos[multipv] = info
   elif options.multi_pv_value == 1:
      results.infos[1] = info
   try:
      result = results.infos[1]
   except KeyError:
       return
   if "time" in result:
      time = result["time"]
   if "nodes" in result:
      node_str = result["nodes"]
   if "pv" in result:
      pv_str = result["pv"]
      # get current bm from the pv
      move = pv_str[0]
      results.total_time = int(1000*time)
      results.total_nodes =  int(node_str)
      if correct(move,position):
          if (time != None and results.solution_time == 0):
              # convert to milliseconds
              results.solution_time = int(1000*time)
          if (node_str != None and results.solution_nodes == 0):
              results.solution_nodes = int(node_str)
      else:
          # solution was found but now a different move is selected
          results.solution_time = 0
          results.solution_nodes = 0

def init(engine,options):
    # note: multipv not set here
    engine.configure({'Hash': options.hash_size, 'Syzygypath': options.syzygy, 'Threads': options.cores})
    print ()
    print ("engine: " + options.engine_name)
    print ("cores: " + str(options.cores))
    print ("hash size: " + str(options.hash_size))
    print ("search time: " + str(options.search_time) + " seconds")
    print ()
    print("engine ready")
    print ()

def main(argv = None):
    global options
    global results
    global position
    global solved
    global tried
    global ttime
    global tnode_str

    engine = None

    if argv is None:
        argv = sys.argv[1:]

    arg = 0
    while ((arg < len(argv)) and (argv[arg][0:1] == '-')):
        if (argv[arg][1] == 'c'):
            arg = arg + 1
            if (arg < len(argv)):
                try:
                    options.cores = int(argv[arg])
                except exceptions.ValueError:
                    print(('Invalid value for parameter %s: %s' % (argv[i], argv[i + 1])),file=sys.stderr)
                    return 2
        elif (argv[arg][1] == 't'):
            arg = arg + 1
            if (arg < len(argv)):
                try:
                    options.search_time = int(argv[arg])
                except exceptions.ValueError:
                    print(('Invalid value for parameter %s: %s' % (argv[i], argv[i + 1])),file=sys.stderr)
                    return 2
        elif (argv[arg][1] == 'e'):
            arg = arg + 1
            if (arg < len(argv)):
                options.engine_name = argv[arg]
        elif (argv[arg][1] == 'H'):
            arg = arg + 1
            if (arg < len(argv)):
                try:
                    options.hash_size = int(argv[arg])
                except exceptions.ValueError:
                    print(('Invalid value for parameter %s: %s' % (argv[i], argv[i + 1])),file=sys.stderr)
                    return 2
        elif (argv[arg][1] == 'm'):
            arg = arg + 1
            if (arg < len(argv)):
                try:
                    options.multi_pv_value = int(argv[arg])
                except exceptions.ValueError:
                    print(('Invalid value for parameter %s: %s' % (argv[i], argv[i + 1])),file=sys.stderr)
                    return 2
        else:
            print("Unrecognized switch: " + argv[arg], file=sys.stderr)
            return
        arg = arg + 1

    time = options.search_time

    if (arg >= len(argv)):
        print("Expected a filename to analyze.", file=sys.stderr)
        return

    try:
        engine = chess.engine.SimpleEngine.popen_uci(options.engine_name)
    except FileNotFoundError:
       print("engine executable " + options.engine_name + " not found", file=sys.stderr)
       return
    except:
       print(traceback.format_exc(), file=sys.stderr)
       print("failed to start child process " + options.engine_name, file=sys.stderr)
       return

    init(engine,options)
    ttime = 0
    tnode_str = 0
    pat = re.compile('^(([pnbrqkPNBRQK1-8])+\/)+([pnbrqkPNBRQK1-8])+ [wb]+ [\-kqKQ]+ [\-a-h1-8]+')

    with open(argv[arg]) as f:
        for line in f:
           # skip blank lines
           if len(line.strip())==0:
               continue
           m = pat.search(line)
           if m == None:
               print("error: invalid FEN in line: %s" % line, file=sys.stderr, flush=True)
           else:
               print()
               print(line)
               position.board = chess.Board(fen=m.group()+' 0 1')
               position.ops = position.board.set_epd(line)
               # set_epd returns moves as Move objects, convert to SAN:
               for key in position.ops:
                  i = 1
                  if (key == 'bm' or key == 'am'):
                     san_moves = []
                     for move in position.ops[key]:
                        try:
                           san_moves.append(position.board.san(move))
                        except:
                           print(key + " solution move " + str(i) + " could not be parsed",file=sys.stderr, flush=True)
                     i = i + 1
                     position.ops[key] = san_moves

               results.solution_time = 0
               results.solution_nodes = 0
               results.total_time = 0
               results.total_nodes = 0
               results.bestmove = None
               results.infos = {}
               with engine.analysis(board=position.board,
                                    limit=chess.engine.Limit(time=options.search_time),multipv=options.multi_pv_value) as analysis:
                  for info in analysis:
                     process_info(info,results)
               # print last group of results
               for i in range(1,options.multi_pv_value+1):
                   group = 0
                   infos = results.infos[i]
                   for key in ["depth","seldepth","multipv","score","nodes",
                               "nps","hashfull","tbhits","time","pv"]:
                       if key in infos:
                           if (group != 0):
                              print(" ",end="")
                           print(key + " ",end="")
                           if (key == "pv"):
                              fen = position.board.fen()
                              for m in infos[key]:
                                  san = position.board.san(m)
                                  print(san,end="")
                                  print(" ",end="")
                                  position.board.push(m)
                              # restore board
                              position.board.set_fen(fen)
                           else:
                              print(infos[key],end="")
                       group = group + 1
                   print()

               pv = results.infos[1].get("pv")
               if (pv != None):
                  results.bestmove = pv[0]
               if (results.bestmove != None):
                  tried = tried + 1
                  ttime = ttime + results.total_time/1000.0
                  tnode_str = tnode_str + results.total_nodes
                  if correct(results.bestmove,position):
                     solved = solved + 1
                     print("++ solved in " + str(results.solution_time/1000.0) + " seconds ("
                            + str(results.solution_nodes)
                            + " nodes)" + " (" + str(solved) + " out of " + str(tried) + " solved, "
                            + str(round(solved * 100 /tried,1)) + "%)", flush=True)
                  else:
                     print("-- not solved" + " (" + str(solved) + " out of " + str(tried) + " solved, "
                            + str(round(solved * 100 /tried,1)) + "%)", flush=True)
    engine.quit()
    print()
    print("RUN COMPLETED - " + str(solved) + " out of " + str(tried) + " solved (" + str(round(solved * 100 /tried,1)) + "%)")
    print ("engine: " + options.engine_name)
    print ("cores: " + str(options.cores))
    print ("total time used: " + str(round(ttime,0)) + " seconds")
    print ("toal nodes searched: " + str(round(tnode_str/1000000,3)) + " million")
    print ("nps: " + str(round(tnode_str/ttime/1000000,3)) + " million")
    print ("hash size: " + str(options.hash_size))
    print ("search time: " + str(options.search_time) + " seconds")

if __name__ == "__main__":
    sys.exit(main())
 

[MikeB]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

A 15 second search solved 77/100:

RUN COMPLETED - 77 out of 100 solved (77.0%)
engine: Black-Diamond-122719
cores: 64
total time used: 1500.0 seconds
toal nodes searched: 195017.397 million
nps: 130.002 million
hash size: 8192
search time: 15 seconds
Details attached

[MikeB]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

Here are the results of some the hardest at 30 minutes per position, the rest are still running
engine: Black-Diamond-122719
cores: 64
hash size: 32768
search time: 1800 seconds

engine ready

[d]4n3/8/8/8/4pNp1/8/1p2K1pk/B2Q3b w - - bm Nh3; id "ACT3.005";[

depth 34 seldepth 87 multipv 1 score +9957 nodes 297693407094 nps 165385134 hashfull 172 tbhits 0 time 1800.001 pv Nh3 bxa1=Q Qxa1 Kxh3 Kf2 e3+ Kg1 Kg3 Qe5+ Kf3 Qxe8 Ke2 Qd8 Kf3 Qd3 Kf4 Qd4+ Kf5 Qxe3 Kf6 Qd4+ Kf5 Qd5+ Kf6 Qd6+ Kf7 Qe5 g3 Qc7+ Ke6 Qxg3 Kd5 Qc7 Ke6 Qc6+ Ke5 Qc4 Kd6 Qa6+ Kd5 Qb5+ Kd6 Qc4 Ke5 Qc6 Kd4 Qb5 Ke4 Qc5 Kd3 Qb4 Ke3 Qc4 Kf3 Qd4 Kg3 Qf6 Kg4 Qe5
++ solved in 4.256 seconds (572109819 nodes) (1 out of 1 solved, 100.0%)

[d]7k/Bp1R1b1p/1p2pK1n/8/4P1P1/6pB/4p3/8 w - - bm Bb8; id "ACT3.008";

depth 54 seldepth 140 multipv 1 score -10 nodes 223379260470 nps 124099520 hashfull 1000 tbhits 0 time 1800.001 pv Bb8 e1=Q
++ solved in 92.563 seconds (12288327065 nodes) (2 out of 2 solved, 100.0%)

[d]2k5/p2p4/1P6/P3p3/1q2N3/2p5/8/2K4Q w - - bm Nd6+; id "ACT3.015";

depth 41 seldepth 43 multipv 1 score #+22 nodes 250525431608 nps 139180718 hashfull 859 tbhits 0 time 1800.001 pv Nd6+ Qxd6 Qa8+ Qb8 b7+ Kc7 a6 d5 Kc2 d4 Kd3 e4+ Kc2 e3 Kd3 c2 Kxc2 e2 Kd2 d3 Ke1 Qxa8 bxa8=Q Kb6 Qb7+ Ka5 Qxa7 Kb5 Qb7+ Kc5 a7 Kd6 a8=Q d2+ Kxd2 e1=Q+ Kxe1 Ke5 Qe4+ Kf6 Qh8+ Kf7 Qee8#
++ solved in 1800.001 seconds (250525431608 nodes) (3 out of 3 solved, 100.0%)
[d]
Q3b3/1p2q3/1p6/bp5P/1p6/1p6/1P1N1PPp/4NK1k w - - bm Qd8; id "ACT3.016";

depth 52 seldepth 37 multipv 1 score #+19 nodes 231513957932 nps 128618794 hashfull 993 tbhits 0 time 1800.001 pv Qd8 Qxd8 Ne4 Qh4 Ng3+ Qxg3 fxg3 Bxh5 Kf2 Bg4 Nd3 Bf5 Nf4 Bg4 Nd5 Bf3 Nc7 Bg4 Na8 Bf3 g4 Bxg2 Nc7 Bc6 Ne6 Bd7 Ng5 Bc6 Nh7 Be4 Nf6 Bg6 g5 Bh7 Nh5 Bg8 Ng3#
++ solved in 214.298 seconds (23527849678 nodes) (4 out of 4 solved, 100.0%)

[d]4B3/1pk1p3/q3p3/1nP1Pp2/PPQ2P2/PK2P3/4b3/8 w - - bm Qxb5; id "ACT3.021";

depth 40 seldepth 13 multipv 1 score 0 nodes 210222717589 nps 116790333 hashfull 798 tbhits 0 time 1800.001 pv Qc2 Na7 Kb2 Nc6 b5 Bxb5 axb5 Qxb5+ Ka2 Qa5 Kb2
-- not solved (4 out of 5 solved, 80.0%)

[d]8/1pp5/1p4k1/n7/1B5P/1K6/5PP1/8 w - - bm Bxa5; id "ACT3.025";

depth 38 seldepth 132 multipv 1 score #+39 nodes 275917375381 nps 153287345 hashfull 531 tbhits 0 time 1800.001 pv Bxa5 bxa5 g4 b5 h5+ Kh6 f4 b4 Ka4 c6 Kb3 c5 Kb2 a4 f5 Kg5 Kc2 c4 Kb1 c3 Kc2 a3 Kb3 c2 Kxc2 a2 Kb2 b3 Ka1 Kxg4 h6 Kxf5 h7 Kf6 h8=Q+ Kg6 Qg8+ Kf5 Qd5+ Kg6 Qxb3 Kf6 Qf3+ Kg6 Qf2 Kg5 Qf7 Kg4 Qf6 Kh3 Qf3+ Kh2 Qf1 Kg3 Qf5 Kg2 Kxa2 Kg3 Kb3 Kh4 Qf4+ Kh5
++ solved in 32.095 seconds (4643061211 nodes) (5 out of 6 solved, 83.3%)

[d]7r/p2b4/rp2p2p/kB6/8/2K5/1P6/4R3 w - - bm Re5; id "ACT3.026";

depth 52 seldepth 14 multipv 1 score 0 nodes 237639840162 nps 132022060 hashfull 992 tbhits 0 time 1800.001 pv Re5 Bxb5 Kb3 Rg8 Ka3 Rg3+ b3 h5 Rxh5 Rg4 Re5 Rg3
++ solved in 147.138 seconds (18421746406 nodes) (6 out of 7 solved, 85.7%)

[d]8/6pp/2Qp1p2/pPpPp3/k7/2K3P1/P1PP4/5q2 w - - bm Kb2; id "ACT3.027";

depth 42 seldepth 17 multipv 1 score +907 nodes 248345081936 nps 137969413 hashfull 981 tbhits 0 time 1800.001 pv Kb2
++ solved in 1470.012 seconds (199307747770 nodes) (7 out of 8 solved, 87.5%)

[Dann Corbit]

some of the problems were solved with alternative engines (not stockfish) like Houdini and Sting.
And some took a very long time (I think the times are included in the analysis file).

I got a notice that my machine arrives today, and I am pretty geeked about it.

That's a pretty impressive machine. Imagine what they will make four years from now

[Jouni]

How many positions from Arasan suite is solved? I got 194/200 with Houdini tactical and 4 cores only. ACT 3 is pure compositions, but Arasan mostly real games! Time 15s or more for position. Thanks in advance

[MikeB]

The key move is mate in 24 (see test set analysis file).
Your alternative was ranked 3rd at about +4.5 pawns.
My threadripper has not arrived yet. The shipping tracker says it is in Tacoma (my house is about 1000 feet from Tacoma).

I would be interested to know what time control is needed to solve them all.
Not that I would want you to rerun the entire set at slow time control, but run the ones that are missed to see how long it takes to solve the slowest ones

Here are the results of some the hardest at 30 minutes per position, the rest are still running
engine: Black-Diamond-122719
cores: 64
hash size: 32768
search time: 1800 seconds

engine ready

[d]4n3/8/8/8/4pNp1/8/1p2K1pk/B2Q3b w - - bm Nh3; id "ACT3.005";[

depth 34 seldepth 87 multipv 1 score +9957 nodes 297693407094 nps 165385134 hashfull 172 tbhits 0 time 1800.001 pv Nh3 bxa1=Q Qxa1 Kxh3 Kf2 e3+ Kg1 Kg3 Qe5+ Kf3 Qxe8 Ke2 Qd8 Kf3 Qd3 Kf4 Qd4+ Kf5 Qxe3 Kf6 Qd4+ Kf5 Qd5+ Kf6 Qd6+ Kf7 Qe5 g3 Qc7+ Ke6 Qxg3 Kd5 Qc7 Ke6 Qc6+ Ke5 Qc4 Kd6 Qa6+ Kd5 Qb5+ Kd6 Qc4 Ke5 Qc6 Kd4 Qb5 Ke4 Qc5 Kd3 Qb4 Ke3 Qc4 Kf3 Qd4 Kg3 Qf6 Kg4 Qe5
++ solved in 4.256 seconds (572109819 nodes) (1 out of 1 solved, 100.0%)

[d]7k/Bp1R1b1p/1p2pK1n/8/4P1P1/6pB/4p3/8 w - - bm Bb8; id "ACT3.008";

depth 54 seldepth 140 multipv 1 score -10 nodes 223379260470 nps 124099520 hashfull 1000 tbhits 0 time 1800.001 pv Bb8 e1=Q
++ solved in 92.563 seconds (12288327065 nodes) (2 out of 2 solved, 100.0%)

[d]2k5/p2p4/1P6/P3p3/1q2N3/2p5/8/2K4Q w - - bm Nd6+; id "ACT3.015";

depth 41 seldepth 43 multipv 1 score #+22 nodes 250525431608 nps 139180718 hashfull 859 tbhits 0 time 1800.001 pv Nd6+ Qxd6 Qa8+ Qb8 b7+ Kc7 a6 d5 Kc2 d4 Kd3 e4+ Kc2 e3 Kd3 c2 Kxc2 e2 Kd2 d3 Ke1 Qxa8 bxa8=Q Kb6 Qb7+ Ka5 Qxa7 Kb5 Qb7+ Kc5 a7 Kd6 a8=Q d2+ Kxd2 e1=Q+ Kxe1 Ke5 Qe4+ Kf6 Qh8+ Kf7 Qee8#
++ solved in 1800.001 seconds (250525431608 nodes) (3 out of 3 solved, 100.0%)
[d]
Q3b3/1p2q3/1p6/bp5P/1p6/1p6/1P1N1PPp/4NK1k w - - bm Qd8; id "ACT3.016";

depth 52 seldepth 37 multipv 1 score #+19 nodes 231513957932 nps 128618794 hashfull 993 tbhits 0 time 1800.001 pv Qd8 Qxd8 Ne4 Qh4 Ng3+ Qxg3 fxg3 Bxh5 Kf2 Bg4 Nd3 Bf5 Nf4 Bg4 Nd5 Bf3 Nc7 Bg4 Na8 Bf3 g4 Bxg2 Nc7 Bc6 Ne6 Bd7 Ng5 Bc6 Nh7 Be4 Nf6 Bg6 g5 Bh7 Nh5 Bg8 Ng3#
++ solved in 214.298 seconds (23527849678 nodes) (4 out of 4 solved, 100.0%)

[d]4B3/1pk1p3/q3p3/1nP1Pp2/PPQ2P2/PK2P3/4b3/8 w - - bm Qxb5; id "ACT3.021";

depth 40 seldepth 13 multipv 1 score 0 nodes 210222717589 nps 116790333 hashfull 798 tbhits 0 time 1800.001 pv Qc2 Na7 Kb2 Nc6 b5 Bxb5 axb5 Qxb5+ Ka2 Qa5 Kb2
-- not solved (4 out of 5 solved, 80.0%)

[d]8/1pp5/1p4k1/n7/1B5P/1K6/5PP1/8 w - - bm Bxa5; id "ACT3.025";

depth 38 seldepth 132 multipv 1 score #+39 nodes 275917375381 nps 153287345 hashfull 531 tbhits 0 time 1800.001 pv Bxa5 bxa5 g4 b5 h5+ Kh6 f4 b4 Ka4 c6 Kb3 c5 Kb2 a4 f5 Kg5 Kc2 c4 Kb1 c3 Kc2 a3 Kb3 c2 Kxc2 a2 Kb2 b3 Ka1 Kxg4 h6 Kxf5 h7 Kf6 h8=Q+ Kg6 Qg8+ Kf5 Qd5+ Kg6 Qxb3 Kf6 Qf3+ Kg6 Qf2 Kg5 Qf7 Kg4 Qf6 Kh3 Qf3+ Kh2 Qf1 Kg3 Qf5 Kg2 Kxa2 Kg3 Kb3 Kh4 Qf4+ Kh5
++ solved in 32.095 seconds (4643061211 nodes) (5 out of 6 solved, 83.3%)

[d]7r/p2b4/rp2p2p/kB6/8/2K5/1P6/4R3 w - - bm Re5; id "ACT3.026";

depth 52 seldepth 14 multipv 1 score 0 nodes 237639840162 nps 132022060 hashfull 992 tbhits 0 time 1800.001 pv Re5 Bxb5 Kb3 Rg8 Ka3 Rg3+ b3 h5 Rxh5 Rg4 Re5 Rg3
++ solved in 147.138 seconds (18421746406 nodes) (6 out of 7 solved, 85.7%)

[d]8/6pp/2Qp1p2/pPpPp3/k7/2K3P1/P1PP4/5q2 w - - bm Kb2; id "ACT3.027";

depth 42 seldepth 17 multipv 1 score +907 nodes 248345081936 nps 137969413 hashfull 981 tbhits 0 time 1800.001 pv Kb2
++ solved in 1470.012 seconds (199307747770 nodes) (7 out of 8 solved, 87.5%)

pickiig up from the last post,

engine: Black-Diamond-122719
cores: 64
hash size: 32768
search time: 1800 seconds

engine ready

4K3/1B1p4/pn1Npb2/k3p3/P1pn4/P7/7B/3N4 w - - bm Bc6; id "ACT3.029";

depth 53 seldepth 93 multipv 1 score +71 nodes 218844366029 nps 121580135 hashfull 948 tbhits 0 time 1800.001 pv Nb2 Nf5 Ndxc4+ Nxc4 Nxc4+ Kxa4 Kxd7 Nd4 Bxa6 Bg7 Bb7 Kb3 Nxe5 Kxa3 Ke7 Bh8 Ng4 Kb3 Bg2 Nb5 Be4 Nc3 Bb7 Bd4 Kxe6 Bh8 Nf6 Bg7 Kf7 Bh6 Ng4 Bc1 Ke6 Bb2 Bf4 Ba3 Bg2 Kc2 Bf1 Nd1 Ne5 Bf8 Kf7 Bc5 Ng4 Bb4 Ba6 Bd2 Bc7 Nb2 Ne5 Na4 Bd6 Kb3 Nc6 Bc3 Ke6 Bg7 Bd3 Nc3 Na5+ Kb2 Kf7 Bd4
-- not solved (7 out of 9 solved, 77.8%)

1qQ4r/p2Kpk2/5p2/1B2PPp1/6Pp/7P/P7/8 w - - bm Qxh8; id "ACT3.033";

depth 38 seldepth 21 multipv 1 score 0 nodes 244318967757 nps 135732684 hashfull 543 tbhits 0 time 1800.001 pv Qxh8 Qxh8 e6+ Kg7 Kc7 a5 Bc6 Qg8 a3 a4 Bd5 Kh7 Bc6
++ solved in 44.892 seconds (6749094114 nodes) (8 out of 10 solved, 80.0%)

n6r/b7/1R4R1/2k5/2pppppp/8/1PPPPPP1/r4NK1 w - - bm b4+; id "ACT3.038";

depth 38 seldepth 70 multipv 1 score -687 nodes 224207028554 nps 124559391 hashfull 992 tbhits 0 time 1800.001 pv Rgc6+ Kd5
-- not solved (8 out of 11 solved, 72.7%)

8/qpp5/8/k1p1N3/2p5/P7/1PP1B3/K7 w - - bm Nc6+; id "ACT3.040";

depth 49 seldepth 107 multipv 1 score -550 nodes 219300585497 nps 121833590 hashfull 959 tbhits 0 time 1800.001 pv Nxc4+ Kb5 b3 Kc6 a4 b5 Na3 bxa4 Kb2 Kd5 Nb5 Qb6 Bc4+ Ke5 Nc3 axb3 cxb3 Kd4 Nb1 Qa7 Kc1 Qb8 Kc2 Qb4 Kb2 Qe1 Kc2 Ke5 Kb2 Qf2+ Kc1 Qe3+ Kb2 Kd4 Kc2 Ke4 Kb2 Qf2+ Kc1 Qe1+ Kb2 Ke3 Kc2 Qf2+ Kc1 Qa2 Bd5 c4 Bxc4 Kd4 Bf7 Qh2 Bc4 Qf4+ Kc2 Ke3 Kc1 Qe5 Kc2 Qf5+ Kc1 Qc5 Kc2 Qb4 Kb2 Kd4 Kc2 Qa5 Kc1 Qg5+ Kb2 Kc5 Kc2 Qe5 Bd3 Kb4 Bc4 Qe4+ Kb2 Qg2+ Kc1 Qf2 Nd2 Qe3 Kd1 Kc3 Nb1+ Kb2 Nd2 Qf2 Bf1 Qd4
-- not solved (8 out of 12 solved, 66.7%)

5N1r/5n1n/ppp3R1/5K2/7k/6p1/6PN/8 w - - bm Rg4+; id "ACT3.049";

depth 62 seldepth 41 multipv 1 score #+21 nodes 314352637977 nps 174640257 hashfull 978 tbhits 0 time 1800.001 pv Rg4+ Kh5 Rh4+ Kxh4 Ng6+ Kh5 Nf4+ Kh6 Ng4+ Kg7 Ne6+ Kg8 Kf4 a5 Ke3 b5 Kd2 b4 Kc1 a4 Kb1 c5 Ka2 a3 Kb3 c4+ Ka2 c3 Kb3 a2 Kxa2 c2 Kb2 b3 Kc1 b2+ Kxb2 c1=Q+ Kxc1 Nd6 Nh6#
++ solved in 104.096 seconds (14273949406 nodes) (9 out of 13 solved, 69.2%)

6bk/5pp1/3N1p1b/8/6pN/5pPp/4pP1P/4K3 w - - bm Ng6+; id "ACT3.051";

depth 37 seldepth 193 multipv 1 score -5740 nodes 318968327091 nps 177204527 hashfull 663 tbhits 0 time 1800.001 pv Nhf5
-- not solved (9 out of 14 solved, 64.3%)

4k3/2p4p/8/p2n1p2/5P1P/4BP2/1PN1K1nP/8 b - - bm Ngxe3 Ndxe3; id "ACT3.055";

depth 40 seldepth 61 multipv 1 score +2840 nodes 273761150301 nps 152089443 hashfull 956 tbhits 0 time 1800.001 pv Ngxe3
++ solved in 15.655 seconds (1920194852 nodes) (10 out of 15 solved, 66.7%)

2k5/1p1p1q1b/1PP1p2p/3PPpQp/5P1P/6KP/8/8 w - - bm Qd8+; id "ACT3.058";

depth 37 seldepth 19 multipv 1 score 0 nodes 243316148474 nps 135175562 hashfull 11 tbhits 0 time 1800.001 pv Qd8+ Kxd8 c7+ Kc8 d6 Qg8+ Kh2 Qg7 Kh1 Bg8 Kh2
++ solved in 0.244 seconds (29940792 nodes) (11 out of 16 solved, 68.8%)

7 more to go from here, but I won't be home for hours - off to babysit the grandchildren with the wife.. really loving Ubuntu , I made the right choice!

ps some of the nodes per second are insane - 177M, 175M, 152M, etc. I have to be honest, this is a far more powerful machine that I expected - Dan I suspect you will want to switch over to Ubuntu, to advantage of the Linux Huge Pages - also always use 'modern' , forget the 'bmi2 'or 'native'. There also some tweakings you can do , google 'HUGE PAGE settings Linux' fwiw, going full tilt, the CPU stays steady at 84 C. Asus adjust the speed of the CPU so as not to go over 85C - occasionally it hits 86 and then it will drop down to 84. You can feel the heat if you're next to the tower almost feels like a room heater at my feet.. I appreciate it now, since our house is kept pretty cool, may not be too cool in the summertime...

[dragontamer5788]

There also some tweakings you can do , google 'HUGE PAGE settings Linux'

Threadripper 3xxx series is kinda funny: there's more L3 cache available than what can be served with normal 4kB pages.

Zen 2 has 2048 L2 TLB entries, each of which can be a 4kB page by default. That's 8MBs that the TLB cache can store, but the L3 cache is 16MB large. Under default settings, Zen2 needs to do a page-walk to access items inside of its own L3 cache.

You fix this with 2MB pages, so 2048x TLB entries can now hold 4GBs. You could also use 1GB pages, but I don't understand AMD Zen "Smashing" at all (see optimization guide: https://developer.amd.com/wp-content/re ... 00_PUB.pdf)

EDIT: It seems like the L1 TLB has 64x entries. 2MB are sufficient for 128MBs, but a 1GB page would be sufficient to keep 64GBs in the L1 TLB.