Remove quadratic remainder copying from code-point/octet slicing in both realizations (skip/take/get/count to their contracts; Value drop no longer walks a shared slice; cost controls enrolled)

.github/workflows/witnesses.yml

@@ -858,6 +858,31 @@ jobs:
           if (! '[' '-f' "$GUNBC_FLOOR_RECEIPT" ']') || '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' || ('[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT"))) || ('[' "$GUNBC_FLOOR_CLASS" '=' 'none' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT")) && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=infra' "$GUNBC_FLOOR_RECEIPT"))); then 'printf' 'class=%s\nsignature=%s\nexit=%s\n' "$GUNBC_FLOOR_CLASS" "$GUNBC_FLOOR_SIGNATURE" "$GUNBC_FLOOR_EXIT" > "$GUNBC_FLOOR_RECEIPT"; if '[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']'; then 'echo' '::error title=environment::floor_class='"$GUNBC_FLOOR_CLASS"' signature='"$GUNBC_FLOOR_SIGNATURE"' exit='"$GUNBC_FLOOR_EXIT"'; this is not a verdict about the diff. Attempt receipt: '"$GUNBC_FLOOR_RECEIPT"; fi; if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']'; then 'echo' '::error title=subject::floor_class='"$GUNBC_FLOOR_CLASS"' exit='"$GUNBC_FLOOR_EXIT"'; read the step log for the subject defect'; fi; fi
           'exit' "$GUNBC_FLOOR_EXIT"
 
+        if: "!cancelled()"
+      - name: Run the slice cost controls
+        id: slice_cost_controls
+        run: |+
+          GUNBC_FLOOR_LOG='gunbc-floor-cmd.log'
+          'set' '+e'
+          'set' '-o' 'pipefail'
+          ('sh' '-e' '-c' 'cargo test --release -p v1-stage0-runtime --lib -- list_slice_tests') 2>&1 | 'tee' "$GUNBC_FLOOR_LOG"
+          GUNBC_FLOOR_EXIT="$?"
+          GUNBC_FLOOR_RECEIPT='gunbc-floor-outcome.txt'
+          GUNBC_FLOOR_CLASS='structural'
+          GUNBC_FLOOR_SIGNATURE=''
+          if '[' "$GUNBC_FLOOR_EXIT" '-eq' '126' ']'; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='CommandInvokedCannotExecute'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' "$GUNBC_FLOOR_EXIT" '-eq' '127' ']'; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='CommandNotFound'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' "$GUNBC_FLOOR_EXIT" '-eq' '0' ']'; then GUNBC_FLOOR_CLASS='none'; GUNBC_FLOOR_SIGNATURE=''; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'MemoryStallRefusedPageThrash' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='MemoryStallRefusedPageThrash'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'The runner has received a shutdown signal' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='RunnerLost'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'sccache: error: failed to execute compile' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheFailedToExecuteCompile'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' '(exit status: 254)' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheRustcWrapperExit254'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'sccache: encountered fatal error' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='SccacheFatalError'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'failed to spawn' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='ProcessSpawnFailure'; fi
+          if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' && '[' '-f' "$GUNBC_FLOOR_LOG" ']' && 'grep' '-q' 'Resource temporarily unavailable' "$GUNBC_FLOOR_LOG"; then GUNBC_FLOOR_CLASS='infra'; GUNBC_FLOOR_SIGNATURE='ResourceTemporarilyUnavailable'; fi
+          if (! '[' '-f' "$GUNBC_FLOOR_RECEIPT" ']') || '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']' || ('[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT"))) || ('[' "$GUNBC_FLOOR_CLASS" '=' 'none' ']' && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=structural' "$GUNBC_FLOOR_RECEIPT")) && (! ('[' '-f' "$GUNBC_FLOOR_RECEIPT" ']' && 'grep' '-q' 'class=infra' "$GUNBC_FLOOR_RECEIPT"))); then 'printf' 'class=%s\nsignature=%s\nexit=%s\n' "$GUNBC_FLOOR_CLASS" "$GUNBC_FLOOR_SIGNATURE" "$GUNBC_FLOOR_EXIT" > "$GUNBC_FLOOR_RECEIPT"; if '[' "$GUNBC_FLOOR_CLASS" '=' 'infra' ']'; then 'echo' '::error title=environment::floor_class='"$GUNBC_FLOOR_CLASS"' signature='"$GUNBC_FLOOR_SIGNATURE"' exit='"$GUNBC_FLOOR_EXIT"'; this is not a verdict about the diff. Attempt receipt: '"$GUNBC_FLOOR_RECEIPT"; fi; if '[' "$GUNBC_FLOOR_CLASS" '=' 'structural' ']'; then 'echo' '::error title=subject::floor_class='"$GUNBC_FLOOR_CLASS"' exit='"$GUNBC_FLOOR_EXIT"'; read the step log for the subject defect'; fi; fi
+          'exit' "$GUNBC_FLOOR_EXIT"
+
         if: "!cancelled()"
       - name: "Stage0 mirrors match one emission by this seed: required CI build lane"
         id: stage0_regen

dag/extdeps/languages/rust/emit.dag

@@ -76,8 +76,8 @@ data rust_simple_method_specs: List<SimpleMethodSpec> = [
   { method_name: "first",     template: "\{recv\}.first().cloned()",                                                                   wraps_result: false },
   { method_name: "enumerate", template: "\{recv\}.iter().cloned().enumerate().map(|(i, v)| (i as i64, v)).collect::<Vec<_>>()",         wraps_result: true },
   { method_name: "chars",     template: "\{recv\}.chars().map(|c| c as i64).collect::<Vec<_>>()",                                      wraps_result: true },
-  { method_name: "skip",      template: "\{recv\}.iter().cloned().skip(\{arg\} as usize).collect::<Vec<_>>()",                         wraps_result: true },
-  { method_name: "take",      template: "\{recv\}.iter().cloned().take(\{arg\} as usize).collect::<Vec<_>>()",                         wraps_result: true },
+  { method_name: "skip",      template: "v1_rt::list_skip(&\{recv\}, \{arg\})",                                                       wraps_result: true },
+  { method_name: "take",      template: "v1_rt::list_take(&\{recv\}, \{arg\})",                                                       wraps_result: true },
   { method_name: "is_empty",  template: "\{recv\}.is_empty()",                                                                       wraps_result: false }
 ]
 

dag/gunbc/repo/repo_self_build.dag

@@ -107,6 +107,30 @@ fn repo_self_test_command() -> String {
   )
 }
 
+// A NAMED SUBSET OF ONE PACKAGE'S UNIT TESTS, for a control in a package the whole-package run above
+// does not cover: the blocking rust-unit-tests lane runs repo_self_test_command, which is
+// v1-compiler only.
+// The filters are libtest's substring filters after `--`; an empty list would run the whole
+// package, which is repo_self_test_command's request and not this one.
+fn repo_self_targeted_test_command(package: String, filters: List<String>) -> String {
+  join(concat(["cargo test", repo_self_build_profile_flag, "-p", package, "--lib", "--"], filters), " ")
+}
+
+// The crate the emitted runtime v1_rt.rs is compiled in (the stage0 partition's foundation crate).
+data repo_self_runtime_package: String = "v1-stage0-runtime"
+
+// THE EMITTED RUNTIME'S SLICE COST CONTROLS, ENROLLED. v1_rt list_slice_tests carries a RED that runs
+// the copying skip / take templates the emit table used to render and a GREEN that runs
+// list_skip / list_take, on non-ASCII code points, so the pair discriminates the quadratic rather
+// than merely exercising the slice. Only this crate is named: the interpreter's slice and drop
+// controls (v1_interpreter slice_cost_tests, value_depth_walker_tests) are in v1-compiler's own
+// unit tests, which the blocking rust-unit-tests lane already runs whole (repo_self_test_command),
+// and running them again here would be the same work twice. v1-stage0-runtime is outside that
+// lane's package, so without this step its controls would only compile.
+fn repo_self_slice_cost_control_command() -> String {
+  repo_self_targeted_test_command(package: repo_self_runtime_package, filters: ["list_slice_tests"])
+}
+
 // THE LINT PASS OVER EVERY TARGET, as the one invocation DESIGN's "Building & checks" names.
 // `--all-targets` is the whole point: the test and example targets outside `--lib` and `--bins`
 // are compiled by no build command above and executed by no test command, so before this row

dag/gunbc/witness/compiler_gate_workflow.dag

@@ -166,7 +166,7 @@ import gunbc.fleet_release_bins_key {
   release_bins_pack_object_script, release_bins_pack_object_path_expression,
   compiler_pair_candidate_artifact_name, compiler_pair_candidate_retention_whole_days,
 }
-import gunbc.repo_self_build { repo_self_build_command, repo_self_clippy_command, repo_self_test_command }
+import gunbc.repo_self_build { repo_self_build_command, repo_self_clippy_command, repo_self_test_command, repo_self_slice_cost_control_command }
 import extdeps.exec.command { shell_command_render }
 import extdeps.github.expressions { interpolate, ContextAccess, Needs, Github, Expression, default_expression_spellings }
 import extdeps.github.log_annotations { emit_line_shell }
@@ -270,6 +270,28 @@ fn compiler_gate_hosted_build_prelude_bound_steps() -> List<CompilerGateBoundSte
 data compiler_gate_clippy_step_name: String = "Lint every target"
 data compiler_gate_lint_step_id: String = "lint_all_targets"
 
+// THE EMITTED RUNTIME'S SLICE COST CONTROLS RUN HERE, beside the lint and under the same status
+// guard, because the blocking unit-test lane runs v1-compiler only and the runtime crate's controls
+// would otherwise only compile: specification without execution (DESIGN section 5). It is a step on
+// an existing job, not a job: the roster is closed to growth. Its subject and its RED / GREEN pair
+// are gunbc.repo_self_build repo_self_slice_cost_control_command's to state.
+data compiler_gate_slice_cost_step_name: String = "Run the slice cost controls"
+data compiler_gate_slice_cost_step_id: String = "slice_cost_controls"
+
+fn compiler_gate_slice_cost_step() -> Step {
+  RunStep {
+    name: Present { value: compiler_gate_slice_cost_step_name },
+    id: Present { value: compiler_gate_slice_cost_step_id },
+    run: concat(wrap_command_with_floor_attempt_receipt(command: repo_self_slice_cost_control_command()), "\n"),
+    shell: none,
+    env: none,
+    working_directory: none,
+    if_condition: Present { value: witness_step_status_guard_expression() },
+    continue_on_error: none,
+    timeout_minutes: none
+  }
+}
+
 fn compiler_gate_lint_step() -> Step {
   RunStep {
     name: Present { value: compiler_gate_clippy_step_name },
@@ -856,6 +878,11 @@ fn compiler_gate_generated_bound_steps() -> List<CompilerGateBoundStep> {
       role: consumes_only(capabilities: [CargoCapability]),
       step_name: compiler_gate_clippy_step_name,
     },
+    CompilerGateBoundStep {
+      step: compiler_gate_slice_cost_step(),
+      role: consumes_only(capabilities: [CargoCapability]),
+      step_name: compiler_gate_slice_cost_step_name,
+    },
     CompilerGateBoundStep {
       step: compiler_gate_stage0_regen_step(),
       role: consumes_only(capabilities: [RustfmtCapability]),
@@ -923,6 +950,7 @@ fn compiler_gate_floor_scripts_are_renderable() -> Bool {
   wrap_command_is_renderable(command: witness_floor_run_script())
     && wrap_command_is_renderable(command: build_lane_run_script())
     && wrap_command_is_renderable(command: repo_self_clippy_command())
+    && wrap_command_is_renderable(command: repo_self_slice_cost_control_command())
     && wrap_command_is_renderable(command: repo_self_build_command(bins: witness_floor_required_bins))
     && required_ci_measurement_scripts_are_renderable()
 }

dag/std/primitives.dag

@@ -409,12 +409,31 @@ data append_contract: PrimitiveContract = {
   carrier_cost: CarrierSensitive { ephemeral_work: "n + m", persistent_work: "log(n + m)" }
 }
 
+// SKIP AND TAKE ARE THE SLICE, AND ON THE PERSISTENT CARRIER THEY SHARE THE RECEIVER'S TREE. A walk
+// that reads a code-point or octet list by offset slices it as `xs |> skip(n: a) |> take(n: b - a)`;
+// when either half copied its result, each slice paid the remainder and the walk was quadratic in
+// the list (DESIGN section 6, bare minimum cost). Both realizations hold the list as an RRB vector
+// (the interpreter's Value::List, v1_rt's im::Vector), whose split is logarithmic, so the slice
+// costs log len to form and only its own length to read. That removes the quadratic remainder
+// copying; it does not make an offset walk linear, since every member read is get_contract's
+// log n on this carrier, so a walk that reads each offset is O(n log n).
+//
+// THE COUNT IS CLAMPED, AND A NEGATIVE COUNT IS THE WHOLE LIST. Both realizations take
+// k = if n < 0 then len else min(n, len): skip keeps len - k members and take keeps k.
 data skip_contract: PrimitiveContract = {
   name: "skip",
-  work: "n",
-  output_size: "max(0, len - n)",
+  work: "log len",
+  output_size: "len - k where k = if n < 0 then len else min(n, len)",
   certainty: Proven,
-  carrier_cost: CarrierInsensitive
+  carrier_cost: CarrierSensitive { ephemeral_work: "len - k where k = if n < 0 then len else min(n, len)", persistent_work: "log len" }
+}
+
+data take_contract: PrimitiveContract = {
+  name: "take",
+  work: "log len",
+  output_size: "k where k = if n < 0 then len else min(n, len)",
+  certainty: Proven,
+  carrier_cost: CarrierSensitive { ephemeral_work: "k where k = if n < 0 then len else min(n, len)", persistent_work: "log len" }
 }
 
 data zip_contract: PrimitiveContract = {
@@ -791,6 +810,7 @@ fn primitive_contract_roster() -> List<PrimitiveContract> {
     list_push_contract,
     append_contract,
     skip_contract,
+    take_contract,
     zip_contract,
     enumerate_contract,
     empty_map_contract,

dag/test/claim/code_point_slice_witness_test.dag

@@ -0,0 +1,94 @@
+module test.claim.code_point_slice_witness
+
+import std.algebra { Cons }
+import std.coercion { unicode_scalar_unfold, unicode_scalar_fold }
+import v2.std.live_tree { LiveTreeDisposition, SubstrateInputsOnly }
+
+data live_tree_disposition: LiveTreeDisposition = SubstrateInputsOnly
+
+// A BODY READ BY OFFSET, THROUGH THE CODE-POINT SLICE. The text is unfolded to its code points
+// once; every later read is one member (`get`), the length (`count`) or a bounded slice
+// (`skip` then `take`) folded back to host text. std.primitives get_contract, count_contract,
+// skip_contract and take_contract price each of those at log len or better on the persistent
+// carrier, so the walk is O(n log n) in the body on every input -- the remainder copying that made
+// it quadratic is gone. Host-text char_at / substring are O(offset) per read on non-ASCII text in
+// the interpreter and on all text in emitted Rust, which is the quadratic this surface avoids.
+// The bodies here are non-ASCII on purpose: that is the input the host-text walk is quadratic on.
+//
+// The wire shape is the length-prefixed field `<decimal count>:<that many code points>`, repeated.
+type CodePointField {
+  value: String
+  next: Int
+}
+
+fn cps_find(cps: List<Int>, at: Int, stop: Int) -> Int? {
+  match get(xs: cps, index: at) {
+    Absent => none
+    Present { value: c } => if c == stop { Present { value: at } } else { cps_find(cps: cps, at: at + 1, stop: stop) }
+  }
+}
+
+fn cps_slice_text(cps: List<Int>, start: Int, end: Int) -> String {
+  unicode_scalar_fold(xs: cps |> skip(n: start) |> take(n: end - start))
+}
+
+fn cps_field(cps: List<Int>, at: Int) -> CodePointField? {
+  match cps_find(cps: cps, at: at, stop: code_point(c: ":")) {
+    Absent => none
+    Present { value: colon } =>
+      match parse_int(s: cps_slice_text(cps: cps, start: at, end: colon)) {
+        Absent => none
+        Present { value: n } =>
+          if n < 0 || colon + 1 + n > count(cps) {
+            none
+          } else {
+            Present { value: CodePointField { value: cps_slice_text(cps: cps, start: colon + 1, end: colon + 1 + n), next: colon + 1 + n } }
+          }
+      }
+  }
+}
+
+fn cps_fields(cps: List<Int>, at: Int, acc: List<String>) -> List<String>? {
+  if at == count(cps) {
+    Present { value: reverse(acc) }
+  } else {
+    match cps_field(cps: cps, at: at) {
+      Absent => none
+      Present { value: f } => cps_fields(cps: cps, at: f.next, acc: Cons { head: f.value, tail: acc })
+    }
+  }
+}
+
+fn decode_fields(body: String) -> List<String>? {
+  cps_fields(cps: unicode_scalar_unfold(s: body), at: 0, acc: [])
+}
+
+// The body doubled `times` times: linear to build, so the measured walk is the only quadratic
+// candidate in the claim.
+fn doubled(s: String, times: Int) -> String {
+  if times <= 0 { s } else { doubled(s: concat(s, s), times: times - 1) }
+}
+
+// POSITIVE CONTROL: the slice reads the right code points, including astral ones (one code point,
+// four UTF-8 bytes) and a field whose length prefix is two digits.
+test fn code_point_slice_decodes_non_ascii_fields() -> Bool {
+  decode_fields(body: "2:\u{e9}\u{4e2d}3:\u{1f600}ab0:12:\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}") == Present { value: ["\u{e9}\u{4e2d}", "\u{1f600}ab", "", "\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}\u{e9}"] }
+}
+
+// A length prefix that runs past the body is refused, not truncated.
+test fn code_point_slice_refuses_an_overlong_field() -> Bool {
+  decode_fields(body: "4:\u{e9}\u{4e2d}") == none
+}
+
+// THE WALK OVER MANY FIELDS: 512 non-ASCII fields, 3,072 code points, sized under the floor's
+// new-witness eval-step budget (v2.workflow.required_floor). This claim's subject is that the
+// decode stays correct field after field; the COST of the walk is not measured here, because eval
+// steps cannot see a host-level copy. The cost controls that can, RED on the copying forms and
+// GREEN on the sharing ones, are gunbc.repo_self_build repo_self_slice_cost_control_command, run on
+// the merge path by the generated job's slice cost step.
+test fn code_point_slice_walk_is_correct_at_scale() -> Bool {
+  match decode_fields(body: doubled(s: "3:\u{e9}\u{4e2d}\u{1f600}", times: 9)) {
+    Absent => false
+    Present { value: fs } => count(fs) == 512 && fs |> all(f => f == "\u{e9}\u{4e2d}\u{1f600}")
+  }
+}

src/v1/05_emit_rust.dag

@@ -13565,7 +13565,7 @@ fn emit_rust_first_method_call(receiver: Node, registry: Map<String, ItemInfo>,
         let skip_args = method_arg_nodes(texpr: receiver)
         let recv_str = emit_typed_expr(texpr: skip_recv, registry: registry, scope: scope, depth: depth, shared_types: shared_types, emit_info: emit_info, fuel: 1024)
         let n_str = emit_typed_first_arg(args: skip_args, registry: registry, scope: scope, depth: depth, shared_types: shared_types, emit_info: emit_info)
-        concat(recv_str, ".iter().cloned().skip(", n_str, " as usize).next()")
+        concat(recv_str, ".get((", n_str, ") as usize).cloned()")
       } else {
         let recv_str = emit_typed_expr(texpr: receiver, registry: registry, scope: scope, depth: depth, shared_types: shared_types, emit_info: emit_info, fuel: 1024)
         concat(recv_str, ".first().cloned()")