Abstract:
A method for integrating test modules in a modular test system is disclosed. The method includes controlling at least one test module and its corresponding device under test (DUT) with a controller, establishing a standard module control interface between a vendor-supplied test module and the modular test system with a module control framework, installing the vendor-supplied test module and a corresponding vendor-supplied control software module, where the vendor-supplied control software module is organized into a plurality of vendor-supplied module control components, configuring the modular test system based on the module control framework and the plurality of vendor-supplied module control components, and accessing the vendor-supplied test module in accordance with the plurality of vendor-supplied module control components using the module control framework.

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS  
       [0001]     This application is a continuation-in-part application and claims the benefit of co-pending U.S. application Ser. No. 10/772,434, “Method and Structure to Develop a Test Program for Semiconductor Integrated Circuits,” filed Feb. 6, 2004, which claims the benefit of application No. 60/447,839, “Method and Structure to Develop a Test Program for Semiconductor Integrated Circuits,” filed Feb. 14, 2003; this application also claims the benefit of U.S. provisional application No. 60/573,577, “Software Development in an Open Architecture Test System” filed May 22, 2004; all of which are assigned to Advantest Corporation and all of which are incorporated herein in their entirety by reference. 
     
    
     FIELD OF THE INVENTION  
       [0002]     The present invention relates to the field of automated test equipment (ATE) for semiconductor testing. In particular, the present invention relates to a method and system for controlling interchangeable components in a modular test system.  
       BACKGROUND OF THE INVENTION  
       [0003]     A major reason for the high cost of test equipment is the specialized nature of conventional tester architecture. Each tester manufacturer has a number of tester platforms that are not only incompatible across companies such as Advantest, Teradyne and Agilent, but also incompatible across platforms within a company, such as the T3300, T5500 and T6600 series testers manufactured by Advantest. Because of these incompatibilities, each tester requires its own specialized hardware and software components, and these specialized hardware and software components cannot be used on other testers. In addition, a significant effort is required to port a test program from one tester to another, and to develop third party solutions. Even when a third party solution is developed for a platform, it cannot be ported or reused on a different platform. The translation process from one platform to another is generally complex and error prone, resulting in additional effort, time and increased test cost.  
         [0004]     Another problem of the specialized tester architecture is that all hardware and software remain in a fixed configuration for a given tester. To test a device-under-test (DUT) or an IC, a dedicated test program is developed that uses some or all of the tester capabilities to define the test data, signals, waveforms, and current and voltage levels, as well as to collect the DUT response and to determine DUT pass/fail.  
         [0005]     Since a test system needs to exercise a wide range of functionalities and operations in order to test a wide variety of test modules and their corresponding DUTs, there is a need for an open architecture test system that can be configured to support the wide variety of test modules. Specifically, in order to support the wide variety of test modules, there is a need for a module control framework within the open architecture test system that can be configured to support the integration of one or more vendor modules into the test system during testing of a particular vendor module and its corresponding DUTs.  
       SUMMARY  
       [0006]     A method for integrating test modules in a modular test system includes controlling at least one test module and its corresponding device under test (DUT) with a controller, establishing a standard module control interface between a vendor-supplied test module and the modular test system with a module control framework, installing the vendor-supplied test module and a corresponding vendor-supplied control software module, where the vendor-supplied control software module is organized into a plurality of vendor-supplied module control components, configuring the modular test system based on the module control framework and the plurality of vendor-supplied module control components, and accessing the vendor-supplied test module in accordance with the plurality of vendor-supplied module control components using the module control framework.  
         [0007]     A modular test system includes a controller for controlling at least one test module and its corresponding device under test (DUT) and a module control framework for establishing a standard module control interface between a vendor-supplied test module and the modular test system. The modular test system further includes means for installing the vendor-supplied test module and a corresponding vendor-supplied control software module, where the vendor-supplied control software module is organized into a plurality of vendor-supplied module control components, means for configuring the modular test system based on the module control framework and the plurality of vendor-supplied module control components, and means for accessing the vendor-supplied test module in accordance with the plurality of vendor-supplied module control components using the module control framework.  
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0008]     The aforementioned features and advantages of the invention as well as additional features and advantages thereof will be more clearly understood hereinafter as a result of a detailed description of embodiments of the invention when taken in conjunction with the following drawings.  
         [0009]      FIG. 13  illustrates a method for integrating a vendor software module to the open architecture test system according to an embodiment of the present invention.  
         [0010]      FIG. 14  illustrates a module control framework according to an embodiment of the present invention. 
     
    
     DESCRIPTION OF EMBODIMENTS  
       [0011]     Methods and systems are provided for controlling interchangeable components in a modular test system. The following description is presented to enable any person skilled in the art to make and use the invention. Descriptions of specific embodiments and applications are provided only as examples. Various modifications and combinations of the examples described herein will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other examples and applications without departing from the spirit and scope of the invention. Thus, the present invention is not intended to be limited to the examples described and shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.  
         [0012]     The open architecture test system of an embodiment of the present invention uses minimally sufficient interfaces at the test system framework level. The test system framework is designed to operate upon vendor modules that follow a set of standard interfaces. Whenever a module vendor integrates a new module component into the test system, the new component preferably provides the predefined standard interfaces to the test system as required. This allows for seamless integration of the vendor modules into the system in a plug-and-play manner.  
         [0013]      FIG. 13  illustrates a method for integrating a vendor software module to the open architecture test system according to an embodiment of the present invention. The vendor software module  1302  includes a resource description component  1304 , a driver component  1306 , a calibration/diagnostic component  1308 , an emulation component  1310 , an optional system loadable pattern compiler component  1312 , and a system loadable module specific component  1314 . As shown in box  1307 , each component preferably comprises: 1) at least one executable (that the system uses at runtime), 2) public header files (i.e., C++“.h” files) that define the component&#39;s API and all associated documentation, and 3) system component configuration records (CCRs) for the component. The CCRs allow the test system&#39;s installation and configuration management sub-system to manage and deploy the required versions of the elements that constitute the component. Each component may also include documentations (Docs) about the component, and application examples (Examples) of the components.  
         [0014]     The open architecture test system  1320  includes a set of standard interfaces  1322 , which in turn includes a calibration/diagnostic framework  1324 , an emulation framework  1326 , and an object file manager (OFM) framework  1328 . Both the standard interfaces  1322  and the individual frameworks of the test system communicate with the corresponding category of software components in the vendor module software  1302 .  
         [0015]     The requirements on the executable of a vendor&#39;s component are that it needs to be loaded and used during runtime. In particular, the requirements include: 
        1. It is provided in the form of a dynamic link library (DLL). Each of the above components is in a separate DLL for purpose of modularity and maintainability. Furthermore, 
            a. The module DLL preferably implement the standard system module DLL interface, which is the basic interface for retrieving intrinsic module information such as the module type, exported resources, etc.     b. The module DLL can export only a single module type.    
            2. A version of the DLL is described by the vendor in a CCR.     3. The user includes the version of the DLL in a system profile, which is the total collection of information necessary to define a particular system software configuration. This causes the DLL specifications for the driver, emulator, calibration, diagnostics and pattern compiler executable components to be generated in the system Module Configuration File (MCF) and the system Utilities Configuration File (UCF). These files are used by the system during runtime to find the components to be loaded.        
 
         [0021]     Once the vendor and the user (in case 3) have satisfied the above requirements, the system can prepare to load the specified executable component.  
         [0022]     The standard interfaces to the test operating system (TOS) are defined as abstract C++ classes. Module-specific software for the system is required to be provided in the form of DLLs, which can be independently and dynamically loaded by the system software at runtime. Each such software module is responsible for providing vendor-specific implementations of the system module interface commands, which comprise the application programming interface (API) for module software development.  
         [0023]     Note that supporting the standard interfaces does not mean that each module software component needs to provide only the functionality represented by the system standard interfaces the modules comply with. On the contrary, vendors are free to add one or more complex layers of functionality on top of the system standard interfaces as required for implementing their modules. However, the system framework is not able to access the additional functionality. It is the responsibility of the users and vendors to interpret and take advantage of the additional functionality, above and beyond the predefined capabilities provided by the framework and the TOS. Thus, the users of the test system are free to use the specific features and custom extensions provided by module vendors. The tradeoff is that using custom extensions may provide more functionality to the specific vendor modules, but the custom extensions make the specific vendor modules and their associated test programs less useable with other vendors&#39; modules.  
         [0024]      FIG. 14  illustrates a module control framework according to an embodiment of the present invention. The module control framework includes a module interface (IModule)  1402 , a resource interface (IResource)  1404 , and a resource group interface (IResourceGroup)  1406 . The IModule  1402  may optionally include a pattern list module interface (IPatternListModule)  1408 , a domain module interface (IDomainModule)  1410 , and a cyclized module interface (ICyclizedModule)  1412 . Similarly, the IResource  1404  may optionally include a cyclized resource interface (ICyclizedResource)  1414  and a cyclized resource group interface (ICyclizedResourceGroup)  1416 , which vendors can choose to implement to provide special functionalities indicated by the chosen interface. Each of the interface is discussed in detail below.  
         [heading-0025]     IModule Interface  
         [0026]     The relationship between a hardware module type and its corresponding software object is defined by the IModule interface  1402 . In other words, the IModule interface implements the system standard interface represents a particular hardware module type, and encompasses the individual units of that module type connected to a site controller. The IModule interface  1402  declares user-level methods to obtain module information, retrieve resources, and resource groups. User can apply this interface at the vendor level in order to utilize vendor-specific features provided by the vendor module. In one embodiment, the IModule interface  1402  includes the following methods. 
        getResource( ): This method retrieves a module resource by resource name.     getResources( ): This method retrieves all module-instantiated resources of a particular type.     getResourceGroups( ): This method retrieves all module-instantiated resource groups of a particular type.     getResourceGroup( ): This method retrieves an existing resource group by its name. 
 
 IResource Interface 
       
 
         [0032]     A specification of a hardware resource (or resource for short) is used to describe hardware module functionality in a way that can be supported by the system framework for all modules. A resource is a logical collection of one or more functional hardware entities that can be controlled as a single, independent object. A resource unit is typically provided by the module. An example of a resource unit is a single digital tester pin provided by a DM250 MHz board that is connected to a single output port of the system Module Connection Enabler (MCE). The relationship between a hardware resource unit and its corresponding software object is that the software object implements the resource interface representing a single logical unit of a particular resource type.  
         [0033]     Each compliant hardware module provides one or more types of resources used by the test system. A hardware module is a vendor-provided hardware entity that contains a vendor-specified module type and is connected to an output port of the system Module Connection Enabler (MCE). The MCE provides units of the one or more resources as necessary. Note that units of modules of the same type can occupy as many port connections on the MCE as required. The type of a module is unique within a particular vendor&#39;s offerings.  
         [0034]     The Resource Definition Language is used to declare a set of resource names for the available resource types, and a set of attributes and types associated with each particular resource type. It is through the setting of parameter values that the vendor supports the configuration of its hardware resources. As an example, the resource name “Digital.dpin” is used to refer to digital tester pins. These resources have parameters such as VIL (for the input low voltage), VIH (for the input high voltage), VOL (for the output low voltage), VOH (for the output high voltage), etc. Thus, each resource has attributes that are defined by the system or the resource vendor, which can be used within the set of attributes of the resources.  
         [0035]     A system Resource Definition File contains resource declarations in the system resource definition language. The system specifies certain standard resource names, which are available in a standard system file. Vendors supplying special purpose resources that require the specification of different parameters are required to provide their own resource definition files, and place them in predefined locations. The system treats the parameters defined in the resource definition file as strings, to be passed on to the vendor-specific software as-is. It is the responsibility of the vendor-specific module software to interpret these strings as the intended parameters, and provide specific APIs, if necessary, by which test programs can make use of these extensions.  
         [0036]     In the object model, each resource unit implements the IResource interface. In support of its particular functionality, the module that provides such a resource can implement an object that exposes an interface derived from the IResource interface, which is used to communicate with the test system. The IResource interface allows the test classes provided by the vendor or user to incorporate additional functionalities without recompiling the tester operating system (TOS), thereby providing users more flexibility in testing the modules and their corresponding DUTs. The IModule interface of a particular resource may create as many IResource objects as specified in the socket description of a particular test program.  
         [0037]     Since every resource unit stores a type, a port-ID, and a channel-ID for identification purposes, an IResource object represents a single unit of a particular resource type is uniquely identifiable in the entire system by the parameters {type, port-ID, channel-ID}. This parameter is the specification “port-ID.channel-ID” defined in the system Module Configuration file (MCF). The “port-ID” and “channel-ID” elements for a particular resource unit are available from the socket object (which provides a mapping from DUT pin names to loadboard connections, and the loadboard connections are mapped to the “port-ID.channel-ID” specification through a resource-type-specific block in the TestHeadConnections section of the MCF).  
         [0038]     Note that the test system supports a shared resource, which can be made available to more than one DUT pin, for any combination of the set of DUT pins at any given time. The test system also supports the connection of a single DUT pin to multiple resource units, with the restriction that no more than a single unit of a resource type (except power supply) may be connected to the same DUT pin.  
         [0039]     In one embodiment, the IResource interface  1404  includes the following methods. 
        getAttributeCache( ): This method retrieves the attribute cache associated with this resource.     getName( ): This method retrieves the name of this IResource.     getChannelID( ): This method retrieves the HW channel ID for the resource.     getPortID( ): This method retrieves the switch matrix port ID for the resource.     getType( ): This method retrieves the TPL type of the resource (e.g., “Digital.dpin”, etc.).     getConnectedDUTPins( ): This method retrieves the set of connected DUT pin names (useful for a shared resource).     getModule( ): This method retrieves a pointer to the IModule that created this IResource.     getAllAttributes( ): This method retrieves the list of name/type info for all attributes for this resource.     getAllAttributeValues( ): This method retrieves the list of full info for all attributes for this resource.     getAttriblntVal( ): This method retrieves the integer value of an attribute (if appropriate).     getAttribUIntVal( ): This method retrieves the unsigned integer value of an attribute (if appropriate).     getAttribDblVal( ): This method retrieves the double value of an attribute (if appropriate). 
 
 IResourceGroup Interface 
       
 
         [0053]     The IResourceGroup interface  1406  represents the collective behavior of a set of IResources. It is an interface exposed to IModules that allows the user to specify a collection of IResources and subsequently use the collection as a single resource unit. While the IResourceGroup contains the set of IResources used to create the IResourceGroup, it provides a unified programming interface to the collection as a whole. For example, a particular vendor may have a hardware-supported mechanism to broadcast an attribute setting call on an IResourceGroup to all the members of IResources at the same time, without individually calling the attribute setting method on each member.  
         [0054]     In the test system, a resource group is created by the system whenever the user defines a group of DUT pins in a signal. This implicit construction is the way in which a resource group is created. An IResourceGroup can only be homogeneous, i.e., containing IResources of the same type (defined by the test program language (TPL)), such as the type “Digital.dpin” or “PowerSupply.dps”, but not both. The creator of an IResourceGroup from a given collection of IResources enforces this requirement.  
         [0055]     An IResourceGroup is uniquely identified in the system by the following set of parameters.  
         [0056]     DUT-Pin-Group-Name, Resource-Type, Vendor-ID, Module-ID  
         [0057]     Note that the IModule interface is required to provide the IResourceGroup interface, whether hardware support is available or not. In the absence of true hardware “resource groups”, a software equivalent of the functionality is provided. In addition, the IModule interface provides a “virtual constructor” for creating an IResourceGroup with a homogeneous collection of IResources. This is enforced by the createResourceGroup( ) method of the IModule interface.  
         [0058]     In one embodiment, the IResourceGroup interface includes the following methods. 
        getName( ): This method retrieves the name of this group.     getMembers( ): This method retrieves the collection of IResources comprising this group.     getModule( ): This method retrieves a pointer to the IModule that created this group.     getType( ): This method retrieves the TPL type of the IResources comprising this group, e.g., “Digital.dpin”, etc.     getAttributeCache( ): This method retrieves the attribute cache for the resource type for this group.     getAllAttributes( ): This method retrieves the list of name/type info for all attributes for the resource type for this group. 
 
 IPatternListModule Interface 
       
 
         [0066]     The IPatternListModule interface  1408  is a specialization of the IModule interface, and represents a hardware module that supports the manipulation of test pattern objects. It includes the following methods. 
        getNumber( )fLoadedPatterns( ): This method retrieves the number of loaded patterns.     getPatternIDs( ): This method gets loaded pattern ID array.     getPatternListIDs( ): This method gets array of Pattern Lists loaded into module. 
 
 IDomainModule Interface 
       
 
         [0071]     The IDomainModule interface  1410  is a specialization of IPatternListModule interface  1408 , and represents a hardware module that supports the functionalities required for working in time domain (such as a group of resources clocked at a particular frequency). It implements the following methods. 
        getVendorDomain( ): This method retrieves a vendor domain object by identifier.     getVendorDomain( ): This method retrieves a vendor domain object by name.     getVendorDomains( ): This method retrieves the collection of all vendor domain objects instantiated by this module.     getVendorDomainsForPattern( ): This method retrieves the collection of all the vendor domains associated with the given pattern. 
 
 ICyclizedModule Interface 
       
 
         [0077]     The ICyclizedModule interface  1412  provides an interface for a cyclized module. It includes the following methods. 
        getCyclizedAddressFailMemory( ): This method obtains the module address fail memory object pointer.     getCyclizedFailMemory( ): This method obtains the module fail memory object pointer.     getCyclizedResource( ): This method retrieves a cyclized resource by its name.     getCyclizedResourceGroup( ): This method retrieves a resource group by its name. 
 
 ICyclizedResource Interface 
       
 
         [0083]     The ICyclizedResource interface  1414  extends the standard IResource interface with functionality specific to cyclized resources. A cyclized resource contains elements with timing attributes, such as components related to the system timing, timing map and cyclized digital pattern data. The ICyclizedResource provides the function of exporting an ICyclizedAttributeCache, which allows the system framework to work with TCM settings [Question: What is TCM?] for system timing and timing map attributes. In addition, the ICyclizedResource allows the user to retrieve the timing and timing maps attributes in use.  
         [0084]     In one embodiment, the ICyclizedResource interface  1414  includes the following methods. 
        getCyclizedAttributeCache( ): This method retrieves the cache object that allows the application of timing and timing map attributes to hardware.     getTimingData( ): This method retrieves the timing data currently set on the resource unit.     getTimingMapData( ): This method retrieves the timing map-related attributes that are currently set on the resource.     setTimingData( ): This method sets the timing-related attributes on this cyclized digital resource. This sets all the contents of a single waveform, as defined in the TPL Timing language.     setTimingMapData( ): This method sets the timing map-related attributes on this cyclized digital resource. 
 
 ICyclizedResourceGroup Interface 
       
 
         [0091]     This ICyclizedResourceGroup interface  1416  provides a specialized IResourceGroup interface for grouping ICyclizedResources. It includes the following methods. 
        getCyclizedAttributeCache( ): This method retrieves the cache object that allows the application of timing and timing map attributes to hardware.     setTimingData( ): This method sets the timing-related attributes on this cyclized digital resource group. This sets all the contents of a single waveform, as defined in the TPL Timing language.     setTimingMapData( ): This method sets the timing map-related attributes on this cyclized digital resource group. 
 
 Module Initialization 
       
 
         [0096]     The driver DLL of a vendor module is automatically loaded by the test system on the site controllers that need it. The term module DLL refers to the module driver DLL in this context. In one embodiment, a module initialization flow is shown below, which happens after the main service processes on the system and site controller(s) have been started. In offline mode, the module bring-up starts after the simulation framework executable (the Simulated Tester, or SimTester) has been started. 
        1. The system controller initializes itself, and establishes connections with the site controllers.     2. The system controller loads the system MCF.     3. The system controller initiates the process of hardware discovery on the master site controller (i.e., site controller  1 ), the one that is connected to input port  1  of the system Module Connection Enabler (MCE). This hardware information is used to create the system Hardware Inventory File on the system controller.     4. The system controller validates the MCF against the information obtained through hardware discovery.     5. The system controller then performs validation of all module software as follows: 
            a. It finds the module DLLs that are specified in the MCF, using a search path for such DLLs.     b. It loads each module DLL (the module DLL preferably implements the interface).     c. It verifies (using a standard method exported by the DLL) that the resources declared in the MCF for that module can be created by the module.    
            6. The system controller then populates all the site controllers (other than the master) with module configuration information. This information is used later for module object construction.     7. The system controller prepares for a default partitioning of the system (where every module is connected to the master site controller). This state is modified for system calibration.        
 
         [0107]     Once a default partitioning has been performed, the system as a whole is in the initialized state.  
         [heading-0108]     Module Setup and Access  
         [0109]     In another embodiment, the sequence of events leading to a successful, non-default system partition are shown below. Since partitioning information is specified in a socket file, it is assumed that the proper socket file has been read, and a socket object based on the socket file has been created. 
        1. The system controller instructs the master site controller to configure the system MCE according to the partition specified in the socket.     2. Each site controller then loads the module DLLs and constructs module objects, each of which preferably implements the standard interface IModule. The process is as follows: 
            a. The module DLL is transferred from the system controller to the site controller. 
                b. The module DLL is loaded in the process space of the site controller service process.     c. An IModule object is created on the module DLL interface. The vendor assumes the responsibility for the creation of vendor-specific objects. In this step, the vendor also performs any internal initialization steps required.    
               
            3. Each site controller initializes the IModule object created above, by calling the initialize( ) method. The parameters for this method are used as references to the socket object, to any vendor-specific data described in the MCF, and to a list of identifiers of the DUTs being tested (in a parallel test environment). In this step, the IModule object creates and initializes the IResource unit objects that are made available to the test system.        
 
         [0116]     The site controller system software maintains the collection of properly configured and initialized IModule, and uses it for test operations, such as test plan loading, pattern loading, test plan execution, fail data retrieval, and etc. It also allows system objects, user test classes, and vendor objects to interact with the IModule and the IResource provided. In one embodiment, the following steps illustrates a method for a user test class to access resource units at runtime (the client referred to below is a user test class): 
        1. A client, in its postExec( ) method, needs to perform datalogging of the current values of pin attributes set on the hardware, for the DUT pin group GO, which contains the pins A 0  and A 1 .     2. The client, which is executing on a Site Controller, retrieves the Signal (which are framework-provided objects encapsulating the relationships between DUT pins and connected hardware resource units) corresponding to DUT pin group G 0  from the test plan.     3. The client uses the method Signal::getResources( ) to retrieve the IResourceGroup pointer from the signal for G 0 .     4. The client uses the IResourceGroup::getMembers( ) method to extract the IResources in it (i.e., the resource units connected to DUT pins A 0  and A 1 ).     5. Given that the cyclized modules and resources have been used, the client uses a C++ dynamic_cast&lt; &gt; operator to cast the IResource pointers to ICyclizedResource pointers.     6. Through each ICyclizedResource pointer, the client retrieves, for example timing data, by using the ICyclizedResource::getTimingData( ) method.     7. The client datalogs the timing attribute values retrieved above.        
 
         [0124]     The disclosed method for controlling interchangeable components allows a new module type to be added to the test system transparently, without recompiling the test operating system. Thus, the disclosed method supports an open architecture test system for integrating fully re-configurable and interchangeable vendor module components, with their associated hardware and software. Thus, the method supports vendor modules in a plug-and-play fashion, after such modules have been independently specified, developed and certified. This provides the end user a flexible, modular, re-configurable and highly scalable open architecture test system that reuses vendor modules for testing and lowers the cost of testing integrated circuits.  
         [0125]     One skilled in the relevant art will recognize that there are many possible modifications and combinations of the disclosed embodiments may be used, while still employing the same basic underlying mechanisms and methodologies. The foregoing description, for purpose of explanation, has been written with references to specific embodiments. However, the illustrative discussions above are not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations are possible in view of the above teachings. The embodiments were chosen and described to explain the principles of the invention and its practical applications, and to enable others skilled in the art to best utilize the invention and various embodiments with various modifications as are suited to the particular use contemplated.