Rework call site identification

[rostan-t]

Category:

Refactoring (Redesign of existing code that doesn't affect functionality)

Description:

Call site identification for stack trace doctoring in dynamic mode is currently performed with hardcoded values to skip dynamic mode's internal plumbing. Although tested, this is brittle and can break easily when the code changes.

This PR removes the hardcoded values and replaces it by marking internal frames "transparent". Identification is then performed by walking up the stack trace, skipping transparent frames. Even if this is done for all calls to DALI functions, the overhead should be small as there are typically not more than 6 frames to walk up.

Additional information:

Affected modules and functionalities:

Key points relevant for the review:

Tests:

• Existing tests apply
  • test_exceptions.py: *
• New tests added
  • Python tests
  • GTests
  • Benchmark
  • Other
• N/A

Checklist

Documentation

• Existing documentation applies
• Documentation updated
  • Docstring
  • Doxygen
  • RST
  • Jupyter
  • Other
• N/A

DALI team only

Requirements

• Implements new requirements
• Affects existing requirements
• N/A

REQ IDs: N/A

JIRA TASK: N/A

[greptile-apps]

Greptile Summary

This PR replaces the hardcoded frame-skip depth used for call-site identification in dynamic mode with a cleaner mark_transparent / resolve_callsite_frame mechanism. Internal plumbing wrappers (call, fn_call, batch_to_tensor, tensor, as_tensor, and their makefun/NVTXRange wrappers) are all marked transparent so stack-walking correctly lands on the user's frame. A follow-up commit removes the now-dead capture_stack helper and a third commit adds a guard to skip frame capture in synchronous eval modes where no async scheduling occurs.

Confidence Score: 5/5

Safe to merge; the refactoring is correct and all remaining findings are P2 style suggestions.

The core transparent-frame logic is sound: mark_transparent correctly follows wrapped chains, resolve_callsite_frame reliably walks past all internal wrappers, and the Invocation assertion in schedule() is safe because _call_stack is always populated when EvalMode is eager. The only P2 finding is a minor performance inconsistency in _batch2tensor.py (missing the same EvalMode guard that _op_builder.py already applies).

_batch2tensor.py — minor EvalMode guard omission; no correctness impact.

Important Files Changed

Filename	Overview
dali/python/nvidia/dali/experimental/dynamic/_callsite.py	New module introducing mark_transparent / resolve_callsite_frame / capture_stack_from_frame utilities; cleanly follows wrapped chains.
dali/python/nvidia/dali/experimental/dynamic/_exceptions.py	Dead capture_stack removed per earlier review; no remaining callers, clean change.
dali/python/nvidia/dali/experimental/dynamic/_invocation.py	Now accepts caller_frame directly; captures call stack only in deferred/eager modes (value ≤ eager) where it is actually needed; assertion in schedule() is safe.
dali/python/nvidia/dali/experimental/dynamic/_op_builder.py	Correctly applies mark_transparent to generated call/fn_call wrappers and their makefun-wrapped counterparts; EvalMode guard present before resolve_callsite_frame() call.
dali/python/nvidia/dali/experimental/dynamic/_batch2tensor.py	BatchToTensor.call and batch_to_tensor marked transparent; resolve_callsite_frame() is called unconditionally unlike _op_builder.py which guards it behind an EvalMode check.
dali/python/nvidia/dali/experimental/dynamic/_tensor.py	tensor and as_tensor decorated with @_callsite.mark_transparent so they are skipped during call-site resolution; straightforward addition.

Sequence Diagram

sequenceDiagram
    participant U as User code
    participant T as tensor() [transparent]
    participant B2T as batch_to_tensor() [transparent]
    participant BT as BatchToTensor.__call__() [transparent]
    participant R as resolve_callsite_frame()
    participant I as Invocation.__init__

    U->>T: tensor(batch)
    T->>B2T: batch_to_tensor(batch, ...)
    B2T->>BT: _batch_to_tensor_instance(batch, ...)
    BT->>R: sys._getframe(1) → BT frame
    Note over R: walk f_back, skipping transparent frames
    R-->>BT: returns User code frame
    BT->>I: Invocation(..., caller_frame=user_frame)
    I-->>BT: _call_stack captured (eager/deferred) or None (sync)

Loading

_{Reviews (5): Last reviewed commit: "Skip caller frame capture in synchronous..." | Re-trigger Greptile}

[rostan-t]

!build

[dali-automaton]

CI MESSAGE: [48516693]: BUILD STARTED

[mzient]

Please refrain from reorganizing imports, especially with other PRs in flight.

[rostan-t]

This is not a file that's very likely to be changed by other PRs. Other PRs currently in flight don't touch it.

[rostan-t]

!builld

[rostan-t]

!build

[dali-automaton]

CI MESSAGE: [48675105]: BUILD STARTED

[rostan-t]

!build

[dali-automaton]

CI MESSAGE: [48676204]: BUILD STARTED

[dali-automaton]

CI MESSAGE: [48676204]: BUILD PASSED