US20080270854A1 - System and method for running test and redundancy analysis in parallel - Google Patents
System and method for running test and redundancy analysis in parallel Download PDFInfo
- Publication number
- US20080270854A1 US20080270854A1 US11/739,599 US73959907A US2008270854A1 US 20080270854 A1 US20080270854 A1 US 20080270854A1 US 73959907 A US73959907 A US 73959907A US 2008270854 A1 US2008270854 A1 US 2008270854A1
- Authority
- US
- United States
- Prior art keywords
- fails
- redundancy
- test pattern
- repair
- test
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
- G11C29/56004—Pattern generation
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/56—External testing equipment for static stores, e.g. automatic test equipment [ATE]; Interfaces therefor
- G11C29/56008—Error analysis, representation of errors
-
- G—PHYSICS
- G11—INFORMATION STORAGE
- G11C—STATIC STORES
- G11C29/00—Checking stores for correct operation ; Subsequent repair; Testing stores during standby or offline operation
- G11C29/70—Masking faults in memories by using spares or by reconfiguring
- G11C29/72—Masking faults in memories by using spares or by reconfiguring with optimized replacement algorithms
Definitions
- One embodiment generally relates to test of memory devices.
- one embodiment relates to systems and methods of repairing memory devices.
- a memory device typically includes at least one array of memory cells arranged in rows and columns. In a relatively large array, it can be expected that some cells will not be usable. Accordingly, redundant rows and columns exist to repair the defective cells via redundancy analysis. Tests are performed on memory devices to identify the cells that need to be replaced. For relatively large arrays, these tests comprising test patterns can be time-consuming and relatively expensive. For example, many test patterns may be run to test for gross failures, and to test for margin such as voltage, speed, and the like.
- FIG. 1 is a flowchart illustrating an example of a conventional test and redundancy analysis.
- the process can be performed by Automated Test Equipment (ATE).
- ATE Automated Test Equipment
- step S 910 a first test pattern is chosen and applied to the device under test (DUT).
- the test results from step S 920 i.e., the information on the failed memory locations (the fails), are collected into a fail capture memory, which is a storage device to store the information on the fails.
- the fail information from test patterns includes information on the fails such as internal addresses.
- the solution or solution information from redundancy analysis includes information on which redundant rows or columns would be activated to replace and repair the fails.
- step S 930 the test results are copied for a redundancy analyzer so that a test pattern and a redundancy analysis for an immediately prior test pattern can be run in parallel.
- step S 940 Threads 1 and 2 are spawned, and run in parallel, in which the redundancy analyzer starts to process the test results obtained in the step S 920 or S 960 and stored in the fail capture memory. While the redundancy analyzer processes the fails in step S 950 , testing with a next test pattern is performed on the DUT in S 960 along Thread 1 . In the step S 950 , the redundancy analysis for both the must fail and sparse fails is performed. The redundancy analysis of S 950 can take more time or less time to complete than the test pattern S 960 .
- step S 970 waits for completion of the step S 950 , the test as a whole runs slower than the speed at which the ATE can perform the test patterns, which adds time and cost to the DUT.
- a second test with “next pattern” S 960 is on hold waiting S 970 for the redundancy analysis S 950 obtained from the first test with “1 st pattern” S 920 is done.
- the process can return to S 930 via S 970 to run further test patterns and redundancy analysis, or finishes the process.
- FIG. 1 is a flowchart illustrating a conventional redundancy analysis.
- FIG. 2 is a schematic block diagram of an apparatus for repairing a memory device.
- FIG. 3A is a diagram illustrating fails and repair for an array of a memory device.
- FIG. 3B is a diagram illustrating manipulating a solution for the repair of FIG. 3A .
- FIG. 4 is a flowchart illustrating a test process according to an embodiment.
- FIG. 5 is a flowchart illustrating a test process according to another embodiment.
- FIG. 2 shows a schematic block diagram illustrating an apparatus 102 for testing and/or repairing a memory device under test (DUT) 10 .
- the memory device can include any memory device such as DRAM, SDRAM, SRAM, MRAM, FRAM, Flash, EEPROM, PCRAM, etc.
- the apparatus 102 comprises a tester 20 , a fail capture memory 22 , a must redundancy analyzer 41 , a queue 30 , a sparse redundancy analyzer 42 , a result storage unit 50 , a pattern generator 21 , and a controller 104 .
- the tester 20 performs tests (test patterns) on the DUT 10 to determine memory locations that fail. The “fails” are collected and stored temporarily at the fail capture memory 22 in the tester 20 .
- the must redundancy analyzer 41 and the sparse redundancy analyzer 42 process the information on the fails to produce a solution to repair the problematic memory locations.
- the controller 104 is configured to control the pattern generator 21 , the fail capture memory 22 , and the must redundancy analyzer 41 in the tester 20 .
- the pattern generator 21 generates multiple test patterns to test the DUT 10 with.
- each of the testers 20 can communicate with a sparse redundancy analyzer as indicated by a dotted box 106 including a queue 30 , a sparse redundancy analyzer 42 , and a result storage unit 50 as shown in FIG. 2 .
- the dotted box portion 106 can be shared by one or more the testers 20 .
- analysis of must fails is performed by the must redundancy analyzer 41 and sparse fails by the sparse redundancy analyzer 42 . Fails are either must fails or sparse fails, and these concepts are explained below.
- a must fail 62 a in FIG. 3B corresponds to multiple single bit fails that should be repaired by a single element.
- a sparse fail is a single bit fail that is not part of a must fail. The other fails in FIG. 3B can be sparse fails.
- a single element can repair one or more sparse fails.
- the solution information for the fail information can be manipulated in the sparse redundancy analyzer 42 ( FIG. 2 ) using sets of rules.
- the must fail 90 and sparse fails 91 , 92 , 93 , 94 can be taken and handled using the sets of rules.
- a sparse fail is typically an isolated single bit fail.
- a common type of fail is single bit fail 91 , 92 , 93 , 94 as shown in FIGS. 3A and 3B .
- Another type of fail is a “must” fail such as a line fail, which is a collection of single bit fails aligned along a row or a column 62 a .
- the must fail 90 can be repaired with a row redundant repair 62 a.
- the fail information from the tester 20 can be placed into a data structure using the sets of rules. If necessary, the fails can be rearranged by moving fails from one solution to another or combining two or more solutions. For example, two solutions, each of which corresponds to a sparse fail, sharing a single row or column can be coalesced into one solution. Sometimes a solution having a sparse fail can be absorbed into another solution having a must fail in it if two solutions share a single row or column.
- FIGS. 3A and 3B illustrate coalescing two solutions into one solution.
- the top sparse fail 93 in the lower right quadrant was in a repair solution 62 c , but is moved to a new repair solution 62 c ′ in FIG. 3B as a result of considering in the bottom sparse fail 94 .
- all the fails 90 , 91 , 92 , 93 , and 94 can be collected into one solution and prepared to be handled by a one-shot analysis.
- the queue 30 is provided in the data flow between the must redundancy analyzer 41 and the sparse redundancy analyzer 42 .
- the fail information from the tester 20 is processed for the must fails by the must redundancy analyzer 41 first, and the solutions from the must redundancy analyzer 41 and the remaining unprocessed fail information are placed into the queue 30 .
- the sparse redundancy analyzer 42 processes the sparse fails for each test pattern in parallel with other test patterns.
- the tester 20 does not have to wait for the must redundancy analyzer 41 and the sparse redundancy analyzer 42 to finish between test patterns, and can add new test results to the queue 30 .
- multiple test patterns can run following the analysis of a single test pattern with no loss to the test origin of fails.
- the parallel processing of the tester 20 and the redundancy analyzer 42 is made possible due to the introduction of the queue 30 .
- the queue 30 can hold must fail information, solutions for the must fails received from the must redundancy analyzer 41 , and the unprocessed sparse fail information.
- the queue 30 is implemented in software.
- the queue 30 permits separate processes, e.g., threads, to run in parallel.
- the must redundancy analyzer 41 can be integrated with the tester 20 .
- the queue 30 can receive the sparse fail information directly from the tester 20 .
- the solution information for previous test patterns can be stored in the result storage unit 50 ( FIG. 2 ).
- the sparse redundancy analyzer 42 can look up this solution information stored in the result storage unit in performing multiple test patterns on the DUT 10 .
- the tester 20 can also evaluate the stored solutions. This will be described later in reference to FIG. 4 .
- multiple test patterns are applied on the same DUT 10 .
- Some of the fails can not be detected by a simple test pattern, but can be detected by a more vigorous and deep test pattern.
- a first group of fails can be detected by one test pattern
- a second group of fails can be detected by another test pattern.
- the second group can include the first group.
- the sparse redundancy analyzer 42 looks up the solution information stored in the result storage unit for the solution for the first group of fails, and processes the second group of fails for the solution. This reuse of the previous results is beneficial because the number of newly detected fails in the second group typically decreases as the test progresses. For example, the number of fails detected in the first test pattern can be tens of thousands. In a second test pattern, the number of newly detected fails can drop to hundreds.
- Each of the must redundancy analyzer 41 , the queue 30 , and the sparse redundancy analyzer 42 can comprise a package of control software.
- the analysis of the fail information can be offloaded into a parallel evaluation space. This can facilitate parallel processing of testing and repairing.
- the introduction of the queue 30 allows for asynchronous parallel processing of the test and the repair. Multiple test patterns can be run in parallel with a previous test pattern's repair analysis. There is no waiting between the test patterns for repair analysis.
- the fails of the DUT 10 can be repaired in a way that reduces waste of the redundant rows and columns, thus leaving more elements available for repair during later test steps.
- the tester 20 and the redundancy analyzer 42 can work in parallel and due to the compression of the fail data, the tester 20 uses less memory space in the fail capture memory 22 .
- the fail capture memory 22 does not have to hold the test results for the entire DUT 10 .
- the DUT 10 can be tested in parts of a predetermined size and addresses adjusted (if necessary) when they are uploaded to the must redundancy analyzer 41 and the sparse redundancy analyzer 42 .
- a first repair solution for a sparse fail can be changed to a second repair solution to optimize the single repair solution and to reduce wasting the memory locations of the redundant rows and columns.
- Test patterns can comprise, for example, a nominal voltage test, a high voltage margin test, and a low voltage margin test.
- the queue 30 can hold the fail information from the tester 20 and the solution information from the first redundancy analyzer 41 .
- the result storage unit 50 can hold solutions from the sparse redundancy analyzer 142 .
- the apparatus 102 can comprise two queues, e.g., a fail queue and a result queue, as shown in FIG. 4 .
- FIG. 4 is a flowchart illustrating a test process having 3 threads (processes) according to an embodiment.
- the portions of processes can be performed by a general purpose computer.
- the processes can be performed in parallel in the three independent threads, i.e., Thread 1 110 , Thread 2 120 , and Thread 3 130 in FIG. 4 .
- the test patterns are generally performed in Thread 1
- the redundancy analysis on the must fails is performed in Thread 2
- the redundancy analysis on the sparse fails is performed in Thread 3 .
- the spawning of Thread 2 occurs for every test pattern of Thread 1
- the spawning of Thread 3 occurs once per DUT.
- a thread does not have to wait for another thread to complete.
- Efficient parallel processing is made possible by the processes of queuing the fails S 1130 and the results S 1140 .
- queuing is performed in software.
- test patterns that come early in the testflow typically have more failures, and therefore take more time to process.
- the sparse redundancy analyzer (Thread 3 ) typically falls behind test patterns (Thread 1 ) early in the test cycle due to the number of failures to analyze. Since the test patterns and redundancy analysis can be processed in parallel, however, the testflow does not have to get stalled. This typically allows the sparse redundancy analyzer to catch up later in the testflow when fewer additional fails are processed.
- the whole process starts at S 1010 , from which the threads are spawned directly or indirectly. Threads 1 and 3 are started at S 1015 . A test is performed using the first test pattern in S 1020 . The test results are copied for later analysis by the redundancy analysis process in S 1030 and Thread 2 starts in S 1040 . The tests using second and subsequent test patterns are performed at S 1050 . In one embodiment, the step S 1030 is optional.
- the must redundancy analysis is performed in S 1100 , and the sparse redundancy analysis is performed in S 1220 to be described later.
- the must redundancy analysis is spawned and initiated from the Thread 1 at S 1040 .
- the must analysis process is not threaded, and steps S 1100 , S 1110 , and S 1120 are performed in line at step S 1040 .
- the must redundancy analysis results from S 1100 is received at S 1110 and then queued in S 1140 by S 1120 .
- a must redundancy analysis process separates the must fails from sparse fails in a first queue for parallel analysis with a sparse redundancy analysis process (S 1220 ).
- the must redundancy analysis process can be optional. That is, the sparse redundancy analyzer can process all the fails as sparse fails and produce repair solutions.
- the redundancy analysis of Thread 3 for a particular test pattern can be done in the background after the must redundancy analysis process of Thread 2 for the particular test pattern by the must redundancy analyzer is complete.
- the test pattern process (Thread 1 ) should wait for the must redundancy analyzer to finish the must screening for a particular test pattern before continuing (S 1060 ), but that task should finish relatively more quickly than with the conventional system of FIG. 1 since it is doing far less work by delegating the analysis on the sparse fails to the sparse redundancy analyzer (Thread 3 ).
- the tester can proceed through several test patterns while the sparse redundancy analysis process is running for an earlier test pattern.
- the bin fails queue (S 1130 ) holds the data from each of these test patterns.
- the parallel redundancy analysis S 1200 waits S 1210 for the fail information from S 1130 , processes the sparse fails at S 1220 , and places its results S 1230 in a second queue (S 1140 ) which the test process checks between test patterns (S 1070 ) to determine if the flow can abort to S 1080 if the DUT has been rejected.
- the testflow does not need to wait for solutions until the test patterns have been completed (S 1080 ).
- a repair solution can be stored in the sparse redundancy analyzer 42 .
- the manipulation such as optimization of the repair solution can occur also in the sparse redundancy analyzer 42 .
- One embodiment is an apparatus for efficient test of a memory device comprising a main array and a plurality of redundant row and columns, each of which have a plurality of memory locations
- the apparatus includes: a tester configured to perform multiple test patterns on the plurality of memory locations and to generate fail information for at least a part of the memory locations; a queue configured to receive the sparse fail information from the tester; and a redundancy analyzer configured to process at least part of the plurality of fails received from the queue and configured to generate corresponding repair solutions; wherein the tester is configured to proceed with a next test pattern before the redundancy analyzer processing the fail information from a previous test pattern.
- FIG. 5 is a flowchart illustrating a test process according to another embodiment.
- One embodiment is a method of repairing a memory device, wherein the method includes: applying a plurality of test patterns to a memory device to detect fails (S 2010 ); and performing a redundancy analysis for the detected fails in a parallel processing path asynchronous to the application of the test patterns (S 2020 ).
- the method can further comprise: storing the fails from test patterns for access by the redundancy analysis process; and initiating the third test pattern before redundancy analysis for the first test pattern is complete.
- the method can still further comprise spawning a first thread for processing the fails from the test pattern and generates repair solutions. The process is finished when all the test patterns are performed and all the detected fails are processed.
- Some redundancy analyzers completely re-evaluate the repair solution after any additional test pattern.
- the process of evaluation can remove the need for a complete evaluation, leveraging required repairs defined earlier and evaluating the solutions required from newly added fails.
- the method can further comprise initiating a subsequent redundancy analysis for processing a plurality of sparse fails after receiving fail information of the last of the multiple test patterns.
- the method can further comprise maintaining and retrieving at least part of fails from at least part of the multiple test patterns and solutions from the redundancy analysis. Receiving failure information, initiating redundancy analysis, initiating a subsequent test pattern, and initiating a subsequent redundancy analysis can be performed substantially concurrently through maintaining and retrieving from the queue.
- the fail information for each test pattern can be compressed.
- the fails are accumulated during analysis rather than before analysis, and can be compressed based on a repair architecture rather than accumulating a full bitmap for the entire DUT 10 . This allows for an algorithm to reuse previous analysis result as basis for current test pattern, and yet still allows for manipulation of previous result.
- the must redundancy analyzer 41 and the sparse redundancy analyzer 42 can retrieve the previous analysis result from a result storage unit 50 ( FIG. 2 ) and perform an analysis on the single newly found fail.
Abstract
A memory redundancy analyzing apparatus having a tester, a queue, and a redundancy analyzer is provided. The tester includes testing portions for different types of fails, and each of the testing portions performs multiple tests on the memory locations and outputs fail information for at least a part of the memory device. The queue stores the fail information. The redundancy analyzer processes the fails using the fail information and produces a plurality of repair solutions. The types of fails include must fails and sparse fails. The fail information is transmitted to the queue, and the fail information includes at least a part of the fail information for the entire memory device. The tester can operate asynchronously from the redundancy analyzer.
Description
- 1. Field of the Invention
- One embodiment generally relates to test of memory devices. In particular, one embodiment relates to systems and methods of repairing memory devices.
- 2. Description of the Related Art
- Semiconductor memory devices can be found in a wide variety of electronics devices. Modern memory devices are relatively large in size and relatively inexpensive. A memory device typically includes at least one array of memory cells arranged in rows and columns. In a relatively large array, it can be expected that some cells will not be usable. Accordingly, redundant rows and columns exist to repair the defective cells via redundancy analysis. Tests are performed on memory devices to identify the cells that need to be replaced. For relatively large arrays, these tests comprising test patterns can be time-consuming and relatively expensive. For example, many test patterns may be run to test for gross failures, and to test for margin such as voltage, speed, and the like.
-
FIG. 1 is a flowchart illustrating an example of a conventional test and redundancy analysis. For example, the process can be performed by Automated Test Equipment (ATE). - To be more specific, the process starts in step S910. In step S920, a first test pattern is chosen and applied to the device under test (DUT). The test results from step S920, i.e., the information on the failed memory locations (the fails), are collected into a fail capture memory, which is a storage device to store the information on the fails. The fail information from test patterns includes information on the fails such as internal addresses. The solution or solution information from redundancy analysis includes information on which redundant rows or columns would be activated to replace and repair the fails. In step S930, the test results are copied for a redundancy analyzer so that a test pattern and a redundancy analysis for an immediately prior test pattern can be run in parallel. In step S940,
Threads Thread 1. In the step S950, the redundancy analysis for both the must fail and sparse fails is performed. The redundancy analysis of S950 can take more time or less time to complete than the test pattern S960. When the step S970 waits for completion of the step S950, the test as a whole runs slower than the speed at which the ATE can perform the test patterns, which adds time and cost to the DUT. For example, in the prior art, a second test with “next pattern” S960 is on hold waiting S970 for the redundancy analysis S950 obtained from the first test with “1st pattern” S920 is done. Once the step S950 is done, then the process can return to S930 via S970 to run further test patterns and redundancy analysis, or finishes the process. - These drawings and the associated description herein are provided to illustrate specific embodiments and are not intended to be limiting.
-
FIG. 1 is a flowchart illustrating a conventional redundancy analysis. -
FIG. 2 is a schematic block diagram of an apparatus for repairing a memory device. -
FIG. 3A is a diagram illustrating fails and repair for an array of a memory device. -
FIG. 3B is a diagram illustrating manipulating a solution for the repair ofFIG. 3A . -
FIG. 4 is a flowchart illustrating a test process according to an embodiment. -
FIG. 5 is a flowchart illustrating a test process according to another embodiment. -
FIG. 2 shows a schematic block diagram illustrating anapparatus 102 for testing and/or repairing a memory device under test (DUT) 10. The memory device can include any memory device such as DRAM, SDRAM, SRAM, MRAM, FRAM, Flash, EEPROM, PCRAM, etc. - The
apparatus 102 comprises atester 20, afail capture memory 22, amust redundancy analyzer 41, aqueue 30, asparse redundancy analyzer 42, aresult storage unit 50, apattern generator 21, and acontroller 104. Thetester 20 performs tests (test patterns) on theDUT 10 to determine memory locations that fail. The “fails” are collected and stored temporarily at thefail capture memory 22 in thetester 20. Themust redundancy analyzer 41 and thesparse redundancy analyzer 42 process the information on the fails to produce a solution to repair the problematic memory locations. Thecontroller 104 is configured to control thepattern generator 21, thefail capture memory 22, and themust redundancy analyzer 41 in thetester 20. Thepattern generator 21 generates multiple test patterns to test theDUT 10 with. - Most types of memory devices, such as DRAM, have row and column repairs. However, the illustrated test process is applicable to other types of repair such as blocks (single repairs that can replace multiple rows or columns), two dimensional plane repairs for a three dimensional array, or the like.
- There can be a plurality of
testers 20 in a system. In one embodiment, each of thetesters 20 can communicate with a sparse redundancy analyzer as indicated by a dottedbox 106 including aqueue 30, asparse redundancy analyzer 42, and aresult storage unit 50 as shown inFIG. 2 . In another embodiment, the dottedbox portion 106 can be shared by one or more thetesters 20. In the illustrated embodiment, analysis of must fails is performed by themust redundancy analyzer 41 and sparse fails by thesparse redundancy analyzer 42. Fails are either must fails or sparse fails, and these concepts are explained below. - Repairing of a memory device and manipulating a solution are explained with reference to
FIGS. 3A and 3B . - A must fail 62 a in
FIG. 3B corresponds to multiple single bit fails that should be repaired by a single element. A sparse fail is a single bit fail that is not part of a must fail. The other fails inFIG. 3B can be sparse fails. A single element can repair one or more sparse fails. - To optimize the solution to repair of the fails 91, the solution information for the fail information can be manipulated in the sparse redundancy analyzer 42 (
FIG. 2 ) using sets of rules. The must fail 90 and sparse fails 91, 92, 93, 94 can be taken and handled using the sets of rules. A sparse fail is typically an isolated single bit fail. A common type of fail is single bit fail 91, 92, 93, 94 as shown inFIGS. 3A and 3B . Another type of fail is a “must” fail such as a line fail, which is a collection of single bit fails aligned along a row or acolumn 62 a. In the illustrated example, the must fail 90 can be repaired with a rowredundant repair 62 a. - The fail information from the
tester 20 can be placed into a data structure using the sets of rules. If necessary, the fails can be rearranged by moving fails from one solution to another or combining two or more solutions. For example, two solutions, each of which corresponds to a sparse fail, sharing a single row or column can be coalesced into one solution. Sometimes a solution having a sparse fail can be absorbed into another solution having a must fail in it if two solutions share a single row or column. -
FIGS. 3A and 3B illustrate coalescing two solutions into one solution. The topsparse fail 93 in the lower right quadrant was in arepair solution 62 c, but is moved to anew repair solution 62 c′ inFIG. 3B as a result of considering in the bottomsparse fail 94. Alternatively, all the fails 90, 91, 92, 93, and 94 can be collected into one solution and prepared to be handled by a one-shot analysis. - Returning now to
FIG. 2 , thequeue 30 is provided in the data flow between themust redundancy analyzer 41 and thesparse redundancy analyzer 42. The fail information from thetester 20 is processed for the must fails by themust redundancy analyzer 41 first, and the solutions from themust redundancy analyzer 41 and the remaining unprocessed fail information are placed into thequeue 30. Then, thesparse redundancy analyzer 42 processes the sparse fails for each test pattern in parallel with other test patterns. In one embodiment, thetester 20 does not have to wait for themust redundancy analyzer 41 and thesparse redundancy analyzer 42 to finish between test patterns, and can add new test results to thequeue 30. In one embodiment, multiple test patterns can run following the analysis of a single test pattern with no loss to the test origin of fails. The parallel processing of thetester 20 and theredundancy analyzer 42 is made possible due to the introduction of thequeue 30. - The
queue 30 can hold must fail information, solutions for the must fails received from themust redundancy analyzer 41, and the unprocessed sparse fail information. In one embodiment, thequeue 30 is implemented in software. Thequeue 30 permits separate processes, e.g., threads, to run in parallel. Themust redundancy analyzer 41 can be integrated with thetester 20. Thequeue 30 can receive the sparse fail information directly from thetester 20. - The solution information for previous test patterns can be stored in the result storage unit 50 (
FIG. 2 ). Thesparse redundancy analyzer 42 can look up this solution information stored in the result storage unit in performing multiple test patterns on theDUT 10. Thetester 20 can also evaluate the stored solutions. This will be described later in reference toFIG. 4 . - Usually, multiple test patterns are applied on the
same DUT 10. Some of the fails can not be detected by a simple test pattern, but can be detected by a more vigorous and deep test pattern. When multiple test patterns are performed on thesingle DUT 10, a first group of fails can be detected by one test pattern, and a second group of fails can be detected by another test pattern. The second group can include the first group. In one embodiment, thesparse redundancy analyzer 42 looks up the solution information stored in the result storage unit for the solution for the first group of fails, and processes the second group of fails for the solution. This reuse of the previous results is beneficial because the number of newly detected fails in the second group typically decreases as the test progresses. For example, the number of fails detected in the first test pattern can be tens of thousands. In a second test pattern, the number of newly detected fails can drop to hundreds. - Each of the
must redundancy analyzer 41, thequeue 30, and thesparse redundancy analyzer 42 can comprise a package of control software. - By introducing the
queue 30, the analysis of the fail information can be offloaded into a parallel evaluation space. This can facilitate parallel processing of testing and repairing. The introduction of thequeue 30 allows for asynchronous parallel processing of the test and the repair. Multiple test patterns can be run in parallel with a previous test pattern's repair analysis. There is no waiting between the test patterns for repair analysis. - In one embodiment, by manipulating the fail information and the solution information as in compressing the fail information and the solution information, the fails of the
DUT 10 can be repaired in a way that reduces waste of the redundant rows and columns, thus leaving more elements available for repair during later test steps. - Since the
tester 20 and theredundancy analyzer 42 can work in parallel and due to the compression of the fail data, thetester 20 uses less memory space in thefail capture memory 22. Thefail capture memory 22 does not have to hold the test results for theentire DUT 10. TheDUT 10 can be tested in parts of a predetermined size and addresses adjusted (if necessary) when they are uploaded to themust redundancy analyzer 41 and thesparse redundancy analyzer 42. - A first repair solution for a sparse fail can be changed to a second repair solution to optimize the single repair solution and to reduce wasting the memory locations of the redundant rows and columns.
- Test patterns can comprise, for example, a nominal voltage test, a high voltage margin test, and a low voltage margin test.
- The
queue 30 can hold the fail information from thetester 20 and the solution information from thefirst redundancy analyzer 41. Theresult storage unit 50 can hold solutions from the sparse redundancy analyzer 142. Furthermore, theapparatus 102 can comprise two queues, e.g., a fail queue and a result queue, as shown inFIG. 4 . -
FIG. 4 is a flowchart illustrating a test process having 3 threads (processes) according to an embodiment. In one embodiment, the portions of processes can be performed by a general purpose computer. The processes can be performed in parallel in the three independent threads, i.e.,Thread 1 110,Thread 2 120, andThread 3 130 inFIG. 4 . The test patterns are generally performed inThread 1, the redundancy analysis on the must fails is performed inThread 2, and the redundancy analysis on the sparse fails is performed inThread 3. In the illustrated embodiment, the spawning ofThread 2 occurs for every test pattern ofThread 1, and the spawning ofThread 3 occurs once per DUT. A thread does not have to wait for another thread to complete. Efficient parallel processing is made possible by the processes of queuing the fails S1130 and the results S1140. In one embodiment, queuing is performed in software. - In practice, test patterns that come early in the testflow typically have more failures, and therefore take more time to process. For example, the sparse redundancy analyzer (Thread 3) typically falls behind test patterns (Thread 1) early in the test cycle due to the number of failures to analyze. Since the test patterns and redundancy analysis can be processed in parallel, however, the testflow does not have to get stalled. This typically allows the sparse redundancy analyzer to catch up later in the testflow when fewer additional fails are processed.
- In the illustrated embodiment of a testing process as shown in
FIG. 4 , the whole process starts at S1010, from which the threads are spawned directly or indirectly.Threads Thread 2 starts in S1040. The tests using second and subsequent test patterns are performed at S1050. In one embodiment, the step S1030 is optional. - Using the test results, the must redundancy analysis is performed in S1100, and the sparse redundancy analysis is performed in S1220 to be described later. The must redundancy analysis is spawned and initiated from the
Thread 1 at S1040. In an alternative embodiment, the must analysis process is not threaded, and steps S1100, S1110, and S1120 are performed in line at step S1040. The must redundancy analysis results from S1100 is received at S1110 and then queued in S1140 by S1120. A must redundancy analysis process separates the must fails from sparse fails in a first queue for parallel analysis with a sparse redundancy analysis process (S1220). In one embodiment, the must redundancy analysis process can be optional. That is, the sparse redundancy analyzer can process all the fails as sparse fails and produce repair solutions. - The redundancy analysis of
Thread 3 for a particular test pattern can be done in the background after the must redundancy analysis process ofThread 2 for the particular test pattern by the must redundancy analyzer is complete. The test pattern process (Thread 1) should wait for the must redundancy analyzer to finish the must screening for a particular test pattern before continuing (S1060), but that task should finish relatively more quickly than with the conventional system ofFIG. 1 since it is doing far less work by delegating the analysis on the sparse fails to the sparse redundancy analyzer (Thread 3). For example, the tester can proceed through several test patterns while the sparse redundancy analysis process is running for an earlier test pattern. The bin fails queue (S1130) holds the data from each of these test patterns. The parallel redundancy analysis S1200 waits S1210 for the fail information from S1130, processes the sparse fails at S1220, and places its results S1230 in a second queue (S1140) which the test process checks between test patterns (S1070) to determine if the flow can abort to S1080 if the DUT has been rejected. The testflow does not need to wait for solutions until the test patterns have been completed (S1080). - A repair solution can be stored in the
sparse redundancy analyzer 42. The manipulation such as optimization of the repair solution can occur also in thesparse redundancy analyzer 42. - Due to the decoupling of the
sparse redundancy analyzer 42 from themust redundancy analyzer 41, there is no need for the repair solution to be cleared between every test pattern. For the repair solutions from a previous test pattern can be queued into theresult storage unit 50. It can be burdensome if a redundancy analysis should be started from a clean slate at every test pattern. - One embodiment is an apparatus for efficient test of a memory device comprising a main array and a plurality of redundant row and columns, each of which have a plurality of memory locations, wherein the apparatus includes: a tester configured to perform multiple test patterns on the plurality of memory locations and to generate fail information for at least a part of the memory locations; a queue configured to receive the sparse fail information from the tester; and a redundancy analyzer configured to process at least part of the plurality of fails received from the queue and configured to generate corresponding repair solutions; wherein the tester is configured to proceed with a next test pattern before the redundancy analyzer processing the fail information from a previous test pattern.
-
FIG. 5 is a flowchart illustrating a test process according to another embodiment. One embodiment is a method of repairing a memory device, wherein the method includes: applying a plurality of test patterns to a memory device to detect fails (S2010); and performing a redundancy analysis for the detected fails in a parallel processing path asynchronous to the application of the test patterns (S2020). - The method can further comprise: storing the fails from test patterns for access by the redundancy analysis process; and initiating the third test pattern before redundancy analysis for the first test pattern is complete. The method can still further comprise spawning a first thread for processing the fails from the test pattern and generates repair solutions. The process is finished when all the test patterns are performed and all the detected fails are processed.
- Some redundancy analyzers completely re-evaluate the repair solution after any additional test pattern. Alternatively, the process of evaluation can remove the need for a complete evaluation, leveraging required repairs defined earlier and evaluating the solutions required from newly added fails.
- The method can further comprise initiating a subsequent redundancy analysis for processing a plurality of sparse fails after receiving fail information of the last of the multiple test patterns. The method can further comprise maintaining and retrieving at least part of fails from at least part of the multiple test patterns and solutions from the redundancy analysis. Receiving failure information, initiating redundancy analysis, initiating a subsequent test pattern, and initiating a subsequent redundancy analysis can be performed substantially concurrently through maintaining and retrieving from the queue.
- In an embodiment, the fail information for each test pattern can be compressed. The fails are accumulated during analysis rather than before analysis, and can be compressed based on a repair architecture rather than accumulating a full bitmap for the
entire DUT 10. This allows for an algorithm to reuse previous analysis result as basis for current test pattern, and yet still allows for manipulation of previous result. - For example, if five fails were located in a previous analysis and six fails in a current analysis, and if five of the six fails are the same as in the previous analysis, the
must redundancy analyzer 41 and thesparse redundancy analyzer 42 do not have to analyze all six fails in the current analysis. Themust redundancy analyzer 41 and thesparse redundancy analyzer 42 can retrieve the previous analysis result from a result storage unit 50 (FIG. 2 ) and perform an analysis on the single newly found fail. - Various embodiments have been described above. Although described with reference to these specific embodiments, the descriptions are intended to be illustrative and are not intended to be limiting. Various modifications and applications can occur to those skilled in the art without departing from the true spirit and scope of the invention as defined in the appended claims.
Claims (17)
1. An apparatus for efficient test of a memory device comprising a main array and a plurality of redundant row and columns, each of which have a plurality of memory locations, the apparatus comprising:
a tester configured to perform multiple test patterns on the plurality of memory locations and to generate fail information for at least a part of the memory locations;
a queue configured to receive the sparse fail information from the tester; and
a redundancy analyzer configured to process at least part of the plurality of fails received from the queue and configured to generate corresponding repair solutions;
wherein the tester is configured to proceed with a next test pattern before the redundancy analyzer processing the fail information from a previous test pattern.
2. The apparatus of claim 1 , wherein the tester further comprises a fail capture memory that receives the fail information from the tester.
3. The apparatus of claim 1 , wherein the redundancy analyzer is configured to manipulate the plurality of repair solutions.
4. The apparatus of claim 3 , wherein the redundancy analyzer changes a first repair solution for a sparse fail into a second repair solution to optimize the repair solution and to reduce the number of redundant rows and columns used in the repair solution.
5. The apparatus of claim 1 , further comprising a result storage unit configured to maintain at least part of the plurality of repair solutions previously evaluated from a previous test pattern, the result storage unit communicating with the redundancy analyzer.
6. The apparatus of claim 5 , wherein each of the plurality of repair solutions comprises addresses of fails and corresponding solutions, and wherein each of the plurality of repair solutions comprises information regarding disconnection of at least one fail and linkage of a plurality of redundant memory locations for replacement.
7. The apparatus of claim 1 , wherein the queue is implemented by software executed by a computer.
8. The apparatus of claim 1 , wherein the redundancy analyzer is configured to analyze sparse fails, further comprising a must redundancy analyzer configured to receive must fail information from the tester and configured to generate must fail solutions.
9. The apparatus of claim 8 , wherein the must redundancy analyzer is configured to proceed to process fail information from the next test pattern before the redundancy analyzer processing the fail information from the previous test pattern.
10. The apparatus of claim 9 , wherein the queue is configured to receive the repair solutions from the must redundancy analyzer.
11. The apparatus of claim 10 , wherein the redundancy analyzer is configured to receive at least part of the fails and the repair solutions from the queue.
12. A method of repairing a memory device, the method comprising:
applying a plurality of test patterns to a memory device to detect fails; and
performing a redundancy analysis for the detected fails in a parallel processing path asynchronous to applying the test patterns.
13. The method of claim 12 , wherein the plurality of test patterns comprise at least a first test pattern, a second test pattern, and a third test pattern, wherein the first test pattern is performed earlier in time than the second test pattern, and wherein the second test pattern is performed earlier in time than the third test pattern, further comprising: storing the fails from test patterns for access by the redundancy analysis process; and initiating the third test pattern before redundancy analysis for the first test pattern is complete.
14. The method of claim 13 , further comprising spawning a first thread for processing the fails from the test pattern and generates repair solutions, wherein the repair solutions comprise a plurality of must repair solutions.
15. The method of claim 14 , further comprising spawning a second thread for processing the fails from the test patterns and generates repair solutions, wherein the repair solutions comprise a plurality of sparse repair solutions.
16. The method of claim 15 , further comprising manipulating the must repair solutions and the sparse repair solutions to combine and optimize the repair solutions.
17. The method of claim 13 , wherein number of fails from each of the plurality of patterns diminishes as the number of the applied test patterns increases.
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/739,599 US20080270854A1 (en) | 2007-04-24 | 2007-04-24 | System and method for running test and redundancy analysis in parallel |
US12/490,657 US8086916B2 (en) | 2007-04-24 | 2009-06-24 | System and method for running test and redundancy analysis in parallel |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US11/739,599 US20080270854A1 (en) | 2007-04-24 | 2007-04-24 | System and method for running test and redundancy analysis in parallel |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/490,657 Division US8086916B2 (en) | 2007-04-24 | 2009-06-24 | System and method for running test and redundancy analysis in parallel |
Publications (1)
Publication Number | Publication Date |
---|---|
US20080270854A1 true US20080270854A1 (en) | 2008-10-30 |
Family
ID=39888488
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US11/739,599 Abandoned US20080270854A1 (en) | 2007-04-24 | 2007-04-24 | System and method for running test and redundancy analysis in parallel |
US12/490,657 Active 2027-10-27 US8086916B2 (en) | 2007-04-24 | 2009-06-24 | System and method for running test and redundancy analysis in parallel |
Family Applications After (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/490,657 Active 2027-10-27 US8086916B2 (en) | 2007-04-24 | 2009-06-24 | System and method for running test and redundancy analysis in parallel |
Country Status (1)
Country | Link |
---|---|
US (2) | US20080270854A1 (en) |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10446253B2 (en) | 2018-02-01 | 2019-10-15 | Samsung Electronics Co., Ltd. | Semiconductor memory device and repair method thereof |
TWI700584B (en) * | 2018-07-06 | 2020-08-01 | 華邦電子股份有限公司 | Testing system and adaptive method of generating testing program |
US10748636B2 (en) | 2018-09-04 | 2020-08-18 | Winbond Electronics Corp. | Testing system and adaptive method of generating test program |
US20210406144A1 (en) * | 2020-06-30 | 2021-12-30 | Tektronix, Inc. | Test and measurement system for analyzing devices under test |
Families Citing this family (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8549480B2 (en) * | 2008-05-13 | 2013-10-01 | Hewlett-Packard Development Company, L.P. | Maintenance for automated software testing |
US9202595B2 (en) | 2013-11-12 | 2015-12-01 | Micron Technology, Inc. | Post package repair of memory devices |
US9343184B2 (en) | 2014-04-07 | 2016-05-17 | Micron Technology, Inc. | Soft post package repair of memory devices |
US9741403B2 (en) | 2014-11-12 | 2017-08-22 | Micron Technology, Inc. | Apparatuses and methods to perform post package trim |
US9349491B1 (en) | 2015-04-17 | 2016-05-24 | Micron Technology, Inc. | Repair of memory devices using volatile and non-volatile memory |
US10832791B2 (en) | 2019-01-24 | 2020-11-10 | Micron Technology, Inc. | Apparatuses and methods for soft post-package repair |
US11360840B2 (en) | 2020-01-20 | 2022-06-14 | Samsung Electronics Co., Ltd. | Method and apparatus for performing redundancy analysis of a semiconductor device |
Citations (29)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US588115A (en) * | 1897-08-10 | Bicycle-lamp | ||
US4627053A (en) * | 1983-03-31 | 1986-12-02 | Hitachi, Ltd. | Method of repairing semiconductor memory |
US5588115A (en) * | 1993-01-29 | 1996-12-24 | Teradyne, Inc. | Redundancy analyzer for automatic memory tester |
US5657075A (en) * | 1993-02-05 | 1997-08-12 | Teradyne, Inc. | Method and apparatus for locating and facilitating the repair of defects on a printed circuit board |
US5754556A (en) * | 1996-07-18 | 1998-05-19 | Teradyne, Inc. | Semiconductor memory tester with hardware accelerators |
US5795797A (en) * | 1995-08-18 | 1998-08-18 | Teradyne, Inc. | Method of making memory chips using memory tester providing fast repair |
US5841783A (en) * | 1995-11-29 | 1998-11-24 | Advantest Corporation | Fail address analysis and repair system for semiconductor test |
US5867435A (en) * | 1996-08-20 | 1999-02-02 | Advantest Corporation | Fault repair method for a memory device |
US5914964A (en) * | 1995-07-19 | 1999-06-22 | Advantest Corp. | Memory fail analysis device in semiconductor memory test system |
US5985677A (en) * | 1990-05-19 | 1999-11-16 | Advantest Corporation | Method of repairing semiconductor memory, electron-beam memory repairing apparatus and redundancy memory circuit to which the method of repairing semiconductor memory is applicable |
US6103991A (en) * | 1996-08-30 | 2000-08-15 | Advantest Corp. | Laser machining apparatus |
US6324665B1 (en) * | 1998-11-03 | 2001-11-27 | Agilent Technologies, Inc. | Event based fault diagnosis |
US6353801B1 (en) * | 1999-04-09 | 2002-03-05 | Agilent Technologies, Inc. | Multi-resolution adaptive solution refinement technique for a method of moments-based electromagnetic simulator |
US6442724B1 (en) * | 1999-04-02 | 2002-08-27 | Teradyne, Inc. | Failure capture apparatus and method for automatic test equipment |
US6459292B1 (en) * | 1999-04-30 | 2002-10-01 | Advantest Corporation | Testing system for semiconductor device |
US6499118B1 (en) * | 2000-05-17 | 2002-12-24 | Teradyne, Inc. | Redundancy analysis method and apparatus for ATE |
US6590182B1 (en) * | 1997-10-20 | 2003-07-08 | Advantest, Corp. | Laser repair apparatus and method |
US6594788B1 (en) * | 1999-07-16 | 2003-07-15 | Advantest Corporation | Method of analyzing a relief of failure cell in a memory and memory testing apparatus having a failure relief analyzer using the method |
US6627880B2 (en) * | 2000-02-17 | 2003-09-30 | Agilent Technologies, Inc. | Micro matrix ion generator for analyzers |
US6631488B1 (en) * | 2000-06-30 | 2003-10-07 | Agilent Technologies, Inc. | Configurable error detection and correction engine that has a specialized instruction set tailored for error detection and correction tasks |
US6651204B1 (en) * | 2000-06-01 | 2003-11-18 | Advantest Corp. | Modular architecture for memory testing on event based test system |
US6697290B2 (en) * | 2001-12-12 | 2004-02-24 | Agilent Technologies, Inc. | Apparatus for random access memory array self-repair |
US6711705B1 (en) * | 1999-07-21 | 2004-03-23 | Advantest Corporation | Method of analyzing a relief of failure cell in a memory and memory testing apparatus having a failure relief analyzer using the method |
US6710590B1 (en) * | 2002-12-12 | 2004-03-23 | Advantest Corporation | Test head Hifix for semiconductor device testing apparatus |
US6751140B2 (en) * | 2001-09-17 | 2004-06-15 | Infineon Technologies Ag | Method for testing integrated semiconductor memory devices |
US6804141B1 (en) * | 2003-05-20 | 2004-10-12 | Agilent Technologies, Inc. | Dynamic reference voltage calibration integrated FeRAMS |
US6840428B2 (en) * | 2001-08-30 | 2005-01-11 | Agilent Technologies, Inc. | Self-adhesive flexible repair circuit |
US6907385B2 (en) * | 2000-10-19 | 2005-06-14 | Advantest Corporation | Memory defect redress analysis treating method, and memory testing apparatus performing the method |
US7257753B2 (en) * | 2001-11-15 | 2007-08-14 | Advantest Corporation | Semiconductor testing apparatus |
Family Cites Families (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4782487A (en) * | 1987-05-15 | 1988-11-01 | Digital Equipment Corporation | Memory test method and apparatus |
US5983374A (en) * | 1996-09-26 | 1999-11-09 | Kabushiki Kaisha Toshiba | Semiconductor test system and method, and medium for recording test program therefor |
TW374951B (en) * | 1997-04-30 | 1999-11-21 | Toshiba Corp | Semiconductor memory |
US6499120B1 (en) * | 1999-12-30 | 2002-12-24 | Infineon Technologies Richmond, Lp | Usage of redundancy data for displaying failure bit maps for semiconductor devices |
DE10063627B4 (en) * | 2000-12-20 | 2016-03-31 | Polaris Innovations Ltd. | Integrated circuit with a data processing unit and a buffer |
KR100399435B1 (en) * | 2001-02-27 | 2003-09-29 | 주식회사 하이닉스반도체 | A semiconductor memory device and a repair analysis method therefor |
WO2005078736A1 (en) * | 2004-02-18 | 2005-08-25 | Advantest Corporation | Semiconductor device testing apparatus and testing method |
US7389453B2 (en) * | 2005-10-20 | 2008-06-17 | Jon Udell | Queuing methods for distributing programs for producing test data |
-
2007
- 2007-04-24 US US11/739,599 patent/US20080270854A1/en not_active Abandoned
-
2009
- 2009-06-24 US US12/490,657 patent/US8086916B2/en active Active
Patent Citations (31)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US588115A (en) * | 1897-08-10 | Bicycle-lamp | ||
US4627053A (en) * | 1983-03-31 | 1986-12-02 | Hitachi, Ltd. | Method of repairing semiconductor memory |
US5985677A (en) * | 1990-05-19 | 1999-11-16 | Advantest Corporation | Method of repairing semiconductor memory, electron-beam memory repairing apparatus and redundancy memory circuit to which the method of repairing semiconductor memory is applicable |
US5588115A (en) * | 1993-01-29 | 1996-12-24 | Teradyne, Inc. | Redundancy analyzer for automatic memory tester |
US5657075A (en) * | 1993-02-05 | 1997-08-12 | Teradyne, Inc. | Method and apparatus for locating and facilitating the repair of defects on a printed circuit board |
US5914964A (en) * | 1995-07-19 | 1999-06-22 | Advantest Corp. | Memory fail analysis device in semiconductor memory test system |
US5795797A (en) * | 1995-08-18 | 1998-08-18 | Teradyne, Inc. | Method of making memory chips using memory tester providing fast repair |
US5841783A (en) * | 1995-11-29 | 1998-11-24 | Advantest Corporation | Fail address analysis and repair system for semiconductor test |
US6434063B1 (en) * | 1996-05-22 | 2002-08-13 | Advantest Corporation | Method of repairing semiconductor memory, electron-beam memory repairing apparatus and redundancy memory circuit to which the method of repairing semiconductor memory is applicable |
US5754556A (en) * | 1996-07-18 | 1998-05-19 | Teradyne, Inc. | Semiconductor memory tester with hardware accelerators |
US5867435A (en) * | 1996-08-20 | 1999-02-02 | Advantest Corporation | Fault repair method for a memory device |
US6103991A (en) * | 1996-08-30 | 2000-08-15 | Advantest Corp. | Laser machining apparatus |
US6590182B1 (en) * | 1997-10-20 | 2003-07-08 | Advantest, Corp. | Laser repair apparatus and method |
US6324665B1 (en) * | 1998-11-03 | 2001-11-27 | Agilent Technologies, Inc. | Event based fault diagnosis |
US6442724B1 (en) * | 1999-04-02 | 2002-08-27 | Teradyne, Inc. | Failure capture apparatus and method for automatic test equipment |
US6353801B1 (en) * | 1999-04-09 | 2002-03-05 | Agilent Technologies, Inc. | Multi-resolution adaptive solution refinement technique for a method of moments-based electromagnetic simulator |
US6459292B1 (en) * | 1999-04-30 | 2002-10-01 | Advantest Corporation | Testing system for semiconductor device |
US6594788B1 (en) * | 1999-07-16 | 2003-07-15 | Advantest Corporation | Method of analyzing a relief of failure cell in a memory and memory testing apparatus having a failure relief analyzer using the method |
US6711705B1 (en) * | 1999-07-21 | 2004-03-23 | Advantest Corporation | Method of analyzing a relief of failure cell in a memory and memory testing apparatus having a failure relief analyzer using the method |
US6627880B2 (en) * | 2000-02-17 | 2003-09-30 | Agilent Technologies, Inc. | Micro matrix ion generator for analyzers |
US6499118B1 (en) * | 2000-05-17 | 2002-12-24 | Teradyne, Inc. | Redundancy analysis method and apparatus for ATE |
US6651204B1 (en) * | 2000-06-01 | 2003-11-18 | Advantest Corp. | Modular architecture for memory testing on event based test system |
US6631488B1 (en) * | 2000-06-30 | 2003-10-07 | Agilent Technologies, Inc. | Configurable error detection and correction engine that has a specialized instruction set tailored for error detection and correction tasks |
US6907385B2 (en) * | 2000-10-19 | 2005-06-14 | Advantest Corporation | Memory defect redress analysis treating method, and memory testing apparatus performing the method |
US6840428B2 (en) * | 2001-08-30 | 2005-01-11 | Agilent Technologies, Inc. | Self-adhesive flexible repair circuit |
US6751140B2 (en) * | 2001-09-17 | 2004-06-15 | Infineon Technologies Ag | Method for testing integrated semiconductor memory devices |
US7257753B2 (en) * | 2001-11-15 | 2007-08-14 | Advantest Corporation | Semiconductor testing apparatus |
US6697290B2 (en) * | 2001-12-12 | 2004-02-24 | Agilent Technologies, Inc. | Apparatus for random access memory array self-repair |
US6914833B2 (en) * | 2001-12-12 | 2005-07-05 | Agilent Technologies, Inc. | Apparatus for random access memory array self-repair |
US6710590B1 (en) * | 2002-12-12 | 2004-03-23 | Advantest Corporation | Test head Hifix for semiconductor device testing apparatus |
US6804141B1 (en) * | 2003-05-20 | 2004-10-12 | Agilent Technologies, Inc. | Dynamic reference voltage calibration integrated FeRAMS |
Cited By (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10446253B2 (en) | 2018-02-01 | 2019-10-15 | Samsung Electronics Co., Ltd. | Semiconductor memory device and repair method thereof |
TWI700584B (en) * | 2018-07-06 | 2020-08-01 | 華邦電子股份有限公司 | Testing system and adaptive method of generating testing program |
US10748636B2 (en) | 2018-09-04 | 2020-08-18 | Winbond Electronics Corp. | Testing system and adaptive method of generating test program |
US20210406144A1 (en) * | 2020-06-30 | 2021-12-30 | Tektronix, Inc. | Test and measurement system for analyzing devices under test |
US11782809B2 (en) * | 2020-06-30 | 2023-10-10 | Tektronix, Inc. | Test and measurement system for analyzing devices under test |
Also Published As
Publication number | Publication date |
---|---|
US20090265588A1 (en) | 2009-10-22 |
US8086916B2 (en) | 2011-12-27 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US8086916B2 (en) | System and method for running test and redundancy analysis in parallel | |
US8760949B2 (en) | Mechanisms for built-in self repair of memory devices using failed bit maps and obvious repairs | |
US6154714A (en) | Method for using wafer navigation to reduce testing times of integrated circuit wafers | |
US8037376B2 (en) | On-chip failure analysis circuit and on-chip failure analysis method | |
US6446017B1 (en) | Method and system for tracking manufacturing data for integrated circuit parts | |
US7571367B2 (en) | Built-in self diagnosis device for a random access memory and method of diagnosing a random access | |
US8724408B2 (en) | Systems and methods for testing and assembling memory modules | |
US20080208492A1 (en) | System and Method for Early Qualification of Semiconductor Devices | |
KR101133689B1 (en) | Device and method for repair analysis | |
DE60018468T2 (en) | CONSUMPTION OF REDUNDANCY DATA FOR DISPLAYING BIT ERROR CARDS FOR SEMICONDUCTOR ELEMENTS | |
US7474979B1 (en) | Integrated circuit device test system and method | |
CN115798559B (en) | Failure unit prediction method, device, equipment and storage medium | |
US6920596B2 (en) | Method and apparatus for determining fault sources for device failures | |
US6499118B1 (en) | Redundancy analysis method and apparatus for ATE | |
JP5001972B2 (en) | Semiconductor inspection system with self-inspection function for memory repair analysis | |
US7016242B2 (en) | Semiconductor memory apparatus and self-repair method | |
DE10019790C2 (en) | Test system for semiconductor devices | |
Tseng et al. | A built-in method to repair SoC RAMs in parallel | |
US20120229155A1 (en) | Semiconductor integrated circuit, failure diagnosis system and failure diagnosis method | |
KR101003076B1 (en) | Semiconductor device test apparatus and method | |
KR101836748B1 (en) | Apparatus and method for repairing memory banks by using various spare cells | |
KR102416994B1 (en) | Redudancy analysis method and redudancy analysis apparatus | |
KR20010006977A (en) | Method and system for analyzing a production failure in a semiconductor device | |
US6751760B2 (en) | Method and system for performing memory repair analysis | |
JP2012099603A (en) | Wafer test equipment, wafer test method and program |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MICRON TECHNOLOGY, INC., IDAHO Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:KOPEL, KRISTOPHER;REEL/FRAME:019226/0170 Effective date: 20070412 |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |