Set the reference Nps using Stockfish 11 as base

ppigazzini · ppigazzini · commit c5e0de5892ed · 2021-10-24T15:44:25.000+02:00
Fishtest with Stockfish 11 had 1.6MNps as reference Nps and 0.7MNps as
threshold for the slow worker.
Set the new reference Nps according to the average 20% slowdown.
Set the new threshold for slow worker according to the 27% slowdown.

- arch=bmi2 (Dual Xeon workstation)
```
base =    1729936 +/- 9448
test =    1381212 +/- 8223
diff =    -348723 +/- 6159
speedup = -0.201582
```
- arch=bmi2 (Xeon server)
```
base =    1377734 +/- 14202
test =    1151238 +/- 9600
diff =    -226496 +/- 20606
speedup = -0.164398
```
- arch=modern (core i7 3770k)
```
base =    1967470 +/- 12952
test =    1435152 +/- 5597
diff =    -532318 +/- 8311
speedup = -0.270560
```

Other fixes

Load the CPU before bench (fix an 8% Nps overestimation with high concurrency).

Account the slowdown due to the concurrency to set the slow worker threashold.

Drop unused function parameter.
diff --git a/server/fishtest/views.py b/server/fishtest/views.py
@@ -1212,7 +1212,7 @@ def homepage_results(request):
         machine["last_updated"] = delta_date(diff)
         if machine["nps"] != 0:
             games_per_minute += (
-                (machine["nps"] / 1080000.0)
+                (machine["nps"] / 1280000.0)
                 * (60.0 / estimate_game_duration(machine["run"]["args"]["tc"]))
                 * (
                     int(machine["concurrency"])
diff --git a/server/utils/delta_update_users.py b/server/utils/delta_update_users.py
@@ -69,7 +69,7 @@ def process_run(run, info, deltas=None):
 def build_users(machines, info):
     for machine in machines:
         games_per_hour = (
-            (machine["nps"] / 1080000.0)
+            (machine["nps"] / 1280000.0)
             * (3600.0 / estimate_game_duration(machine["run"]["args"]["tc"]))
             * (int(machine["concurrency"]) // machine["run"]["args"].get("threads", 1))
         )
diff --git a/worker/games.py b/worker/games.py
@@ -3,6 +3,7 @@
 import glob
 import hashlib
 import json
+import math
 import os
 import platform
 import re
@@ -244,6 +245,7 @@ def verify_signature(engine, signature, remote, payload, concurrency, worker_inf
             )
             busy_process.stdin.write("go infinite\n")
             busy_process.stdin.flush()
+            time.sleep(1)  # wait CPU loading
 
         bench_sig = ""
         print("Verifying signature of {} ...".format(os.path.basename(engine)))
@@ -500,7 +502,7 @@ def setup_engine(
 
 def kill_process(p):
     p_name = os.path.basename(p.args[0])
-    print("\Killing {} with pid {} ... ".format(p_name, p.pid), end="", flush=True)
+    print("Killing {} with pid {} ... ".format(p_name, p.pid), end="", flush=True)
     try:
         if IS_WINDOWS:
             # p.kill() doesn't kill subprocesses on Windows.
@@ -524,7 +526,7 @@ def kill_process(p):
         print("killed", flush=True)
 
 
-def adjust_tc(tc, factor, concurrency):
+def adjust_tc(tc, factor):
     # Parse the time control in cutechess format.
     chunks = tc.split("+")
     increment = 0.0
@@ -915,7 +917,8 @@ def run_games(worker_info, password, remote, run, task_id, pgn_file):
     threads = int(run["args"]["threads"])
     spsa_tuning = "spsa" in run["args"]
     repo_url = run["args"].get("tests_repo", REPO_URL)
-    games_concurrency = int(worker_info["concurrency"]) // threads
+    worker_concurrency = int(worker_info["concurrency"])
+    games_concurrency = worker_concurrency // threads
 
     opening_offset = task.get("start", task_id * task["num_games"])
     if "start" in task:
@@ -1087,24 +1090,20 @@ def parse_options(s):
         worker_info,
     )
 
-    if base_nps < 350000:  # lowered from 450000 - dirty fix for some slow workers
+    if base_nps < 500000 / (1 + math.tanh((worker_concurrency - 1) / 8)):
         raise FatalException(
             "This machine is too slow to run fishtest effectively - sorry!"
         )
 
     factor = (
-        1080000 / base_nps
-    )  # 1080000 nps is the reference core, also used in fishtest views.
+        1280000 / base_nps
+    )  # 1280000 nps is the reference core, also used in fishtest views.
 
     # Adjust CPU scaling.
-    scaled_tc, tc_limit = adjust_tc(
-        run["args"]["tc"], factor, int(worker_info["concurrency"])
-    )
+    scaled_tc, tc_limit = adjust_tc(run["args"]["tc"], factor)
     scaled_new_tc = scaled_tc
     if "new_tc" in run["args"]:
-        scaled_new_tc, new_tc_limit = adjust_tc(
-            run["args"]["new_tc"], factor, int(worker_info["concurrency"])
-        )
+        scaled_new_tc, new_tc_limit = adjust_tc(run["args"]["new_tc"], factor)
         tc_limit = (tc_limit + new_tc_limit) / 2
 
     result["nps"] = base_nps

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ def process_run(run, info, deltas=None):`
`69`	`69`	`def build_users(machines, info):`
`70`	`70`	`for machine in machines:`
`71`	`71`	`games_per_hour = (`
`72`		`- (machine["nps"] / 1080000.0)`
	`72`	`+ (machine["nps"] / 1280000.0)`
`73`	`73`	`* (3600.0 / estimate_game_duration(machine["run"]["args"]["tc"]))`
`74`	`74`	`* (int(machine["concurrency"]) // machine["run"]["args"].get("threads", 1))`
`75`	`75`	`)`