refactor: align lightweight estimation with weak scaling [code:qws] [system:RC_GH200]

Author: yoshifuminakamura

programs/qws/estimate.sh

@@ -8,13 +8,16 @@ BK_ESTIMATION_PACKAGE="lightweight_fom_scaling"
 BK_ESTIMATION_BASELINE_SYSTEM="Fugaku"
 BK_ESTIMATION_BASELINE_EXP="CASE0"
 BK_ESTIMATION_FUTURE_SYSTEM="FugakuNEXT"
-BK_ESTIMATION_SCALE_FACTOR="2"
+BK_ESTIMATION_FUTURE_FOM_FACTOR="${BK_ESTIMATION_FUTURE_FOM_FACTOR:-1}"
 BK_ESTIMATION_MODEL_NAME="scale-mock"
 BK_ESTIMATION_MODEL_VERSION="0.1"
 BK_ESTIMATION_INPUT_JSON="$1"
 
 read_values "$BK_ESTIMATION_INPUT_JSON"
 
+BK_ESTIMATION_CURRENT_TARGET_NODES="${BK_ESTIMATION_CURRENT_TARGET_NODES:-$est_node_count}"
+BK_ESTIMATION_FUTURE_TARGET_NODES="${BK_ESTIMATION_FUTURE_TARGET_NODES:-$est_node_count}"
+
 if ! bk_estimation_package_check_applicability; then
   echo "ERROR: estimation package ${BK_ESTIMATION_PACKAGE} is not applicable for input ${BK_ESTIMATION_INPUT_JSON}" >&2
   exit 1

scripts/estimate_common.sh

@@ -186,19 +186,21 @@ bk_estimation_set_applicability() {
 }
 
 # ---------------------------------------------------------------------------
-# fetch_current_fom — Fetch Fugaku FOM from result_server API
+# fetch_current_fom — Fetch baseline-system FOM from result_server API
 #
 # Arguments:
-#   $1  code (e.g. qws)
-#   $2  exp  (optional, e.g. default)
+#   $1  system (e.g. Fugaku)
+#   $2  code   (e.g. qws)
+#   $3  exp    (optional, e.g. default)
 #
 # Requires: RESULT_SERVER, RESULT_SERVER_KEY environment variables
-# Sets: est_current_fom (FOM value from Fugaku result)
+# Sets: est_current_fom (FOM value from the selected baseline-system result)
 # Exits with 1 on failure.
 # ---------------------------------------------------------------------------
 fetch_current_fom() {
-  local code="$1"
-  local exp="${2:-}"
+  local system="$1"
+  local code="$2"
+  local exp="${3:-}"
 
   if [[ -z "${RESULT_SERVER:-}" ]]; then
     echo "ERROR: RESULT_SERVER is not set" >&2
@@ -209,7 +211,7 @@ fetch_current_fom() {
     exit 1
   fi
 
-  local url="${RESULT_SERVER}/api/query/result?system=Fugaku&code=${code}"
+  local url="${RESULT_SERVER}/api/query/result?system=${system}&code=${code}"
   if [[ -n "$exp" ]]; then
     url="${url}&exp=${exp}"
   fi
@@ -221,26 +223,26 @@ fetch_current_fom() {
   curl_exit=$?
   set -e
   if [[ $curl_exit -ne 0 || -z "$response" ]]; then
-    echo "ERROR: Failed to fetch Fugaku result for code=${code}, exp=${exp} (curl exit=$curl_exit)" >&2
+    echo "ERROR: Failed to fetch baseline result for system=${system}, code=${code}, exp=${exp} (curl exit=$curl_exit)" >&2
     echo "ERROR: URL was: ${url}" >&2
     exit 1
   fi
 
   est_current_fom=$(echo "$response" | jq -r '.FOM')
   if [[ -z "$est_current_fom" || "$est_current_fom" == "null" ]]; then
-    echo "ERROR: FOM not found in Fugaku result for code=${code}, exp=${exp}" >&2
+    echo "ERROR: FOM not found in baseline result for system=${system}, code=${code}, exp=${exp}" >&2
     exit 1
   fi
 
   # Populate benchmark sub-object variables for current_system
-  est_current_bench_system="Fugaku"
+  est_current_bench_system="$system"
   est_current_bench_fom="$est_current_fom"
   est_current_bench_nodes=$(echo "$response" | jq -r '.node_count // empty')
   est_current_bench_numproc_node=$(echo "$response" | jq -r '.numproc_node // empty')
   est_current_bench_timestamp=$(echo "$response" | jq -r '._meta.timestamp // empty')
   est_current_bench_uuid=$(echo "$response" | jq -r '._meta.uuid // empty')
 
-  echo "Fetched Fugaku FOM for ${code}: ${est_current_fom}"
+  echo "Fetched baseline FOM for ${system}/${code}: ${est_current_fom}"
 }
 
 # ---------------------------------------------------------------------------

scripts/estimation/packages/lightweight_fom_scaling.sh

@@ -9,7 +9,7 @@ bk_estimation_package_metadata() {
   "method_class": "lightweight",
   "detail_level": "basic",
   "required_inputs": {
-    "mandatory": ["result_json", "fom", "node_count"],
+    "mandatory": ["result_json", "fom", "target_nodes_current", "target_nodes_future"],
     "optional": ["fom_breakdown"],
     "external": []
   },
@@ -46,7 +46,9 @@ bk_estimation_package_run() {
   local baseline_system="${BK_ESTIMATION_BASELINE_SYSTEM:-Fugaku}"
   local baseline_exp="${BK_ESTIMATION_BASELINE_EXP:-CASE0}"
   local future_system="${BK_ESTIMATION_FUTURE_SYSTEM:-FugakuNEXT}"
-  local scale_factor="${BK_ESTIMATION_SCALE_FACTOR:-2}"
+  local current_target_nodes="${BK_ESTIMATION_CURRENT_TARGET_NODES:-$est_node_count}"
+  local future_target_nodes="${BK_ESTIMATION_FUTURE_TARGET_NODES:-$est_node_count}"
+  local future_fom_factor="${BK_ESTIMATION_FUTURE_FOM_FACTOR:-${BK_ESTIMATION_SCALE_FACTOR:-1}}"
   local model_name="${BK_ESTIMATION_MODEL_NAME:-scale-mock}"
   local model_version="${BK_ESTIMATION_MODEL_VERSION:-0.1}"
 
@@ -60,14 +62,14 @@ bk_estimation_package_run() {
 
   # Current/baseline side.
   est_current_system="$baseline_system"
-  fetch_current_fom "$est_code" "$baseline_exp"
-  est_current_target_nodes="$est_node_count"
+  fetch_current_fom "$baseline_system" "$est_code" "$baseline_exp"
+  est_current_target_nodes="$current_target_nodes"
   est_current_scaling_method="measured"
 
   # Future/predicted side.
   est_future_system="$future_system"
-  est_future_fom=$(awk -v fom="$est_fom" -v factor="$scale_factor" 'BEGIN {printf "%.3f", fom * factor}')
-  est_future_target_nodes="$est_node_count"
+  est_future_fom=$(awk -v fom="$est_fom" -v factor="$future_fom_factor" 'BEGIN {printf "%.3f", fom * factor}')
+  est_future_target_nodes="$future_target_nodes"
   est_future_scaling_method="$model_name"
 
   est_measurement_json=$(jq -cn \
@@ -87,11 +89,22 @@ bk_estimation_package_run() {
   est_assumptions_json=$(jq -cn \
     --arg future_system "$future_system" \
     --arg baseline_system "$baseline_system" \
-    --arg scale_factor "$scale_factor" \
+    --arg current_target_nodes "$current_target_nodes" \
+    --arg future_target_nodes "$future_target_nodes" \
+    --arg future_fom_factor "$future_fom_factor" \
     '{
+      scaling_assumption: "weak-scaling",
       future_system_assumption: $future_system,
       baseline_system: $baseline_system,
-      future_fom_rule: ($scale_factor + "x benchmark FOM when no detailed model is available")
+      current_target_nodes: $current_target_nodes,
+      future_target_nodes: $future_target_nodes,
+      future_fom_rule: (
+        if $future_fom_factor == "1" then
+          "keep FOM constant unless additional correction terms are explicitly introduced"
+        else
+          ($future_fom_factor + "x benchmark FOM with explicit lightweight correction")
+        end
+      )
     }')
 
   est_model_json=$(jq -cn \
@@ -117,9 +130,9 @@ bk_estimation_package_run() {
   fi
 
   if [[ -n "$raw_breakdown" ]]; then
-    est_future_fom_breakdown=$(echo "$raw_breakdown" | jq -c --arg scale_factor "$scale_factor" --arg model_name "$model_name" '{
-      sections: [.sections[] | {name, bench_time: .time, scaling_method: $model_name, time: (.time * ($scale_factor | tonumber))}],
-      overlaps: [(.overlaps // [])[] | {sections, bench_time: .time, scaling_method: $model_name, time: (.time * ($scale_factor | tonumber))}]
+    est_future_fom_breakdown=$(echo "$raw_breakdown" | jq -c --arg future_fom_factor "$future_fom_factor" --arg model_name "$model_name" '{
+      sections: [.sections[] | {name, bench_time: .time, scaling_method: $model_name, time: (.time * ($future_fom_factor | tonumber))}],
+      overlaps: [(.overlaps // [])[] | {sections, bench_time: .time, scaling_method: $model_name, time: (.time * ($future_fom_factor | tonumber))}]
     }')
 
     est_current_fom_breakdown=$(echo "$raw_breakdown" | jq -c '{
@@ -138,7 +151,7 @@ bk_estimation_package_run() {
 bk_estimation_package_apply_metadata() {
   bk_estimation_set_package_metadata \
     "lightweight_fom_scaling" \
-    "${BK_ESTIMATION_MODEL_VERSION:-0.1}" \
+    "0.1" \
     "lightweight" \
     "basic"