A Hybrid Approach to the test of Cache Memory Controllers Embedded in SoCs
|
|
- Erik Melton
- 6 years ago
- Views:
Transcription
1 14th IEEE International On-Line Testing Symposium 2008 A Hybrid Approach to the test of Cache Memory Controllers Embedded in SoCs W. J. Perez 1, J. Velasco 1, D. Ravotto 2, E. Sanchez 2, M. Sonza Reorda 2 1 Universidad del Valle Grupo de Bionanoelectrónica Cali, Colombia {wjperezh, jvelasco}@univalle.edu.co Abstract Software-Based Self-Test (SBST) is increasingly used for testing processor cores embedded in SoCs, mainly because it allows at-speed, low-cost testing, while requiring limited (if any) hardware modifications to the original design. However, the method requires effective techniques for generating suitable test programs and for monitoring the results. In the case of processor core testing, a particularly complex module to test is the cache controller, due to its limited accessibility and observability. In this paper we propose a hybrid methodology that exploits an Infrastructure Intellectual Property (I-IP) to complement an SBST algorithm for testing the data and instruction cache controllers of embedded processors in SoCs. In particular, the I-IP may be programmed to monitor the system buses and generate the appropriate feedback about the correct result of the executed programs (in terms of obtained hit or miss operations). The effectiveness of the proposed methodology is evaluated resorting to a sample SoC design. I. INTRODUCTION Today s high performing processors require efficient memory hierarchy subsystems. A memory hierarchy is usually organized into some consecutive levels of memory, each one smaller, faster, and more expensive per byte than the next one. The main goal of such a kind of structure is to provide the final user with a memory system as cheap and fast as possible [1]. One of the most important elements within the memory system that try to reduce the gap between fast and high performing processors cores and slow memory devices is the cache memory; indeed, in modern designs the relative chip area occupation of cache devices is about 50%, and is still growing. As sketched by the SIA05 [2] technology roadmap, today most of the integrated circuit (IC) manufacturing cost is brought by the test and validation processes. This work was partially supported by the European Union through the ALFA/NICRON Project. Contact author: E. Sanchez. Dip. Automatica e Informatica. Politecnico di Torino. Cso. Duca degli Abruzzi 24, 10129, Torino, Italy. Tel: , Fax ernesto.sanchez@polito.it 2 Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy {danilo.ravotto,ernesto.sanchez, Only few years ago, testing cost represented a small percentage of the total cost, but (among others) the increasing difficulty to generate appropriate testing and validation patterns, and the expensive elaboration times required to test an IC, raised these costs up to near 70%. Indeed, while the production costs continue to go down, the testing cost slope remains flat or trends upward. The previous considerations are particularly valid regarding the first level of memory hierarchy systems embedded in SoCs (Systems on Chip), i.e., caches, since there is not a mature enough methodology able to cope with all testing issues. In the SoC testing arena, Software-Based Self-Test (SBST) strategies are increasingly used for microprocessor and peripheral testing. These strategies are based on using the processor core itself to execute a program, which is able to test the processor, and possibly other cores accessible by it [9]. The program is loaded in an internal memory of the SoC; then, the onboard processor executes it and, eventually, the result produced by the system is checked by monitoring what is produced on specified output ports or memory variables. The method has several advantages with respect to traditional hardware-based ones (e.g., scan test): it allows cheap at-speed testing of the SoC; it is relatively fast and flexible; it has very limited, if any, requirements in terms of additional hardware for the test; it is applicable even when the structure of a core is not known, or cannot be modified. Currently, the real challenge of software-based testing techniques is how to generate effective test programs. An SBST algorithm devoted to test the circuitry implementing the controller of caches has been proposed in [8]: this algorithm assumes that an accurate counter is available, which is exploited to check whether the expected hit or miss operations are performed by the controller. However, in some case these accurate timers could not be available or easily usable. For this purpose, an alternative solution has been investigated, which is proposed in this paper. In the last years, a new family of cores, called Infrastructure Intellectual Property cores (I-IPs), has been introduced in order to improve (among the others) testing, silicon debugging, and diagnosis facilities in /08 $ IEEE DOI /IOLTS
2 SoCs [15]. For example in [12] and [13] the authors report the use of I-IPs for testing and fault detection in microprocessor based systems. As it has been experimentally demonstrated, the inclusion of I-IPs in a microprocessor-based SoC does not generate system performance degradation, nor requires an excessive hardware overhead, while improving testing and diagnostic capabilities of the SoC. In this paper we propose a hybrid strategy able to exploit SBST techniques and an improved version of an I-IP [12] for supporting the test of data and instruction cache controllers; the presented method is particularly suitable for post-production and incoming inspection testing of processor cores. The stimula are internally generated by the application of some specially crafted test programs, while test responses are observed by the I-IP, which generates an error signal when an unexpected behaviour is detected. The exploited test programs are generated by flexible and parametric algorithm, previously introduced and detailed in [8] able to generate implementationindependent solutions for different cache configurations. In a few words, the exploited algorithms are based on a series of specially crafted memory access operations able to generate cache hits and misses for every data element in the cache memory, while thoroughly exciting the rest of the cache controller. In the former approach [8] the authors exploited embedded timers to determine the correctness of the executed programs; on the contrary, in this case we propose the inclusion of an I-IP to accurately and inexpensively verify whether memory accesses have been performed. In order to provide the reader with enough information about the suitability and usefulness of the presented method, the detailed approach was implemented resorting to the implementation of a SoC containing a processor core with data and instruction caches; we will also provide the reader with a feedback about the real performance of the approach detailing information about stuck-at fault coverage and test length duration, as well as about the hardware overhead required to implement the proposed I-IP. The rest of the paper is organized as follows: section II outlines the basic concepts required to better understand the rest of the paper; section III describes the proposed approach, and sections IV and V illustrate a proposed case study and the gathered experimental results. Finally, section VI concludes the paper. II.BACKGROUND Different approaches have been proposed to deal with cache testing. These approaches can be classified in two basic categories: software-based and hardwarebased techniques. Hardware-based approaches usually require considerable modifications to the initial design in order to support testing procedures but it normally allows too high frequency operation testing. For example in [3], the authors propose a structural modification of the cache architecture in order to improve the IDDQ (Quiescent supply current) testing sensitivity. In [4], authors include a MBIST (Memory Built-in Self-Test) device capable of applying an improved March C- algorithm to L1 and L2 caches. Software-based approaches, on the other side, normally propose a direct transformation of March-like tests in order to test mainly the data part of cache memories [5], [6], [7]. The main drawback of these methodologies relies on the fact that these methods require the adoption of special system features to facilitate main memory writing and reading operations while the cache memory is disabled; such enabling-disabling mechanisms may not be present in SoCs normal operation mode. Moreover, these methods do not adequately deal with the test of the control part of the cache, despite the importance of this part for the correct behaviour of the processor. Alternatively, in [8] the authors proposed an SBST-based technique suitable for testing the controller of data cache memories. This technique does not require special features in the cache memory but relies on an accurate counter in order to validate cache memory operations. A. Cache memory description Cache memories are small but fast memories placed in the first levels of the memory hierarchy. Roughly speaking, caches are composed of two clearly separated parts: data part and control part. The data portion in caches is organized in cache lines, usually containing a data storage portion, an address tag, and some validity bits. Each data storage portion is called a block; cache blocks are grouped together forming the so called data storage array. Tags and validity bits are usually stored together; tags contain the high order address bits of the memory block stored in each line, whereas validity bits enclose information about the current status of the cache line. The three most adopted organization models for the cache are direct mapped, set associative and fully associative, while the most common writing mechanisms are write-through and write-back [1]. The cache control circuit is devoted to manage the data part by performing the following tasks: determine if a required block is placed in cache (hit) or not (miss), place a block in the appropriate cache position, find a block in cache, replace a block on a miss, and eventually, in the case of data caches, write in the main memory the updated information when it is required. Comparing the most significant bits of the effective address with the cache tags, the cache controller is able to determine whether a required data or instruction is in the cache or not. In the case of read misses, the controller circuit performs block replacements following the adopted replacement policy (random, least recently replaced, least recently used, etc.). The valid bits are used together with tags to understand if a cache block contains or not valid information. Dirty bits are used to indicate the presence of modified data inside the cache memory in caches that implement the write-back policy. 144
3 B. Cache controller testing challenges The cache controller is a module deeply embedded in the SoC architecture and is not possible to directly access to this part of the design. Instead, it is necessary to indirectly try to thoroughly excite the cache controller by executing specially crafted programs that perform several memory operations carefully selecting the effective address of every memory access; depending on the cache, memory operations must be reading operations (during the fetch stage in the case of the instruction cache), and reading and writing operations (in the case of data caches). In order to devise a suitable test program for testing the cache memory controllers, the generated program should be able to activate and verify the correct behavior of three functional blocks within the cache control circuitry: (i) the look-up circuit in charge of identifying the cache block storing the required information, (ii) the circuit in charge of implementing the replacement policy for every cache block, (iii) in the specific case of the data cache, the circuitry in charge of implementing the write support strategy. On the other hand, the introduction of some special hardware specifically devoted to test the cache controller is not always feasible, especially if designers cannot access the processor core description. Thus, exploiting an I-IP may support the test program application providing with an appropriate feedback information about its elaboration results. Additionally, the I-IP implementation does not require any modification of the memory cache controller (for example a cache memory freeze facilities), but it is simply an additional core plugged in the SoC. III.PROPOSED APPROACH In the following, a hybrid approach for testing the controller circuit of data and instruction caches embedded in a SoC is presented. In order to cope with the different constraints imposed by data and instruction memory caches, a couple of algorithms have been devised and briefly summarized here. In order to support the observation of produced results, the method proposes the introduction of an I-IP connected to the system buses, which is used by the SBST test program for receiving feedbacks regarding the program execution as well as to identify the faulty conditions in the cache controller. The same I-IP is exploited for testing both controllers and performs a continuous bus sniffing in order to provide the SBST test programs with the necessary input to understand the hit / miss condition in the cache. A. Algorithm notation In this paragraph we introduce the notation used in the description of the algorithms. The following parameters are used by the algorithms to calculate the memory addresses, as well as to calculate the exact number of write / read operations in the cache: As is the start address of the memory cacheable zone, Cs is the Cache size, Bs is the Block size, Ds is the Data size, Is is the Instruction size, Ms is the implemented Memory size and Wp is the Write policy (Write Back or Write Through). In consequence Nb = Cs/Bs is the number of blocks in the cache, Nd = Bs/Ds is the number of data words in the block, and Ni = Bs/Is is the number of instructions in the block. B. Data cache The algorithm proposed for data cache testing (Figure 1) is divided in two parts, each structured as a for loop. In both cases, a series of memory operations are performed Na=Nd*Nb times, where Na represents the total amount of data elements contained in the cache. Variables Initialization Flush operation (or function) for (n = 0 to Nd-1) do for (m = 0 to Nb-1) do A = Address_Calculation(As,Cs,Ds,Nd,Nt,n,m) Set_IIP(1) //Memory access allowed Write_Data (b, A) //w(miss) Set_IIP(0) //Memory access avoided Rx = Read_Data (A) //r(hit) Idle_IIP() //I-IP idle state if (Rx b) then Abnormal Termination <<Cache Faulty>> end if Restart variables for (n = 0 to Nd-1) do for (m = 0 to Nb-1) do A = Address_Calculation (As,Cs,Ds,Nd,Nt,n,m) Set_IIP(1) //Memory access allowed Rx = Read_Data (A) //r(miss) if (Wp = WB) then Set_IIP(0) //Memory access avoided else Set_IIP(1) //Memory access allowed end if Write_Data (/b, A) //w(hit) Set_IIP(0) //Memory access avoided Ry = Read_Data (A) //r(hit) Idle_IIP() //I-IP idle state if (Ry Rx 0) then Abnormal Termination <<Cache Faulty>> end if Normal Termination << Cache OK >> End I-IP_Exception Abnormal termination << Cache Faulty >> end Exception Figure 1. Proposed algorithm for the data cache controller After initializing some variables and carrying out a complete flush on the data cache (thus invalidating all cache lines), the first loop is intended to set the cache memory in a known initial condition, as well as to write into the main memory some useful information exploited later in the second loop. It is important to notice that before and after every read/write operation in the memory the I-IP is programmed (using the macro SetIIP()). The structure of the I-IP as well as its functioning will be detailed in section III.C. Once the memory address A has been computed, data b is written in the memory. In this case, every write instruction (Write_Data) generates a miss since the whole cache is invalid. Later on, data b is read from memory at the same memory address A, always 145
4 producing a hit. Finally, for every couple of write and read instructions the acquired data (Rx) is compared with reference value b. This couple of loops is repeated Na times in order to guarantee a set of writing-reading operations in every data element of the cache. The second loop of the algorithm presented in figure 1 exploits the same address calculation function for reading and writing; however, the value used for writing is the bit by bit logical complement of the value used in the first loop. In this case the external loop contains a series of read (r(miss)), write (w(hit)), read (r(hit)) loops in order to excite the rest or the cache controller. As mentioned before, accessed addresses are essential to carefully excite the cache controller; to this end a function called Address_Calculation is used. The function provides the cache entries with information as much as possible diverse. Additionally, this function guarantee cache accesses to every position of each cache block, and contemporarily the generated addresses must fully excite all circuits correlated with the tag, index and offset fields. The generic form of the address calculation function is outlined in the following: A = As + a_tag + a_index + a_offset (1) where values denoted with a_ supply the desired patterns to be applied at every address section, while As is the initial address of the cacheable memory. The following equations guarantee a marching one (2) and a marching zero (3) series on the tag, while thoroughly exciting index and offset parts: A = As + 2 k Cs + m Bs + j Ds (2) A = As + (2 Nt -2 k -1)Cs + m Bs + j Ds (3) where k, m and j determine the limits for these functions, and are strictly defined considering cache specification parameters: k = 0.. Nt-1 m = 0.. Nb-1 j = 0.. Nd-1 where Nt is the number of bits required to address the cache blocks, Nb is the number of cache blocks, and Nd is the number of data per block. The function (2) implemented to calculate the acceded addresses is reported in Figure 2: function Address_Calculation(As,Cs,Ds,Nd,Nt,n,m) k = mod (m, Nt); j = mod (m, Nd); A = As + 2 k * Cs + m * Bs +mod((j+n),nd) * Ds; return (A); end function Figure 2. Marching one function for data cache controller C. I-IP Description The previous defined algorithm is devised to carefully excite the cache controller and the logic behind it: it is able to guarantee the activation of a miss and a hit in the cache for every data element in the block. The execution of the algorithm, however, must be stopped when the operation in the cache is not the expected one. Using a pure SBST methodology this goal may be reached by exploiting an embedded timer properly activated and deactivated before and after the target instruction for the cache. Clearly, this is not always possible, especially when the granularity of the timer does not allow the measurement accuracy to detect one clock cycle variations. The introduction of an I-IP, on the other hand, guarantees a more simple identification of the memory accesses by a continuous sniffing on the system bus. The I-IP is also able to provide to the SBST test programs with the information about the bus activity through the interrupt mechanism. Finally, the area overhead introduced by the I-IP is negligible with respect to the entire SoC area. When enabled, the I-IP continuously spies the bus identifying the memory cycles on the bus. The I-IP is connected to the system bus and is addressable like a normal I/O device or a memory mapped register. Additionally, the I-IP is connected to one of the interrupt ports of the processor, generating an interrupt when an abnormal functioning of the cache is detected. In the following table the bus behavior (in terms of write and read cycles) on the different cache operations and different write policies is summarized. In table 1 the column Write Cycle is labeled with possible indicating that some memory bus cycles can be performed in order to write in the main memory the dirty words or the entire line. It is interesting to note that, for example, in a data cache memory implementing the write-through policy there are not writing cycles on a read miss, since every write operations in cache contemporarily performed in the main memory. TABLE 1. BUS BEHAVIOUR ON DIFFERENT CACHE OPERATIONS Cache Operation Write Policy Write Cycles Read cycles Read Miss WB Possible Certainly WT None Certainly Read Hit WB None None WT None None Write Miss WB Possible Certainly WT One Certainly Write Hit WB None None WT One None For simplifying and limiting the area overhead introduced by the I-IP only the memory accesses are checked. The I-IP is designed to be transparent to the write policy thus when a different behavior on the bus is possible, the test program has to take care of it. Moreover, since the main objective of the I-IP is to verify if the current read or write operation is performed in cache or in the main memory, no controls are made on the data value, since these controls are also performed by software. Following the previous consideration the I-IP was designed to be programmed to only check if a memory access is performed or not. The I-IP continuously checks the bus and verifies if a memory access is performed or not. If a violation is detected, the I-IP generates an interrupt that break the flow of the program and signal a faulty condition in the cache. 146
5 It is also possible to stop the continuous I-IP sniffing of the bus, so that the program flow can be correctly continued if the cache works correctly. In the proposed algorithms, the programming of the I-IP is done through the macro Set_IIP(), while the macro Idle_IIP put the I-IP in an idle state where the continuous I-IP sniffing is stopped. D. Instruction cache Even though there are several similarities with data cache, when moving to the test of the instruction cache controller, some additional considerations must be highlighted: (i) in order to adequately excite the control part of the instruction caches, a set of instructions placed on carefully selected memory addresses must be executed; (ii) no writing instructions are allowed in instruction caches, since usually program memory is only read but not modified; (iii) differently from data caches, the proposed algorithm must consider possible overlapping inconveniences. As depicted in Figure 3, after a first configuration step (Variable Initialization and Memory Flushing), three main elements compose the algorithm for testing the instruction cache controller: - Jumping main loop: this loop iterates Na = Cs/Is times, and for every iteration a properly generated address is calculated exploiting the Address_Calculation function; consequently, the control flow of the program is changed jumping to this position; the main goal behind this jumping loop is to guarantee the execution of instructions carefully placed in memory addresses able to thoroughly excite the cache controller; Variables Initialization Flush operation (or function) for (n = 0 to Nd-1) do for (m = 0 to Nb-1) do A = Address_Calculation (As,Cs,Is,Nb,Nd,Nt,n,m) Set_IIP(0) //Memory access avoided Jump to A //r(miss) Set_IIP(1) //Memory access allowed Jump to A //r(hit) Normal termination << Cache OK >> End I-IP_Exception Abnormal termination << Cache Faulty >> end Exception / Address_A 1 / Instruction 1 Idle_IIP(); //I-IP idle state Return / Address_A Na / Instruction 1 Idle_IIP(); //I-IP idle state Return Fig. 3. Instruction Cache Controller; proposed algorithm - I-IP configuration: in order to guarantee the correct execution of the devised program, the I-IP mechanism described above is used. - Atomic routines: small routines previously placed in the main memory, in charge of executing some instructions that assure miss and hit events in an appropriate word of every block in the instruction cache; at the end of its execution, return the program control flow to the main jump loop; It is worth noting that in the jumping main loop two jumps are performed to the same address; the first one always produce a miss in the cache, while the second always produce an hit. Doing so, it is possible to guarantee the sequence of miss/hit in the cache also for the routines stored in two blocks. It is important to notice that the Jumping main loop is placed in a non-cacheable zone in order to avoid the loading in the cache of the respective machine code. The pseudo-code of the Address_Calculation function for the instruction cache controller testing is provided in Figure 4. function Address_Calculation (As,Cs,Is,Nd,Nt,n,m) k = mod (m, Nt); j = mod (m, Ni); if (mod(n,2)==0) then pag = 2 k ; //TAG: marching one else pag= (2 Nt 1) 2 k ; //TAG: marching zero endif A = As + pag*cs + m*bs +mod((j+n),ni)*is; return(a); end function Fig. 4. Address calculation function pseudo-code In order to avoid overlapping problems, in this case, alternatively for every consecutive cache filling, the tag field is excited exploiting a marching one followed by a marching zero strategy. IV. CASE OF STUDY The effectiveness of our hybrid methodology has been experimentally evaluated on a benchmark SoC derived from a publicly available one [11] containing the fullypipelined RISC processor OpenRISC 1200, described at RTL in Verilog, the I-IP previously described in the proposed approach, 64KB on-chip RAM and several other IP cores. The SoC uses a 32 bit WISHBONE bus rev. B for the communication between the cores. The operating frequency of the SoC is 150 MHz. The OpenRISC processor is a 32 bit scalar RISC architecture with Harvard architecture, 5 stages integer pipeline, and virtual memory support. It includes supplementary functionalities, such as programmable interrupt controller, power management unit and highresolution tick timer. The processor implements a 8Kbyte data cache and a 8Kbyte 1-way direct mapped instruction cache; both caches implements a writethrough mechanism. Table 2 shows details about the gate level descriptions of the data cache and instruction cache. It is important to note that the information provided at gate-level does not include the memory elements of the cache memory. 147
6 TABLE 2. DATA CACHE AND INSTRUCTION CACHE DESCRIPTIONS INFORMATION Gates faults D-cache 985 4,528 I-cache 831 3,805 The I-IP counts about 150 gates and is implemented as a memory mapped register sharing the system bus with the memory banks. If the previous described I-IP functionalities are added to the I-IP presented in [12] the area overhead is lower than 2%. V.EXPERIMENTAL RESULTS Following the guidelines detailed above, we developed two test programs in assembly language for the OpenRISC 1200 microprocessor core. The first one implements the algorithm described in section III.B and aims at testing the data cache controller of the microprocessor. This assembly program contains 230 lines of code and its machine version occupies about 410 bytes, requiring about 159 K clock cycles to be executed. The second assembly program implements the algorithm outlined in section III.D. The program counts 10,370 lines of code, occupies about 29 Kbytes of memory and takes about 435 K clock cycles to be executed. The test size in this case is higher than in the case of data cache since the test program is structured with many atomic routines stored in different memory addresses. This is necessary since the instruction cache can not be directly written, but only accessed by mean of jumps to predefined addresses in the test program, as we described above. Each test program was simulated using a commercial logic simulator (Modelsim 6.2e by Menthor Graphics) and fault simulation results are gathered against the stuck-at faults using the Tetramax version Z tool by Synopsys. The executed experiments have been performed on a PC with an Intel Core 2 with 2 GB of RAM. For proving the effectiveness of the proposed algorithms at the gate level, the data cache and the instruction cache have been synthesized using a generic home-developed technologic library. Targeting the stuck-at fault model, the proposed methodology achieved more than 95% of stuck-at fault coverage for both instruction and data cache memory controllers. The missed fault coverage is mainly due to the address space limitation for the processor in this specific SoC implementation that prevents the registers involved in the memory exchanges to alter some bits in the higher part of the address without causing a memory exception. VI.CONCLUSIONS AND FUTURE WORKS In this paper we proposed a mixed methodology for testing the control part of data and instruction caches often existing in processor cores embedded in a SoC. For both controllers a fully parametric algorithm able to deal with different cache configurations, while maintaining a linear complexity with respect to the cache size, was previously proposed, which exploited a timer to check the correct behavior of the controller: in order to remove the requirement for the timer, while still avoiding the need for any change in the processor/cache architecture, a hybrid solution has been proposed in this paper, based on integrating the same SBST algorithm with an external module (in the form of an I-IP) to be added to the SoC. The effectiveness of the proposed methodology has been evaluated resorting to a sample SoC that included an improved version of the I-IP core described previously: for both controllers the methodology is able to reach a high stuck-at fault coverage with reduced cost in terms of code memory size and test application time. It is also interesting to note that even though cache memories are deeply embedded in SoCs, the inclusion of an improved I-IP avoids hardware modifications to the processor core, while still achieving very high coverage figures. We are currently working toward the evaluation of this methodology with respect to delay faults in cache controllers. REFERENCES [1] John L, Henessey & David A, Pattterson. "Computer Architecture". 3th edition. Morgan Kaufmann publishers [2] Semiconductor Industry Association, International Technology Roadmap for Semiconductors 2006 Update, [3] S. Bhunia, Li Hai, K. Roy, A high performance IDDQ testable cache for scaled CMOS technologies, IEEE Asian Test Symposium, (ATS '02), pp [4] P. J. Tan, Le Tung, Mantri Prasad, J. Westfall, Testing of UltraSPARC T1 Microprocessor and its Challenges, IEEE International Test Conference, 2006, ITC '06, pp [5] Sultan M. Al-Harbi, Sandeep K. Gupta. "A Methodology for Transforming Memory Tests for In-System Testing of Direct Mapped Cache Tags". 16th IEEE VLSI Test Symposium (VTS '98), pp [6] J. Sosnowski. "In system of cache memories". IEEE International Test Conference, 1995, ITC pp [7] J. Sosnowski, Improving software based self-testing for cache memories, Proc. Of IEEE 2nd Int. design and Test workshop, 2007, pp [8] W. J. Perez, J. Velasco, D. Ravotto, E. Sanchez, M. Sonza Reorda, Software-Based Self-Test Strategy for Data Cache Memories Embedded in SoCs, IEEE Workshop on Design and Diagnostics of Electronic Systems DDECS, 2008, pp [9] N. Kranitis, A. Paschalis, D. Gizopoulos, G. Xenoulis, Software-based self-testing of embedded processors, IEEE Transactions on Computers, Vol 54, issue 4, 2005, pp [10] Ad J. Van De Goor, Using March Tests to Test SRAMs, IEEE Design & Test, Vol. 10, issue 1, 1993, pp [11] Opencores, [12] P. Bernardi, M. Grosso, M. Rebaudengo, M. Reorda. Exploiting an I-IP for both Test and Silicon Debug of Microprocessor Cores Microprocessor Test and Verification, IEEE Sixth International Workshop, pp [13] P. Bernardi, L. Bolzani, M. Sonza; A Hybrid Approach to Fault Detection and Correction in SoCs On-Line Testing Symposium, IOLTS th IEEE International 2007 pp [14] IEEE P1500 Standard for Embedded Core Test (SECT), [15] Y. Zorian, What Is an Infrastructure IP? IEEE Design and Test of Computers, vol. 19, no. 3, pp. 5-7, May/June
Applying March Tests to K-Way Set-Associative Cache Memories
13th European Test Symposium Applying March Tests to K-Way Set-Associative Cache Memories Simone Alpe, Stefano Di Carlo, Paolo Prinetto, Alessandro Savino Politecnico di Torino, Dep. of Control and Computer
More informationReport on benchmark identification and planning of experiments to be performed
COTEST/D1 Report on benchmark identification and planning of experiments to be performed Matteo Sonza Reorda, Massimo Violante Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy
More informationFault Tolerant and BIST design of a FIFO cell
Fault Tolerant and design of a FIFO cell F. Corno, P. Prinetto, M. Sonza Reorda Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy Abstract * This paper presents a design of a
More informationAccurate Analysis of Single Event Upsets in a Pipelined Microprocessor
Accurate Analysis of Single Event Upsets in a Pipelined Microprocessor M. Rebaudengo, M. Sonza Reorda, M. Violante Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy www.cad.polito.it
More informationThe Impact of Write Back on Cache Performance
The Impact of Write Back on Cache Performance Daniel Kroening and Silvia M. Mueller Computer Science Department Universitaet des Saarlandes, 66123 Saarbruecken, Germany email: kroening@handshake.de, smueller@cs.uni-sb.de,
More informationOn the Automatic Generation of Software-Based Self-Test Programs for Functional Test and Diagnosis of VLIW Processors
On the Automatic Generation of Software-Based Self-Test Programs for Functional Test and Diagnosis of VLIW Processors Davide Sabena, Luca Sterpone, and Matteo Sonza Reorda Dipartimento di Automatica e
More informationScalable Controller Based PMBIST Design For Memory Testability M. Kiran Kumar, G. Sai Thirumal, B. Nagaveni M.Tech (VLSI DESIGN)
Scalable Controller Based PMBIST Design For Memory Testability M. Kiran Kumar, G. Sai Thirumal, B. Nagaveni M.Tech (VLSI DESIGN) Abstract With increasing design complexity in modern SOC design, many memory
More informationA Parametric Design of a Built-in Self-Test FIFO Embedded Memory
A Parametric Design of a Built-in Self-Test FIFO Embedded Memory S. Barbagallo, M. Lobetti Bodoni, D. Medina G. De Blasio, M. Ferloni, F.Fummi, D. Sciuto DSRC Dipartimento di Elettronica e Informazione
More informationAutomatic Test Program Generation from RT-level microprocessor descriptions
Automatic Test Program Generation from RT-level microprocessor descriptions F. Corno, G. Cumani, M. Sonza Reorda, G. Squillero Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy
More informationFunctional Verification of DMA Controllers
Functional Verification of DMA Controllers M. Grosso W.J. Perez H. D. Ravotto E. Sanchez M. Sonza Reorda A. Tonda J. Velasco Medina Abstract - Today s SoCs are composed of a wide variety of modules, such
More informationModeling And Simulation Of Microcode Based Asynchronous Memory Built In Self Test For Fault Detection Using Verilog
Modeling And Simulation Of Microcode Based Asynchronous Memory Built In Self Test For Fault Detection Using Verilog Amruta P. Auradkar # and Dr. R. B. Shettar * # M.Tech.,2 nd year, Digital Electronics,
More informationBuilt-in Self-repair Mechanism for Embedded Memories using Totally Self-checking Logic
International Journal of Information and Computation Technology. ISSN 0974-2239 Volume 3, Number 5 (2013), pp. 361-370 International Research Publications House http://www. irphouse.com /ijict.htm Built-in
More informationSOFTWARE-IMPLEMENTED HARDWARE FAULT TOLERANCE
SOFTWARE-IMPLEMENTED HARDWARE FAULT TOLERANCE SOFTWARE-IMPLEMENTED HARDWARE FAULT TOLERANCE O. Goloubeva, M. Rebaudengo, M. Sonza Reorda, and M. Violante Politecnico di Torino - Dipartimento di Automatica
More informationEXPLOITING PROGRAMMABLE BIST FOR THE DIAGNOSIS OF EMBEDDED MEMORY CORES
EXPLOITING POGAMMABLE BIST FO THE DIAGNOSIS OF EMBEDDED MEMOY COES D. Appello**, P. Bernardi*, A. Fudoli**, M. ebaudengo*, M. Sonza eorda*, V. Tancorre**, M. Violante* * Politecnico di Torino Dipartimento
More informationEffective Software-Based Self-Testing for CMOS VLSI Processors
Effective Software-Based Self-Testing for CMOS VLSI Processors Nektarios KRANITIS Abstract. Processor testing approaches based on the execution of self-test programs have been recently proposed as an effective
More informationA Software-Based Test Methodology for Direct-Mapped Data Cache
17th Asian Test Symposium A Software-Based Test Methodology for Direct-Mapped Data Cache Yi-Cheng Lin, Yi-Ying Tsai, Kuen-Jong Lee, Cheng-Wei Yen, and Chung-Ho Chen Department of Electrical Engineering,
More informationPOLITECNICO DI TORINO Repository ISTITUZIONALE
POLITECNICO DI TORINO Repository ISTITUZIONALE Evolution of Test Programs Exploiting a FSM Processor Model Original Evolution of Test Programs Exploiting a FSM Processor Model / E. Sanchez; G. Squillero;
More informationHIGH-LEVEL AND HIERARCHICAL TEST SEQUENCE GENERATION
HIGH-LEVEL AND HIERARCHICAL TEST SEQUENCE GENERATION Gert Jervan, Zebo Peng Linköping University Embedded Systems Laboratory Linköping, Sweden Olga Goloubeva, Matteo Sonza Reorda, Massimo Violante Politecnico
More informationSoft-Core Embedded Processor-Based Built-In Self- Test of FPGAs: A Case Study
Soft-Core Embedded Processor-Based Built-In Self- Test of FPGAs: A Case Study Bradley F. Dutton, Graduate Student Member, IEEE, and Charles E. Stroud, Fellow, IEEE Dept. of Electrical and Computer Engineering
More informationA unifying formalism to support automated synthesis of SBSTs for embedded caches
! Politecnico di Torino A unifying formalism to support automated synthesis of SBSTs for embedded caches Authors: Di Carlo S., Gambardella G., Indaco M., Rolfo D., Prinetto P., Published in the Proceedings
More information4. Hardware Platform: Real-Time Requirements
4. Hardware Platform: Real-Time Requirements Contents: 4.1 Evolution of Microprocessor Architecture 4.2 Performance-Increasing Concepts 4.3 Influences on System Architecture 4.4 A Real-Time Hardware Architecture
More informationReport on automatic generation of test benches from system-level descriptions
COTEST/D2 Report on automatic generation of test benches from system-level descriptions Olga GOLOUBEVA, Matteo SONZA REORDA, Massimo VIOLANTE Politecnico di Torino Dipartimento di Automatica e Informatica
More informationA Universal Test Pattern Generator for DDR SDRAM *
A Universal Test Pattern Generator for DDR SDRAM * Wei-Lun Wang ( ) Department of Electronic Engineering Cheng Shiu Institute of Technology Kaohsiung, Taiwan, R.O.C. wlwang@cc.csit.edu.tw used to detect
More informationA P1500-compatible programmable BIST approach for the test of Embedded Flash Memories
A P1500-compatible programmable BIST approach for the test of Embedded Flash Memories P. Bernardi, M. ebaudengo, M. Sonza eorda, M. Violante Abstract In this paper we present a microprocessor-based approach
More informationChapter 6 Memory 11/3/2015. Chapter 6 Objectives. 6.2 Types of Memory. 6.1 Introduction
Chapter 6 Objectives Chapter 6 Memory Master the concepts of hierarchical memory organization. Understand how each level of memory contributes to system performance, and how the performance is measured.
More informationDiagnostic Testing of Embedded Memories Using BIST
Diagnostic Testing of Embedded Memories Using BIST Timothy J. Bergfeld Dirk Niggemeyer Elizabeth M. Rudnick Center for Reliable and High-Performance Computing, University of Illinois 1308 West Main Street,
More informationDesign of a Self-Test Unit for Microprocessor in On-Line Scenario using Verilog
IJSRD - International Journal for Scientific Research & Development Vol. 3, Issue 06, 2015 ISSN (online): 2321-0613 Design of a Self-Test Unit for Microprocessor in On-Line Scenario using Verilog Swathi
More informationCHAPTER 1 INTRODUCTION
CHAPTER 1 INTRODUCTION Rapid advances in integrated circuit technology have made it possible to fabricate digital circuits with large number of devices on a single chip. The advantages of integrated circuits
More informationLecture-14 (Memory Hierarchy) CS422-Spring
Lecture-14 (Memory Hierarchy) CS422-Spring 2018 Biswa@CSE-IITK The Ideal World Instruction Supply Pipeline (Instruction execution) Data Supply - Zero-cycle latency - Infinite capacity - Zero cost - Perfect
More informationCPU issues address (and data for write) Memory returns data (or acknowledgment for write)
The Main Memory Unit CPU and memory unit interface Address Data Control CPU Memory CPU issues address (and data for write) Memory returns data (or acknowledgment for write) Memories: Design Objectives
More informationMemory Hierarchy. Maurizio Palesi. Maurizio Palesi 1
Memory Hierarchy Maurizio Palesi Maurizio Palesi 1 References John L. Hennessy and David A. Patterson, Computer Architecture a Quantitative Approach, second edition, Morgan Kaufmann Chapter 5 Maurizio
More informationEvaluating the Fault Tolerance Capabilities of Embedded Systems via BDM
Evaluating the Fault Tolerance Capabilities of Embedded Systems via BDM M. Rebaudengo, M. Sonza Reorda Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy Abstract * Fault Injection
More informationTimed Compiled-Code Functional Simulation of Embedded Software for Performance Analysis of SOC Design
IEEE TRANSACTIONS ON COMPUTER-AIDED DESIGN OF INTEGRATED CIRCUITS AND SYSTEMS, VOL. 22, NO. 1, JANUARY 2003 1 Timed Compiled-Code Functional Simulation of Embedded Software for Performance Analysis of
More informationMoodle WILLINGDON COLLEGE SANGLI (B. SC.-II) Digital Electronics
Moodle 4 WILLINGDON COLLEGE SANGLI (B. SC.-II) Digital Electronics Advanced Microprocessors and Introduction to Microcontroller Moodle developed By Dr. S. R. Kumbhar Department of Electronics Willingdon
More informationChapter Seven. Memories: Review. Exploiting Memory Hierarchy CACHE MEMORY AND VIRTUAL MEMORY
Chapter Seven CACHE MEMORY AND VIRTUAL MEMORY 1 Memories: Review SRAM: value is stored on a pair of inverting gates very fast but takes up more space than DRAM (4 to 6 transistors) DRAM: value is stored
More informationModeling and Simulation of Microcode-based Built-In Self Test for Multi-Operation Memory Test Algorithms
IJCSI International Journal of Computer Science Issues, Vol. 7, Issue 3,. 2, May 2010 36 Modeling and Simulation of Microcode-based Built-In Self Test for Multi-Operation Memory Test Algorithms Dr. R.K.
More informationMemory Design. Cache Memory. Processor operates much faster than the main memory can.
Memory Design Cache Memory Processor operates much faster than the main memory can. To ameliorate the sitution, a high speed memory called a cache memory placed between the processor and main memory. Barry
More informationEvaluation of FPGA Resources for Built-In Self-Test of Programmable Logic Blocks
Evaluation of FPGA Resources for Built-In Self-Test of Programmable Logic Blocks Charles Stroud, Ping Chen, Srinivasa Konala, Dept. of Electrical Engineering University of Kentucky and Miron Abramovici
More informationOnline and Offline BIST in IP-Core Design
International Test Conference Online and Offline BIST in IP-Core Design Alfredo Benso, Silvia Chiusano, Giorgio Di Natale, and Paolo Prinetto Politecnico di Torino Monica Lobetti Bodoni Siemens Information
More informationSOFTWARE-BASED self-test (SBST) has become increasingly
IEEE TRANSACTIONS ON VERY LARGE SCALE INTEGRATION (VLSI) SYSTEMS, VOL. 15, NO. 5, MAY 2007 505 Software-Based Self-Testing With Multiple-Level Abstractions for Soft Processor Cores Chung-Ho Chen, Member,
More informationEffective Software-Based Self-Test Strategies for On-Line Periodic Testing of Embedded Processors
Effective Software-Based Self-Test Strategies for On-Line Periodic Testing of Embedded Processors Antonis Paschalis Department of Informatics & Telecommunications University of Athens, Greece paschali@di.uoa.gr
More informationComputer Systems Architecture I. CSE 560M Lecture 18 Guest Lecturer: Shakir James
Computer Systems Architecture I CSE 560M Lecture 18 Guest Lecturer: Shakir James Plan for Today Announcements No class meeting on Monday, meet in project groups Project demos < 2 weeks, Nov 23 rd Questions
More informationCache Performance (H&P 5.3; 5.5; 5.6)
Cache Performance (H&P 5.3; 5.5; 5.6) Memory system and processor performance: CPU time = IC x CPI x Clock time CPU performance eqn. CPI = CPI ld/st x IC ld/st IC + CPI others x IC others IC CPI ld/st
More informationA VLSI Implementation of High Speed FSM-based programmable Memory BIST Controller
Quest Journals Journal of Electronics and Communication Engineering Research ISSN:2321-5941 Volume1 ~ Issue 2 (2013) pp: 01-06 www.questjournals.org Research Paper A VLSI Implementation of High Speed FSM-based
More informationDesign and Implementation of Microcode based Built-in Self-Test for Fault Detection in Memory and its Repair
Design and Implementation of Microcode based Built-in Self-Test for Fault Detection in Memory and its Repair C. Padmini Assistant Professor(Sr.Grade), ECE Vardhaman college of Engineering, Hyderabad, INDIA
More informationMemory Hierarchy. Maurizio Palesi. Maurizio Palesi 1
Memory Hierarchy Maurizio Palesi Maurizio Palesi 1 References John L. Hennessy and David A. Patterson, Computer Architecture a Quantitative Approach, second edition, Morgan Kaufmann Chapter 5 Maurizio
More informationRAM Testing Algorithms for Detection Multiple Linked Faults
RAM Testing Algorithms for Detection Multiple Linked Faults V.G. Mikitjuk, V.N. Yarmolik, A.J. van de Goor* Belorussian State Univ. of Informatics and Radioelectronics, P.Brovki 6, Minsk, Belarus *Delft
More informationCPS104 Computer Organization and Programming Lecture 16: Virtual Memory. Robert Wagner
CPS104 Computer Organization and Programming Lecture 16: Virtual Memory Robert Wagner cps 104 VM.1 RW Fall 2000 Outline of Today s Lecture Virtual Memory. Paged virtual memory. Virtual to Physical translation:
More informationMemory. From Chapter 3 of High Performance Computing. c R. Leduc
Memory From Chapter 3 of High Performance Computing c 2002-2004 R. Leduc Memory Even if CPU is infinitely fast, still need to read/write data to memory. Speed of memory increasing much slower than processor
More informationEvaluating the Fault Tolerance Capabilities of Embedded Systems via BDM
Evaluating the Fault Tolerance Capabilities of Embedded Systems via BDM M. Rebaudengo, M. Sonza Reorda Politecnico di Torino Dipartimento di Automatica e Informatica Torino, Italy Fault tolerant system
More informationMemory. Objectives. Introduction. 6.2 Types of Memory
Memory Objectives Master the concepts of hierarchical memory organization. Understand how each level of memory contributes to system performance, and how the performance is measured. Master the concepts
More informationInternational Journal of Digital Application & Contemporary research Website: (Volume 1, Issue 7, February 2013)
Programmable FSM based MBIST Architecture Sonal Sharma sonal.sharma30@gmail.com Vishal Moyal vishalmoyal@gmail.com Abstract - SOCs comprise of wide range of memory modules so it is not possible to test
More informationCOEN-4730 Computer Architecture Lecture 12. Testing and Design for Testability (focus: processors)
1 COEN-4730 Computer Architecture Lecture 12 Testing and Design for Testability (focus: processors) Cristinel Ababei Dept. of Electrical and Computer Engineering Marquette University 1 Outline Testing
More informationTesting Digital Systems I
Testing Digital Systems I Lecture 1: Introduction Instructor: M. Tahoori Copyright 2011, M. Tahoori TDS I: Lecture 1 1 Today s Lecture Logistics Course Outline Introduction Copyright 2011, M. Tahoori TDS
More informationSelf-repairing in a Micro-programmed Processor for Dependable Applications
Self-repairing in a Micro-programmed Processor for Dependable Applications A. BENSO, S. CHUSANO, P. PRNETTO, P. SMONOTT, G UGO Politecnico di Torino Dipartimento di Automatica e nformatica Corso duca degli
More informationModeling and Simulation of Multi-Operation Microcode-based Built-in Self Test for Memory Fault Detection and Repair
Modeling and Simulation of Multi-Operation Microcode-based Built-in Self Test for Memory Fault Detection and Repair Dr. R.K. Sharma and Aditi Sood Abstract As embedded memory area on-chip is increasing
More informationHigh Speed Fault Injection Tool (FITO) Implemented With VHDL on FPGA For Testing Fault Tolerant Designs
Vol. 3, Issue. 5, Sep - Oct. 2013 pp-2894-2900 ISSN: 2249-6645 High Speed Fault Injection Tool (FITO) Implemented With VHDL on FPGA For Testing Fault Tolerant Designs M. Reddy Sekhar Reddy, R.Sudheer Babu
More informationA New Approach to Determining the Time-Stamping Counter's Overhead on the Pentium Pro Processors *
A New Approach to Determining the Time-Stamping Counter's Overhead on the Pentium Pro Processors * Hsin-Ta Chiao and Shyan-Ming Yuan Department of Computer and Information Science National Chiao Tung University
More informationDESIGN AND VERIFICATION ANALYSIS OF APB3 PROTOCOL WITH COVERAGE
DESIGN AND VERIFICATION ANALYSIS OF APB3 PROTOCOL WITH COVERAGE Akhilesh Kumar and Richa Sinha Department of E&C Engineering, NIT Jamshedpur, Jharkhand, India ABSTRACT Today in the era of modern technology
More informationReducing Hit Times. Critical Influence on cycle-time or CPI. small is always faster and can be put on chip
Reducing Hit Times Critical Influence on cycle-time or CPI Keep L1 small and simple small is always faster and can be put on chip interesting compromise is to keep the tags on chip and the block data off
More informationDonn Morrison Department of Computer Science. TDT4255 Memory hierarchies
TDT4255 Lecture 10: Memory hierarchies Donn Morrison Department of Computer Science 2 Outline Chapter 5 - Memory hierarchies (5.1-5.5) Temporal and spacial locality Hits and misses Direct-mapped, set associative,
More informationSoftware Techniques for Dependable Computer-based Systems. Matteo SONZA REORDA
Software Techniques for Dependable Computer-based Systems Matteo SONZA REORDA Summary Introduction State of the art Assertions Algorithm Based Fault Tolerance (ABFT) Control flow checking Data duplication
More informationMemory Hierarchy: Motivation
Memory Hierarchy: Motivation The gap between CPU performance and main memory speed has been widening with higher performance CPUs creating performance bottlenecks for memory access instructions. The memory
More informationSarah L. Harris and David Money Harris. Digital Design and Computer Architecture: ARM Edition Chapter 8 <1>
Chapter 8 Digital Design and Computer Architecture: ARM Edition Sarah L. Harris and David Money Harris Digital Design and Computer Architecture: ARM Edition 215 Chapter 8 Chapter 8 :: Topics Introduction
More informationEmbedded Systems Dr. Santanu Chaudhury Department of Electrical Engineering Indian Institute of Technology, Delhi
Embedded Systems Dr. Santanu Chaudhury Department of Electrical Engineering Indian Institute of Technology, Delhi Lecture - 13 Virtual memory and memory management unit In the last class, we had discussed
More informationImproving Memory Repair by Selective Row Partitioning
200 24th IEEE International Symposium on Defect and Fault Tolerance in VLSI Systems Improving Memory Repair by Selective Row Partitioning Muhammad Tauseef Rab, Asad Amin Bawa, and Nur A. Touba Computer
More informationStructure of Computer Systems
222 Structure of Computer Systems Figure 4.64 shows how a page directory can be used to map linear addresses to 4-MB pages. The entries in the page directory point to page tables, and the entries in a
More informationChapter Seven Morgan Kaufmann Publishers
Chapter Seven Memories: Review SRAM: value is stored on a pair of inverting gates very fast but takes up more space than DRAM (4 to 6 transistors) DRAM: value is stored as a charge on capacitor (must be
More informationDigital Design Methodology
Digital Design Methodology Prof. Soo-Ik Chae Digital System Designs and Practices Using Verilog HDL and FPGAs @ 2008, John Wiley 1-1 Digital Design Methodology (Added) Design Methodology Design Specification
More informationChapter 12. CPU Structure and Function. Yonsei University
Chapter 12 CPU Structure and Function Contents Processor organization Register organization Instruction cycle Instruction pipelining The Pentium processor The PowerPC processor 12-2 CPU Structures Processor
More informationDesign and Implementation of Online BIST for Different Word Sizes of Memories MUNEERA JAMAL 1, K. PADMAJA DEVI 2
www.semargroup.org, www.ijsetr.com ISSN 2319-8885 Vol.03,Issue.13 June-2014, Pages:2858-2863 Design and Implementation of Online BIST for Different Word Sizes of Memories MUNEERA JAMAL 1, K. PADMAJA DEVI
More informationMemory and multiprogramming
Memory and multiprogramming COMP342 27 Week 5 Dr Len Hamey Reading TW: Tanenbaum and Woodhull, Operating Systems, Third Edition, chapter 4. References (computer architecture): HP: Hennessy and Patterson
More informationCPS 104 Computer Organization and Programming Lecture 20: Virtual Memory
CPS 104 Computer Organization and Programming Lecture 20: Virtual Nov. 10, 1999 Dietolf (Dee) Ramm http://www.cs.duke.edu/~dr/cps104.html CPS 104 Lecture 20.1 Outline of Today s Lecture O Virtual. 6 Paged
More informationN-Model Tests for VLSI Circuits
40th Southeastern Symposium on System Theory University of New Orleans New Orleans, LA, USA, March 16-18, 2008 MC3.6 N-Model Tests for VLSI Circuits Nitin Yogi and Vishwani D. Agrawal Auburn University,
More informationA Performance Degradation Tolerable Cache Design by Exploiting Memory Hierarchies
A Performance Degradation Tolerable Cache Design by Exploiting Memory Hierarchies Abstract: Performance degradation tolerance (PDT) has been shown to be able to effectively improve the yield, reliability,
More informationChapter 5: ASICs Vs. PLDs
Chapter 5: ASICs Vs. PLDs 5.1 Introduction A general definition of the term Application Specific Integrated Circuit (ASIC) is virtually every type of chip that is designed to perform a dedicated task.
More informationk -bit address bus n-bit data bus Control lines ( R W, MFC, etc.)
THE MEMORY SYSTEM SOME BASIC CONCEPTS Maximum size of the Main Memory byte-addressable CPU-Main Memory Connection, Processor MAR MDR k -bit address bus n-bit data bus Memory Up to 2 k addressable locations
More informationHardware Sharing Design for Programmable Memory Built-In Self Test
International Journal of Engineering Research and Development e-issn: 2278-067X, p-issn: 2278-800X, www.ijerd.com Volume 10, Issue 6 (June 2014), PP.77-83 Hardware Sharing Design for Programmable Memory
More informationApplication of Power-Management Techniques for Low Power Processor Design
1 Application of Power-Management Techniques for Low Power Processor Design Sivaram Gopalakrishnan, Chris Condrat, Elaine Ly Department of Electrical and Computer Engineering, University of Utah, UT 84112
More informationCHAPTER 5 ANT-FUZZY META HEURISTIC GENETIC SENSOR NETWORK SYSTEM FOR MULTI - SINK AGGREGATED DATA TRANSMISSION
CHAPTER 5 ANT-FUZZY META HEURISTIC GENETIC SENSOR NETWORK SYSTEM FOR MULTI - SINK AGGREGATED DATA TRANSMISSION 5.1 INTRODUCTION Generally, deployment of Wireless Sensor Network (WSN) is based on a many
More informationOutline Marquette University
COEN-4710 Computer Hardware Lecture 1 Computer Abstractions and Technology (Ch.1) Cristinel Ababei Department of Electrical and Computer Engineering Credits: Slides adapted primarily from presentations
More informationChapter 5. Large and Fast: Exploiting Memory Hierarchy
Chapter 5 Large and Fast: Exploiting Memory Hierarchy Principle of Locality Programs access a small proportion of their address space at any time Temporal locality Items accessed recently are likely to
More informationDigital Design Methodology (Revisited) Design Methodology: Big Picture
Digital Design Methodology (Revisited) Design Methodology Design Specification Verification Synthesis Technology Options Full Custom VLSI Standard Cell ASIC FPGA CS 150 Fall 2005 - Lec #25 Design Methodology
More informationComplex test pattern generation for high speed fault diagnosis in Embedded SRAM
Complex test pattern generation for high speed fault diagnosis in Embedded SRAM 1 Prasanna Kumari P., 2 Satyanarayana S. V. V., 3 Nagireddy S. 1, 3 Associate professor, 2 Master of Engineering, Teegala
More informationLow-Cost Software-Based Self-Testing of RISC Processor Cores
1530-1591/03 $17.00 2003 IEEE Low-Cost Software-Based Self-Testing of RISC Processor Cores N. Kranitis 1 G. Xenoulis 2 D. Gizopoulos 2 A. Paschalis 1 Y. Zorian 3 1 Department of Informatics & Telecom.
More informationCHAPTER 6 Memory. CMPS375 Class Notes (Chap06) Page 1 / 20 Dr. Kuo-pao Yang
CHAPTER 6 Memory 6.1 Memory 341 6.2 Types of Memory 341 6.3 The Memory Hierarchy 343 6.3.1 Locality of Reference 346 6.4 Cache Memory 347 6.4.1 Cache Mapping Schemes 349 6.4.2 Replacement Policies 365
More informationARM Processors for Embedded Applications
ARM Processors for Embedded Applications Roadmap for ARM Processors ARM Architecture Basics ARM Families AMBA Architecture 1 Current ARM Core Families ARM7: Hard cores and Soft cores Cache with MPU or
More informationThe Memory Hierarchy & Cache Review of Memory Hierarchy & Cache Basics (from 350):
The Memory Hierarchy & Cache Review of Memory Hierarchy & Cache Basics (from 350): Motivation for The Memory Hierarchy: { CPU/Memory Performance Gap The Principle Of Locality Cache $$$$$ Cache Basics:
More informationCOMPUTER ORGANISATION CHAPTER 1 BASIC STRUCTURE OF COMPUTERS
Computer types: - COMPUTER ORGANISATION CHAPTER 1 BASIC STRUCTURE OF COMPUTERS A computer can be defined as a fast electronic calculating machine that accepts the (data) digitized input information process
More informationEfficient Algorithm for Test Vector Decompression Using an Embedded Processor
Efficient Algorithm for Test Vector Decompression Using an Embedded Processor Kamran Saleem and Nur A. Touba Computer Engineering Research Center Department of Electrical and Computer Engineering University
More informationDepartment of Computer Science, Institute for System Architecture, Operating Systems Group. Real-Time Systems '08 / '09. Hardware.
Department of Computer Science, Institute for System Architecture, Operating Systems Group Real-Time Systems '08 / '09 Hardware Marcus Völp Outlook Hardware is Source of Unpredictability Caches Pipeline
More informationFACTOR: A Hierarchical Methodology for Functional Test Generation and Testability Analysis
FACTOR: A Hierarchical Methodology for Functional Test Generation and Testability Analysis Vivekananda M. Vedula and Jacob A. Abraham Computer Engineering Research Center The University of Texas at Austin
More informationPower Estimation of System-Level Buses for Microprocessor-Based Architectures: A Case Study
Power Estimation of System-Level Buses for Microprocessor-Based Architectures: A Case Study William Fornaciari Politecnico di Milano, DEI Milano (Italy) fornacia@elet.polimi.it Donatella Sciuto Politecnico
More informationThe Central Processing Unit
The Central Processing Unit All computers derive from the same basic design, usually referred to as the von Neumann architecture. This concept involves solving a problem by defining a sequence of commands
More informationCaches and Memory Hierarchy: Review. UCSB CS240A, Winter 2016
Caches and Memory Hierarchy: Review UCSB CS240A, Winter 2016 1 Motivation Most applications in a single processor runs at only 10-20% of the processor peak Most of the single processor performance loss
More informationARCHITECTURAL APPROACHES TO REDUCE LEAKAGE ENERGY IN CACHES
ARCHITECTURAL APPROACHES TO REDUCE LEAKAGE ENERGY IN CACHES Shashikiran H. Tadas & Chaitali Chakrabarti Department of Electrical Engineering Arizona State University Tempe, AZ, 85287. tadas@asu.edu, chaitali@asu.edu
More informationEfficient VLSI Huffman encoder implementation and its application in high rate serial data encoding
LETTER IEICE Electronics Express, Vol.14, No.21, 1 11 Efficient VLSI Huffman encoder implementation and its application in high rate serial data encoding Rongshan Wei a) and Xingang Zhang College of Physics
More informationSlide Set 9. for ENCM 369 Winter 2018 Section 01. Steve Norman, PhD, PEng
Slide Set 9 for ENCM 369 Winter 2018 Section 01 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary March 2018 ENCM 369 Winter 2018 Section 01
More informationTESTING OF FAULTS IN VLSI CIRCUITS USING ONLINE BIST TECHNIQUE BASED ON WINDOW OF VECTORS
TESTING OF FAULTS IN VLSI CIRCUITS USING ONLINE BIST TECHNIQUE BASED ON WINDOW OF VECTORS Navaneetha Velammal M. 1, Nirmal Kumar P. 2 and Getzie Prija A. 1 1 Department of Electronics and Communications
More informationMemory Hierarchy: The motivation
Memory Hierarchy: The motivation The gap between CPU performance and main memory has been widening with higher performance CPUs creating performance bottlenecks for memory access instructions. The memory
More information