# Patent

## Title
Heterogeneous memory system

## Abstract

A heterogeneous memory system includes a network interface card, a main memory arrangement, a first-level cache, and a memory management unit (MMU). The main memory arrangement, first-level cache and the MMU are disposed on the network interface card. The first-level cache includes an SRAM arrangement and a DRAM arrangement. The MMU is configured and arranged to read first data from the main memory arrangement in response to a stored first value associated with the first data and indicative of a start time. The MMU selects one of the SRAM arrangement or the DRAM arrangement for storage of the first data and stores the first data in the selected one of the SRAM arrangement or DRAM arrangement. The MMU reads second data from one of the SRAM arrangement or DRAM arrangement and writes the data to the main memory arrangement in response to a stored second value associated with the second data and indicative of a duration.

## Background
CROSS REFERENCE TO CO-PENDING APPLICATION
This application is a continuation in part of patent application Ser. No. 13/910,355, by Sundararajan et al., entitled “HETEROGENEOUS MEMORY SYSTEM,” and filed on Jun. 5, 2013, which claims priority to provisional patent application No. 61/656,123, entitled “HETEROGENEOUS MEMORY SYSTEM,” and filed on Jun. 6, 2012.


FIELD OF THE INVENTION
One or more embodiments generally relate to memory systems.
BACKGROUND
Present memory systems often include static random-access memory (SRAM), dynamic random-access memory (DRAM), and non-volatile storage, such as a hard disk or solid-state memory (e.g., flash memory). Typically SRAM is a memory that is at a lower level in the memory hierarchy and receives memory access requests from the processing element(s). If the requested data is not present in SRAM, the DRAM memory is queried for presence of the requested data. If the data is not present in DRAM, the data is retrieved from non-volatile storage, which contains all of the program instructions and data required for the execution of the program.
Since SRAM is fast relative to DRAM, SRAM is often used to implement caches. Since DRAM is less expensive than SRAM and requires fewer transistors, DRAM is often used to implement the main memory in a memory system hierarchy.
SUMMARY
In one embodiment, a heterogeneous memory system includes a network interface card, a main memory arrangement, a first-level cache, and a memory management unit (MMU). The main memory arrangement, first-level cache, and MMU are disposed on the network interface card. The first-level cache caches data from the main memory arrangement and includes an SRAM arrangement and a DRAM arrangement. The MMU is coupled to the SRAM arrangement, the DRAM arrangement, and to the main memory arrangement. The MMU is configured and arranged to read first data from the main memory arrangement in response to a stored first value associated with the first data, the stored first value indicative of a start time relative to initiation of execution of a program that accesses the first data. The MMU selects one of the SRAM arrangement or the DRAM arrangement in the first-level cache for storage of the first data and stores the first data in the selected one of the SRAM arrangement or DRAM arrangement. The MMU is further configured and arranged to read second data from one of the SRAM arrangement or DRAM arrangement and write the data to the main memory arrangement in response to a stored second value associated with the second data. The stored second value indicates a duration for which the second data is accessed during execution of the program.
In another embodiment, a data processing system is provided. The data processing system includes a processing element in combination with the heterogeneous memory system described above. The processing element is also disposed on the network interface card.
A method of determining data layout in a memory arrangement for data accessed by a program is provided in another embodiment. The method includes determining for each of a plurality of data sets accessed by the program, a respective start time and a respective duration. The start time indicates a time that the program accesses the data set relative to initiation of execution of the program, and the duration indicates a time for which the data set is accessed during execution of the program. Values indicative of the respective start times and durations are stored in a storage element disposed on a network interface card for use by a memory management unit (MMU) during execution of the program. The MMU is also disposed on the network interface card. The method also determines for each data set, whether the data set should be cached in an SRAM memory arrangement in a first-level cache or in a DRAM memory arrangement in the first-level cache. A respective value is stored for each data set to indicate whether the data set should be cached in the SRAM memory arrangement or in the DRAM memory arrangement. The SRAM memory arrangement and the DRAM memory arrangement are disposed on the network interface card. The MMU uses each respective value during execution of the program.
Other embodiments will be recognized from consideration of the Detailed Description and Claims, which follow.



BRIEF DESCRIPTION OF THE DRAWINGS
Various aspects and advantages of the disclosed embodiments will become apparent upon review of the following detailed description and upon reference to the drawings in which:
FIG. 1 shows an example heterogeneous memory system;
FIG. 2 shows an example memory access data pattern entries table;
FIG. 3 is a flowchart of an example process for processing a read request; and
FIG. 4 is a flowchart of an example process for processing a write request.



DETAILED DESCRIPTION OF THE DRAWINGS
The disclosed heterogeneous memory system and data processing system employ both SRAM and DRAM in a first-level cache. A memory management unit (MMU) is coupled to the SRAM arrangement, the DRAM arrangement, and to a main memory arrangement of the system.
The MMU uses data obtained in prior program analysis to determine when data is to be fetched from the main memory arrangement and stored in the first-level cache, whether the fetched data is to be cached in the SRAM arrangement or the DRAM arrangement of the first-level cache, and when data in the first-level cache is to be evicted.
Given that SRAM and DRAM are peers in the first-level cache, bandwidth of the memory system is the combined memory bandwidth of SRAM and DRAM. This is in contrast to a conventional memory system in which at a particular level of the memory hierarchy, memory bandwidth is either the memory bandwidth of SRAM or DRAM (e.g., SRAM in the cache or DRAM in the main memory).
FIG. 1 shows an example heterogeneous memory system 200. Heterogeneous memory system 200 includes heterogeneous storage 202 and a memory management unit (MMU) 201. The heterogeneous storage 202 includes one or more flash memory devices (arrangement) 235 that store program data using flash memory technology, one or more DRAM memory devices (arrangement) 240 that stores the data using DRAM memory technology, and one or more SRAM memory devices (arrangement) 245 that store the data using SRAM memory technology. The flash memory may serve as a system main memory depending on implementation requirements. The heterogeneous storage stores data during the operation of an application program.
A working set is defined as the data that is needed by the application over a moving time window. A goal of the MMU 201 is to maximize the availability of the working set data in SRAM and/or DRAM. A function of the MMU is to manage the access to the data stored in the heterogeneous storage 202 and optimize the data request to and from the processing element and optimization being defined as faster access to the data while increasing the reliability of the flash memory arrangement. For instance, SRAM has the fastest access times among the three memory storage technologies, and DRAM has faster access times than flash storage. Thus the functions of the MMU include caching the data as much as possible in SRAM and/or DRAM; pre-fetching the data into SRAM and/or DRAM from flash memory; and limiting the number of write operations into flash memory to increase the reliability of the flash memory.
Memory management unit 201 includes logic for managing access to the heterogeneous storage and for moving data between the flash memory and SRAM and DRAM arrangements that are peers in a first-level cache. The memory access data pattern entries table 205 is an example of a storage element that stores information that describes data sets accessed by an application program. The information that describes each data set includes an address of the data set, a first time value (start time) that indicates the time at which the application program accesses the data set, and a second time value (duration) that indicates the period of time for which the program will continue to access the data set. In an alternative implementation, a directory or other format may be used to store the information that describes the data sets.
Evict logic 210 is responsible for evicting a data set from SRAM or DRAM once the duration of the data set in the SRAM or DRAM has ended. Evict logic 210 reads the memory access data pattern entries table 205 and determines which data set needs to be read from SRAM or DRAM in the first-level cache and written back to the flash memory devices 235. The data set is moved ahead of an actual need to move data to make space for a new data set in the SRAM or DRAM of the first-level cache.
Pre-fetch logic 215 is responsible for pre-fetching a data set before the actual time of use by the processing element. Pre-fetch logic 215 reads the memory access data pattern entries table 205 and determines which data set, at a specific moment in time and ahead of the actual read request for the data set, needs to be read from a flash memory device and written to either the SRAM or DRAM in the first-level cache.
SRAM controller 220 is responsible for reading data from and writing data to the SRAM memory arrangement. An example controller includes a state machine that performs a sequence of operations to implement read and write operations on the SRAM memory arrangement and includes an interface to accept commands that request read and write operations. An example interface communicates an address, a command (read or write), and the data read or to be written.
DRAM controller 225 is responsible for reading data from and writing data to the DRAM memory arrangement. An example controller includes a state machine that performs a sequence of operations to implement read and write operations on the DRAM memory arrangement and includes an interface to accept commands that request read and write operations. An example interface communicates an address, a command (read or write), and the data read or to be written.
Flash controller 230 is responsible for reading data from and writing data to the flash memory arrangement. An example controller includes a state machine that performs a sequence of operations to implement read and write operations on the flash memory arrangement and an interface to accept commands to perform read or write operations. An example interface communicates an address, a command (read or write), and the data read or to be written.
Hit/miss logic 250 receives an address corresponding to a read or write request and is responsible for determining if the requested data set is present in SRAM or DRAM. The Hit/Miss logic maintains a Data Allocation Table (not shown), which includes entries for data sets that are present in the SRAM and DRAM memory arrangements of the first-level cache. This table is used by the Hit/miss logic 250 to determine whether an address of the read/write request is present in the SRAM arrangement or is present in the DRAM arrangement and pass the control to the appropriate logic block to service the request.
Fetch logic 255 is responsible for fetching the data from the SRAM, DRAM, or flash memory arrangements. The fetch logic 255 receives control from the Hit/miss logic 250 along with the information of where the data is present, in either the SRAM, DRAM or flash memory arrangements, and the fetch logic retrieves the data from the specified memory device and returns the data to the requesting processing element 100.
Write logic 260 is responsible for writing data to SRAM, DRAM, or the flash memory arrangement. The write logic 260 receives control from the Hit/miss logic 250 along with address information that indicates where the data is to be written in the SRAM, DRAM, or flash memory arrangements. The write logic writes the data to the appropriate memory device.
In an implementation of a data processing system, one or more processing elements 100 may be coupled to the MMU. The processing elements may be parallel processing elements, application-specific integrated circuits (ASIC), or a central processing unit (CPU), for example. The processing element may execute programs compiled from applications written in high level languages such as C/C++, or the processing element may implement circuitry specified in hardware description languages such as Verilog or VHDL. The processing elements, heterogeneous storage, and MMU may also be alternatively implemented on resources of one or more field programmable gate arrays (FPGAs) or in system-on-chip (SoC) having programmable logic resources.
The processing element(s) 100, heterogeneous MMU 201, and heterogeneous storage 200 may be implemented on a network interface card (NIC) 103, or integrated with a CPU as a System on Chip, for example. The processing element(s) are coupled to a receive/transmit port circuit 101, which conveys requests over a connected network, such as an Ethernet network. The circuitry may be implemented in a field programmable gate array (FGPA), as an application specific integrated circuit (ASIC), as part of a CPU architecture, or in various combinations of the forgoing. The MMU and its components may be designed using a hardware description language (HDL), a register transfer language (RTL), or a high-level programming language such as C or C++, for example. A high-level programming language differs from an HDL and RTL in that a program written in a high-level programming language may be compiled into instructions that are executable by a microprocessor.
FIG. 2 shows an example memory access data pattern entries table 205. The memory access data pattern entries table contains respective entries for data sets that will be used in an application. Each entry includes an address or address offset, a value indicating a start-time at which the data set will be used in an application, a duration of a memory data, and a value indicating whether the data set should be cached in the SRAM or DRAM. The data layout (cache in SRAM or DRAM) of the memory at run time is controlled by the contents of the memory access data pattern entries table. Thus the contents of the memory access data pattern entries table specify the application-specific data layout.
The memory management unit will use the entries in the memory access data pattern entries table to pre-fetch data sets into the SRAM and/or DRAM of the first-level cache from the flash memory. A data set may be pre-fetched ahead of an actual request to access the data set by the application. Flash memory is large enough to hold the application data and stores all the data used by an application.
A program may be analyzed to determine the desired data layout. Depending on the life-time of a data set and frequency of use of the data set, the analysis determines if the data should be cached in SRAM or DRAM, as well as when the data set should be prefetched and evicted from cache. This information is stored in the memory access data pattern entries table.
The memory access data pattern entries table may be determined by either static compiler analysis or dynamic run-time analysis. An application written in high level language such as C/C++ or hardware description language may be analyzed for data access patterns. The output of this analysis is a table of address offsets, values that indicate durations of the time during which respective data sets are going to be actively used in an application, and start-times that denote the earliest time at which a data set will be used in an application.
Dynamic run-time analysis of an application program may be performed to deal with scenarios in which the compiler cannot statically determine the data usage patterns. Data dependency may be one such scenario. During these scenarios, the application program will be instrumented to create an instrumented version, and the user may be requested to run the program in a “test_mode”. In executing the instrumented application program, data usage patterns are gathered, and the information needed to populate the memory access data pattern entries table is extracted.
In an alternative implementation, the memory access data pattern may be characterized in microcode that specifies the schedule of pre-fetch. For instance, the output of the compiler analysis or dynamic run-time analysis can be further analyzed, and microcode can be generated containing the schedule for pre-fetching data sets to the SRAM or DRAM in the first-level cache and for eviction of the data sets.
FIG. 3 is a flowchart of an example process 300 for processing a read request. The data allocation table 305 stores the addresses of data sets present in SRAM and/or DRAM. At block 310, the Hit/Miss logic receives a read request from a processing element. In response to receipt of the read request, the Hit/Miss logic determines the location of the data set. Specifically, the Hit/Miss logic determines whether the data to be read is in the SRAM arrangement or the DRAM arrangement in the first-level cache or is in the flash memory. At decision block 315, the process determines whether or not the data set is present in the SRAM arrangement. If the requested data is present, the data is fetched from the SRAM arrangement at block 320. Otherwise, at decision block 325, the process determines whether or not the data set is present in the DRAM arrangement. If the data set is present in the DRAM arrangement, the data set is fetched from the DRAM arrangement at block 330. If the data set is not present in the DRAM arrangement, the data set is fetched from the flash memory at block 335. At block 350, the fetched data set is output to the requesting processing element.
At block 340, the data set fetched from flash memory is written to the SRAM arrangement or to the DRAM arrangement, depending on the corresponding indicator value in the memory access data pattern entries table 205. At block 345, the data allocation table 305 in Hit/Miss logic is updated with the location (SRAM or DRAM) of the data fetched from the flash device.
FIG. 4 is a flowchart of an example process 400 for processing a write request. At block 410, the Hit/Miss logic receives a write request from a processing element. In response to receipt of the write request, the Hit/Miss logic determines whether the address for the data to be written is in the SRAM arrangement, the DRAM arrangement or in the flash memory. Decision block 415 determines whether or not the requested address is in the SRAM arrangement. If so, at block 420, the data is written to the SRAM arrangement. Otherwise, decision block 425 determines whether or not the requested address is in the DRAM arrangement. If so, the data is written to the DRAM arrangement at block 430. If the requested address is not in the DRAM arrangement, at block 435 the data is written to the flash memory.
Though aspects and features may in some cases be described in individual figures, it will be appreciated that features from one figure can be combined with features of another figure even though the combination is not explicitly shown or explicitly described as a combination.
The embodiments are thought to be applicable to a variety of memory systems. Other aspects and embodiments will be apparent to those skilled in the art from consideration of the specification. The embodiments may be implemented as one or more processors configured to execute software, as an application specific integrated circuit (ASIC), or as a logic on a programmable logic device. It is intended that the specification and illustrated embodiments be considered as examples only, with a true scope of the invention being indicated by the following claims.

## Claims

1. A heterogeneous memory system, comprising:
a network interface card;
a main memory arrangement disposed on the network interface card;
a first-level cache for caching data from the main memory arrangement, the first-level cache disposed on the network interface card and including an SRAM arrangement and a DRAM arrangement;
a memory management unit (MMU) disposed on the network interface card and coupled to the SRAM arrangement, the DRAM arrangement, and to the main memory arrangement, the memory management unit configured and arranged to:
read a first data set from the main memory arrangement in response to a stored first value associated with the first data set, the stored first value indicative of a start time relative to initiation of execution of a program that accesses the first data set;
select one of the SRAM arrangement or the DRAM arrangement in the first-level cache for storage of the first data set;
store the first data set in the selected one of the SRAM arrangement or DRAM arrangement; and
read a second data set from one of the SRAM arrangement or DRAM arrangement and write the data to the main memory arrangement in response to a stored second value associated with the second data set, the stored second value indicative of a duration for which the second data set is accessed during execution of the program.

2. The heterogeneous memory system of claim 1, wherein the main memory arrangement includes flash memory.

3. The heterogeneous memory system of claim 1, wherein the main memory arrangement includes a DRAM arrangement.

4. The heterogeneous memory system of claim 1, wherein the MMU includes a storage element configurable with addresses and respectively associated values indicating start times and durations for data sets accessed by a program.

5. The heterogeneous memory system of claim 4, wherein the storage element is further configurable with values respectively associated with the addresses stored in the storage element for indicating whether data sets referenced by the addresses are to be stored in the SRAM arrangement or the DRAM arrangement.

6. The heterogeneous memory system of claim 1, wherein the MMU is further configured and arranged to read the first data set from the main memory arrangement and store the first data set in one of the SRAM arrangement or the DRAM arrangement prior to receiving a request for access to the first data set.

7. The heterogeneous memory system of claim 1, wherein the MMU is further configured and arranged to read the second data set from one of the SRAM arrangement or DRAM arrangement and write the data to the main memory arrangement prior to detecting a need to remove data from the first-level cache to make space available in the first-level cache for data other than the second data set.

8. A data processing system, comprising:
a network interface card;
a processing element disposed on the network interface card;
a main memory arrangement disposed on the network interface card;
a first-level cache for caching data from the main memory arrangement, the first-level cache disposed on the network interface card and including an SRAM arrangement and a DRAM arrangement;
a memory management unit disposed on the network interface card and coupled to the processing element, the SRAM arrangement, the DRAM arrangement, and to the main memory arrangement, the memory management unit (MMU) configured and arranged to:
read first data from the main memory arrangement in response to a stored first value associated with the first data, the stored first value indicative of a start time relative to initiation of execution on the processing element of a program that accesses the first data;
select one of the SRAM arrangement or the DRAM arrangement in the first-level cache for storage of the first data;
store the first data in the selected one of the SRAM arrangement or DRAM arrangement; and
read second data from one of the SRAM arrangement or DRAM arrangement and write the data to the main memory arrangement in response to a stored second value associated with the second data, the stored second value indicative of a duration for which the second data is accessed during execution of the program.

9. The data processing system of claim 8, wherein the main memory arrangement includes flash memory.

10. The data processing system of claim 8, wherein the MMU includes a storage element configurable with addresses and respectively associated values indicating start times and durations for data sets accessed by a program.

11. The data processing system of claim 10, wherein the storage element is further configurable with values respectively associated with the addresses stored in the storage element for indicating whether data sets referenced by the addresses are to be stored in the SRAM arrangement or the DRAM arrangement.

12. The data processing system of claim 8, wherein the MMU is further configured and arranged to read the first data from the main memory arrangement and store the first data in one of the SRAM arrangement or the DRAM arrangement prior to receiving a request for access to the first data.

13. The data processing system of claim 8, wherein the MMU is further configured and arranged to read the second data from one of the SRAM arrangement or DRAM arrangement and write the data to the main memory arrangement prior to detecting a need to remove data from the first-level cache to make space available in the first-level cache for data other than the second data.

14. The data processing system of claim 8, wherein the processing element is implemented on a field programmable gate array (FPGA).

15. The data processing system of claim 8, wherein the processing element is implemented on an application specific integrated circuit (ASIC).

16. The data processing system of claim 8, wherein the processing element is a central processing unit.

17. A method of determining data layout in a memory arrangement for data accessed by a program, comprising:
determining for each of a plurality of data sets accessed by the program, a respective start time and a respective duration, the start time indicative of a time that the program accesses the data set relative to initiation of execution of the program, and the duration indicative of a time for which the data set is accessed during execution of the program;
storing in a storage element disposed on a network interface card, values indicative of the respective start times and durations for use by a memory management unit (MMU) during execution of the program, wherein the MMU is disposed on the network interface card;
determining for each data set, whether the data set should be cached in an SRAM memory arrangement in a first-level cache or in a DRAM memory arrangement in the first-level cache, wherein the SRAM memory arrangement and the DRAM memory arrangement are disposed on the network interface card; and
storing a respective value for each data set indicative of whether the data set should be cached in the SRAM memory arrangement or in the DRAM memory arrangement, each respective value for use by the MMU during execution of the program.

18. The method of claim 17, wherein the determining steps and storing steps are performed during compilation of the program.

19. The method of claim 17, wherein the determining steps and storing steps are performed during execution of an instrumented version of the program.

20. The method of claim 17, further comprising implementing the MMU using a high-level programming language, a hardware description language, or a register transfer language, or a combination thereof.