Method for storing data operands in a memory unit and method for accessing data operands in a memory unit - Patents.com
The method enhances memory access efficiency by using a memory controller with independent channels and a tag store to optimize memory access for vector data structures, reducing latency and energy consumption in high-performance computing systems.
Patent Information
- Application Number
- JP2024533081
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Filing Date
- 2021-12-03
- Publication Date
- 2024-11-08
- Estimated Expiration
- Not applicable · inactive patent
AI Technical Summary
Modern computing systems face inefficiencies in memory access and power consumption when dealing with non-sequential data access patterns, particularly in high-performance computing systems that use vector data structures, as existing methods fail to optimize memory bandwidth and power usage for random or non-consecutive operand references.
A method for accessing data operands in a computer memory unit involving a memory controller that utilizes a memory cache and tag store, with N independent channels, allowing simultaneous access to multiple columns of data and exploiting locality of reference through look-ahead operations, reducing unnecessary reads and writes.
This approach minimizes memory access time and energy consumption by enabling simultaneous reading and writing of multiple data blocks, optimizing performance for vector operations and reducing latency in multiprocessor systems.
Smart Images

Figure 2024541672000001_ABST
Abstract
Description
[Technical field]
[0001] The present invention relates to a method for storing and accessing operands in a computer memory unit, in particular to a method for accessing a data operand stored in a main memory unit having N independently controlled channels, a memory cache and a tag store, the method including a step of comparing a physical address with the tag store, the cache tag comprising N status bits referencing the N independent channels, and to a method for writing a data operand to a main memory unit having N independently controlled channels. [Background technology]
[0002] In current computer systems, the primary way to reference physical data is to first access the cache block that contains the referenced operand, where a cache block typically contains multiple operands addressed in sequence. The operands in the cache block are then referenced (loaded and / or stored). This works very well when the references are sequential in nature. However, performance can be severely impacted if subsequent references are not sequential, since a single cache reference contains only one referenced operand. When this happens, it consumes memory bandwidth and power required to read all operands, even if only one operand is used. In most systems, each individual processor on the system has a local cache structure to optimize access to data that is reused or close to data that is already in use.
[0003] However, in very high performance computing systems, the vector data structure is often used. A vector can mean an array of values, or more broadly, any large data structure. Programs that manipulate arrays often perform calculations using the strings of values in one or more vectors, and write the results to another vector. This access pattern is different from the access patterns typically found on general purpose computers: if you have a vector of millions of elements, accessing each value simply overwrites the data held in a cache.
[0004] This is a known situation, and it is common to provide hardware that supports streaming operations. Such hardware is notified that consecutive values are required from a vector, and it will fetch the data ahead of time in the most efficient way possible, and keep the prefetched data in some form of buffering so that the required data can be provided quickly when requested. In technical terms, the distance between consecutive values of a vector is known as the "stride". The consecutive values may be any positive or negative integer, and are valid for both vector loads and vector stores.
[0005] Most modern computing systems use Dynamic Random Access Memory (DRAM) memory units. A feature of DRAM memory is that a read access causes the memory die to select one of several internal buffers and read a complete internal row of data from the DRAM page into that row buffer. A row buffer is understood to mean a high-speed cache of the memory unit formed by the last row read from the memory bank; physically, this is often implemented by sense amplifier cells in the read / write interface of the memory bank. These internal buffers are often called pages. Selecting a page to store data is called opening that page. If a new page is needed and all available pages are in use, a page must be selected and closed, and a new page must be opened to hold the other data. If data already in a row buffer is requested, it is provided very quickly by the DRAM's logic, without reading the main DRAM array. A DRAM die generally provides a small number of row buffers, and reading data from a row buffer is faster and consumes less power than reading from the memory array itself. Therefore, a DRAM operation involves three main latencies: i) operating on a DRAM page already present in a row buffer, ii) opening a page and performing the operation on that row buffer, and iii) if all row buffers are in use, selecting a page to close and opening a new page to perform the operation on that row buffer.
[0006] While it is possible to construct useful adaptive heuristics for a single stream of accesses from a single processor, in typical use of multiprocessor systems this becomes much more difficult, as accesses from dozens or hundreds of processors present the memory system as an essentially random set of requests. Memory controllers have added limited buffering to consolidate and reorder memory requests for optimal performance, but the window size is limited. Similarly, caches and store buffers act as write-combining mechanisms to reduce the number of DRAM writes.
[0007] Therefore, what is needed is a way to optimally use memory units for a particular set of access patterns. Summary of the Invention
[0008] To overcome the problems found in the prior art, the present invention provides a method for accessing data operands stored in a computer having a processing unit and a main memory unit, the main memory unit comprising: a memory configured to store data words operably arranged into a plurality of rows, the rows being operably divided into N columns, N being greater than 1; a memory controller configured to read or write data blocks of one or more words from or to a memory, the memory controller comprising: a memory cache configured to store blocks retrieved by the memory controller; and a tag store configured to store tags for blocks stored in the memory cache; the memory further comprising a write buffer configured to write data words to the memory, and a store buffer; the memory is in data communication with the processing unit via a memory cache, the memory cache being in data communication with the memory via N independently controlled channels, each channel configured to access one or more columns; The method includes, when a processing unit requests access to an operand, the memory controller: receiving a physical address of an operand from a processing unit; comparing the physical address to a tag in a tag store; reading one or more blocks containing the operands from a memory cache; Including, The physical address includes a row index, The tag provides a way to contain N status bits, each of which references a channel.
[0009] Throughout this disclosure, it should be understood that the claimed methods are directed to any type of computer or computer system, including networked computers and computers with multiple processing units. An operand should be understood as a data element stored in the computer's memory and used by the processor in a calculation or processing. An operand should be understood as a data unit of calculation or processing, regardless of the size of the data element. Examples of operands include integers, especially large integers, vectors, matrices, etc. A data word, or simply a word, should be understood as a natural unit of data used in a particular processor or memory design. A data block, or block, should be understood as a data element containing one or more words sent to or from a memory unit in response to a single write or read command. An access should be understood as an operation to read data from a memory, write data to a memory, or both.
[0010] Preferably, the processing unit includes a processor and a plurality of processing caches arranged in hierarchical levels that are accessed sequentially to retrieve the required operand. In one embodiment, the memory unit in which the method is performed is configured as a processing cache, in particular an L3 cache, or level 3 cache.
[0011] A main memory unit, or simply a memory unit, comprises a memory body, preferably an array of memory cells implemented in multiple chips that store data, and other control and / or access circuitry. The memory unit is preferably a conventional dynamic random access memory (DRAM) memory unit, and in a more preferred embodiment, an HBM (High Bandwidth Memory). HBM should be understood to be a high-speed computer memory interface for 3D stacked synchronous dynamic random access memory (SDRAM), realized by stacking up to eight, or possibly more, DRAM dies, interconnected vertically by through silicon vias (TSVs). It should be noted that a processing cache is not to be confused with a memory cache, which is a specific storage element of a memory unit configured to temporarily store data from memory chips and facilitate write and read operations of the memory unit. Data is stored in the memory in a conventional manner as data words, operably arranged in rows and columns. These columns are accessed by N channels or buses, each configured to access one or more columns. A block has a specific size, which is the same as the bandwidth of the channel, which depends on the size and number N of rows. The memory unit further includes a tag store, which is a storage element configured to hold an updated list of elements currently stored in the memory cache. Entries in the memory cache are identified by respective tags. Each tag is generated from the physical address in memory of each block and includes N status bits, each bit corresponding to a channel, and the tag identifies a channel that can read the block containing the operand. The physical address in turn includes an index that identifies a row of the block.
[0012] The operations performed on the memory unit, i.e., receiving the physical addresses of the operands from the processing unit, comparing the physical addresses of the operands with the tags in the tag store, reading the operands from the memory cache, and preferably sending the blocks to the processing unit, are performed by a memory controller, which in an embodiment includes a processor.
[0013] Preferably, each selective read or write has its own physical address, and once the operands are retrieved from memory in accordance with the claimed method, independent operation of the channels allows selective reading of one or more blocks within a row, rather than reading an entire row of data. This is particularly preferred when the requested operands are stored in multiple words belonging to different rows, and conventional processes require reading each row separately and storing a single block of the row. Thus, the present invention requires less time and consumes less energy to access memory than conventional methods.
[0014] After receiving the physical address of the operand and comparing it with the tag in the tag store, if there is a match or cache hit, the requested block is already stored in the memory cache and the memory controller only needs to read the cache entry that matches the physical address of the block and send it to the processing unit. If there is no match, i.e. a cache miss, the memory controller needs to retrieve the block from memory.
[0015] In a particular embodiment, after the step of comparing the physical address with the tag, if there is a memory cache miss, the method includes the memory controller reading a block from each channel whose tag status bit is active and writing the block to the memory cache. A read from memory is performed by reading blocks (regardless of the row they belong to) that can be accessed simultaneously by all N channels. That is, two words stored in the same column cannot be accessed simultaneously by corresponding channels, so the read must be performed in two different accesses.
[0016] In a particular embodiment, reading the blocks includes reading the blocks from each channel according to increasing physical addresses. Typically, processes and operations performed by a processing unit require multiple operands within a short period of time, which are often stored in adjacent locations in memory. To exploit locality of reference, the memory controller reads not only the requested block, but also several subsequent blocks in ascending physical memory order. In another embodiment, reading the blocks includes reading the blocks from each channel according to decreasing physical addresses.
[0017] In a particular embodiment, the memory includes a multiplexer and the method includes the memory controller selecting a word within a row using the multiplexer. The multiplexer is a preferred embodiment of the logic circuitry that enables and streamlines channel selection.
[0018] In a particular embodiment, if two or more words contain operands located in the same column but different rows, the memory controller executes the read or write operation as an out-of-order instruction. Similar to the previous case, a read operation from the memory may require reading two or more blocks that cannot be accessed simultaneously by the channel. In other words, the words are stored in the same column but different rows, and in such a case, the read requires two or more accesses. To minimize the latency of the process, the operation performed by the memory controller may execute a calculation or process as an out-of-order instruction using the available data while waiting for the remaining data.
[0019] In a particular embodiment, if the operand is a vector reference, the access request of the processing unit includes information of the stride and length of the vector reference. Preferably, if the operand is a vector, there is a physical address for each vector element. This method is particularly suitable for processing large operands such as vector references. A vector reference is defined by a stride and a length, and certain combinations of these values reduce the access time to memory.
[0020] In particular embodiments, the memory unit includes 2, 4, or 8 channels. Advantageously, a larger number of channels allows for finer block granularity and reduces unnecessary data reads from memory.
[0021] In a particular embodiment, the memory unit is a high-bandwidth memory (HBM) memory unit. High-bandwidth memory allows for the creation of very high-performance memory systems that are space and power efficient. HBM provides high bandwidth by stacking multiple DRAM dies vertically and providing interconnects through all the stacked dies to the base die. The base die houses the controller logic that manages access to the dies and presents data to the system to which the assembly is connected. Current HBM memory units already have a 1024-bit interface and 8 channels, allowing for very fast data access, but the next generation of HBM products will have increased capacity and bandwidth. In other embodiments, the memory unit is a different type of storage, such as NVRAM, 3D XPoint, or NAND flash. In another embodiment, the memory unit comprises a combination of memory technologies, such as a combination of HBM memory and 3D XPoint memory.
[0022] In a particular embodiment, the processing unit comprises multiple processing cores. Advantageously, the performance of the method is maximized on large multi-core computing systems that perform primarily vector calculations, which exhibit much better operational access patterns since all calculations are performed in a vector-like manner on linear arrays of data.
[0023] In a particular embodiment, the memory unit comprises a memory controller processing unit. Advantageously, the memory controller comprises a tightly coupled processing unit, allowing programs executing on the processing unit to implement various access strategies. The desired strategy for a future program phase may be set by a protocol between the application software and the software executing on the memory controller processing unit. In a preferred embodiment, the memory controller processing unit is a memory controller CPU (MCPU). Additional MCPUs may be provisioned to perform operating system (OS) services and other management functions such as daemons, services and OS-related services. Similarly, memory structures with accelerators may play multiple roles, for example, a shared L2 cache may use a cache way to provide a scratch pad.
[0024] In a particular embodiment, the method includes prefetching a cache block.
[0025] In certain embodiments, the method includes vector referencing.
[0026] In a second aspect of the present invention, the present invention provides a method of writing a data operand to a main memory unit of a computer further comprising a processing unit, the main memory unit comprising: a memory configured to store data words operably arranged into a plurality of rows, the rows being operably divided into N columns, N being greater than 1; a memory controller configured to read and write data blocks of one or more words from and to a memory, the memory controller comprising a memory cache configured to store blocks retrieved by the memory controller, and a tag store configured to store tags for blocks stored in the memory cache; the memory further comprising a write buffer configured to write data words to the memory, and a store buffer; the memory is in data communication with the processing unit via a memory cache, the memory cache being in data communication with the memory via N independently controlled channels, each channel configured to access one or more columns; The method includes, when a processing unit requests to write an operand, the memory controller: receiving a physical address of an operand from a processing unit, the physical address including N valid bits and N dirty bits; receiving an operand from a processing unit; writing one or more blocks containing operands whose addresses include active valid bits and active dirty bits to a memory cache; updating a tag in a tag store; The present invention provides a method comprising:
[0027] In a particular embodiment, if the operand is a vector operand and the operand is not stored in the cache, the method comprises: Writing the operands from the processing unit to a write buffer in the memory is included.
[0028] In a particular embodiment, if the operand is a vector operand and the operand is stored in a cache, the method comprises: setting a valid bit of one or more channels containing the operand to inactive; writing operands from the processing unit to a write buffer of the memory; Includes. [Brief description of the drawings]
[0029] The foregoing advantages and features, as well as other advantages and features, will be more fully understood from the following detailed description of illustrative embodiments, taken in conjunction with the accompanying drawings, which are to be considered as illustrative and not restrictive, in which:
[0030] [Figure 1] FIG. 1 shows a diagram of a main memory unit and a processing unit. [Diagram 2] FIG. 2 depicts a diagram of a block's physical address and cache tag. [Diagram 3] FIG. 3 depicts a flow diagram of the method. [Figure 4] FIG. 4 shows a diagram of the contents of three memory rows containing channels and operands. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0031] It will be understood that throughout this specification various parts or steps of one embodiment of the invention, even if not explicitly described, can be freely combined with parts or steps described in other embodiments, provided that such combination is not detrimental.
[0032] A preferred embodiment of the present invention provides a mechanism to coordinate memory operations among multiple requesters. This provides multiple benefits: i) the memory hierarchy is reformulated to present vectors instead of cache lines, and ii) the analysis of vectors allows the DRAM system to virtually extend and provide additional DRAM row buffer capacity on-chip. The former provides a more efficient way to manipulate and present non-unit stride data structures to the compute units, moving only useful data on-chip. The latter reduces the energy requirements for larger granularity data chunks, DRAM pages, and creates a larger virtual interleaved memory subsystem. This reduces the latency and energy of requests to hot DRAM pages that would otherwise be reopened and closed multiple times in DRAM.
[0033] The illustrative example is implemented in a conventional computer with an HBM memory unit (100) and a conventional processing unit (104). In one example, the HBM memory unit (100) has a memory controller (107), a 1024-bit wide interface, eight independent control channels (hence N=8 in this example) each capable of providing 128 bits of data, and a 128-bit wide memory cache. In another example, the HBM memory unit has four channels, each of which is 256 bits, totaling 1024 bits (N=4). In yet another example, the HBM memory unit has eight channels, each of which is 256 bits, totaling 2048 bits (N=8). In a preferred example, shown in FIG. 4 and used in the following examples, the memory has a 512-bit wide interface and four channels (N=4), each providing 128 bits. Typically, a cache block can contain a large number of operands, typically up to eight 64-bit operands (or up to sixteen 32-bit operands).
[0034] 1 shows a diagram of an HBM memory unit (102) and the processes involved in the method. The 512-bit memory is in data communication with a memory cache via a 4:1 multiplexer (101), and the memory cache (103) is in data communication with a processing unit (104) via a 4:1 multiplexer (105).
[0035] In this example, the operand access method is implemented as shown in Figure 3 and is described as follows: A processing unit issues a request for an operand including a physical address (201), as shown in the upper part of Figure 2. The physical address includes a row index indicating the block in which the operand is stored. The physical address (201) is received by the memory controller (107) and compared to the tag (202) of the tag store. Preferably, the physical address (201) is issued by a translation lookaside buffer (TLB) of the processing unit (104).
[0036] If the requested operand is stored in the cache, the memory controller (107) simply reads the entry from the memory cache (103) and sends it to the processing unit (104). If the operand is not stored in the memory cache (103), the memory controller (107) accesses the memory (102) and simultaneously reads as many blocks as possible from the channels. That is, depending on the location of the blocks within a row of memory, operands from different rows may be read simultaneously if they are stored in different columns.
[0037] Thus, if an operand spans four memory blocks in the same row, the memory controller (107) will read all four channels simultaneously, and if the operand is stored in a single block accessible from, say, channel 2, the memory controller (107) will only read channel 2, ignoring the data in the remaining channels.
[0038] The memory controller (107) then writes the block to the memory cache (103) and sends it to the processing unit (104). In the above case, the channel 2 operand is read from memory and stored in the cache. Valid bit 1 of the tag (202) in the tag store (106) corresponding to channel 2 is set to a logical "1", indicating that the operand is present in the memory cache (103). Valid bits 3, 1, and 0, which correspond to channels 3, 1, and 0, respectively, are set to a logical "0", indicating that the memory cache (103) does not contain the operands of channels 3, 1, and 0 for the memory location referenced by the physical address (201).
[0039] Figure 4 shows a simplified diagram of a memory (102) according to an embodiment. In this example, the memory (102) has four channels and 512-bit rows, each row containing four 128-bit data blocks (N=4), each block containing two 64-bit operands, and each operand having a physical address (201). For convenience, only three rows are shown in Figure 4, the operands are labeled AX, and their respective physical addresses are represented by the numbers 0-23.
[0040] Next, some concrete examples are described according to the type of reference. In all the following examples, it is assumed that the memory (102) is configured as in FIG. 4, and the read of the HBM memory unit reads four channels (N=4). Furthermore, the term "foo" is used as a placeholder for any name. In accordance with the requirements of the claimed method, the virtual channels can be controlled independently. This means that the read or write of the HBM can be treated as four independent reads or writes. Independent means four physical addresses that are independent of each other.
[0041] <Scalar Lord> For scalar loads, a scalar reference <g>Upon execution of an instruction to load operand "G" into a processing unit (104) register, the processing unit (104) generates a physical address (201) for this operand "G", which is used to access the tag store (106), and the output of the tag store (106) is compared with the tag field of the physical address (201). The valid bit is then checked, and if the valid bit is "1", it means that the operand "G" is stored in the memory cache (103) and there is a cache hit. In this case, the cache multiplexer (105) retrieves the operand, which is then sent to the corresponding register of the processing unit (104).
[0042] If the valid bit is "0", it means that the operand "G" is not stored in the memory cache (103) and a cache miss occurs. In such a case, the operand "G" needs to be retrieved from the HBM memory (102). Since memory access is costly, the locality of reference is exploited by a look-ahead operation. That is, the memory controller (107) loads the block containing the requested operand and the subsequent blocks according to increasing physical addresses. Since the memory (102) is accessed by independent control channels, the memory controller (107) accesses the channel and row where the operand "G" is stored, which according to FIG. 4 is row 0 and channel 3, which contains the operands "G" and "H". The look-ahead process also retrieves the contents accessible by channel 0, channel 1 and channel 2, which is in row 1 according to increasing physical addresses, i.e., operands "I" to "N". These operands are written to the memory cache (103) and the tag store (106) is updated accordingly, with the valid bit of the corresponding channel set to "1" and the remaining valid bits set to "0".
[0043] <Vector Load> In a vector load instruction, multiple operands are loaded in the same instruction. For this, the instruction must contain i) the starting address of the first operand of the vector, ii) the length of the vector, or the number of operands requested, and iii) the stride of the vector, or the distance between consecutive operands. In one example, a vector is requested starting with operand "C", with a length of 4 operands and a stride of 1. Thus, the requested operands are "C", "D", "E", and "F" (hereafter, vector_1). Hence, only two channels (channels 2 and 1) are read; channels 0 and 3 are not read. If the starting address is "A" and the stride is 4, then the requested operands are "A", "E", "I", and "M" (hereafter, vector_2).
[0044] When vector_1 is requested, four physical addresses are generated by the processing unit (104), one for each operand. The subsequent access process is the same as for a scalar load, except that only channel_1 and channel_2, which contain all four "C", "D", "E", and "F" operands, are read. The contents of the tag store (106) are then updated, with the valid bits of channel_1 and channel_2 set to "1", respectively.
[0045] Because the operands are stored in different rows in vector_2, the memory controller (107) needs to perform two access operations: one for row_0 on channel_0 and channel_2, and another for row_1 on channel_0 and channel_2.
[0046] The process of reading an operand is similarly described for the same computer-implemented example as above, as follows: The processing unit (104) generates both the operand and the physical address (201) of the operand. The operand is loaded into a register of the processing unit (104), from where it is sent to the write buffer (109) and the cache (103), and the address (201) is sent to the tag store (106), which generates a tag (202) with N valid bits and N dirty bits. The purpose of the dirty bits is the same as in conventional memory configurations, but here the address (201) has one dirty bit for each channel. If the operand is not stored in the cache (103), a new entry for the operand is created, and in some examples the write buffer (109) also writes the operand to memory (102).
[0047] If the cache block to which an operand needs to be written is already in use, the contents of the cache block are first written to memory (102) and then the operand is written to the cache (103). Also, thanks to the dirty bits of each channel, only blocks with active dirty bits are written through the corresponding channel.
[0048] A scalar operand can be considered as a vector operand of length 1, so that the only channels that are written to are those marked as dirty. If only one channel is dirty, then only one word is written back to memory (102). Thus, the write or store process is similar to that for vector operands, with the difference that if the operand is not in the cache (103), it is sent directly to the channel in the write buffer (109) and a memory (102) write operation is performed if the data cannot be written to the write buffer (109). Conversely, if the operand is in the cache (103), the corresponding valid bit is set to logic "0" and the above process is performed. [Explanation of symbols]
[0049] 100 main memory units 101 Memory Multiplexer 102 Memory 103 Memory Cache 104 Processing equipment 105 Cache Multiplexer 106 Tag Store 107 Memory Controller 109 Memory Write Buffer 201 Physical Address 202 Tags< / g>
Claims
1. A method for accessing data operands stored in a computer having a processing unit (104) and a main memory unit (100), the main memory unit (100) comprising: a memory (102) configured to store data words operably arranged into a plurality of rows, the rows being operably divided into N columns, N being greater than 1; a memory controller (107) configured to read or write data blocks consisting of one or more words from or to said memory (102), said memory controller (107) comprising a memory cache (103) configured to store blocks retrieved by said memory controller (107), and a tag store (106) configured to store tags for said blocks stored in said memory cache (103); the memory (102) further comprising a write buffer (109) configured to write data words to the memory (102), and a store buffer; the memory (102) is in data communication with the processing unit (104) via the memory cache (103), the memory cache (103) being in data communication with the memory (102) via N independent control channels, each channel configured to access one or more columns; The method further comprises, when the processing unit (104) requests access to the operand, the memory controller (107): receiving a physical address (201) of the operand from the processing unit (104); comparing said physical address (201) with said tag in said tag store (106); reading one or more blocks containing said operands from said memory cache (103); Including, The physical address (201) includes a row index; The tag includes N status bits, each of which references a channel. method.
2. If after the step of comparing the physical address (201) with the tag there is a memory cache miss, the method further comprises the memory controller (107) reading a block from each of said channels for which said tag status bit is active; writing said block to said memory cache (103); The method of claim 1 , comprising:
3. 3. The method of claim 2, wherein reading the blocks comprises reading blocks from remaining channels according to increasing physical addresses (201).
4. 4. The method of claim 1, wherein the memory (102) includes a multiplexer (101), and the method includes the step of the memory controller (107) selecting a word in a row using the multiplexer (101).
5. 5. The method of claim 1, wherein the memory controller (107) executes a read or write operation as an out-of-order instruction if two or more words contain the operands located in the same column and different rows.
6. The method of claim 1 , wherein if the operand is a vector reference, the access request of the processing unit (104) includes stride and length information of the vector reference.
7. The method of claim 1 , wherein the memory unit comprises 2, 4 or 8 channels.
8. The method of claim 1 , wherein the memory unit is a high bandwidth memory (HBM) memory unit.
9. The method of claim 1 , wherein the processing unit (104) comprises a plurality of processing cores.
10. The method of claim 1 , wherein the memory unit comprises a memory controller (107) processing unit.
11. A method for writing a data operand to a main memory unit (100) of a computer having a processing unit (104), the main memory unit (100) comprising: a memory (102) configured to store data words operably arranged into a plurality of rows, the rows being operably divided into N columns, N being greater than 1; a memory controller (107) configured to read or write data blocks consisting of one or more words from or to said memory (102), said memory controller (107) comprising a memory cache (103) configured to store blocks retrieved by said memory controller (107), and a tag store (106) configured to store tags for the blocks stored in said memory cache (103); the memory (102) further comprising a write buffer (109) configured to write data words to the memory (102), and a store buffer; the memory (102) is in data communication with the processing unit (104) via the memory cache (103), the memory cache (103) being in data communication with the memory (102) via N independent control channels, each channel configured to access one or more columns; The method further comprises the steps of: when the processing unit (104) requests to write the operand, the memory controller (107) receiving a physical address (201) of the operand from the processing unit (104), the physical address (201) including N valid bits and N dirty bits; receiving the operands from the processing unit (104); writing one or more blocks containing the operands whose addresses include active valid bits and active dirty bits to the memory cache (103); updating the tag in the tag store (106); A method comprising:
12. If the operand is a vector operand and the operand is not stored in the cache, the method further comprises:
12. The method of claim 11, comprising writing the operands from the processing unit (104) to the write buffer (109) of the memory (102).
13. If the operand is a vector operand and the operand is stored in the cache, the method further comprises: setting the valid bit of one or more channels containing the operand to inactive; writing said operands from said processing unit (104) to said write buffer (109) of said memory (102); The method of claim 11 , comprising:
