rayforce: wait for the old server to exit before restarting; client timeouts cover a long query

rayforce/check.rfl

@@ -2,7 +2,10 @@
 ; The server binds its socket before running server.rfl but only accepts
 ; connections once that script has finished opening the table, so a successful
 ; round trip means "table open, ready to query".
-(set h (.ipc.open (format "127.0.0.1:%" (.os.getenv "RAYFORCE_PORT")) 2000))
+; The server answers one request at a time, so during the concurrent phase
+; the handshake waits behind whatever query is running; the timeout must
+; cover a long query, or a busy server is mistaken for a dead one.
+(set h (.ipc.open (format "127.0.0.1:%" (.os.getenv "RAYFORCE_PORT")) 300000))
 (set ok (.ipc.send h "(+ 1 1)"))
 (.ipc.close h)
 (if (== ok 2) (exit 0) (exit 1))

rayforce/query.rfl

@@ -4,7 +4,10 @@
 ; back so ./query can print it. The elapsed milliseconds are written to
 ; $RAYFORCE_MS; ./query converts them to the fractional seconds the benchmark
 ; driver expects.
-(set h (.ipc.open (format "127.0.0.1:%" (.os.getenv "RAYFORCE_PORT")) 60000))
+; The connect timeout also covers the wait behind other clients' queries
+; (the server is single-threaded on IPC), so it spans the whole 600 s
+; concurrent window rather than a fixed 60 s.
+(set h (.ipc.open (format "127.0.0.1:%" (.os.getenv "RAYFORCE_PORT")) 600000))
 (set ms (.ipc.send h
     (format "(timeit (set rf-result %))" (read (.os.getenv "RAYFORCE_QUERY")))))
 (show (.ipc.send h "rf-result"))

rayforce/results/20260926/c6a.4xlarge.json

@@ -0,0 +1,60 @@
+{
+      "system": "Rayforce",
+      "date": "2026-09-26",
+      "machine": "c6a.4xlarge",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["C","column-oriented","embedded"],
+      "load_time": 3550,
+      "data_size": 59039728485,
+      "concurrent_qps": 0.095,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0, 0, 0],
+        [0.54, 0.006, 0.006],
+        [0.941, 0.209, 0.208],
+        [2.067, 0.021, 0.021],
+        [2.321, 0.218, 0.218],
+        [1.758, 0.104, 0.104],
+        [0.764, 0.138, 0.138],
+        [0.403, 0.012, 0.012],
+        [5.581, 0.855, 0.85],
+        [5.912, 0.559, 0.569],
+        [3.707, 0.108, 0.108],
+        [4.48, 0.119, 0.12],
+        [0.807, 0.12, 0.118],
+        [3.882, 0.285, 0.282],
+        [1.449, 0.143, 0.14],
+        [2.649, 0.471, 0.469],
+        [3.906, 0.604, 0.602],
+        [3.865, 0.568, 0.566],
+        [7.185, 0.838, 0.828],
+        [0.023, 0, 0],
+        [0.792, 0.158, 0.159],
+        [2.082, 0.104, 0.103],
+        [4.3, 0.263, 0.262],
+        [160.028, 0.199, 0.2],
+        [3.574, 0.029, 0.028],
+        [0.701, 0.064, 0.064],
+        [3.572, 0.028, 0.028],
+        [2.547, 0.542, 0.544],
+        [37.511, 34.274, 33.731],
+        [0.86, 0.017, 0.017],
+        [4.449, 0.183, 0.18],
+        [6.817, 0.243, 0.239],
+        [6.987, 1.524, 1.496],
+        [0.855, 0.243, 0.252],
+        [0.858, 0.246, 0.252],
+        [1.075, 0.433, 0.432],
+        [0.068, 0.024, 0.024],
+        [0.073, 0.023, 0.023],
+        [0.091, 0.012, 0.012],
+        [0.161, 0.104, 0.098],
+        [0.631, 0.016, 0.016],
+        [0.066, 0.006, 0.006],
+        [0.958, 0.104, 0.103]
+]
+  } 
+

rayforce/results/20260926/c6a.metal.json

@@ -0,0 +1,60 @@
+{
+      "system": "Rayforce",
+      "date": "2026-09-26",
+      "machine": "c6a.metal",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["C","column-oriented","embedded"],
+      "load_time": 406,
+      "data_size": 59039728485,
+      "concurrent_qps": 0.662,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0, 0, 0],
+        [0.162, 0.003, 0.004],
+        [0.832, 0.033, 0.027],
+        [2.082, 0.012, 0.012],
+        [2.3, 0.154, 0.151],
+        [1.662, 0.113, 0.109],
+        [0.557, 0.044, 0.046],
+        [0.204, 0.011, 0.013],
+        [5.23, 0.188, 0.201],
+        [5.911, 0.368, 0.375],
+        [3.836, 0.218, 0.239],
+        [4.612, 0.253, 0.222],
+        [0.758, 0.206, 0.279],
+        [4.029, 0.487, 0.565],
+        [1.527, 0.222, 0.294],
+        [2.72, 0.705, 0.912],
+        [4.024, 1.027, 1.022],
+        [4.101, 0.857, 1.123],
+        [7.3, 1.1, 1.339],
+        [0.036, 0.001, 0.001],
+        [0.576, 0.08, 0.087],
+        [2.096, 0.066, 0.136],
+        [4.267, 0.203, 0.202],
+        [148.459, 0.399, 0.179],
+        [3.587, 0.014, 0.014],
+        [0.551, 0.026, 0.025],
+        [3.587, 0.014, 0.014],
+        [6.342, 4.462, 4.481],
+        [37.702, 36.471, 42.618],
+        [0.82, 0.016, 0.022],
+        [4.478, 0.282, 0.283],
+        [6.794, 0.352, 0.266],
+        [5.81, 1, 0.979],
+        [0.854, 0.174, 0.349],
+        [0.847, 0.178, 0.378],
+        [1.204, 0.631, 0.926],
+        [0.152, 0.043, 0.056],
+        [0.135, 0.033, 0.05],
+        [0.161, 0.022, 0.022],
+        [0.225, 0.113, 0.125],
+        [0.306, 0.024, 0.024],
+        [0.119, 0.024, 0.022],
+        [0.97, 0.06, 0.123]
+]
+  } 
+

rayforce/results/20260926/c7a.metal-48xl.json

@@ -0,0 +1,60 @@
+{
+      "system": "Rayforce",
+      "date": "2026-09-26",
+      "machine": "c7a.metal-48xl",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["C","column-oriented","embedded"],
+      "load_time": 384,
+      "data_size": 59039728485,
+      "concurrent_qps": 0.795,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0, 0, 0],
+        [0.137, 0.001, 0.001],
+        [0.557, 0.017, 0.015],
+        [2.08, 0.003, 0.003],
+        [2.168, 0.04, 0.037],
+        [1.661, 0.118, 0.106],
+        [0.557, 0.012, 0.011],
+        [0.169, 0.008, 0.011],
+        [5.169, 0.078, 0.08],
+        [5.787, 0.243, 0.283],
+        [3.78, 0.126, 0.159],
+        [4.545, 0.143, 0.157],
+        [0.667, 0.127, 0.118],
+        [3.824, 0.257, 0.351],
+        [1.418, 0.147, 0.147],
+        [2.503, 0.668, 0.534],
+        [3.89, 0.614, 0.86],
+        [3.876, 0.58, 0.895],
+        [6.979, 0.66, 0.679],
+        [0.036, 0.001, 0.001],
+        [0.578, 0.029, 0.029],
+        [2.096, 0.045, 0.052],
+        [4.298, 0.118, 0.091],
+        [147.898, 0.133, 0.085],
+        [3.587, 0.005, 0.005],
+        [0.55, 0.01, 0.012],
+        [3.587, 0.005, 0.005],
+        [5.818, 3.736, 3.916],
+        [33.777, 31.178, 31.785],
+        [0.813, 0.008, 0.01],
+        [4.434, 0.161, 0.15],
+        [6.733, 0.177, 0.184],
+        [5.722, 0.824, 0.825],
+        [0.748, 0.079, 0.092],
+        [0.746, 0.08, 0.08],
+        [0.855, 0.479, 0.51],
+        [0.107, 0.042, 0.063],
+        [0.117, 0.043, 0.057],
+        [0.117, 0.018, 0.025],
+        [0.162, 0.098, 0.097],
+        [0.231, 0.018, 0.02],
+        [0.096, 0.016, 0.019],
+        [0.652, 0.025, 0.025]
+]
+  } 
+

rayforce/results/20260926/c8g.4xlarge.json

@@ -0,0 +1,60 @@
+{
+      "system": "Rayforce",
+      "date": "2026-09-26",
+      "machine": "c8g.4xlarge",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["C","column-oriented","embedded"],
+      "load_time": 3558,
+      "data_size": 59039728485,
+      "concurrent_qps": 0.148,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0, 0, 0],
+        [0.568, 0.003, 0.003],
+        [0.946, 0.078, 0.078],
+        [2.064, 0.003, 0.003],
+        [2.159, 0.072, 0.072],
+        [1.593, 0.087, 0.087],
+        [0.699, 0.07, 0.07],
+        [0.396, 0.008, 0.008],
+        [5.01, 0.411, 0.413],
+        [5.593, 0.334, 0.338],
+        [3.637, 0.052, 0.05],
+        [4.4, 0.054, 0.053],
+        [0.777, 0.056, 0.056],
+        [3.692, 0.115, 0.114],
+        [1.347, 0.06, 0.06],
+        [2.267, 0.194, 0.195],
+        [3.752, 0.232, 0.232],
+        [3.733, 0.231, 0.229],
+        [6.883, 0.324, 0.324],
+        [0.02, 0, 0],
+        [0.805, 0.086, 0.086],
+        [2.071, 0.053, 0.053],
+        [4.272, 0.119, 0.119],
+        [145.578, 0.122, 0.122],
+        [3.571, 0.016, 0.016],
+        [0.662, 0.038, 0.038],
+        [3.571, 0.016, 0.016],
+        [2.31, 0.282, 0.282],
+        [28.387, 25.789, 25.563],
+        [0.783, 0.01, 0.01],
+        [4.383, 0.072, 0.072],
+        [6.683, 0.092, 0.092],
+        [5.725, 0.528, 0.52],
+        [0.723, 0.143, 0.138],
+        [0.719, 0.14, 0.134],
+        [0.716, 0.177, 0.176],
+        [0.053, 0.018, 0.018],
+        [0.052, 0.018, 0.017],
+        [0.071, 0.01, 0.01],
+        [0.121, 0.075, 0.073],
+        [0.706, 0.007, 0.007],
+        [0.05, 0.005, 0.004],
+        [1.005, 0.049, 0.049]
+]
+  } 
+

rayforce/results/20260926/c8g.metal-48xl.json

@@ -0,0 +1,60 @@
+{
+      "system": "Rayforce",
+      "date": "2026-09-26",
+      "machine": "c8g.metal-48xl",
+      "cluster_size": 1,
+      "proprietary": "no",
+      "hardware": "cpu",
+      "tuned": "no",
+      "tags": ["C","column-oriented","embedded"],
+      "load_time": 378,
+      "data_size": 59039728485,
+      "concurrent_qps": 0.923,
+      "concurrent_error_ratio": 0,
+      "result": [
+        [0, 0, 0],
+        [0.171, 0.001, 0.001],
+        [1.583, 0.014, 0.014],
+        [2.075, 0.002, 0.002],
+        [2.163, 0.035, 0.033],
+        [1.598, 0.084, 0.084],
+        [0.547, 0.012, 0.012],
+        [0.143, 0.005, 0.005],
+        [5.168, 0.058, 0.06],
+        [5.555, 0.228, 0.225],
+        [3.723, 0.099, 0.106],
+        [4.493, 0.103, 0.111],
+        [0.63, 0.101, 0.107],
+        [3.779, 0.266, 0.289],
+        [1.389, 0.133, 0.132],
+        [2.365, 0.481, 0.52],
+        [3.89, 0.761, 0.981],
+        [3.853, 0.773, 1.004],
+        [6.993, 0.816, 1.034],
+        [0.028, 0, 0],
+        [0.554, 0.02, 0.021],
+        [2.075, 0.026, 0.027],
+        [5.773, 0.084, 0.077],
+        [144.954, 0.069, 0.054],
+        [3.577, 0.003, 0.003],
+        [0.54, 0.007, 0.007],
+        [3.583, 0.003, 0.003],
+        [5.66, 3.596, 3.555],
+        [26.64, 23.457, 23.162],
+        [0.789, 0.01, 0.01],
+        [4.414, 0.118, 0.113],
+        [6.711, 0.138, 0.133],
+        [5.707, 0.717, 0.937],
+        [0.762, 0.07, 0.071],
+        [0.708, 0.071, 0.071],
+        [0.816, 0.432, 0.462],
+        [0.064, 0.025, 0.025],
+        [0.06, 0.022, 0.022],
+        [0.08, 0.011, 0.011],
+        [0.123, 0.081, 0.081],
+        [0.209, 0.012, 0.01],
+        [0.067, 0.01, 0.007],
+        [1.809, 0.021, 0.021]
+]
+  } 
+

rayforce/start

@@ -22,6 +22,14 @@ if pgrep -x -f "rayforce -p $port server.rfl" >/dev/null 2>&1; then
     exit 0
 fi
 
+# A server that has just been stopped keeps its listening socket open while
+# it unmaps the table on exit, so a start issued right after ./stop could
+# fail with "Address already in use". Wait for the port to be released.
+for i in $(seq 1 300); do
+    ss -ltn 2>/dev/null | grep -q ":$port " || break
+    sleep 1
+done
+
 # Tell server.rfl whether a table is supposed to be there: the driver starts
 # the server once before ./load, when ./hits legitimately does not exist yet,
 # and again before every query, when it must open successfully.

rayforce/stop

@@ -16,4 +16,16 @@ if [ -f server.pid ]; then
     rm -f server.pid
 fi
 pkill -x -f "rayforce -p $port server.rfl" 2>/dev/null || true
+
+# The signal only starts the shutdown: the process keeps the listening socket
+# while it unmaps the table, and its command line is already cleared, so a
+# ./start that follows immediately could bind neither the port nor see the
+# process. Wait until both the process and the port are gone.
+for i in $(seq 1 300); do
+    if ! pgrep -x -f "rayforce -p $port server.rfl" >/dev/null 2>&1 \
+       && ! ss -ltn 2>/dev/null | grep -q ":$port "; then
+        break
+    fi
+    sleep 1
+done
 exit 0