8000 Improving on SplitStr by kenhkan · Pull Request #47 · noflo/noflo · GitHub
[go: up one dir, main page]

Skip to content

Improving on SplitStr - #47

Merged
bergie merged 2 commits into
noflo:masterfrom
kenhkan:splitstr
Nov 2, 2012
Merged

bergie merged 2 commits into
noflo:masterfrom
kenhkan:splitstr

Conversation

@kenhkan
@kenhkan kenhkan commented Oct 26, 2012
Copy link
Copy Markdown
Contributor
  • Added group forwarding
  • Fixed multiple IPs string-jamming issue

bergie added a commit that referenced this pull request Nov 2, 2012
@bergie
bergie merged commit 5825f09 into noflo:master Nov 2, 2012
AsherBond pushed a commit to AsherBond/noflo that referenced this pull request Oct 12, 2026
AsherBond pushed a commit to AsherBond/noflo that referenced this pull request Oct 14, 2026
Add a component for converting regular IPs into Assembly messages
bergie added a commit that referenced this pull request Oct 17, 2026
The firing model follows work document #47 and delivers the semantics
trustmaster (Vladimir Sibirov, the Process API's originator)
articulated in the #607 discussion, agreed with the
maintainer: an arrival on any port re-fires the process once per scope
that holds unprocessed input on any port, with the arriving IP —
stamped to the firing scope — as the activation's context.

- handleIP routes all non-forwarding arrivals through the per-scope
  walk. The firing predicate is any buffered IP in the scope — data
  and brackets both, since a closeBracket completing a hasStream wait
  is a firing edge and openBracket arrivals engage auto-ordering.
  Forwarding inports are exempt (their brackets are owned by the
  forwarding machinery). Control ports lose their firing role
  entirely: their buffers are standing state — the walk skips them,
  so a control arrival with nothing pending buffers silently.
  Addressable and IIP buffers join the walk's scan (the IIP buffer
  was previously invisible to the walk, and addressable pending work
  was never re-offered).
- The 1.x triggering port option is accepted and ignored during the
  alpha window (removed from the accepted set at 2.0.0). A port
  declaring it behaves identically to one that does not.
- The #607 fixtures rewritten to the component-declares-pattern shape:
  the firing pattern lives in the has-checks; the engine's job is the
  wakeup. Assertions are observable (what was consumed and produced),
  not engine internals (which ports fired).

The determinism contract is pinned by spec/FiringModel.js: every
permutation of multi-port arrival orders (scoped and unscoped, spread
across edges) produces identical outputs and final state. The matrix
earned its keep immediately, catching three genuine defects on its
first run:

- the control-port hasStream wrapper destroyed the bracket-stack walk,
  so a control stream's completeness gate fired on any partially open
  stream — the corpus-gate-early shape behind the jekyll footer race;
  hasStream now takes the framing-aware check on control ports while
  plain has() keeps the data-presence semantics
- the multi-value-config scenario's completion semantics: values
  arriving after a stream's close do not join an already-fired
  activation
- two read-then-decline deadlocks in the matrix's own scenario code
  (gate on everything before any consuming read)
bergie added a commit that referenced this pull request Oct 17, 2026
- The determinism test's load assertion was vacuous (InternalSocket has
  no component property): wire() returns the component and the
  assertion reads it directly
- The framing state is per walk: ProcessInput.hasStream builds the
  bracket-walk validator through a factory, and InPort.hasStream walks
  each buffer (regular, IIP) with fresh state — a partially open
  regular stream no longer poisons the IIP-buffer check
- The forwarding-inport exemption stays intentional (the forwarding
  machinery owns the brackets and the scenario-C interaction), now
  documented in the one-rule statement; the matrix's non-coverage is
  noted in work document #47
- ExtractField guards a non-object message envelope with a kind error
  instead of a framework TypeError
- A debug warning for stream-completeness gating on addressable control
  ports (the data-presence path cannot see the framing)
- CHANGELOG: Changed before Fixed; the one-rule statement precise about
  control buffers and the forwarding exemption; triggering is removed,
  not deprecated-ignored
- Migration guide: the jammed reference unwound, the one-rule sentence
  precise
bergie added a commit that referenced this pull request Oct 17, 2026
bergie added a commit that referenced this pull request Oct 18, 2026
…the buffers' remaining work

The fanout clone-drop verification (the un-skipped two shapes) revealed
the deadlock's precise mechanism — and it was never a clone-drop. The
probe showed: every collector firing before the late-arriving standing
config declined on the missing precondition; the config's arrival fired
exactly ONE round (consuming one pair); and the remaining buffered pairs
stranded — no arrival ever comes to wake them. The has-first
decline-and-wait model has an incomplete wakeup: arrivals wake, but an
activation that CONSUMED input leaves buffered work that nothing wakes.

The fix is the firing model's own guarantee (#47: every state change that
could satisfy a precondition causes an evaluation) applied to its natural
completion: a consumption IS a state change. The drain pump: when an
activation that consumed input deactivates, one scheduled offer fires the
process for every scope still holding deliverable input. Scheduled (not
recursive), so a multi-pair drain chains through macrotasks without stack
depth; each offer either consumes (progress) or declines (the buffers
unchanged, no further offer) — the pump terminates with the buffers. The
ready-scope walk is shared with the arrival walk (handleIP), deduped per
scope, and the pump's offer is guarded by the closedown state and the
in-flight load.

- ProcessContext gains the consumed counter; ProcessInput.get increments
  it on ownership-moving reads (control reads are non-consuming and do
  not count)
- The two clone-drop tests un-skipped and passing: the unscoped
  sequential flow drains all pairs (the collector's pairing crossover
  under reversed async inner delivery is the documented
  parallel-positional-streams contract, pinned by the test's scope
  variant); the scoped interleaved flow pairs per scope correctly — the
  fixture's encoding port needed the standing-config idiom
  (scoped: false), not an engine change
- The bare-class loader finding: fixed — createComponent constructs
  bare classes with new (detected by prototype.constructor identity and
  the class source prefix), while factory functions keep the plain-call
  contract; the registered-factory behavior is unchanged
- The wrapAssembly subgraph capability stays open (the sync registry
  contract vs the async graph-instance harvesting needs its own design
  pass) — the verification spec pins the gap's current observable

The #35 update-#6 sidestep note (bracket-strip before wrapped adapters)
can be revisited: the correlation now works
AsherBond pushed a commit to AsherBond/noflo that referenced this pull request Oct 19, 2026
…closed-stream strand pin, and the spread-timing matrix

- The IIP-buffer check in plain has() could be poisoned by a partially
  open regular stream: the validator traveled as a bare callback, so
  the bracket-walk state built during the regular-buffer walk carried
  into the IIP-buffer walk — an IIP-fed standing value beside an
  unfinished stream read as being inside brackets. The validator now
  travels as a factory through the whole has() chain (ProcessInput.has,
  hasStream, InPort.has), and every buffer walk gets fresh framing
  state. hasStream's non-control path calls InPort.has directly with
  its factory — the per-walk item from the follow-up ledger is closed
  for the control and non-control paths alike
- The strand pin: a stream left unclosed (the sender disconnects with
  the open bracket outstanding) strands its framing, and the port's
  terminal disconnect reports it. The test documents the discovery that
  a close-before-open never reaches the buffer at all — the Edge's
  bracket-integrity validation rejects it at the sender, so the
  malformed-order class is already handled upstream of the strand
  diagnostics
- The spread-timing matrix variant: arrivals across macrotask gaps
  produce the same result as back-to-back posting — the shape that
  makes async components tractable
- The per-arrival O(pending scopes) cost stays a noted trade-off of the
  wakeup-completeness model (recorded in work document noflo#47), closing
  the last ledger item without code
AsherBond pushed a commit to AsherBond/noflo that referenced this pull request Oct 19, 2026
…ent engine

Substantial engine work has landed since the document's open items were
written (the firing model noflo#47, the scoped liveness noflo#45, bounded edges
noflo#38, the deterministic closing noflo#45/noflo#46) — this verification pass checks
whether each is still open, against the current engine:

- The two skipped fanout-clone-drop tests un-skipped and run: BOTH
  SHAPES STILL HANG at their timeout — the sequential multi-message
  clone-drop is real and current. Re-skipped with the fresh evidence;
  the buffer-lifecycle fix remains the document's central open item
- The adapter bracket correlation: VERIFIED WORKING — the spec pins the
  end-to-end shape the jekyll pipeline sidestepped (concurrent scoped
  messages with bracketed inner streams pair per message, and the
  closedown completes on the boundary disconnect). The 'cleaner end
  state' gap from work document noflo#35 update noflo#6 is closed by the engine
  work; this spec is now the green pin, not a gap report
- The bare-class loader finding: verified still open — the registered
  bare class throws 'cannot be invoked without new' (the message names
  the class); the spec pins the current behavior for the fix to flip
- The wrapAssembly subgraph capability: verified still open — a graph
  definition skips with asAssembly's rejection (the observable reason
  the capability gap carries today)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants

0