Trace Directives for Compiled Code Boundary Control

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

In emulated processing environments, the lack of visibility into program boundaries makes it difficult for compiler developers to control and reproduce trace compilation and execution, leading to unpredictable execution and reduced productivity.

Innovation Solution

Incorporating trace directives, such as START_TRACE and END_TRACE pseudo-instructions, during code compilation to define clear boundaries for tracing, allowing for controlled and repeatable trace compilation and execution.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of operation

If traditional compilation frameworks are used without trace directives, then code can be compiled and executed, but control over trace compilation and execution is lost and program boundaries become invisible

Engineering Contradiction:

Improvecontrol over trace compilationVSAvoidtrace framework complexity

Core Design Contradiction:

Ease of operationVSDevice complexity

Solution Approach 1:

The patent segments the execution stream by inserting trace directives (START_TRACE, END_TRACE) at program boundaries such as function entries and exits. This segmentation allows the compiler to identify and control specific trace regions within the code, making program boundaries visible and controllable despite the trace framework's tendency to absorb execution streams indiscriminately.

Inventive Principle:

Principle #1Segmentation

Solution Approach 2:

The patent introduces trace directives as intermediary elements between the compiler and the trace framework. These directives act as markers that the compiler can recognize and use to control trace compilation, providing a handle on program boundaries without requiring fundamental changes to the trace framework's operation.

Inventive Principle:

Principle #24Intermediary (Mediator)

2Adaptability or versatility

If execution order is perturbed from startup, then the system can adapt to different execution paths, but trace compilation becomes unpredictable and problem reproduction becomes difficult

Engineering Contradiction:

Improveexecution path flexibilityVSAvoidtrace compilation reproducibility

Core Design Contradiction:

Adaptability or versatilityVSReliability

Solution Approach 1:

The patent applies preliminary action by inserting trace directives into the code during compilation, before execution occurs. This ensures that program boundaries are pre-marked with START_TRACE and END_TRACE directives, so that regardless of how execution order is perturbed during runtime, the trace compilation will consistently follow the same boundaries and be reproducible.

Inventive Principle:

Principle #10Preliminary action

3Duration of action of moving object

If traces absorb the execution stream irrespective of program boundaries, then continuous execution can be traced, but visibility into program boundaries is lost

Engineering Contradiction:

Improvetrace coverage continuityVSAvoidprogram boundary visibility

Core Design Contradiction:

Duration of action of moving objectVSDifficulty of detecting and measuring

Solution Approach 1:

The patent applies local quality by making different parts of the execution stream have different properties. Within trace regions marked by directives, the execution is continuously traced, but at program boundaries (function entries, exits, loops), special markers are inserted. This allows the trace framework to maintain continuous tracing while simultaneously providing visibility into program boundaries through the strategically placed directives.

Inventive Principle:

Principle #3Local quality

Data Source

PatentUS8490073B2Controlling tracing within compiled code

Publication Date: 2013.07.16 INTERNATIONAL BUSINESS MACHINE CORPORATION

AI summary

Tracing within a processing environment is controlled. Trace directives are automatically included within code being compiled in order to control where one or more traces begin and end within the code. The trace directives provide a framework for mapping traces to well understood boundaries of the code.