DaCe框架Tasklet调试信息编辑方法及关联原始代码可行性咨询

1. Editing Tasklet Debugging Info During/After Creation #

DaCe gives you straightforward ways to set and modify debugging-related attributes for Tasklets, both when you create them and after they're part of an SDFG. Here's how:

During Creation #

If you're using the @dace.tasklet decorator, you can directly set a descriptive label (which shows up in debug views and logs) and even specify a custom code location right away:

import dace

@dace.tasklet(label="IntegerAdditionTasklet", location=dace.Location(filename="my_application.py", line=100))
def add_tasklet(a: dace.int32, b: dace.int32) -> dace.int32:
    c = a + b
    return c

If you're manually instantiating a Tasklet node (common when generating SDFGs programmatically), pass the same parameters to the constructor:

from dace.sdfg.nodes import Tasklet

tasklet_node = Tasklet(
    label="ManualAdditionTasklet",
    code="c = a + b; return c",
    inputs={"a", "b"},
    outputs={"c"},
    location=dace.Location(filename="sdfg_generator.py", line=50)
)

The label acts as a human-readable identifier for debugging, while location ties the Tasklet to a specific file and line number.

After Creation #

Once the Tasklet is added to an SDFG graph, you can modify these attributes directly by accessing the node object:

# Assuming you have a reference to the Tasklet node in your SDFG
tasklet_node.label = "Updated_Addition_Tasklet"
tasklet_node.location = dace.Location(filename="updated_source.py", line=200, column=5)
# You can also add arbitrary custom metadata for debugging context
tasklet_node.metadata["debug_note"] = "Handles addition logic ported from legacy code"

2. Associating Tasklet Debug Info with Original Source Code (Not Conversion Code) #

Absolutely doable! This is a common requirement when transpiling code to DaCe SDFGs, and DaCe's Location class is built to support exactly this scenario.

The core idea is to override the default auto-generated location (which points to your Python conversion code) with the actual file path, line numbers, and columns from the original source code you're translating. Here's a step-by-step approach:

1. Capture original code location: When parsing your input code (e.g., C, Fortran, or another Python script), extract the source location details (filename, start line, columns) for the code snippet that maps to the Tasklet.
2. Assign the custom location to the Tasklet: When creating the Tasklet (either via decorator or direct instantiation), pass this custom Location instead of relying on the default.

Example workflow for a hypothetical C-to-DaCe transpiler:

import dace
from dace.sdfg.nodes import Tasklet

# Suppose we parsed a C function at line 42 in "original_c_code.c"
original_filename = "original_c_code.c"
original_line = 42

# Create Tasklet tied to the original C code's location
tasklet = Tasklet(
    label="OriginalC_Addition",
    code="c = a + b",
    inputs={"a", "b"},
    outputs={"c"},
    location=dace.Location(filename=original_filename, line=original_line)
)

# Add the Tasklet to an SDFG (example setup)
sdfg = dace.SDFG("c_to_dace_example")
state = sdfg.add_state()
state.add_node(tasklet)

If you need to adjust the location after the Tasklet is created, just modify the location attribute as shown in the first question. This ensures that when you debug (e.g., using DaCe's profiling tools or when errors are raised), the debug info points back to your original source code rather than the Python script that handled the conversion.

内容的提问来源于stack exchange，提问作者StillLearning