@invarn/cibuild 2.8.9 → 2.9.1

package/dist/src/yaml/steps/gradle-memory.d.ts

@@ -13,12 +13,17 @@
  *
  *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
  *     daemon and the Kotlin daemon. When their sum is past
- *     `GRADLE_HEAP_SHARE_PERCENT` of memory, scale both down to fit, and pass
- *     them on the command line (`-Dorg.gradle.jvmargs=`,
- *     `-Pkotlin.daemon.jvmargs=`). One line names the old values and the new.
- *  2. **Say so.** When a Gradle run exits 137 or its output says the daemon
- *     disappeared, print the kernel's out-of-memory lines and one sentence
- *     with the machine's memory and what the build asked for.
+ *     `GRADLE_HEAP_SHARE_PERCENT` of memory, run one heap instead: the Gradle
+ *     daemon gets the whole budget (`-Dorg.gradle.jvmargs=`) and Kotlin
+ *     compiles in it (`-Pkotlin.compiler.execution.strategy=in-process`). One
+ *     line names the old values and the new. Two heaps did not fit: halved,
+ *     ReFra's Kotlin compile ran out of heap; split 60/40, its Kotlin daemon
+ *     was lost mid-compile, and mifos-mobile's Gradle daemon ran out of its
+ *     40 % on a 6 GiB guest.
+ *  2. **Say so.** When a Gradle run exits 137, its output says the daemon
+ *     disappeared, or the Kotlin daemon was lost mid-compile, print the
+ *     kernel's out-of-memory lines and one sentence with the machine's memory
+ *     and what the build asked for.
  *  3. **Workers.** A heap cap does not bound what runs beside the heaps:
  *     off-heap memory, and native compilers run in parallel. IacobIonut01/ReFra
  *     was killed again at a capped -Xmx3712m, one JVM holding ~5.1 GiB
@@ -29,7 +34,10 @@
  * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
  * home's and the project's `gradle.properties` for the daemon's heap, and
  * `-P` beats `gradle.properties` for a Gradle property, which is how the
- * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `--max-workers` beats
+ * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs` and
+ * `kotlin.compiler.execution.strategy`: with
+ * `-Pkotlin.compiler.execution.strategy=in-process`, no Kotlin daemon starts
+ * even where the project's file says `daemon`. `--max-workers` beats
  * `org.gradle.workers.max` in both files (`gradle.startParameter.maxWorkerCount`).
  * `GRADLE_OPTS` is not used: it sizes the client JVM, not the daemon.
  *
@@ -38,7 +46,7 @@
  */
 /** The share of the machine's memory the two daemon heaps may take together. */
 export declare const GRADLE_HEAP_SHARE_PERCENT = 75;
-export declare const GRADLE_MEMORY_FUNCTIONS = "# This machine's memory in MiB, or nothing when it cannot be read.\ncibuild_mem_mib() {\n  if [ -r /proc/meminfo ]; then\n    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo\n  else\n    local bytes\n    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)\n    if [ -n \"$bytes\" ]; then echo $(( bytes / 1048576 )); fi\n  fi\n}\n\n# $1 a .properties file, $2 a key. Prints \"<line number><TAB><value>\" for the\n# last assignment of the key, or nothing.\ncibuild_prop_line() {\n  [ -f \"$1\" ] || return 0\n  awk -v key=\"$2\" '\n    { line = $0; sub(/^[ \\t]+/, \"\", line) }\n    line ~ /^[#!]/ { next }\n    {\n      k = line; sub(/[ \\t]*[=:].*$/, \"\", k)\n      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, \"\", v); sub(/[ \\t\\r]+$/, \"\", v); found = NR \"\\t\" v }\n    }\n    END { if (found != \"\") print found }\n  ' \"$1\"\n}\n\n# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),\n# or nothing when it has none.\ncibuild_xmx_mib() {\n  printf '%s\\n' \"$1\" | tr ' \\t' '\\n\\n' | awk '\n    /^-Xmx[0-9]+[kKmMgGtT]?$/ {\n      n = substr($0, 5); u = substr(n, length(n))\n      if (u ~ /[0-9]/) { v = n / 1048576 }\n      else {\n        n = substr(n, 1, length(n) - 1)\n        if (u ~ /[kK]/) v = n / 1024\n        else if (u ~ /[mM]/) v = n\n        else if (u ~ /[gG]/) v = n * 1024\n        else v = n * 1048576\n      }\n      r = int(v)\n    }\n    END { if (r != \"\") print r }'\n}\n\n# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every\n# -Xmx replaced by that one (added in front when there was none).\ncibuild_with_xmx() (\n  set -f\n  out=\"\"\n  replaced=0\n  for arg in $1; do\n    case \"$arg\" in\n      -Xmx*) if [ \"$replaced\" -eq 0 ]; then out=\"$out -Xmx${2}m\"; replaced=1; fi ;;\n      *) out=\"$out $arg\" ;;\n    esac\n  done\n  [ \"$replaced\" -eq 1 ] || out=\" -Xmx${2}m$out\"\n  printf '%s' \"${out# }\"\n)\n\n# MiB as GiB with one decimal.\ncibuild_gib() {\n  awk -v m=\"$1\" 'BEGIN { printf \"%.1f\", m / 1024 }'\n}\n\n# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.\ncibuild_scaled_heap() {\n  local v=$(( $1 * $2 / $3 / 64 * 64 ))\n  [ \"$v\" -ge 512 ] || v=512\n  echo \"$v\"\n}\n\n# The plan, from its inputs only, so a test can run it:\n#   $1 this machine's memory in MiB (empty when unknown)\n#   $2 the project's gradle.properties   $3 the Gradle user home's\n#   $4 JVM arguments the pipeline asks for instead (may be empty)\n# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),\n# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when\n# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a\n# daemon is killed).\n#\n# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's\n# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of\n# its own inherits the Gradle daemon's, and in-process compilation has no\n# Kotlin daemon at all.\ncibuild_gradle_memory_plan() {\n  local mem=\"$1\" project=\"$2\" user=\"$3\" preferred=\"$4\" l\n  local jvm=\"\" jvm_at=\"\" kd=\"\" kd_at=\"\" strategy=\"\"\n  CIBUILD_GRADLE_MEMORY_ARGS=()\n  CIBUILD_GRADLE_MEMORY_LINE=\"\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"\"\n\n  if [ -n \"$preferred\" ]; then jvm=\"$preferred\"; jvm_at=\"the pipeline\"; fi\n  for f in \"$user\" \"$project\"; do\n    if [ -z \"$jvm_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" org.gradle.jvmargs)\n      if [ -n \"$l\" ]; then jvm=\"${l#*\t}\"; jvm_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$kd_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.daemon.jvmargs)\n      if [ -n \"$l\" ]; then kd=\"${l#*\t}\"; kd_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$strategy\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.compiler.execution.strategy)\n      strategy=\"${l#*\t}\"\n    fi\n  done\n\n  local g k kd_own=\"\"\n  g=$(cibuild_xmx_mib \"$jvm\")\n  [ -n \"$g\" ] || g=512\n  if [ \"$strategy\" = \"in-process\" ]; then\n    k=0\n  else\n    kd_own=$(cibuild_xmx_mib \"$kd\")\n    k=\"${kd_own:-$g}\"\n  fi\n  local total=$(( g + k ))\n\n  local asked\n  if [ -n \"$jvm_at\" ]; then asked=\"org.gradle.jvmargs=$jvm at ${jvm_at}\"; else asked=\"Gradle's default -Xmx512m\"; fi\n  if [ \"$k\" -eq 0 ]; then\n    asked=\"$asked; Kotlin compiles in-process\"\n  elif [ -n \"$kd_own\" ]; then\n    asked=\"$asked, kotlin.daemon.jvmargs=$kd at ${kd_at}\"\n  else\n    asked=\"$asked; the Kotlin daemon inherits its -Xmx\"\n  fi\n\n  if [ -z \"$mem\" ]; then\n    CIBUILD_GRADLE_MEMORY_SENTENCE=\"This build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked); this machine's memory could not be read.\"\n    if [ -n \"$preferred\" ]; then CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\"); fi\n    return 0\n  fi\n\n  local budget=$(( mem * 75 / 100 ))\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"The build machine has $(cibuild_gib \"$mem\") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked).\"\n\n  if [ \"$total\" -le \"$budget\" ]; then\n    if [ -n \"$preferred\" ]; then\n      CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\")\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line).\"\n    fi\n    return 0\n  fi\n\n  case \"$jvm\" in\n    *\\\\)\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: the declared heaps ask for $(cibuild_gib \"$total\") GiB of this machine's $(cibuild_gib \"$mem\") GiB, but org.gradle.jvmargs at ${jvm_at} continues onto another line, so it is left as it is.\"\n      return 0\n      ;;\n  esac\n\n  local ng nk new_jvm\n  ng=$(cibuild_scaled_heap \"$g\" \"$budget\" \"$total\")\n  new_jvm=$(cibuild_with_xmx \"$jvm\" \"$ng\")\n  CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$new_jvm\")\n  local now=\"Gradle -Xmx${ng}m\"\n  if [ \"$k\" -eq 0 ]; then\n    :\n  elif [ -n \"$kd_own\" ]; then\n    nk=$(cibuild_scaled_heap \"$k\" \"$budget\" \"$total\")\n    CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Pkotlin.daemon.jvmargs=$(cibuild_with_xmx \"$kd\" \"$nk\")\")\n    now=\"$now and the Kotlin daemon -Xmx${nk}m\"\n  else\n    now=\"$now, which the Kotlin daemon inherits\"\n  fi\n  CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: this machine has $(cibuild_gib \"$mem\") GiB and the declared heaps ask for $(cibuild_gib \"$total\") GiB ($asked), past the $(cibuild_gib \"$budget\") GiB this build allows them. Running with $now, set on the command line.\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now.\"\n}\n\n# $1 the number of Gradle workers the pipeline asks for (may be empty). Adds\n# --max-workers to the plan's arguments; run after cibuild_gradle_memory_plan.\n# Sets CIBUILD_GRADLE_WORKERS_LINE (what to print; empty when nothing asked).\ncibuild_gradle_workers_plan() {\n  CIBUILD_GRADLE_WORKERS_LINE=\"\"\n  [ -n \"$1\" ] || return 0\n  case \"$1\" in\n    *[!0-9]*|0*)\n      CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: max_workers=$1 is not a positive whole number, so it is not passed and Gradle picks its own worker count.\"\n      return 0\n      ;;\n  esac\n  CIBUILD_GRADLE_MEMORY_ARGS+=(\"--max-workers=$1\")\n  CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: running with --max-workers=$1, as the pipeline asks (set on the command line, over any org.gradle.workers.max).\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE Gradle ran with --max-workers=$1.\"\n}\n\n# The kernel's out-of-memory lines, if this user may read the kernel log.\n# Linux guests restrict dmesg to root by default; their build user has\n# non-interactive sudo, so that is the second try.\ncibuild_kernel_oom_lines() {\n  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |\n    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true\n}\n\n# $1 Gradle's exit status, $2 a file holding its output. Says so when the\n# failure is a killed daemon rather than a failed build.\ncibuild_gradle_memory_report() {\n  if [ \"$1\" -ne 137 ] && ! grep -q \"daemon disappeared unexpectedly\" \"$2\" 2>/dev/null; then\n    return 0\n  fi\n  local oom\n  oom=$(cibuild_kernel_oom_lines)\n  echo \"\"\n  echo \"Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1).\"\n  if [ -n \"$oom\" ]; then\n    echo \"The kernel's out-of-memory lines:\"\n    printf '%s\\n' \"$oom\" | sed 's/^/    /'\n  else\n    echo \"The kernel log shows no out-of-memory kill, or this machine does not let the build read it.\"\n  fi\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_SENTENCE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_SENTENCE\"; fi\n}\n\n# Runs Gradle with the plan's arguments, and reports a killed daemon.\ncibuild_gradle() {\n  local log rc\n  log=$(mktemp)\n  set +e\n  \"$CIBUILD_GRADLE_BIN\" \"${CIBUILD_GRADLE_MEMORY_ARGS[@]}\" \"$@\" 2>&1 | tee \"$log\"\n  rc=${PIPESTATUS[0]}\n  set -e\n  if [ \"$rc\" -ne 0 ]; then cibuild_gradle_memory_report \"$rc\" \"$log\" || true; fi\n  rm -f \"$log\"\n  return \"$rc\"\n}\n\n# $1 JVM arguments the pipeline asks for, $2 the Gradle workers it asks for\n# (either may be empty). Run in the Gradle project directory, after GRADLE_CMD\n# is chosen.\ncibuild_gradle_memory_cap() {\n  cibuild_gradle_memory_plan \"$(cibuild_mem_mib || true)\" \"gradle.properties\" \\\n    \"${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties\" \"$1\"\n  cibuild_gradle_workers_plan \"$2\"\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_LINE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_LINE\"; fi\n  if [ -n \"$CIBUILD_GRADLE_WORKERS_LINE\" ]; then echo \"$CIBUILD_GRADLE_WORKERS_LINE\"; fi\n  CIBUILD_GRADLE_BIN=\"$GRADLE_CMD\"\n  GRADLE_CMD=cibuild_gradle\n}";
+export declare const GRADLE_MEMORY_FUNCTIONS = "# This machine's memory in MiB, or nothing when it cannot be read.\ncibuild_mem_mib() {\n  if [ -r /proc/meminfo ]; then\n    awk '/^MemTotal:/ { print int($2 / 1024); exit }' /proc/meminfo\n  else\n    local bytes\n    bytes=$(sysctl -n hw.memsize 2>/dev/null || true)\n    if [ -n \"$bytes\" ]; then echo $(( bytes / 1048576 )); fi\n  fi\n}\n\n# $1 a .properties file, $2 a key. Prints \"<line number><TAB><value>\" for the\n# last assignment of the key, or nothing.\ncibuild_prop_line() {\n  [ -f \"$1\" ] || return 0\n  awk -v key=\"$2\" '\n    { line = $0; sub(/^[ \\t]+/, \"\", line) }\n    line ~ /^[#!]/ { next }\n    {\n      k = line; sub(/[ \\t]*[=:].*$/, \"\", k)\n      if (k == key) { v = line; sub(/^[^=:]*[=:][ \\t]*/, \"\", v); sub(/[ \\t\\r]+$/, \"\", v); found = NR \"\\t\" v }\n    }\n    END { if (found != \"\") print found }\n  ' \"$1\"\n}\n\n# The -Xmx of a JVM argument string in MiB (the last one wins, as in the JVM),\n# or nothing when it has none.\ncibuild_xmx_mib() {\n  printf '%s\\n' \"$1\" | tr ' \\t' '\\n\\n' | awk '\n    /^-Xmx[0-9]+[kKmMgGtT]?$/ {\n      n = substr($0, 5); u = substr(n, length(n))\n      if (u ~ /[0-9]/) { v = n / 1048576 }\n      else {\n        n = substr(n, 1, length(n) - 1)\n        if (u ~ /[kK]/) v = n / 1024\n        else if (u ~ /[mM]/) v = n\n        else if (u ~ /[gG]/) v = n * 1024\n        else v = n * 1048576\n      }\n      r = int(v)\n    }\n    END { if (r != \"\") print r }'\n}\n\n# $1 a JVM argument string, $2 a heap in MiB: the same arguments with every\n# -Xmx replaced by that one (added in front when there was none).\ncibuild_with_xmx() (\n  set -f\n  out=\"\"\n  replaced=0\n  for arg in $1; do\n    case \"$arg\" in\n      -Xmx*) if [ \"$replaced\" -eq 0 ]; then out=\"$out -Xmx${2}m\"; replaced=1; fi ;;\n      *) out=\"$out $arg\" ;;\n    esac\n  done\n  [ \"$replaced\" -eq 1 ] || out=\" -Xmx${2}m$out\"\n  printf '%s' \"${out# }\"\n)\n\n# MiB as GiB with one decimal.\ncibuild_gib() {\n  awk -v m=\"$1\" 'BEGIN { printf \"%.1f\", m / 1024 }'\n}\n\n# A heap scaled by budget/total, rounded down to 64 MiB, never below 512 MiB.\ncibuild_scaled_heap() {\n  local v=$(( $1 * $2 / $3 / 64 * 64 ))\n  [ \"$v\" -ge 512 ] || v=512\n  echo \"$v\"\n}\n\n# The plan, from its inputs only, so a test can run it:\n#   $1 this machine's memory in MiB (empty when unknown)\n#   $2 the project's gradle.properties   $3 the Gradle user home's\n#   $4 JVM arguments the pipeline asks for instead (may be empty)\n# Sets CIBUILD_GRADLE_MEMORY_ARGS (extra Gradle arguments),\n# CIBUILD_GRADLE_MEMORY_LINE (what to print before Gradle runs; empty when\n# nothing changes) and CIBUILD_GRADLE_MEMORY_SENTENCE (what to print if a\n# daemon is killed).\n#\n# Precedence is Gradle's own: the command line beats GRADLE_USER_HOME's\n# gradle.properties, which beats the project's. A Kotlin daemon with no -Xmx of\n# its own inherits the Gradle daemon's, and in-process compilation has no\n# Kotlin daemon at all.\ncibuild_gradle_memory_plan() {\n  local mem=\"$1\" project=\"$2\" user=\"$3\" preferred=\"$4\" l\n  local jvm=\"\" jvm_at=\"\" kd=\"\" kd_at=\"\" strategy=\"\"\n  CIBUILD_GRADLE_MEMORY_ARGS=()\n  CIBUILD_GRADLE_MEMORY_LINE=\"\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"\"\n\n  if [ -n \"$preferred\" ]; then jvm=\"$preferred\"; jvm_at=\"the pipeline\"; fi\n  for f in \"$user\" \"$project\"; do\n    if [ -z \"$jvm_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" org.gradle.jvmargs)\n      if [ -n \"$l\" ]; then jvm=\"${l#*\t}\"; jvm_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$kd_at\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.daemon.jvmargs)\n      if [ -n \"$l\" ]; then kd=\"${l#*\t}\"; kd_at=\"$f:${l%%\t*}\"; fi\n    fi\n    if [ -z \"$strategy\" ]; then\n      l=$(cibuild_prop_line \"$f\" kotlin.compiler.execution.strategy)\n      strategy=\"${l#*\t}\"\n    fi\n  done\n\n  local g k kd_own=\"\"\n  g=$(cibuild_xmx_mib \"$jvm\")\n  [ -n \"$g\" ] || g=512\n  if [ \"$strategy\" = \"in-process\" ]; then\n    k=0\n  else\n    kd_own=$(cibuild_xmx_mib \"$kd\")\n    k=\"${kd_own:-$g}\"\n  fi\n  local total=$(( g + k ))\n\n  local asked\n  if [ -n \"$jvm_at\" ]; then asked=\"org.gradle.jvmargs=$jvm at ${jvm_at}\"; else asked=\"Gradle's default -Xmx512m\"; fi\n  if [ \"$k\" -eq 0 ]; then\n    asked=\"$asked; Kotlin compiles in-process\"\n  elif [ -n \"$kd_own\" ]; then\n    asked=\"$asked, kotlin.daemon.jvmargs=$kd at ${kd_at}\"\n  else\n    asked=\"$asked; the Kotlin daemon inherits its -Xmx\"\n  fi\n\n  if [ -z \"$mem\" ]; then\n    CIBUILD_GRADLE_MEMORY_SENTENCE=\"This build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked); this machine's memory could not be read.\"\n    if [ -n \"$preferred\" ]; then CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\"); fi\n    return 0\n  fi\n\n  local budget=$(( mem * 75 / 100 ))\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"The build machine has $(cibuild_gib \"$mem\") GiB; this build's Gradle and Kotlin daemons asked for $(cibuild_gib \"$total\") GiB ($asked).\"\n\n  if [ \"$total\" -le \"$budget\" ]; then\n    if [ -n \"$preferred\" ]; then\n      CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$preferred\")\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: org.gradle.jvmargs=$preferred, as the pipeline asks (-Dorg.gradle.jvmargs on the command line).\"\n    fi\n    return 0\n  fi\n\n  case \"$jvm\" in\n    *\\\\)\n      CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: the declared heaps ask for $(cibuild_gib \"$total\") GiB of this machine's $(cibuild_gib \"$mem\") GiB, but org.gradle.jvmargs at ${jvm_at} continues onto another line, so it is left as it is.\"\n      return 0\n      ;;\n  esac\n\n  # One heap, the whole budget. Two did not fit: ReFra's Kotlin daemon was\n  # lost mid-compile at a 60/40 split, and mifos-mobile's Gradle daemon ran out\n  # of its 40 %. In-process, Kotlin compiles in the Gradle daemon's heap.\n  local ng now\n  ng=$(cibuild_scaled_heap \"$budget\" 1 1)\n  CIBUILD_GRADLE_MEMORY_ARGS=(\"-Dorg.gradle.jvmargs=$(cibuild_with_xmx \"$jvm\" \"$ng\")\")\n  now=\"Gradle -Xmx${ng}m\"\n  if [ \"$k\" -gt 0 ]; then\n    CIBUILD_GRADLE_MEMORY_ARGS+=(\"-Pkotlin.compiler.execution.strategy=in-process\")\n    now=\"$now and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon)\"\n  fi\n  CIBUILD_GRADLE_MEMORY_LINE=\"Gradle memory: this machine has $(cibuild_gib \"$mem\") GiB and the declared heaps ask for $(cibuild_gib \"$total\") GiB ($asked), past the $(cibuild_gib \"$budget\") GiB this build allows them. Running with $now, set on the command line.\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now.\"\n}\n\n# $1 the number of Gradle workers the pipeline asks for (may be empty). Adds\n# --max-workers to the plan's arguments; run after cibuild_gradle_memory_plan.\n# Sets CIBUILD_GRADLE_WORKERS_LINE (what to print; empty when nothing asked).\ncibuild_gradle_workers_plan() {\n  CIBUILD_GRADLE_WORKERS_LINE=\"\"\n  [ -n \"$1\" ] || return 0\n  case \"$1\" in\n    *[!0-9]*|0*)\n      CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: max_workers=$1 is not a positive whole number, so it is not passed and Gradle picks its own worker count.\"\n      return 0\n      ;;\n  esac\n  CIBUILD_GRADLE_MEMORY_ARGS+=(\"--max-workers=$1\")\n  CIBUILD_GRADLE_WORKERS_LINE=\"Gradle memory: running with --max-workers=$1, as the pipeline asks (set on the command line, over any org.gradle.workers.max).\"\n  CIBUILD_GRADLE_MEMORY_SENTENCE=\"$CIBUILD_GRADLE_MEMORY_SENTENCE Gradle ran with --max-workers=$1.\"\n}\n\n# The kernel's out-of-memory lines, if this user may read the kernel log.\n# Linux guests restrict dmesg to root by default; their build user has\n# non-interactive sudo, so that is the second try.\ncibuild_kernel_oom_lines() {\n  { dmesg 2>/dev/null || sudo -n dmesg 2>/dev/null || true; } |\n    grep -i -E 'out of memory|oom-kill|oom_reaper|killed process' | tail -n 20 || true\n}\n\n# $1 Gradle's exit status, $2 a file holding its output. Says so when the\n# failure is a killed daemon rather than a failed build.\ncibuild_gradle_memory_report() {\n  local kotlin_lost=\"\"\n  if grep -q \"Connection to the Kotlin daemon has been unexpectedly lost\" \"$2\" 2>/dev/null; then kotlin_lost=1; fi\n  if [ \"$1\" -ne 137 ] && [ -z \"$kotlin_lost\" ] && ! grep -q \"daemon disappeared unexpectedly\" \"$2\" 2>/dev/null; then\n    return 0\n  fi\n  local oom\n  oom=$(cibuild_kernel_oom_lines)\n  echo \"\"\n  if [ -n \"$kotlin_lost\" ]; then\n    echo \"Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit $1). Kotlin then compiled without it, in the Gradle daemon's heap.\"\n  else\n    echo \"Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1).\"\n  fi\n  if [ -n \"$oom\" ]; then\n    echo \"The kernel's out-of-memory lines:\"\n    printf '%s\\n' \"$oom\" | sed 's/^/    /'\n  else\n    echo \"The kernel log shows no out-of-memory kill, or this machine does not let the build read it.\"\n  fi\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_SENTENCE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_SENTENCE\"; fi\n}\n\n# Runs Gradle with the plan's arguments, and reports a killed daemon.\ncibuild_gradle() {\n  local log rc\n  log=$(mktemp)\n  set +e\n  \"$CIBUILD_GRADLE_BIN\" \"${CIBUILD_GRADLE_MEMORY_ARGS[@]}\" \"$@\" 2>&1 | tee \"$log\"\n  rc=${PIPESTATUS[0]}\n  set -e\n  if [ \"$rc\" -ne 0 ]; then cibuild_gradle_memory_report \"$rc\" \"$log\" || true; fi\n  rm -f \"$log\"\n  return \"$rc\"\n}\n\n# $1 JVM arguments the pipeline asks for, $2 the Gradle workers it asks for\n# (either may be empty). Run in the Gradle project directory, after GRADLE_CMD\n# is chosen.\ncibuild_gradle_memory_cap() {\n  cibuild_gradle_memory_plan \"$(cibuild_mem_mib || true)\" \"gradle.properties\" \\\n    \"${GRADLE_USER_HOME:-$HOME/.gradle}/gradle.properties\" \"$1\"\n  cibuild_gradle_workers_plan \"$2\"\n  if [ -n \"$CIBUILD_GRADLE_MEMORY_LINE\" ]; then echo \"$CIBUILD_GRADLE_MEMORY_LINE\"; fi\n  if [ -n \"$CIBUILD_GRADLE_WORKERS_LINE\" ]; then echo \"$CIBUILD_GRADLE_WORKERS_LINE\"; fi\n  CIBUILD_GRADLE_BIN=\"$GRADLE_CMD\"\n  GRADLE_CMD=cibuild_gradle\n}";
 /**
  * The commands a Gradle step runs once it has chosen `GRADLE_CMD` and is in
  * the project directory. Afterwards `$GRADLE_CMD` runs Gradle with the plan's

package/dist/src/yaml/steps/gradle-memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradle-memory.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,eAAO,MAAM,uBAAuB,4hTAgPlC,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACjC,UAAU,SAAK,GACd,MAAM,EAAE,CAOV"}
+{"version":3,"file":"gradle-memory.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/gradle-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAG5C,eAAO,MAAM,uBAAuB,ohUAmPlC,CAAC;AAEH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACjC,UAAU,SAAK,GACd,MAAM,EAAE,CAOV"}

package/dist/src/yaml/steps/gradle-memory.js

@@ -13,12 +13,17 @@
  *
  *  1. **Cap.** Read the machine's memory and the declared `-Xmx` of the Gradle
  *     daemon and the Kotlin daemon. When their sum is past
- *     `GRADLE_HEAP_SHARE_PERCENT` of memory, scale both down to fit, and pass
- *     them on the command line (`-Dorg.gradle.jvmargs=`,
- *     `-Pkotlin.daemon.jvmargs=`). One line names the old values and the new.
- *  2. **Say so.** When a Gradle run exits 137 or its output says the daemon
- *     disappeared, print the kernel's out-of-memory lines and one sentence
- *     with the machine's memory and what the build asked for.
+ *     `GRADLE_HEAP_SHARE_PERCENT` of memory, run one heap instead: the Gradle
+ *     daemon gets the whole budget (`-Dorg.gradle.jvmargs=`) and Kotlin
+ *     compiles in it (`-Pkotlin.compiler.execution.strategy=in-process`). One
+ *     line names the old values and the new. Two heaps did not fit: halved,
+ *     ReFra's Kotlin compile ran out of heap; split 60/40, its Kotlin daemon
+ *     was lost mid-compile, and mifos-mobile's Gradle daemon ran out of its
+ *     40 % on a 6 GiB guest.
+ *  2. **Say so.** When a Gradle run exits 137, its output says the daemon
+ *     disappeared, or the Kotlin daemon was lost mid-compile, print the
+ *     kernel's out-of-memory lines and one sentence with the machine's memory
+ *     and what the build asked for.
  *  3. **Workers.** A heap cap does not bound what runs beside the heaps:
  *     off-heap memory, and native compilers run in parallel. IacobIonut01/ReFra
  *     was killed again at a capped -Xmx3712m, one JVM holding ~5.1 GiB
@@ -29,7 +34,10 @@
  * `-Dorg.gradle.jvmargs` on the command line beats both the Gradle user
  * home's and the project's `gradle.properties` for the daemon's heap, and
  * `-P` beats `gradle.properties` for a Gradle property, which is how the
- * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs`. `--max-workers` beats
+ * Kotlin Gradle plugin reads `kotlin.daemon.jvmargs` and
+ * `kotlin.compiler.execution.strategy`: with
+ * `-Pkotlin.compiler.execution.strategy=in-process`, no Kotlin daemon starts
+ * even where the project's file says `daemon`. `--max-workers` beats
  * `org.gradle.workers.max` in both files (`gradle.startParameter.maxWorkerCount`).
  * `GRADLE_OPTS` is not used: it sizes the client JVM, not the daemon.
  *
@@ -192,19 +200,16 @@ cibuild_gradle_memory_plan() {
       ;;
   esac
 
-  local ng nk new_jvm
-  ng=$(cibuild_scaled_heap "$g" "$budget" "$total")
-  new_jvm=$(cibuild_with_xmx "$jvm" "$ng")
-  CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$new_jvm")
-  local now="Gradle -Xmx\${ng}m"
-  if [ "$k" -eq 0 ]; then
-    :
-  elif [ -n "$kd_own" ]; then
-    nk=$(cibuild_scaled_heap "$k" "$budget" "$total")
-    CIBUILD_GRADLE_MEMORY_ARGS+=("-Pkotlin.daemon.jvmargs=$(cibuild_with_xmx "$kd" "$nk")")
-    now="$now and the Kotlin daemon -Xmx\${nk}m"
-  else
-    now="$now, which the Kotlin daemon inherits"
+  # One heap, the whole budget. Two did not fit: ReFra's Kotlin daemon was
+  # lost mid-compile at a 60/40 split, and mifos-mobile's Gradle daemon ran out
+  # of its 40 %. In-process, Kotlin compiles in the Gradle daemon's heap.
+  local ng now
+  ng=$(cibuild_scaled_heap "$budget" 1 1)
+  CIBUILD_GRADLE_MEMORY_ARGS=("-Dorg.gradle.jvmargs=$(cibuild_with_xmx "$jvm" "$ng")")
+  now="Gradle -Xmx\${ng}m"
+  if [ "$k" -gt 0 ]; then
+    CIBUILD_GRADLE_MEMORY_ARGS+=("-Pkotlin.compiler.execution.strategy=in-process")
+    now="$now and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon)"
   fi
   CIBUILD_GRADLE_MEMORY_LINE="Gradle memory: this machine has $(cibuild_gib "$mem") GiB and the declared heaps ask for $(cibuild_gib "$total") GiB ($asked), past the $(cibuild_gib "$budget") GiB this build allows them. Running with $now, set on the command line."
   CIBUILD_GRADLE_MEMORY_SENTENCE="$CIBUILD_GRADLE_MEMORY_SENTENCE This build ran them capped: $now."
@@ -238,13 +243,19 @@ cibuild_kernel_oom_lines() {
 # $1 Gradle's exit status, $2 a file holding its output. Says so when the
 # failure is a killed daemon rather than a failed build.
 cibuild_gradle_memory_report() {
-  if [ "$1" -ne 137 ] && ! grep -q "daemon disappeared unexpectedly" "$2" 2>/dev/null; then
+  local kotlin_lost=""
+  if grep -q "Connection to the Kotlin daemon has been unexpectedly lost" "$2" 2>/dev/null; then kotlin_lost=1; fi
+  if [ "$1" -ne 137 ] && [ -z "$kotlin_lost" ] && ! grep -q "daemon disappeared unexpectedly" "$2" 2>/dev/null; then
     return 0
   fi
   local oom
   oom=$(cibuild_kernel_oom_lines)
   echo ""
-  echo "Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1)."
+  if [ -n "$kotlin_lost" ]; then
+    echo "Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit $1). Kotlin then compiled without it, in the Gradle daemon's heap."
+  else
+    echo "Gradle memory: a Gradle daemon was killed rather than failing the build (exit $1)."
+  fi
   if [ -n "$oom" ]; then
     echo "The kernel's out-of-memory lines:"
     printf '%s\\n' "$oom" | sed 's/^/    /'

package/dist/src/yaml/steps/gradle-memory.test.js

@@ -50,21 +50,35 @@ describe("cibuild_gradle_memory_plan", () => {
     test("ReFra: -Xmx8G, inherited by the Kotlin daemon, is capped on a 10 GiB machine", () => {
         copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
         const p = plan(TEN_GIB);
-        // 75% of 10 GiB, halved because the Kotlin daemon inherits it. Their own
-        // CI runs 4g.
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -Dfile.encoding=UTF-8"]);
+        // One heap, the whole 75% of 10 GiB, with Kotlin compiled in it: two
+        // daemons did not fit (split 60/40, ReFra's Kotlin daemon was lost
+        // mid-compile, and the fallback ran out of the Gradle daemon's heap).
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
         expect(p.line).toContain("org.gradle.jvmargs=-Xmx8G -Dfile.encoding=UTF-8 at gradle.properties:9");
         expect(p.line).toContain("16.0 GiB");
-        expect(p.line).toContain("-Xmx3840m");
+        expect(p.line).toContain("Running with Gradle -Xmx7680m and Kotlin compiled in-process in it (kotlin.compiler.execution.strategy=in-process: one heap, not a Gradle and a Kotlin daemon), set on the command line.");
         expect(p.sentence).toMatch(/^The build machine has 10\.0 GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
+        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx7680m and Kotlin compiled in-process in it .*\.$/);
     });
-    test("amethyst: both heaps are scaled, and the Kotlin one keeps its other flags", () => {
+    test("ReFra on its 9.7 GiB build guest", () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        expect(plan("9933").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7424m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
+    });
+    test("mifos-mobile on its 6 GiB mac guest gets the one heap too", () => {
+        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx6g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1g\n");
+        expect(plan("6144").args).toEqual([
+            "-Dorg.gradle.jvmargs=-Xmx4608m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1g",
+            "-Pkotlin.compiler.execution.strategy=in-process",
+        ]);
+    });
+    test("the one heap never goes below 512 MiB", () => {
+        writeFileSync(join(dir, "gradle.properties"), "org.gradle.jvmargs=-Xmx4g\n");
+        expect(plan("600").args).toEqual(["-Dorg.gradle.jvmargs=-Xmx512m", "-Pkotlin.compiler.execution.strategy=in-process"]);
+    });
+    test("amethyst: a Kotlin daemon with its own -Xmx is compiled in-process too, in one heap", () => {
         copyFileSync(join(FIXTURES, "amethyst.gradle.properties"), join(dir, "gradle.properties"));
         const p = plan(TEN_GIB);
-        expect(p.args).toEqual([
-            "-Dorg.gradle.jvmargs=-Xmx3264m -Dfile.encoding=UTF-8",
-            "-Pkotlin.daemon.jvmargs=-Xmx4352m -XX:MaxMetaspaceSize=2g",
-        ]);
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
         expect(p.line).toContain("kotlin.daemon.jvmargs=-Xmx8g -XX:MaxMetaspaceSize=2g at gradle.properties:27");
         expect(p.line).toContain("14.0 GiB");
     });
@@ -91,7 +105,7 @@ describe("cibuild_gradle_memory_plan", () => {
         mkdirSync(home);
         writeFileSync(join(home, "gradle.properties"), "org.gradle.jvmargs=-Xmx6g -XX:+UseParallelGC\n");
         const p = plan(TEN_GIB, "", home);
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -XX:+UseParallelGC"]);
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -XX:+UseParallelGC", "-Pkotlin.compiler.execution.strategy=in-process"]);
         expect(p.line).toContain(`at ${home}/gradle.properties:1`);
     });
     test("JVM arguments the pipeline asks for replace the project's, and are still capped", () => {
@@ -100,7 +114,7 @@ describe("cibuild_gradle_memory_plan", () => {
         expect(fits.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8"]);
         expect(fits.line).toContain("as the pipeline asks");
         const capped = plan("4096", "-Xmx4g -Dfile.encoding=UTF-8");
-        expect(capped.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx1536m -Dfile.encoding=UTF-8"]);
+        expect(capped.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3072m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process"]);
         expect(capped.line).toContain("at the pipeline");
     });
     test("a value continued onto another line is left as it is, and says so", () => {
@@ -118,10 +132,7 @@ describe("cibuild_gradle_memory_plan", () => {
     test("-Xmx in every unit, and a comment is not an assignment", () => {
         writeFileSync(join(dir, "gradle.properties"), "# org.gradle.jvmargs=-Xmx64g\norg.gradle.jvmargs = -Xms1g -Xmx6144m\nkotlin.daemon.jvmargs:-Xmx4194304k\n");
         const p = plan("8192");
-        expect(p.args).toEqual([
-            "-Dorg.gradle.jvmargs=-Xms1g -Xmx3648m",
-            "-Pkotlin.daemon.jvmargs=-Xmx2432m",
-        ]);
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xms1g -Xmx6144m", "-Pkotlin.compiler.execution.strategy=in-process"]);
     });
 });
 /** The plan, then the workers plan, as the step runs them. */
@@ -150,9 +161,9 @@ describe("cibuild_gradle_workers_plan", () => {
     test("ReFra: the worker count goes after the heap cap, and the sentence names it", () => {
         copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
         const p = workersPlan(TEN_GIB, "2");
-        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx3840m -Dfile.encoding=UTF-8", "--max-workers=2"]);
+        expect(p.args).toEqual(["-Dorg.gradle.jvmargs=-Xmx7680m -Dfile.encoding=UTF-8", "-Pkotlin.compiler.execution.strategy=in-process", "--max-workers=2"]);
         expect(p.line).toBe("Gradle memory: running with --max-workers=2, as the pipeline asks (set on the command line, over any org.gradle.workers.max).");
-        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx3840m, .* Gradle ran with --max-workers=2\.$/);
+        expect(p.sentence).toMatch(/This build ran them capped: Gradle -Xmx7680m and Kotlin compiled in-process in it .* Gradle ran with --max-workers=2\.$/);
     });
     test("heaps that fit still get the worker count", () => {
         const p = workersPlan(TEN_GIB, "4");
@@ -204,6 +215,17 @@ describe("the Gradle steps", () => {
         expect(run.stdout).toMatch(/The build machine has [0-9.]+ GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
         expect(run.stdout).not.toContain("Gradle build completed successfully");
     });
+    test("a lost Kotlin daemon is named like a killed Gradle daemon", async () => {
+        copyFileSync(join(FIXTURES, "refra.gradle.properties"), join(dir, "gradle.properties"));
+        // ReFra, bld_bd0132cc5229acb16c54130f: KGP's words, then its fallback.
+        fakeGradlew('echo "e: Daemon compilation failed"\necho "org.jetbrains.kotlin.gradle.tasks.DaemonCrashedException: Connection to the Kotlin daemon has been unexpectedly lost. This might be caused by the daemon being killed by another process or the operating system, or by JVM crash."\necho "Using fallback strategy: Compile without Kotlin daemon"\nexit 1');
+        const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);
+        const run = runStep(step.script, fakeBin(OOM_LINE));
+        expect(run.status).toBe(1);
+        expect(run.stdout).toContain("Gradle memory: the Kotlin daemon was lost mid-compile rather than the build failing (exit 1). Kotlin then compiled without it, in the Gradle daemon's heap.");
+        expect(run.stdout).toContain(`    ${OOM_LINE}`);
+        expect(run.stdout).toMatch(/The build machine has [0-9.]+ GiB; this build's Gradle and Kotlin daemons asked for 16\.0 GiB/);
+    });
     test("an ordinary failure says nothing about memory", async () => {
         fakeGradlew('echo "Compilation error"\nexit 1');
         const step = await new GradleBuildStepExecutor().execute({ gradle_task: "assembleDebug" }, {}, testConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invarn/cibuild",
-  "version": "2.8.9",
+  "version": "2.9.1",
   "description": "CI Build CLI — local pipeline orchestration and validation",
   "type": "module",
   "main": "dist/cli.cjs",