FLOGO-18450: Concurrent execution of parallel transition branches

[awakchau-tibco]

What

Adds opt-in concurrent execution of activities on parallel transition branches (fan-out) in the flow action. Branches modeled as parallel now run at the same time instead of one activity being processed at a time.

Why

The flow drains work sequentially, so independent branches were serialized — total latency equaled the sum of branch times. Concurrent execution reduces this to roughly the slowest branch, especially impactful for I/O-bound branches (delay / REST / DB).

Design & safety

• Gated behind the existing FLOGO_FLOW_CONCURRENT_TASK_EXECUTION env flag (default off). When off, the sequential DoStep loop is byte-for-byte unchanged, so no existing flow regresses unless explicitly opted in.
• When on, FlowAction.Run drives a new IndependentInstance.RunConcurrent worker pool (min(GOMAXPROCS, 32) workers) that runs ready tasks concurrently while preserving join semantics (a task runs only after all its incoming links resolve) and order-independent results.
• support/env.go: GetConcurrentExecution(); instance/util.go IsConcurrentTaskExcutionEnabled delegates to it (one source of truth, shared with the change-tracker lock).
• Two-lock design on IndependentInstance: coarse stateLock (traversal/scheduling, taskInsts/linkInsts/subflows) + attrsLock RWMutex (shared scope + returnData), both nil in sequential mode. Lock order: stateLock -> changeTracker -> attrsLock.
• stepID / wiCounter / subflowCtr promoted to atomics.
• Per-task cancellable context (TaskInst.evalCtx) so context-aware activities abort on sibling failure.
• Drain-then-fail: the first unhandled branch error cancels siblings, the pool waits for in-flight branches to return, then the global error handler fires once.
• execTask and the new execTaskConcurrent share extracted evalTaskBehavior + handleEvalResult helpers (removes duplication).

Testing

• Unit + integration tests (parallelism, join-fires-once, drain-then-fail, sequential parity), ~87% coverage of the new code; clean under go test -race.
• Fixed pre-existing map-order-flaky TestGetErrorObject_* (def.Tasks()[0] -> def.GetTask("LogStart")).

Performance

• Benchmarks + a when-to-enable guide in instance/PARALLEL_BENCHMARKS.md. Crossover ≈ 50–100 µs of work per branch; recommend enabling only for 2+ branches each doing blocking I/O or ≳ ~100 µs of CPU.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Adds an opt-in concurrent scheduler for flow execution so parallel transition (fan-out) branches can run simultaneously, reducing end-to-end latency for independent branches while aiming to preserve join semantics.

Changes:

• Introduces a concurrent worker-pool drain path (IndependentInstance.RunConcurrent) and wires it into FlowAction.Run behind an env flag.
• Adds concurrency safety mechanisms (per-instance locks, atomic counters, per-task cancellable context) and refactors shared task-eval helpers.
• Adds unit/integration tests and benchmarks covering concurrency behavior, join behavior, cancellation on failure, and parity checks.

Reviewed changes

Copilot reviewed 12 out of 12 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
support/env.go	Adds env-flag helper for enabling concurrent branch execution.
support/env_test.go	Adds unit tests for the new env-flag helper.
instance/util.go	Switches concurrency-flag reading to the shared support helper.
instance/taskinst.go	Adds per-task context override to support sibling-cancellation in concurrent mode.
instance/taskinst_test.go	Fixes flakiness by selecting tasks by ID rather than map/array order.
instance/parallel_test.go	Adds white-box unit tests for concurrency locks, latching, helpers, and atomic counters.
instance/parallel_integration_test.go	Adds black-box integration tests exercising RunConcurrent end-to-end.
instance/parallel_bench_test.go	Adds benchmarks comparing sequential vs concurrent execution overhead and gains.
instance/instance.go	Adds locking around shared attrs/return data for concurrent safety.
instance/instance_ser.go	Updates subflow counter handling to use atomic storage.
instance/ind_instance.go	Implements the concurrent worker-pool scheduler and concurrency coordination fields/locks.
action.go	Wires concurrent execution into the flow action run loop and logs when enabled.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.