In the past decade, semiconductor devices have undergone a remarkable evolution, becoming increasingly sophisticated to meet the expanding demands of diverse industries. The surge in complexity has necessitated more extensive and intricate testing processes for these devices. However, the tools used in post-silicon validation are typically fragmented across groups because different teams and the teams operating at different geographic sites often custom develop and maintain software catering to their needs. While some of these software interfaces are built from scratch, others leverage a variety of commercial off-the-shelf (COTS) test sequencers. This disparity and non-uniformity in the software interfaces and toolchain limits the data collection and correlation. This often results in wasted effort in large organizations where multiple groups independently develop similar functionality. With more of the available IP being integrated into a single chip, previously distinct validation teams must now work with each other and explore means for sharing and correlating data across different engineering sites and stages of the product development lifecycle to get the product out in the market faster.
To address these growing complexities, it becomes essential to build/ adopt a framework that can help in achieving the following primary objectives:
- Facilitating higher software assets and code reuse across teams, projects, and programs.
- Increasing automation while enabling an intuitive debug environment for designers and validation engineers
- Supporting easy onboarding of new engineers onto the validation activity
Despite the apparent simplicity of the primary objectives, challenges arise based on factors such as team size, organization structure, and various aspects related to software practices and hardware platforms. Let’s examine some of these critical challenges and factors highlights how a standardization framework can offer solutions.
1. Challenges in reusing the test code due to varying instrument setup:
The dynamic nature of post-silicon validation benches often introduces changes in instrument models across stations, driven by factors such as instrument availability, project requirements, and other considerations. This variability poses a challenge to sharing test code across projects, as validation engineers may need to constantly update or rewrite code to accommodate new instrument models or drivers, resulting in repetitive tasks throughout the organization.
While standardizing instrument models across validation stations is a potential solution, it proves expensive and limits engineers’ flexibility in choosing the most suitable instruments to validate the new products. However, there’s a powerful alternative—leveraging software principles to develop an instrument-agnostic test program. This is achieved through object-oriented programming, creating a “Hardware Abstraction Layer” (HAL) embedded in the test program to control instruments.
The HAL is a one-time development effort for the organization, reusable across projects. Programming languages with native instrument driver support, such as LabVIEW, which offers comprehensive support for both NI and 3rd party instruments, expedites HAL development and ensures code quality. In cases where native drivers don’t align with the HAL API design, direct utilization of SCPI commands enables seamless integration.
For languages lacking off-the-shelf instrument driver support, referencing the instrument’s remote control programming manual allows engineers to employ SCPI commands for control and configuration.
In essence, adopting a test program written with HALs facilitates instrument model swaps within a project without significant code edits, promoting efficient code reuse across diverse projects. This approach not only streamlines development efforts but also enhances adaptability to evolving design requirements and variation in instrument configurations in the ever-changing landscape of semiconductor post-silicon validation.
2. Handle inefficiencies in code sharing across projects – a centralized repository for reusables and test code:
In the intricate landscape of test code development, managing dependencies proves to be a critical challenge. Often, test code relies on reusable components like Hardware Abstraction Layers (HALs), digital communication libraries and other reusable libraries. Sharing this code without properly managed dependencies across projects becomes daunting, leading to broken code and additional efforts for engineers to make it runnable.
Engineers encounter difficulties reusing code when dependencies are not adequately managed, exacerbating the challenge when collaborating across different geographies and business units. Establishing centralized repositories emerges as a transformative solution to address this difficulty. These repositories house well-documented, versioned reusables and test code, accessible to all members of the validation community.
Versioning and dependency assignment are vital features of this centralized approach. Test code is linked to specific dependencies, ensuring that when a validation engineer accesses the code, they are informed of the required reusables. This process can be automated, enhancing workflow efficiency.
Recognizing that different programming languages have varied packaging and distribution techniques; the repository accommodates these differences. For instance, LabVIEW utilizes VIP and NIPkg package formats, while C# relies on NuGet packages. This versatility ensures seamless integration regardless of the programming language used.
The centralized repository serves as more than a storage space. It becomes a portal for validation engineers to explore existing test code, mitigating the risk of redundant efforts and rework. By offering a comprehensive view of available resources, it not only simplifies access to standardized test code but also acts as a catalyst for optimizing time and effort.
In essence, establishing centralized repositories represents a paradigm shift in test code management. It not only addresses the challenges of dependency management but also fosters collaboration, efficiency, and a culture of resource-sharing within the validation community.
3. Consideration of multi-stack development:
In the pursuit of standardizing test code development practices across an organization through the implementation of a framework, careful consideration of supported programming languages is paramount. Several factors contribute to the significance of this decision:
- Diverse Engineer Skill Sets: Engineers within an organization often possess proficiency in different programming languages. Supporting a variety of languages accommodates these diverse skill sets, allowing engineers to contribute effectively based on their expertise.
- Language Strengths: No single programming language excels in all aspects. Each language offers unique strengths, some quick examples and an overview of their capabilities: Matlab provides rich toolboxes for applications like signal processing and control systems, Python boasts extensive library support for scientific computing and visualization, and LabVIEW excels in instrument control, data acquisition, real-time test and measurement support, graphical programming, etc.
- Equipment Manufacturer Support: Equipment manufacturers may provide driver support exclusively for a specific programming language. The chosen framework should align with these manufacturer specifications to ensure seamless integration.
Hence it is important to note that the selected programming language for the framework should offer robust connectivity and support for integration and execution of test code written in other languages. The framework should also ensure that it provides a mechanism to share instrument sessions and data between these programming languages. This facilitates a cohesive and collaborative development environment.
LabVIEW serves as an exemplary model in this context to build a framework. Its capability to access reusables and tests written in diverse languages such as Python, .NET (C#, VB.NET), Matlab, and C/C++ exemplifies a hybrid programming infrastructure. This approach leverages the strengths of different languages while consolidating them on a common platform, exemplifying the adaptability and versatility required in modern validation frameworks.
In essence, the decision on programming language support is pivotal, shaping the framework’s ability to foster collaboration, enhance productivity, and accommodate the diverse skill sets and preferences inherent in a dynamic engineering environment.
4. Save time by standardizing the infrastructure for testing and automating the test execution:
Now that we’ve explored the efficiency gains achievable through test code reuse, it’s crucial to delve into additional factors influencing test development and execution. Validation engineers often grapple with the task of constructing supplementary infrastructure—User Interface, UUT tracking, result archival, report generation, and, notably, automating test execution to characterize the device across different conditions. These elements are indispensable for comprehensive testing across diverse products.
Upon closer inspection, these software modules transcend specificity to any Device Under Test (DUT) or product. They embody product-independent components, termed Framework-specific components. Serving as foundational building blocks, these components are universally applicable, establishing a standardized framework for streamlined and efficient testing processes. Recognizing their product-agnostic nature underscores the strategic importance of developing and maintaining these components, optimizing overall test development efforts.
Organizations have the flexibility to construct these framework components from scratch or leverage built-in and community-reusable elements supported by programming languages such as LabVIEW, C#, and Python. These languages offer robust capabilities for datalogging, report generation, and automated test sequencing. Additionally, infrastructure tools like TestStand contribute immense value by enabling test and measurement sequencing, with strong support for sequencing tests written in languages including LabVIEW, .Net, Python, C/C++, and few other languages.
In essence, recognizing and enabling these framework components empowers validation engineers with more time to concentrate on the actual tests to be performed on the product. This shift minimizes concerns about engineering software intricacies, enhancing overall test execution capabilities for every product. The strategic emphasis on these foundational components not only streamlines current testing procedures but also lays the groundwork for scalable and adaptable testing practices in the dynamic landscape of semiconductor post-silicon validation engineering.
5.Software to enable interactive execution and efficient debugging:
An interactive debugging environment is indispensable for not only validation engineers but also design and apps engineers, especially during critical phases like device wakeup and when unexpected results arise. This entails several crucial aspects:
- Interactive Control of Instruments and Device Registers: The environment should allow engineers to interactively control instruments and device registers. This can be achieved through an intuitive GUI or remote-control panels, providing real-time access for effective debugging.
- Flexible Execution of Measurements: Engineers should possess the flexibility to execute measurements interactively through user interfaces, allowing them to step into the code for debugging purposes. This capability is crucial for pinpointing the root cause of errors and refining the code during the testing phase.
- Error Handling and Runtime Notifications: Robust error handling is paramount. The test code should capture runtime errors from instruments and other reusable components, notifying users promptly. Moreover, the code should be capable of altering the execution flow based on certain errors, allowing for the execution of routines to safely shut down instruments or handle specific events.
For interactive execution and effective debugging, the chosen framework and programming language must empower engineers with these capabilities without imposing additional development overhead. Framework developers should prioritize providing seamless access to these features.
Languages like LabVIEW stand out in this regard, offering out-of-the-box user interface support that significantly enhances debugging and error-handling capabilities. Similarly, languages like C# provide a strong foundation, and frameworks can leverage these language features to further augment debugging capabilities.
In essence, the emphasis on incorporating these features into the framework not only facilitates efficient debugging but also elevates the overall development experience for engineers working on semiconductor post-silicon validation.
In conclusion, an effective semiconductor validation framework addresses challenges by reducing time to market, enhancing efficiency through standardization and code reuse, increasing the quality of the device by expanding test coverage, unifying data analysis across the product lifecycle, delivering an advanced debug experience, and providing well-defined structures, documentation, and processes for quick recreation of automation software. Moreover, it supports easy onboarding, reducing the learning curve for engineers transitioning between different product lines.