Patent Description:
The complexity of integrated circuits (ICs) has increased steadily in recent years. Some ICs include a plurality of circuits. For example, a system-on-a-chip (SoC) may integrate all components of a computer or another electronic system on a chip to, e.g., perform a number of functions, such as receiving and sending data, receiving and making phone calls, playing virtual games, etc. For example, a microcontroller IC may include, in addition to a central processing unit (CPU) and associated registers, a plurality of memories for, e.g., software storage, analog-to-digital converters (ADCs), digital-to-analog converters (DACs), communication interface modules, such as SPI and I<NUM>C, internal oscillators, as well as other digital and analog circuits. Other examples of complex ICs include field programmable gate arrays (FPGAs), power management ICs (PMICs), processors (such as ARM or x86 processors), digital signal processors (DSPs), etc. Some applications are considered safety critical and demand self-test and/or real time monitoring of its circuits during mission mode (during normal operation), or during start/stop of the application in the field. An example is an automotive grade application controlling safety mechanism such as Braking, Parking, Lane change, etc..

Complex ICs may include a built-in-self-test (BIST) circuit. A BIST circuit, (also referred to as built-in test circuit, or BIT circuit), is a test circuit included in the complex IC that allows such complex IC to test itself. BIST circuits may be used to assist automatic test equipment (ATE), e.g., by testing logical or memory functions, or improve coverage or other test performance during manufacturing (production) of the IC.

BIST circuits may also be used in the field (e.g., during start/stop). For example, an automotive grade microcontroller may use BIST to test different components of the microcontroller each time the car is started, and report any detected faults to a central processing unit of the car.

During normal operation, circuits, such as complex ICs may use error-correcting code (ECC) to detect and correct errors.

Document <CIT> describes a method and a configuration for the output of bit error tables from semiconductor devices. A test control unit reads the bit error table from the memory device following a request from the test apparatus. Then, the bit error tables are transmitted sequentially to the test apparatus for further processing.

Document <CIT> discloses a system-on-chip (SoC) including a master, a slave, and an asynchronous interface having a first first-in first-out (FIFO) memory connected to the master and the slave. A write operation of the FIFO memory is controlled based upon a comparison of a write pointer and an expected write pointer of the FIFO memory, and a read operation of the FIFO memory is controlled based upon a comparison of a read pointer and an expected read pointer of the FIFO.

Document <CIT> discloses a fault-tolerant, high-speed wafer scale system comprises a plurality of functional modules, a parallel hierarchical bus which is fault-tolerant to defects in an interconnect network, and one or more bus masters. This bus includes a plurality of bus lines segmented into sections and linked together by programmable bus switches and bus transceivers or repeaters in an interconnect network.

Document <CIT> discloses apparatus and methods for clock domain crossing between a first clock domain and a second clock domain. The apparatus comprises a first control logic element for processing a handshake signal and producing a first arbiter input signal. Concurrently a second control logic element processes a second handshake signal and produces a second arbiter input signal. Exemplary embodiments include exactly one arbiter element inputting the first arbiter input signal, inputting the second arbiter input signal, outputting a first clocking signal to the first sequential element and outputting a second clocking signal to the second sequential element.

A first aspect of the invention is a method for capturing memory errors according to claim <NUM>.

Another aspect of the invention is a circuit according to claim <NUM>. Preferred embodiments are defined in appended dependent claims <NUM> - <NUM> and <NUM> - <NUM>.

The making and using of the embodiments disclosed are discussed in detail below. It should be appreciated, however, that the present invention provides many applicable inventive concepts that can be embodied in a wide variety of specific contexts. The specific embodiments discussed are merely illustrative of specific ways to make and use the invention, and do not limit the scope of the invention.

The description below illustrates the various specific details to provide an in-depth understanding of several example embodiments according to the description. The embodiments may be obtained without one or more of the specific details, or with other methods, components, materials and the like. In other cases, known structures, materials or operations are not shown or described in detail so as not to obscure the different aspects of the embodiments. References to "an embodiment" in this description indicate that a particular configuration, structure or feature described in relation to the embodiment is included in at least one embodiment. Consequently, phrases such as "in one embodiment" that may appear at different points of the present description do not necessarily refer exactly to the same embodiment. Furthermore, specific formations, structures or features may be combined in any appropriate manner in one or more embodiments.

Embodiments of the present invention will be described in a specific context, a circuit and method for capturing and transporting memory errors in a safety critical application, such as in a car. Embodiments of the present invention may be used in other types of safety-critical applications, such as industrial applications, as well as non-safety critical applications, such as a smartphone or table. Some embodiments may also be used for capturing errors different than memory errors.

In an embodiment of the present invention, an IC having a plurality of memories uses a central memory error management unit (MEMU) circuit to store and process error data packets received from the plurality of memories. Data flow control is performed by an asynchronous handshake between a multi-write shared first-in-first-out (FIFO) buffer and the central MEMU circuit to facilitate transmission of the error data packets to the MEMU circuit. In some embodiments, the asynchronous handshake advantageously allows for error data packet flow across different clock domains.

In some embodiments, a synchronous handshake between the FIFO buffer and error packet generators (e.g., BIST or integrity checkers inside one or more memories) is used to backstall the error source from executing further testing until the previous error packet has been acknowledged to be processed (e.g., stored in MEMU).

In some safety-critical applications, memories of an IC may need to be tested in the field at different times. For example, a microcontroller for automotive applications that is compliant with ISO <NUM>, such as compliant with automotive safety integrity level (ASIL) D, needs to test the integrated memories for faults each time the car starts, as well when the car is on (e.g., while driving). The memories tested at startup and during runtime may be volatile and/or non-volatile.

At startup, memory BIST (MBIST) may be executed to detect correctable and uncorrectable error locations in each memory. Since it is generally desirable to minimize the time to startup a car, the MBIST is generally run at-speed (at maximum speed), and covering multiple (or all) memories in parallel.

During runtime, error-correcting code (ECC) codes, stored along with data, are decoded to detect and report faults associated with the memories.

In some embodiments, MBIST is also run during runtime. For example, in some embodiments, MBIST may be run in response to the detection of one or more ECC errors. For example, upon detection of an ECC error associated with a memory, processes associated with such memory may be stopped, and an MBIST may be performed on such memory.

All memory errors and their characteristics, such as error type (correctable/uncorrectable), error bit position, error address location, and memory identifiers, are sent to a central memory error management unit (MEMU) circuit in the form of error data packets (also referred to as error packets) for logging (storing) and further processing. The logged errors may also be stored and made available, e.g., via an on-board diagnostics (OBD) <NUM> port. The error packets may be sent from memories operating in different clock domains, e.g., from <NUM>, to <NUM>, and may have a size of dozens of bits. For example, in a <NUM>-bit system the error packet width may be, e.g., from <NUM>-<NUM> bits.

In some embodiments, there may be more than <NUM> type of error packets. For example, some embodiments may have <NUM> types of error packets: one for the startup memory test (e.g., MBIST) and one for the runtime memory test (e.g., ECC). Some embodiments may also have different types of error packets for non-volatile memories and volatile memories. In some embodiments, all error packets may be of the same type. For example, an embodiment may have four types of error packets associated with non-volatile memories (e.g., single/double/tripler error correction, and multiple error detection).

After receiving errors at startup, the MEMU circuit may report the errors to the user (e.g., via one or more lights in a dashboard and/or a noise) and/or prevent the start of the car). When receiving errors during runtime, the MEMU circuit may report the error to the user, as well as taking other actions.

A complex SoC may include hundreds of volatile memories (e.g., associated systems and peripheral modules), such as of the random-access-memory (RAM) type, as well a plurality of memories of the non-volatile memory type. These memories are placed in different locations of the SoC. For example, <FIG> shows an exemplary floorplan of SoC <NUM>, according to an embodiment of the present invention. SoC <NUM> is implemented as an integrated circuit and includes MEMU circuit <NUM> and a plurality of memories <NUM> disposed on a (e.g., monolithic) semiconductor substrate. The plurality of memories <NUM> may be of different sizes and types (e.g., volatile or non-volatile). Other circuits of SoC <NUM> are not shown in <FIG> for clarity purpose.

Although <FIG> shows <NUM> memories <NUM>, some embodiments have hundreds of memories <NUM>. For example, in some embodiments, SoC <NUM> may include, e.g., more than <NUM> volatile memories of the RAM type, and, e.g., more than <NUM> non-volatile memories, e.g., of the EEPROM type. A different number of memories and other memory types, e.g., flash, OTP, ROM, PCM, etc., may also be used.

In some embodiments, SoC <NUM> may be, e.g., a microcontroller, processor, DSP, FPGA, or PMIC.

Routing dedicated wires from each memory <NUM> to MEMU circuit <NUM> may be challenging. For example, the placement of the interconnects in the various metal layers of SoC <NUM> to route signals from the memories <NUM> to MEMU circuit <NUM> may be challenging in itself. For example, routing <NUM>-<NUM> error bits (e.g., <NUM> types of error packets, where each error packet has a size between <NUM> and <NUM>) from each of, e.g., the more than <NUM> memories <NUM> may be challenging. Additionally, performing timing closure (the process in which a logic design is modified to meet timing requirements) may also be challenging.

In an embodiment of the present invention, a memory management unit (MEMU) circuit includes an error aggregator unit (EAU) to process error packets from a plurality of memories of a SoC. An error compactor unit (ECU) is used to capture concurrent error packets from a sub-set of the plurality of memories of the SoC and sequentially transfer the error packets to the EAU using a multi-write first-in-first-out (FIFO) buffer. The EAU arbitrates and captures error packets from multiple ECUs for further processing using a handshaking mechanism.

<FIG> shows a schematic diagram of SoC <NUM>, according to an embodiment of the present invention. SoC <NUM> includes MEMU <NUM> and ECU <NUM>. MEMU <NUM> includes controller <NUM> and EAU <NUM>.

As shown in <FIG>, the plurality of memories <NUM> are grouped in sub-groups <NUM>. The number of memories <NUM> in each sub-group <NUM> may be the same or different. In some embodiments, each ECU <NUM> is customized for the number of input sources that it supports.

ECU <NUM> is configured to capture, e.g., concurrently, error packets and sequentially transfer the error packets to EAU <NUM> using a handshaking mechanism, which may be synchronous or asynchronous. In some embodiments, ECU also reports to a central fault collection unit when an error packet is lost.

EAU is configured to arbitrate and capture error packets from multiple ECUs for further processing.

During startup, a startup memory test is performed on each memory <NUM>. For example, an MBIST may be performed on each memory <NUM> of the volatile type, and an integrity test may be performed on each memory <NUM> of the non-volatile type. Errors detected during the startup memory test are transmitted from each faulty memory <NUM> to the corresponding ECU <NUM> in the form of error packets using bus Derror packet. Each ECU <NUM> receives error packets from the plurality of corresponding memories <NUM> and stores them in a multi-write shared FIFO. The error packets are then transmitted from each ECU <NUM> to EAU <NUM> using a handshaking mechanism and an arbitration process (such as round robin). EAU <NUM> then transmits the error packets to controller <NUM>. Controller <NUM> then transmits the error packets to an external circuit, such as a central processing unit of a car (e.g., such as a central fault processing unit or safety faults collection and controller).

During runtime, error-correcting code (ECC) codes are used to detect faults in each memory <NUM>. Detected faults in each memory <NUM> are transmitted as error packets to the corresponding <NUM> using bus Derror packet. Each ECU <NUM> receives error packets from the plurality of corresponding memories <NUM> and stores them in the multi-write shared FIFO. The error packets are then transmitted from each ECU <NUM> to EAU <NUM> using a handshaking mechanism and an arbitration process. EAU <NUM> then transmits the error packets to controller <NUM>, which then transmits the error packets to an external circuit.

In some embodiments, bus Derror_packet is shared for transmitting error packets at startup and during runtime. In other embodiments, different buses are used for transmitting error packets at startup and during runtime.

In some applications, it may be desirable to minimize the startup time by, e.g., performing the startup memory test at speed (as fast as possible) and by testing multiple (or all) memories <NUM> in parallel. Performing so many tests in parallel and so fast may cause multiple error packets to be transmitted to each ECU <NUM> simultaneously. In some cases, the rate of transmission of error packets from each sub-group <NUM> exceeds the processing capacity of ECUs <NUM> and EAU <NUM>. For example, in some embodiments, MEMU <NUM> can read/process <NUM> error packet per clock period of clock CLKMEMU.

In some embodiments, ECU <NUM> may pause execution of the startup memory test on the corresponding sub-group <NUM> when, e.g., the respective shared FIFO buffer is full or near full. In some embodiments, ECU <NUM> signals the corresponding sub-group <NUM> to pause or resume execution of the startup memory test using signal Sflow control. In some embodiments, each ECU <NUM> produces an independent signal Sflow_control. In other embodiments, a single signal Sflow control is used to pause or resume execution of the entire IC. Other implementations are also possible.

In some embodiments, stopping execution of the startup test when the shared FIFO buffer is full or near full advantageously allows for preventing the loss of error packets while still performing the startup test as fast as possible.

In some embodiments, each bus Derror packet is implemented as independent serial buses from each memory <NUM>. In other embodiments, each bus Derror packet is implemented as independent parallel buses from each memory <NUM>. Other implementations are also possible.

In some embodiments, controller <NUM> is configured to process and transmit the error packets to an external circuit or to a safety controller, maintain internal records of memory faults, avoid storing the same faults more than once, and/or count errors coming in a certain memory range/modules. Controller <NUM> may be implemented, e.g., using custom logic, which may include, for example, a state machine and/or combinatorial logic coupled to a memory. Some embodiments may be implemented with a generic core, such as an ARM core, for example. Other implementations are also possible.

MBIST and memory integrity tests may be performed in any way known in the art, such as, e.g., by using a state machine to exercise the memories with predetermined patterns.

ECC tests may be performed in any way known in the art. For example, in some embodiments, ECC is capable of correcting single-bit errors and detecting double-bit errors. In some embodiments, ECC is capable of correcting double-bit errors and detecting triple-bit errors. Other implementations are also possible. In some embodiments, ECC checks are also performed automatically during functional usage of the memory by any other functional unit, e.g., a CPU reading its cache memories during a code execution.

Each memory <NUM> of the non-volatile memory type includes test circuits (not shown) for performing the memory integrity tests and ECC tests. Each memory <NUM> of the volatile type includes test circuits (not shown) for performing MBIST tests and ECC tests. Such test circuits may also be referred to as safety monitors. The safety monitors may be implemented in any way known in the art.

In some embodiments, the error packet may be based on the characteristics of the memories <NUM>. For example, <FIG> shows error packet <NUM>, according to an embodiment of the present invention. Error packet <NUM> is for example suitable for a <NUM> bit system having <NUM> bit data.

As shown, error packet <NUM> has <NUM> bits for the address location of the detected error, <NUM> bits for the location of the error at the error address ERR ADDRESS, and <NUM> bits for the error type (e.g., type of error, such as single error, or double error, and whether the error is correctable or not). In some embodiments, the error packet may have a size different than <NUM> bits, such as a size between <NUM> bits and <NUM> bits. Error packets of other sizes are also possible.

In some embodiments, the error packet may have a different form. For example, in some embodiment, a different number of bits may be allocated to the ERR ADDRESS (e.g., different than <NUM> bits), ERR LOC (e.g., different than <NUM> bits), and ERR TYPE (e.g., different than <NUM> bits), for example. In some embodiments, the error packet may also include additional ERR SRC field to identify the source memory <NUM> which is causing the error packet generation. In some embodiments, ERR SRC field may aid in performing debugging, as alternative to processing the error address to identify the source memory.

<FIG> shows error packet <NUM>, according to an embodiment of the present invention. As shown in <FIG>, ERR SRC field may have m bits, and ERR ADDRESS field may have n bits such that m+n is less than or equal to <NUM>. Embodiments implementing error packet <NUM> may advantageously reduce packet length when SoC <NUM> has a relatively small number of memories <NUM> and/or when the size of the memories <NUM> is small.

In some embodiments, some memories <NUM> may be larger than others (e.g., as shown in <FIG>), or may use larger words than others (e.g., <NUM>, <NUM>, <NUM>, or <NUM> bit words). For example, in some embodiments, some memories <NUM> may have more than <NUM> kB, such as <NUM> MB, or more; and other memories may have only a few kB, such as <NUM> kB, or less. In some embodiments, all error packets transmitted by each memory <NUM> have the same form (e.g., such as the error packet form that satisfies the requirements of the biggest memory <NUM> present in SoC <NUM>).

In some embodiments, different memories <NUM> may transmit error packets of different forms (e.g., of different sizes). For example, small memories <NUM> may transmit a smaller error packets (e.g., of <NUM> bits) while large memories <NUM> may transmit larger error packets (e.g., of <NUM> bits).

In some embodiments, some memories <NUM> may operate in different clock domains. For example, in some embodiments, some memories <NUM> may operate in a first clock domain (e.g., at a frequency of <NUM>), and other memories <NUM> may operate in a second clock domain (e.g., at a frequency of <NUM>). In some embodiments, all memories <NUM> of a particular sub-group <NUM> operate in the same clock domain.

In some embodiments, all memories of a particular sub-group <NUM> are of the same type. For example, in some embodiments, all memories of a first sub-group <NUM> are of the EEPROM type; and all memories of a second sub-group <NUM> are of the RAM type.

<FIG> shows a possible implementations of ECUs <NUM> and EAU <NUM>, according to an embodiment of the present invention. As shown in <FIG>, SoC <NUM> includes n ECUs <NUM>, where n is greater than <NUM>. Each ECU <NUM> includes a multi-write shared FIFO <NUM> and a handshake circuit <NUM>. EAU <NUM> includes a plurality of handshake circuits <NUM> coupled to respective ECUs <NUM>, arbiter <NUM> and selector circuit <NUM>.

<FIG> shows a flow chart of embodiment method <NUM> for capturing memory errors, according to an embodiment of the present invention. Method <NUM> may be performed at startup or during runtime.

<FIG> and <FIG> may be understood together. Although <FIG> and <FIG> are explained with respect to ECU <NUM>i, it is understood that ECU <NUM>i could be any ECU of SoC <NUM>.

During step <NUM>, when a memory <NUM> of sub-group <NUM>i detects a fault/error, such memory <NUM> writes into multi-write shared FIFO <NUM>i a corresponding error packet (e.g., with the form of error packet <NUM> or <NUM>). In some embodiments, multiple memories <NUM> of sub-group <NUM>i simultaneously write respective error packets into multi-write shared FIFO <NUM>i.

In some embodiments, FIFO <NUM> may be a dedicated (non-shared FIFO). For example, in some embodiments, a dedicated FIFO <NUM> may be used to when an error source (e.g., a particular memory <NUM>) is physically or clock-wise distinct from other error sources.

During step <NUM>, a determination of whether shared FIFO <NUM>i is empty is performed. When shared FIFO <NUM>i is not empty, shared FIFO <NUM>i makes the next error packet available at bus SDATA i (e.g., in a first-in-first-out manner) during step <NUM> and requests EAU <NUM> to read bus SDATA i during step <NUM>.

In some embodiments, bus SDATA i is a parallel bus (e.g., having <NUM> parallel lines for error packet <NUM>). In other embodiments, bus SDATA i is a serial bus.

In some embodiments, signal Sempty is deasserted (e.g., transitions from high to low) during step <NUM> when shared FIFO <NUM>i is not empty. In other embodiments, shared FIFO <NUM>i may signal that it is not empty in other ways, e.g., such as by asserting a Snon-empty signal (e.g., from low to high).

In some embodiments, ECU <NUM>i requests that bus SDATA i be read during step <NUM> by asserting signal SREQ_i (e.g., by transitioning signal SREQ_i from low to high) using handshake circuit <NUM>i.

During step <NUM>, the read of bus SDATA_i is scheduled. For example, in some embodiments, EAU <NUM> receives signal SREQ_i with a corresponding handshake circuit <NUM>. Upon reception of signal SREQ_i (e.g., when SREQi is asserted), handshake circuit <NUM> signals arbiter <NUM> that an error packet is available in bus SDATA i (e.g., by asserting signal REQi by, e.g., transitioning signal REQi from low to high). Arbiter <NUM> schedules the read of bus SDATA_i, e.g., in a round robin manner or priority-based manner (e.g., if a REQi is set to be highest priority, then all its errors are read before moving to REQ(i+<NUM>)), based on read requests REQ received from other handshake circuits <NUM>.

When it is the turn to read the error packet available at bus SDATA_i, EAU <NUM> reads the error packet at bus SDATA_i during step <NUM>. For example, in some embodiments, arbiter selects bus SDATA_i for reading using selector circuit <NUM> and transmits the selected error packet to controller <NUM> using bus SERR. In some embodiments, bus SERR is a parallel bus. In other embodiments, bus SERR is a serial bus. In some embodiments, arbiter424 is capable of processing and acknowledging a request from the ECUs <NUM> every clock cycle of clock CLKMEMU.

Once the error packet at bus SDATA i is read, step <NUM> is performed again, repeating the sequence. For example, in some embodiments, once the error packet at bus SDATA i is read, arbiter <NUM> asserts signal ACKi (e.g., by transitioning signal ACKi from low to high). When signal ACKi is asserted, handshake circuit <NUM>i asserts signal SACK i. When signal Sack i is asserted, handshake circuit <NUM>i asserts signal Sack to indicate that the error packet at bus SDATA i have been read.

In some embodiments, when the shared FIFO <NUM>i is not empty after step <NUM>, signal Sempty is toggled to cause handshake circuit <NUM>i to assert (e.g., toggle, or cause a rising edge, or cause falling edge) signal SREQ_i. In some embodiments, handshake circuit 404i asserts SREQ_i each time-shared FIFO <NUM>i makes a new error packet available in bus SDATA i without toggling signal Sempty.

Some embodiments may also perform steps <NUM>, <NUM>, and <NUM> for flow control.

For example, in some embodiments, when it is determined during step <NUM> that the shared FIFO is full, the error sources (e.g., memories <NUM> associated with the shared FIFO <NUM>) are stopped (e.g., the MBIST is paused), to prevent an overflow of the FIFO buffer.

In some embodiments, when the shared FIFO overflows (e.g., when the FIFO buffer drops an error packet because, e.g., the FIFO buffer received an error packet when full), an error signal (e.g., Soverflow) is asserted, e.g., to indicate that an error packet was lost.

In some embodiments, step <NUM> is performed by one or more memories <NUM> of sub-group <NUM>i, steps <NUM>, <NUM>, and <NUM> are performed by ECU <NUM>i, and steps <NUM> and <NUM> are performed by EAU <NUM>.

Multi-write shared FIFO <NUM>i may be implemented in any way known in the art. For example, in some embodiments, shared FIFO 402i operates in a synchronous manner and the read and write clocks are the same (e.g., CLKMEM_i). In some embodiments, multi-write shared FIFO <NUM>i is implemented as a multiple write ports (e.g., one for each memory <NUM> of sub-group 208i) and a single read port (e.g., bus SDATA i). In some embodiments, other types of buffers, such as a last-in-first-out (LIFO) may be used.

Arbiter <NUM> may be implemented, e.g., with a state machine, and may implement a round robin scheduling scheme. Some embodiments may implement other scheduling schemes, such as first-come-first-serve (FCFS), a priority scheduling, or other type of scheduling schemes.

In some embodiments, the handshaking mechanism (e.g., as illustrated in steps <NUM>, <NUM>, <NUM>, <NUM>, and <NUM>) results in variable execution time, e.g., since the memory test may be paused and/or the flow of error packets may be asynchronous and based on a scheduling scheme that may vary based on when the error packets are issued.

As shown in <FIG>, the memories <NUM> of sub-group 208i and ECU <NUM>i operate in a first clock domain (e.g., based on clock CLKMEM_i) and EAU <NUM> operates in a second clock domain (e.g., based on CLKMEMU). In some embodiments, clocks CLKMEM_i and CLKMEMU are equal. In other embodiments, clocks CLKMEM_i and CLKMEMU are different.

In some embodiments, the handshaking mechanism (e.g., as illustrated in steps <NUM>, <NUM>, <NUM>, <NUM>, and <NUM>) advantageously allows error packets to flow from the first clock domain to the second clock domain when clocks CLKMEM_i and CLKMEMU are different.

In some embodiments, the handshaking mechanism also advantageously allows for minimizing or eliminating the loss of error packets, since the error packets can be accumulated in shared FIFO <NUM>i until MEMU <NUM> is read to read them.

Selector circuit <NUM> may be implemented with a multiplexer (MUX). In some embodiments, selector circuit <NUM> samples the error packet and stores it (e.g., temporarily) in a table before transmitting the error packet via bus SERR. In some embodiments, keeping available the error packet of shared FIFO <NUM>i at bus SDATA i until handshake circuit <NUM>i issues an acknowledge (e.g., by asserting SACK_i) advantageously allows for sampling the error packet at bus SDATA_i while the bus SDATA i is stable, thereby avoiding metastability issues.

It is possible that shared FIFO <NUM>i becomes full while memories <NUM> of sub-group <NUM>i continue to attempt to write error packets into shared FIFO <NUM>i. In some embodiments, such scenario may be more likely to happen, e.g., during startup (since all memories <NUM> are tested, e.g., in parallel). In some embodiments, shared FIFO <NUM>i asserts a signal Soverflow when it loses a packet (e.g., when a memory <NUM> attempts to write an error packet into shared FIFO <NUM>i when shared FIFO <NUM>i is full). In some embodiments, the startup test may be restarted (e.g., at a lower speed) when signal Soverflow from any ECU <NUM> is asserted (e.g., when signal Severflow transitions from low to high).

In some embodiments, each ECU <NUM> is advantageously placed as close as possible to the memories <NUM> of the corresponding sub-group <NUM> to, e.g., avoid long interconnects and routing congestion.

In some embodiments, the use of ECUs <NUM> allows for a tree-like structure for the routing of error packets that advantageously allows MEMU <NUM> to be placed at a desirable physical location (e.g., in a corner of SoC <NUM>), since the number of interconnects between ECUs <NUM> and MEMU <NUM> is substantially lower than the number of interconnects from all memories <NUM>.

Advantages of some embodiments include ease of implementation of, e.g., clock tree and timing closure, as well as improved routing congestion. For example, in some embodiments, a reduction of MEMU channels may be higher than <NUM>% when compared with an architecture that routes error packets directly from each memory to the MEMU.

Some embodiments may advantageously result in smaller area, e.g., because of the reduction in interconnects routing, as well as on the freedom of placement of MEMU, e.g., without impacting performance. Some embodiments may advantageously result in lower probably of error packet loss, leading to better safety and reliability of the product/application.

Some embodiments may also implement distributed MEMU units having multiple local MEMUs responsible for memories within a local cluster, which may advantageously increase performance as well as response time.

<FIG> shows a possible implementation of handshake circuit <NUM>i, according to an embodiment of the present invention. Other implementations are also possible.

<FIG> shows exemplary waveforms associated with the handshake circuit <NUM>i of <FIG>, according to an embodiment of the present invention. <FIG> may be understood in view of <FIG>.

As shown in <FIG>, handshake circuit <NUM>; includes flip-flops <NUM> and <NUM>, AND gate <NUM>, inverters <NUM> and <NUM>, XOR gate <NUM>, XNOR gate <NUM>, and synchronization logic <NUM>.

During normal operation, when shared FIFO <NUM>i is empty (e.g., at time t<NUM> in <FIG>), flip-flop <NUM> is disabled.

When shared FIFO <NUM>i is not empty (e.g., when signal Sempty is low), signal SREQ_i toggles (is asserted) each time signal SACK_i is asserted (e.g., when signal SACK_i is pulsed). For example, in <FIG>, signal SREQ_i is asserted at times t<NUM> and t<NUM>.

As also shown in <FIG>, when signal SACK_i is asserted (e.g., toggles), signal Sack is also asserted (e.g., pulsed). As shown in <FIG>, each time signal Sack is asserted, a new error packet becomes available in bus SDATA i (such as at time t<NUM>).

When the last error packet is read from shared FIFO <NUM>i, signal Sempty is asserted (such as at time t<NUM>).

<FIG> shows a possible implementation of handshake circuit <NUM>i, according to an embodiment of the present invention. Other implementations are also possible. For example, some embodiments may use a <NUM>-level handshake scheme instead of a <NUM>-lelvel handshake scheme (as implemented by handshake circuit <NUM>i).

As shown in <FIG>, handshake circuit <NUM>i includes flip-flop <NUM>, inverter <NUM>, XOR gate <NUM>, and synchronization logic <NUM>.

During normal operation, when signal SREQ_i is asserted (e.g., toggles), signal REQi is also asserted (e.g., pulses), e.g., at times t<NUM> and t<NUM>, thereby signaling arbiter <NUM> that data is available at bus SDATA_i.

Once the error packet is read at bus SDATA i (or concurrently with reading the error packet at bus SDATAi), arbiter <NUM> causes signal SACK i to be asserted (e.g., by toggling), such as at times t<NUM> and t<NUM>. In some embodiments, arbiter <NUM> may initiate the process of asserting signal SACK_i upon reception of REQi by asserting (e.g., pulsing) signal ACKi (e.g., depending on the scheduling algorithm and loading of arbiter <NUM>).

As can be seen from <FIG>, <FIG>, the implementations shown in <FIG> and <FIG> are suitable to operating together.

<FIG> shows a possible implementation of multi-write shared FIFO <NUM>i, according to an embodiment of the present invention. As shown in <FIG>, multi-write shared FIFO <NUM>i may be implemented as a <NUM>-deep FIFO. A FIFO buffer of a different size (e.g., with size <NUM>, <NUM>, <NUM>, <NUM>, <NUM>, or higher), may also be used. <FIG> shows exemplary waveforms associated with the multi-write FIFO <NUM>i of <FIG>, according to an embodiment of the present invention.

At time t<NUM>, FIFO <NUM>i of <FIG> is empty, as shown by signal Sempty.

At time t<NUM>, memories MEM1 and MEM2 simultaneously begin writing FIFO_ENTRY[o] and FIFO ENTRY[<NUM>], respectively. The written data is latched into the registers at time t<NUM>.

At time t<NUM>, MEM1 again begins writing the FIFO <NUM>i (now at location FIFO_ENTRY[<NUM>]).

At time t14, both MEM1 and MEM2 again begin writing the FIFO <NUM>i. Since the FIFO can only store <NUM> error packets and at time t<NUM> the FIFO transitions from having <NUM> error packets to having <NUM> error packets (full) and losing <NUM> error packet (the second packet from MEM2 is not stored in the FIFO 402i), signals Sfull and Soverflow are both asserted at time t<NUM>.

In some embodiments, a signal Sflow control, e.g., from FIFO 402i, may be used to pause generation of error packets from the error sources to avoid reaching a condition in which Soverflow is asserted. In some embodiments, Sflow_control may be asserted, e.g., when Sfull is asserted.

<FIG> show schematic diagrams memories <NUM> and <NUM>, according to an embodiment of the present invention. Memories <NUM> may be implemented as memories <NUM> or <NUM>.

As shown in <FIG>, memory <NUM> is of the volatile memory type and includes memory plane <NUM>, and safety monitor <NUM>. Safety monitor is configured to test memory plane <NUM> during startup using MBIST circuit <NUM> and during runtime using ECC circuit <NUM>.

As shown in <FIG>, memory <NUM> is of the non-volatile memory (NVM) type and includes memory plane <NUM>, and safety monitor <NUM>. Safety monitor is configured to test memory plane <NUM> during startup using integrity test circuit <NUM> and during runtime using ECC circuit <NUM>.

MBIST circuit <NUM> is configured to perform an MBIST test, and may be implemented in any way known in the art. Integrity test circuit <NUM> is configured to perform a memory integrity test and may be implemented in any way known in the art. ECC circuits <NUM> and <NUM> are configured to perform ECC tests and may be implemented in any way known in the art.

<FIG> shows car <NUM> having SoC <NUM> and central processing unit <NUM>, according to an embodiment of the present invention.

When car <NUM> is started (e.g., when the ignition key is inserted and turned), memories <NUM> are tested (e.g., with MBIST and integrity tests). Any faults detected in any of the memories <NUM> of SoC <NUM> are transmitted in error packets to MEMU <NUM> from corresponding ECUs <NUM>. MEMU <NUM> then sequentially transmits information about the detected faults to central processing unit <NUM>. Central processing unit <NUM> then may take an action based on the information received, such as prevent the start of the car <NUM>, turn on a light in a dashboard, or trigger a sound, for example.

During runtime (e.g., when car <NUM> is being driven), ECC tests are performed on the memories <NUM> (e.g., as data is read and written into the memories <NUM>. When fault are detected, (e.g., such as uncorrectable errors in one or more memories <NUM>), the faults are transmitted in error packets to MEMU <NUM> from a corresponding ECUs <NUM>. MEMU <NUM> then sequentially transmits information about the detected faults to central processing unit <NUM>. Central processing unit <NUM> then may take an action based on the information received, such as turn on a light in a dashboard, or trigger a sound, for example.

<FIG> shows a schematic diagram of the SoC <NUM>, according to an embodiment of the present invention. As shown in <FIG>, SoC <NUM> includes a plurality of local clusters <NUM>. Each local cluster <NUM> includes a local MEMU <NUM>, a plurality of ECUs <NUM>, and a plurality of memories <NUM> arranged in a plurality of sub-groups <NUM>. SoC <NUM> may be implemented as SoC <NUM>.

In some embodiments, the MEMU <NUM> and the plurality of ECUs <NUM> and sub-groups <NUM> of each local cluster <NUM> operate in a similar manner as described with respect to <FIG>. By having a plurality of local MEMUs <NUM>, some embodiments advantageously achieve localized MEMU control and response, and further optimization of wires and response time (e.g., by optimizing the physical location in the substrate of the memories <NUM>, ECUs <NUM> and MEMUs <NUM> to, e.g., minimize routing). In some embodiments, segregation of components is achieved by implementing the segregated components in a particular cluster <NUM>.

Claim 1:
A method for capturing memory errors, the method comprising:
receiving, with a first buffer (<NUM>) of a first error compactor unit, ECU circuit (<NUM>) configured to capture concurrent error packets from a sub-set of a plurality of memories, a first memory error packet (<NUM>, <NUM>) from a first memory (<NUM>);
receiving, with the first buffer, a second memory error packet (<NUM>, <NUM>) from a second memory (<NUM>);
transmitting (<NUM>) a first reading request (SREQ_i) for reading the first memory error packet (<NUM>, <NUM>);
receiving the first reading request with an arbiter circuit (<NUM>) of an error aggregator unit, EAU circuit (<NUM>) of a central memory error management unit, MEMU circuit (<NUM>), the EAU circuit (<NUM>) configured to process error packets from the plurality of memories and the MEMU circuit (<NUM>) configured to store and process error data packets received from the plurality of memories;
in response to receiving the first reading request, reading (<NUM>) the first memory error packet (<NUM>, <NUM>) from the first buffer, transmitting the first memory error packet (<NUM>, <NUM>) to a controller (<NUM>) of the central MEMU circuit (<NUM>), and transmitting a first acknowledgement (SACK i) to the first ECU circuit (<NUM>) ;
receiving the first acknowledgement with the first ECU circuit (<NUM>); and
in response to receiving the first acknowledgement, transmitting a second reading request for reading the second memory error packet (<NUM>, <NUM>).