Automated Edit and Update for Semiconductor Test Plan Debugging

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Conventional automated test equipment (ATE) debugging processes are inefficient and error-prone, particularly when dealing with 64-bit code, as they limit code changes to minor edits and require manual unloading and reloading of test plans, making it difficult for developers to make substantial changes or handle intricate code alterations during debugging sessions.

Innovation Solution

The implementation of an automated edit and update functionality within tester software systems allows users to make changes to test classes during execution, involving breakpoint management, state information storage, compilation, and reloading of edited test classes, enabling more substantial code changes and reducing the need for manual intervention.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If conventional debugging processes are used for ATE, then system stability is maintained, but code changes are limited to minor edits and require manual unloading and reloading

Engineering Contradiction:

Improvecode change capabilityVSAvoiddebugging efficiency

Core Design Contradiction:

Adaptability or versatilityVSEase of operation

Solution Approach 1:

The system dynamically switches between conventional debugging mode and automated edit-and-update mode based on the type of code changes needed. The automated mode enables substantial code modifications without manual unloading/reloading, while the conventional mode remains available for stability-critical operations. This dynamic approach resolves the contradiction by making the system adaptable to different debugging scenarios.

Inventive Principle:

Principle #15Dynamics

Solution Approach 2:

The invention changes the operational parameters of the debugging process by introducing automated compilation and reloading mechanisms. Instead of manually unloading and reloading test plans, the system automatically compiles modified code and updates the running test, fundamentally changing how code modifications are applied during debugging sessions.

Inventive Principle:

Principle #35Parameter changes

2Reliability

If manual unloading and reloading of test plans is required, then code stability is ensured, but debugging time increases significantly

Engineering Contradiction:

Improvecode stabilityVSAvoiddebugging time

Core Design Contradiction:

ReliabilityVSLoss of time

Solution Approach 1:

The system performs preliminary compilation of modified code before applying it to the running test. By pre-compiling the code and preparing update packages beforehand, the system ensures that only validated, stable code is loaded, maintaining reliability while reducing the time penalty associated with frequent reloading operations.

Inventive Principle:

Principle #10Preliminary action

Solution Approach 2:

The invention introduces an intermediary compilation and update mechanism between code editing and test execution. Instead of direct manual unloading/reloading, the system uses an automated update process that acts as a mediator, compiling code changes and applying them systematically. This intermediary process ensures code stability through proper compilation while significantly reducing the time loss compared to manual operations.

Inventive Principle:

Principle #24Intermediary (Mediator)

3Adaptability or versatility

If substantial code changes are made during debugging, then development flexibility improves, but system complexity increases

Engineering Contradiction:

Improvecode modification flexibilityVSAvoiddebugging system complexity

Core Design Contradiction:

Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The invention extracts the complex compilation and reloading operations from the manual debugging process and encapsulates them in an automated update mechanism. By taking out these complex operations and automating them, the system allows developers to make substantial code changes through simple commands, improving flexibility while managing complexity through automation rather than manual procedures.

Inventive Principle:

Principle #2Taking out (Extraction)

4Productivity

If automated edit and update functionality is implemented, then debugging efficiency improves, but risk of errors during code transitions increases

Engineering Contradiction:

Improvedebugging speedVSAvoiderror rate during code updates

Core Design Contradiction:

ProductivityVSReliability

Solution Approach 1:

The system implements feedback mechanisms during the automated edit-and-update process, including compilation status checks and update verification. The compiler provides feedback on code validity before updating, and the system monitors the update process to detect and handle errors. This feedback loop maintains reliability by validating each step of the automated process while preserving debugging speed.

Inventive Principle:

Principle #23Feedback

Solution Approach 2:

The invention applies beforehand cushioning by performing compilation checks and validity verification before actually applying code updates to the running test. This preparatory validation acts as a cushion against potential errors, ensuring that only valid code changes are applied and reducing the risk of runtime errors during automated updates.

Inventive Principle:

Principle #11Beforehand cushioning (Prior cushioning)

Data Source

PatentUS9785542B2Implementing edit and update functionality within a development environment used to compile test plans for automated semiconductor device testing

Publication Date: 2017.10.10 ADVANTEST CORP

AI summary

A method for debugging test procedures for automated device testing is disclosed. The method comprises receiving a command to update at least one modified test procedure modified during a first debugging session and saving state information for a test plan, wherein the state information comprises information regarding a breakpoint entry location, and wherein the modified test procedure is invoked within the test plan. The method subsequently comprises suspending execution of the test plan and unloading the modified test procedure. It also comprises compiling the modified test procedure to produce a compiled file and then reloading the test procedure into the test plan using the compiled file. Finally, it comprises resuming execution of the modified test procedure in a second debugging session and breaking the execution during the second debugging session at a breakpoint corresponding to the breakpoint entry location.