Multimedia compressed frame aware cache replacement policy

TWI945321BActive Publication Date: 2026-11-11QUALCOMM INC
View PDF 6 Cites 0 Cited by

Patent Information

Application Number
TW111143377
Authority / Receiving Office
TW · TW
Patent Type
Patents
Current Assignee / Owner
Priority Date
2021-12-31
Filing Date
2022-11-14
Publication Date
2026-11-11
Estimated Expiration
2042-11-13

AI Technical Summary

Technical Problem

Conventional cache replacement policies such as nMRU and FIFO are not optimal for multimedia frame-based clients, where temporal locality is within frame time boundaries and capacity allocation varies based on compression ratio, leading to inefficiencies in cache usage.

Method used

Implementing a standard-aware cache replacement strategy that uses a stale counter associated with data in the system cache to determine staleness, updating the counter based on signals from clients and comparing it to a staleness threshold to decide when to replace data.

Benefits of technology

Improves cache efficiency by identifying and replacing stale data, enhancing last-level cache usage and reducing DDR SDRAM services, resulting in improved computing device performance.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure TWG2TB001920066_001
    Figure TWG2TB001920066_001
  • Figure TWG2TB001920066_002
    Figure TWG2TB001920066_002
  • Figure TWG2TB001920066_003
    Figure TWG2TB001920066_003
Patent Text Reader

Abstract

Various embodiments include methods and apparatus for implementing a standard cache-aware replacement strategy by a computing device. Embodiments may include: updating an obsolescence counter, writing the value of a local counter to the system cache in association with the location of data in the system cache, wherein when the associated data is written to the system cache (i.e., when the associated data is written to the system cache), the value of the local counter includes the value of the obsolescence counter, and the value of the local counter of the associated data is used to determine whether the associated data is obsolescence.
Need to check novelty before this filing date? Find Prior Art

Description

[Technical Field]

[0001] This case concerns a multimedia compression frame-aware cache memory replacement strategy. [Previous Technology]

[0002] The system cache memory of a computing device can store data according to one or more replacement strategies, such as Not Recently Used (nMRU) and capacity-based First-In-First-Out (FIFO). The nMRU and FIFO strategies are not optimal for various use cases, such as multimedia frame-based clients, where temporal locality is within the frame's time boundaries and capacity allocation can vary based on compression ratio. [Summary of the Invention]

[0003] The methods provided in various forms of this case include methods and apparatus for implementing such a standard-aware cache replacement strategy via a computing device, which may include the steps of: updating a staling counter, writing the value of the local counter to the system cache in association with the location of the associated data in the system cache, wherein when the associated data is written to the system cache, the value of the local counter includes the value of the staling counter, and using the value of the local counter of the associated data to determine whether the associated data is stale.

[0004] In some cases, updating an obsolete counter may include: receiving a signal from a client of a computing device configured to indicate whether to update the obsolete counter, determining whether to update the obsolete counter based on the signal, and updating the obsolete counter in response to the decision to update the obsolete counter.

[0005] In some cases, the signal is a register write command. Receiving the signal from the client of the computing device may include reading a value from a register set by the client, and deciding whether to update the stale counter based on the signal may include deciding whether to update the stale counter based on the value from the register.

[0006] Some states may include values ​​set in a register by a client of the computing device according to a time-based criterion.

[0007] Some states may include values ​​set in a register by a client of the computing device according to an event-based standard.

[0008] Some states may include: receiving a memory write command, wherein writing the value of the local counter to the system cache in association with the location of the associated data in the system cache may occur before updating the stale counter, and wherein the associated data is the data of the memory write command.

[0009] In some cases, using the value of the local counter of the associated data to determine whether the associated data is obsolete may include using the value of the obsolete counter and the value of the local counter to calculate a replacement value and determine whether the replacement value exceeds an obsolete threshold, wherein in response to determining that the replacement value exceeds the obsolete threshold, the associated data is determined to be obsolete.

[0010] Some states may include: receiving a memory access command, and writing the data of the memory access command into the system cache at a location where the replacement value exceeds the obsolescence threshold, wherein the data of the memory access command written into the system cache is associated data.

[0011] Some states may include: receiving a memory write command to invalidate data at a location where the replacement value exceeds an obsolescence threshold, and writing the data of the memory write command to a location in the system cache containing invalidated data, wherein the data of the memory write command written to the system cache is associated data.

[0012] Some states may include: receiving a memory write access command, and in response to determining that no replacement value exceeds the obsolescence threshold, writing the data of the memory write access command to a location in the system cache that conforms to another cache replacement policy.

[0013] A further embodiment includes a computing device including a memory control device configured to perform operations of any of the methods summarized above. Other embodiments include a non-transitory processor-readable storage medium storing processor-executable software instructions configured to cause a processor to perform operations of any of the methods summarized above. Still other embodiments include a computing device having components for implementing the functionality of any of the methods summarized above.

Implementation Method

[0031] Various embodiments will be described in detail with reference to the accompanying drawings. Where possible, the same element symbols will be used throughout the drawings to refer to the same or similar parts. References to specific examples and embodiments are for illustrative purposes and not for limiting the scope of the claims.

[0032] Various embodiments include methods and computing devices implementing such methods, which implement a standard cache-aware replacement strategy. Embodiments may include associating data written to the system cache with a local counter. The value of the local counter may include the value of an stale counter at the time the associated data is written to the system cache (i.e., when the associated data is written to the system cache). The local value of the associated data may be used to calculate a replacement value for the data in the system cache and compared to a stale threshold. The value of the local counter for the associated data may be used to determine whether the associated data is stale. In response to a replacement value exceeding and / or equal to the stale threshold, data in the system cache associated with the local counter used to calculate the replacement value may be replaced.

[0033] The term "computing device" is used herein to refer to fixed computing devices, including personal computers, desktop computers, all-in-one computers, workstations, supercomputers, mainframe computers, embedded computers (e.g., in vehicles and other larger systems), computerized vehicles (e.g., partially or fully autonomous land, air and / or water vehicles, such as passenger cars, commercial vehicles, recreational vehicles, military vehicles, drones, etc.), servers, multimedia computers, and game consoles. The terms "computing device" and "mobile computing device" are used interchangeably herein and refer to any or all of the following: cellular phones, smartphones, personal or mobile multimedia players, personal digital assistants (PDAs), laptops, tablets, convertible laptops / tablets (2-in-1 computers), smart computers, ultrabooks, netbooks, handheld computers, wireless email receivers, cellular phones with multimedia internet access, mobile game consoles, wireless game controllers, and similar personal electronic devices, including memory and programmable processors.

[0034] For ease of explanation and clarity, various embodiments are described in terms of code (e.g., processor-executable instructions), but the same can be applied to any material, such as code, program data, or other information stored in memory. The terms "code," "material," and "information" are used interchangeably herein and are not intended to limit the scope of the claims and specification to the types of code, material, or information used as examples in describing the various embodiments.

[0035] Typically, computing devices use one or more data replacement strategies, such as Not Recently Used (nMRU) and First-In-First-Out (FIFO), to control the memory space where data is cached in the system cache. nMRU and FIFO strategies are not optimal for a wide range of use cases, including, for example, multimedia frame-based clients, where temporal locality is within the frame's time boundaries and capacity allocation can vary based on compression ratios. The nMRU replacement strategy is insufficient when cache columns accessed from a multimedia client have different access frequencies and are only valid within specific time ranges. Self-adjusting partitions do not guarantee FIFO replacement behavior, where the size of the cache partition may change over time as sub-cache memory fills a compressed frame.

[0036] Various embodiments address and resolve limitations in conventional cache replacement strategies. A client, such as a processor or a program of software executed by the processor (e.g., an operating system and / or application), can signal (e.g., via communication, register write, direct interrupt, etc.) the need to update a stale counter for data in the system cache. For ease of illustration, some instances may be described herein as register writes; however, such instances are not intended to limit the scope of the request or description to register writes. Those skilled in the art will understand that other types or methods of signaling the processor can provide the same or similar functionality. Register writes can be issued based on criteria such as time (i.e., time-based standards), events (i.e., event-based standards), and / or other metrics. For example, register writes can be issued at the beginning and / or end of a compressed multimedia data frame based on frame time boundaries, color gamut within a compressed multimedia data frame, etc. The processor or system cache can associate the value of the stale counter, which serves as a local counter, with the data in the system cache. For example, the processor or system cache can associate the value of an aging counter in a label of a system cache column during the insertion or use of data at that column. When the associated data is written to the system cache (i.e., while the associated data is being written to the system cache), the processor or system cache can associate its local counter (including the value of the aging counter) with the data. Because the local counter is associated with the data in the system cache when the associated data is written, the aging counter can indicate aging data by distinguishing it from the data in the system cache, and therefore can be used by the processor or to assist in identifying candidate replacement memory locations for new write commands.

[0037] The staleness threshold can be used by the processor or system cache to determine whether data in the system cache is stale and can be replaced the next time the data is written to the system cache. The staleness threshold can be pre-configured based on a standard cache-aware replacement policy. The replacement value of the data in the system cache (which can be calculated using the staleness counter and the value of the local counter associated with the data) can be compared with the staleness threshold to determine whether the associated data is stale and can be replaced the next time the data is written to the system cache.

[0038] Various embodiments provide cache replacement strategy methods that can track stale data in the cache, such that stale data has a higher chance of being replaced than non-stale data when data is written to the system cache next time. Identifying stale data using the methods of various embodiments enables decisive cache usage and thus improves the operation of computing devices by improving last-level cache usage and reducing traffic in Double Data Rate (DDR) Synchronous Dynamic Random Access Memory (SDRAM).

[0039] FIG1 illustrates a system including a computing device 100 suitable for various embodiments. The computing device 100 may include a system-on-a-chip (SoC) 102 having a central processing unit 104, memory 106, a communication interface 108, a memory interface 110, a peripheral device interface 120, and a processing device 124. The computing device 100 may also include communication elements 112, such as a wired or wireless modem, memory 114, an antenna 116 for establishing a wireless communication link, and / or peripheral devices 122. The processor 124 may include any of a variety of processing devices, such as multiple processor cores.

[0040] The terms "System-on-a-Chip" or "SoC" are used herein to refer to a set of interconnected electronic circuits, typically but not exclusively including processing devices, memory, and communication interfaces. Processing devices may include various types of processors and / or processor cores, such as central processing units (CPUs) 104 and / or processors 124, including general-purpose processors, CPUs 104, digital signal processors (DSPs), graphics processing units (GPUs), accelerated processing units (APUs), security processing units (SPUs), intellectual property units (IPUs), subsystem processors for specific elements of a computing device (such as image processors for camera subsystems or display processors for displays), auxiliary processors, peripheral processors, single-core processors, multi-core processors, controllers, and / or microcontrollers. Processing devices may further embody other hardware and hardware combinations, such as field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), other programmable logic devices, individual gate logic, transistor logic, performance monitoring hardware, watchdog hardware, and / or time references. Integrated circuits can be configured such that the components of the integrated circuit reside on a monolithic semiconductor material such as silicon.

[0041] SoC 102 may include one or more CPUs 104 and processors 124. Computing device 100 may include more than one SoC 102, thereby increasing the number of CPUs 104, processors 124, and processor cores. Computing device 100 may also include CPUs 104 and processors 124 not associated with SoC 102. Individual CPUs 104 and processors 124 may be multi-core processors. Each CPU 104 and processor 124 may be configured for a specific purpose, which may be the same as or different from the other CPUs 104 and processors 124 of computing device 100. One or more of the CPUs 104, processors 124, and processor cores with the same or different configurations may be grouped together. A group of CPUs 104, processors 124, or processor cores may be referred to as a multiprocessor cluster.

[0042] The memory 106 of the SoC 102 may be volatile or non-volatile memory configured to store data and processor-executable code for access by the CPU 104, processor 124, or other elements of the SoC 102. The computing device 100 and / or the SoC 102 may include one or more memory units 106 configured for various purposes. The one or more memory units 106 may include volatile memory, such as random access memory (RAM), including DDR memory, implemented as main memory or cache memory. The memory 106 may be configured to temporarily store a limited amount of data received from a data sensor or subsystem, data and / or processor executable code instructions loaded from non-volatile memory and expected to be accessed in the future based on various factors, and / or intermediate processing data and / or processor executable code instructions generated by CPU 104 and / or processor 124 and temporarily stored for future fast access without being stored in non-volatile memory. The memory 106 may be configured to at least temporarily store data and processor executable code loaded from another memory device (e.g., another memory 106 or memory 114) for access by one or more of the other elements of CPU 104, processor 124, or SoC 102. In some embodiments, any number and combination of memory 106 may include one-time programmable or read-only memory.

[0043] Memory interface 110 and memory 114 may work together to allow computing device 100 to store and retrieve data and processor executable code on and from volatile and / or non-volatile storage media. Memory 114 may be configured much like embodiments of memory 106, such as main memory, wherein memory 114 may store data or processor executable code for access by one or more of the other elements of CPU 104, processor 124, or SoC 102. In some embodiments, non-volatile memory 114 may retain information after the computing device 100 has been powered off. When the power is turned back on and the computing device 100 is restarted, the information stored in memory 114 is available to the computing device 100. In some embodiments, volatile memory 114 may not retain information after the computing device 100 has been powered off. The memory interface 110 can control access to the memory 114 and allow the CPU 104, processor 124, or other components of the SoC 102 to read data from and write data to the memory 114.

[0044] Some or all of the components of the computing device 100 and / or SoC 102 may be arranged and / or combined differently, while still supporting the functionality of various embodiments. The computing device 100 may not be limited to one of each component, and multiple examples of each component may be included in various configurations of the computing device 100.

[0045] FIG2 illustrates an exemplary SoC suitable for implementing various embodiments. Referring to FIG1 and FIG2, SoC 200 (e.g., SoC 102 in FIG1) may include various combinations of elements, including any number and combination of processors 202 (e.g., CPU 104, processor 124 in FIG1), L3 cache memory 216 (e.g., memory 106 in FIG1), system cache memory 218 (e.g., memory 106 in FIG1) and / or system memory 224 (e.g., memory 106 in FIG1).

[0046] The processor 202 may include any number of processor cores 204a, 204b, 204c, 206a, 206b, 206c, and combinations thereof. For example, the multi-core processor 202 may have a plurality of homogeneous or heterogeneous processor cores 204a, 204b, 204c, 206a, 206b, 206c. A homogeneous multi-core processor may include a plurality of homogeneous processor cores. The processor cores 204a, 204b, 204c, 206a, 206b, 206c may be homogeneous because the processor cores 204a, 204b, 204c, 206a, 206b, 206c of the multi-core processor 202 may be configured for the same purpose and have the same or similar performance characteristics. For example, the multi-core processor 202 can be a general-purpose processor, and processor cores 204a, 204b, 204c, 206a, 206b, and 206c can be homogeneous general-purpose processor cores. As another example, the multi-core processor 202 can be a graphics processing unit or a digital signal processor, and processor cores 204a, 204b, 204c, 206a, 206b, and 206c can be homogeneous graphics processing unit cores or digital signal processor cores, respectively.

[0047] A heterogeneous multi-core processor may include a plurality of heterogeneous processor cores. Processor cores 204a, 204b, 204c, 206a, 206b, and 206c may be heterogeneous because the processor cores 204a, 204b, 204c, 206a, 206b, and 206c of the multi-core processor 202 may be configured for different purposes and / or have different performance characteristics. Such heterogeneity of the heterogeneous processor cores may include different instruction set architectures, pipelines, operating frequencies, etc. Instances of such heterogeneous processor cores may include the so-called "big.LITTLE" architecture, in which slower, lower-power processor cores may be coupled with more powerful, higher-power processor cores.

[0048] Processor cores 204a, 204b, 204c, 206a, 206b, and 206c can be grouped together as processor core clusters 212 and 214. Typically, processor core clusters 212 and 214 can include homogeneous processor cores within each processor core cluster 212 and 214. Processor core clusters 212 and 214 can be homogeneous or heterogeneous with other processor core clusters 212 and 214. For example, processor core clusters 212 and 214 can be homogeneous, having the same processor cores as each other. As another example, processor core clusters 212 and 214 can be heterogeneous, having different processor cores as each other. For ease of explanation, the terms "processor," "processor core," and "processor core cluster" are used interchangeably herein.

[0049] The processor 202 may also include any number and combination of L2 caches 208a, 208b, 208c, 210a, 210b, 210c (e.g., memory 106 in FIG. 1). For example, each processor core cluster 212, 214 and / or each processor core 204a, 204b, 204c, 206a, 206b, 206c may have dedicated L2 caches 208a, 208b, 208c, 210a, 210b, 210c. Each L2 cache 208a, 208b, 208c, 210a, 210b, 210c may be designated for read and / or write access by a designated processor core cluster 212, 214 and / or processor core 204a, 204b, 204c, 206a, 206b, 206c. L2 caches 208a, 208b, 208c, 210a, 210b, and 210c can store data and / or instructions, and make the stored data and / or instructions available to specified processor core clusters 212, 214 and / or processor cores 204a, 204b, 204c, 206a, 206b, and 206c. L2 caches 208a, 208b, 208c, 210a, 210b, and 210c may include volatile memory as described herein with reference to memory 106 in FIG1.

[0050] L3 cache 216, system cache 218, and system memory 224 can be shared and configured for read and / or write access by processor core clusters 212, 214 and / or processor cores 204a, 204b, 204c, 206a, 206b, 206c. L3 cache 216, system cache 218, and system memory 224 can store data and / or instructions, and make the stored data and / or instructions available to processor core clusters 212, 214 and / or processor cores 204a, 204b, 204c, 206a, 206b, 206c. L3 cache 216, system cache 218, and / or system memory 224 can be used as buffers for data and / or instructions input to and / or output from processor 202. L3 cache 216, system cache 218, and system memory 224 may include volatile memory as described herein with reference to memory 106 in FIG1.

[0051] The processor 202 may include a memory controller 220 configured to manage memory access to L2 cache memories 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216, and / or system cache memory 218. The memory controller may receive memory access commands from processor cores 204a, 204b, 204c, 206a, 206b, 206c, and may allow, implement, and / or deny memory access to cache memories 208a, 208b, 208c, 210a, 210b, 210c, 216, 218. The memory controller 220 may be configured to implement cache maintenance, cache consistency, and / or cache replacement policies. The memory controller 220 may be configured to implement virtual cache address translation.

[0052] The processor 202 may include any number and combination of registers 222, which may be configured to temporarily store small amounts of data. Registers 222 may be implemented in hardware and / or implemented as memory locations in cache memories 208a, 208b, 208c, 210a, 210b, 210c, 216, 218. Any number of registers may be configured to store data individually and / or in combination for a specific purpose associated with the register 222. For example, a register may store data configured to indicate to the processor 202 information related to a specific purpose associated with the register 222. As another example, the register array 222 may store a data vector in which any number and combination of bits can indicate to the processor 202 information related to a specific purpose associated with the register array 222.

[0053] Some or all of the components of the SoC 200 and / or processor 202 may be arranged and / or combined differently, while still supporting the functionality of various embodiments. For example, the memory controller 220 may be a component of the SoC 200 that is separate from the processor 202.

[0054] Figures 3A and 3B illustrate the elements and signal transmission of examples of a standard aware cache memory replacement strategy according to various embodiments. Referring to Figures 1-3, a processor (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2) can implement a client 300 that can issue memory access commands to the system cache memory 218. For example, the processor can be the client 300. As another example, the processor can execute a program that can be the client 300, such as an operating system and / or an application.

[0055] In the example shown in Figure 3A, client 300 can issue a memory access command 302, such as a write command, to the system cache memory, which can be received by memory controller 220. Client 300 can also implement a register write 304 to one or more registers 222, which can set a stale counter update value in the registers 222. Registers 222 can be associated with stale counter update features used for a standard-aware cache memory replacement policy. The value stored in registers 222 can be configured to indicate to memory controller 220 whether to update a stale counter (not shown) configured for use by the standard-aware cache memory replacement policy. For example, register write 304 can set the stale counter update value to a "1" value, which is configured to instruct memory controller 220 to update the stale counter. Client 300 can implement register write 304 based on the standard of the standard-aware cache memory replacement policy. In various embodiments, the standard can be a time-based standard, an event-based standard, or another type of standard. As an example of a time-based standard, client 300 can implement register writing 304 based on time periods, the number of processor clock cycles, the number of executed instructions, etc. As an example of an event-based standard, client 300 can implement register writing 304 based on the completion, pause, and / or termination of tasks, programs, and / or applications; the start, restart, and / or loading of tasks, programs, and / or applications; interrupt signals; error and / or fault signals, etc. As an example of other standards, client 300 can implement register writing 304 based on specific states or state changes (e.g., power state, security state, availability state, etc.) of processors (e.g., CPU 104, processor 124 in Figure 1, processor 202 in Figure 2), memory (e.g., memory 106, 114 in Figure 1, cache memory 208a, 208b, 208c, 210a, 210b, 210c, 216, 218 in Figure 2), peripheral devices (e.g., peripheral device 122 in Figure 1), communication elements (e.g., communication element 112), etc. As another example, client 300 can implement register writing 304 based on the beginning and / or end of a portion of data, such as compressing multimedia data frames based on frame time boundaries, compressing the color gamut within multimedia data frames, etc.

[0056] In response to receiving a write memory command 302, the memory controller 220 may read register 222 306 to determine whether to update the stale counter. The memory controller 220 may obtain the value of register 222 and determine whether the value from the register instructs the memory controller 220 to update the stale counter.

[0057] In response to the value of the decision register 222 instructing the memory controller 220 to update the stale counter, the memory controller 220 may update the stale counter 308. The stale counter may include values ​​stored in memory that can be read and written by the memory controller 220 (e.g., memory 106, memory 114 in FIG. 1, L2 cache memories 208a, 208b, 208c, 210a, 210b, 210c in FIG. 2, L3 cache memory 216, system cache memory 218 in FIG. 2 and 3, and register 222). The memory controller 220 may update the stale counter via any mathematical operation, algorithmic operation, heuristic operation, etc., such as by incrementing and / or decrementing the stale counter. In response to the value of the decision register 222 instructing the memory controller 220 not to update the stale counter, the memory controller 220 may choose not to update the stale counter 308.

[0058] The memory controller 220 can read local counters 310 for data at locations in the system cache memory 218. The value of the local counter may include the value of a stale counter stored in connection with writing associated data to the system cache memory 218 in response to a previous write memory command. In one instance, the memory controller 220 can read one or more local counter values ​​stored together with a cache tag for the memory location targeted by the write memory command. In another instance, the memory controller 220 can read one or more local counter values ​​for locations within blocks, partitions, the entire cache, and / or any other portion of the system cache memory 218.

[0059] The memory controller 220 can use the acquired local counter value to help determine which portion of the system cache memory 218 should be replaced according to a standard cache memory replacement policy when implementing a write memory command. In operation 312, the memory controller 220 can calculate a replacement value and compare it with an aging threshold. For example, the memory controller 220 can use arithmetic operations to generate a replacement value using the local counter value and the aging counter value. For example, the memory controller 220 can subtract the local counter value from the aging counter value to determine the replacement value. The memory controller 220 can compare the replacement value and the aging threshold to determine whether to replace the data associated with the local counter value. The aging threshold can be a pre-configured value. For example, the aging threshold can be pre-configured based on a standard cache memory replacement policy. As another example, the aging threshold can be pre-configured based on the size, state, usage, availability, etc. of the system cache memory 218. As another example, obsolescence thresholds can be pre-configured based on the status, usage, power availability, etc. of the processor and / or computing device (e.g., computing device 100 in Figure 1). As another example, obsolescence thresholds can be pre-configured based on the tasks, programs, and / or applications executed by client 300 and / or client 300.

[0060] The comparison result between the replacement value and the obsolescence threshold can instruct the memory controller 220 whether the standard-aware cache replacement policy should replace the data associated with the local counter value. For example, in response to a replacement value greater than or equal to the obsolescence threshold, the memory controller 220 can implement the standard-aware cache replacement policy to replace the data associated with the local counter value with the data of the write memory command. The memory controller 220 can replace the data associated with the local counter value by writing the data of the write memory command 314 to the location in the system cache memory 218 where the data associated with the local counter is stored. Otherwise, the memory controller 220 can write the data of the write memory command 314 to another location in the system cache memory 218. The memory controller 220 can also write the value of the obsolescence counter as the local counter and the write memory command data written to the system cache memory 218 to the system cache memory 218 in association 316. For example, memory controller 220 can write the value of the obsolete counter to 316 and then to the tag location in system cache memory 218 associated with the data of the write command written to system cache memory 218.

[0061] In the example shown in Figure 3B, the client 300 can issue a memory access command 302, such as a read memory command, to the system cache memory, which can be received by the memory controller 220. The client 300 can also perform a register write 304 on one or more registers 222, which can set an update value for the stale counter in the registers 222. In response to receiving the read memory command 302, the memory controller 220 can read 306 registers 222 to determine whether to update the stale counter. In response to determining the value of registers 222 and instructing the memory controller 220 to update the stale counter, the memory controller 220 can update the stale counter 308. The memory controller 220 can read the data associated with the local counter value by reading the data stored in the system cache memory 218 at the location associated with the local counter and the data targeted by the read memory command. The memory controller 220 can also write the value of an obsolete counter, which serves as a local counter, to the system cache 218 in association with the data at the location targeted by the read memory command. For example, the memory controller 220 can write the value of the obsolete counter to a tag location in the system cache 218 that is associated with the data at the location targeted by the read memory command.

[0062] The order of signals 302, 304, 308, 310, 312, 314, and 316 in Figure 3A and the order of signals 302, 304, 308, 315, and 317 in Figure 3B are merely examples. The order of signals 302, 304, 308, 310, 312, 314, 315, 316, and 317 can be executed in different orders. For example, the order of signals 302 and 304, signals 314 and 316, and / or signals 315 and 317 can be reversed. As another example, signals 302 and 304, signals 314 and 316, and / or signals 315 and 317 can be transmitted concurrently.

[0063] Figure 4 illustrates an example of a memory flow for implementing a standard-aware cache memory replacement strategy according to an embodiment. Referring to Figures 1-4, a memory controller (e.g., memory controller 220 in Figures 2 and 3) can implement write memory commands 410a, 410b, 410c in system cache memory 400 (e.g., system cache memory 218 in Figures 2 and 3) and implement stale counter updates 412a, 412b for stale counter 402. Write memory commands 410a, 410b, 410c can be issued by a client (e.g., client 300) of a computing device (e.g., computing device 100 in Figure 1).

[0064] The write memory command 410a can be received by the memory controller and prompt the memory controller to write data to the system cache memory 400. When implementing the write memory command 410a, the stale counter 402 can be "1". The data of the write memory command 410a can be written to the system cache memory 400 together with the stale counter value "1" of the local counter associated with the location 404 in the system cache where data is written.

[0065] Another write memory command 410b can be received by the memory controller and can prompt the memory controller to write data to the system cache memory 400. In response to the register value read by the memory controller from the register (e.g., register 222 in Figures 2 and 3), the stale counter 412a can be updated. The register value can be set by the client in conjunction with the register write implemented by the write memory command 410b (e.g., register write 304 in Figure 3). The stale counter 402 when implementing the write memory command 410c can be "2". The data of the write memory command 410b can be written to the system cache memory 400 together with the stale counter value "2" which is associated with the local counter at location 406 where data is written in the system cache memory. In this example, location 406 can be an open location before the data of the write memory command 410b and the local counter are written to location 406. The write memory command 410b may prompt the standard cache-aware replacement policy to check the data to be replaced in the system cache 400, but replacement cannot be performed in the system cache 400. Data that does not meet the criteria of the standard cache-aware replacement policy cannot be replaced. For example, the standard cache-aware replacement policy may determine whether the difference between the local counter ("1" in this example) at the location 404 where data has already been written in the system cache 400 and the stale counter 402 ("2" in this example) at the time of the write memory command 410b is less than the stale threshold.

[0066] Another write memory command 410c can be received by the memory controller and can prompt the memory controller to write data to the system cache memory 400, and the stale counter can be updated 412b in response to the register value read by the memory controller. The register value can be set by the client in conjunction with the register write implemented by the write memory command 410c (e.g., register write 304 in FIG3). The stale counter 402 when the write memory command 410c is implemented can be "3". The data of the write memory command 410c can be written to the system cache memory 400 together with the stale counter value "3" of the local counter associated with the location 404 in the system cache where data is written. In this example, the location 404 can be a location that was occupied before the data of the write memory command 410c and the local counter were written to the location 404. The write memory command 410b can prompt a standard-aware cache replacement policy to check the data to be replaced in the system cache 400. In this example, replacement can be performed on some locations 404 in the system cache 400 instead of other locations 406. Data that does not meet the criteria of the standard-aware cache replacement policy cannot be replaced. For example, the standard-aware cache replacement policy can determine whether the difference between the local counter (in this example, "2") of the location 406 in the system cache 400 where data has already been written and the stale counter 402 (in this example, "3") at the time of the write memory command 410c is likely less than a stale threshold. Replacement can be performed on data that does meet the criteria of the standard-aware cache replacement policy. For example, a standard cache-aware replacement strategy can determine whether the difference between the local counter (in this example, "1") at location 404 in system cache 400 where data has already been written and the stale counter 402 (in this example, "3") at the time of write memory command 410c is greater than or equal to a stale threshold. The memory controller can replace the data at location 404 and the local counter with the data from write memory command 410c and the value of the stale counter.

[0067] FIG5 illustrates an example of a memory flow for implementing a standard-aware cache memory replacement strategy according to an embodiment. Referring to FIGS. 1-5, a memory controller (e.g., memory controller 220 in FIGS. 2 and 3) can implement write memory commands (Write N) and read memory commands (Read N) in system cache memory (e.g., system cache memory 218 in FIGS. 2 and 3, system cache memory 400 in FIG. 4). The write memory commands and read memory commands can be issued by the processors of a computing device (e.g., CPU 104, processor 124 in FIG. 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG. 2, and client 300 in FIG. 3) (e.g., processor 1 and processor 2 in FIG. 5).

[0068] When a Write 0 write memory command is sent from processor 1, the value of the stale counter may be "0". The data of Write 0 may be written to the system cache memory together with the stale counter value "0" which is the local counter associated with the data of Write 0.

[0069] Write 0 can be followed by a Read 0 command from processor 2 to read memory. The memory controller can read data from the system cache targeted by Read 0. For example, the memory controller can read data from the location in the system cache associated with the local counter value "0".

[0070] Read 0 may be followed by a Write 1 write memory command from processor 1. The stale counter may have been updated and may have a value "1" at the time of Write 1. Write 1 may prompt a standard cache-aware replacement policy to check for stale data by comparing the local counter associated with the data in the system cache with a stale threshold. For example, the memory controller may read the local counter from the system cache, calculate the difference between the value of the stale counter and the value of the local counter, and compare the difference with the stale threshold. In response to a difference less than the stale threshold, the standard cache-aware replacement policy may decide not to replace the data associated with the local counter in the system cache, as is the case in the Write 1 instance. In this instance, the data for Write 1, along with the stale counter value "2" associated with the local counter of the data for Write 1, may be written to an open location in the system cache.

[0071] Write 1 may be followed by a second (i.e., Write 2) write memory command from processor 1. The stale counter may have been updated and may have a value "2" at Write 2. Write 2 may prompt a standard cache-aware replacement policy to check for stale data by comparing the local counter associated with the data in the system cache with a stale threshold. For example, the memory controller may read the local counter from the system cache, calculate the difference between the value of the stale counter and the value of the local counter, and compare the difference with the stale threshold. In response to the difference being less than the stale threshold, the standard cache-aware replacement policy may decide not to replace the data associated with the local counter in the system cache. In response to the difference being greater than or equal to the stale threshold, the standard cache-aware replacement policy may decide to replace the data associated with the local counter in the system cache. In this example, data associated with a local counter having a value of "0" can be determined to be obsolete because the difference between the obsolete counter and the local counter may be greater than or equal to the obsolete threshold. As a result, the standard cache-aware replacement policy can decide to replace data associated with a local counter having a value of "0". Data associated with a local counter having a value of "1" can be determined not to be obsolete because the difference between the obsolete counter and the local counter is less than the obsolete threshold. As a result, the standard cache-aware replacement policy can decide not to replace data associated with a local counter having a value of "2". The data for Write 2, along with the obsolete counter value "2" associated with the local counter of the data for Write 2, can be written to an open location in the system cache and the location occupied by data associated with a local counter value of "0".

[0072] Write 2 can be followed by a Read 1 command from processor 2 to read memory. The memory controller can read the data targeted by Read 1 from the system cache. For example, the memory controller can read the data at the location in the system cache associated with the local counter value "1".

[0073] Read 1 may be followed by a Write 3 write memory command from processor 1. The stale counter may have been updated and may have a value of "3" at the time of Write 3. Write 3 may prompt a standard cache-aware replacement policy to check for stale data by comparing the local counter associated with the data in the system cache with a stale threshold. For example, the memory controller may read the local counter from the system cache, calculate the difference between the value of the stale counter and the value of the local counter, and compare the difference with the stale threshold. In response to the difference being less than the stale threshold, the standard cache-aware replacement policy may decide not to replace the data associated with the local counter in the system cache. In response to the difference being greater than or equal to the stale threshold, the standard cache-aware replacement policy may decide to replace the data associated with the local counter in the system cache. In this example, data associated with a local counter having a value of "0" or "1" can be determined to be obsolete because the difference between the obsolete counter and the local counter may be greater than or equal to the obsolete threshold. As a result, the standard-aware cache replacement policy can decide to replace data associated with a local counter having a value of "0" or "1". Data associated with a local counter having a value of "2" can be determined not to be obsolete because the difference between the obsolete counter and the local counter may be less than the obsolete threshold. As a result, the standard-aware cache replacement policy can decide not to replace data associated with a local counter having a value of "2". However, the standard-aware cache replacement policy may not be able to replace all data in the system cache. For example, the mechanism used to write data to the system cache can be defined in a way that may not fully conform to the standard-aware cache replacement policy in certain situations. The data in Write 3, along with the obsolete counter value "3" associated with the local counter of Write 2, can be written to the location in the system cache occupied by data associated with local counter values ​​"0" or "1". However, the mechanism for writing data to the system cache can write data in a manner determined by the number of rows in a set. Therefore, it is possible that data that is not obsolete under the standard cache-aware replacement policy, such as data associated with local counter value "2", may be replaced by Write 3.

[0074] Write 3 may be followed by a Read 2 command from processor 2. The memory controller can read the data targeted by Read 2 from the system cache. For example, the memory controller can read the data in the system cache at the location associated with the local counter value "2". Although the data targeted by Read 2 may be partially replaced by the data written to the system cache by Write 3, the standard-aware cache replacement strategy results in a higher hit rate (or lower miss rate) for the data in the system cache compared to other cache replacement strategies (such as Not Recently Used (nMRU) and capacity-based First-In-First-Out (FIFO)).

[0075] Figure 6 illustrates a method 600 for implementing a standard aware cache memory replacement strategy according to some embodiments. Referring to Figures 1-6, method 600 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104, processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or in a combination of processors and dedicated hardware configured with software, which includes other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). In order to include alternative configurations enabled in various embodiments, the hardware implementing method 600 is referred to herein as a "client" and a "memory control device".

[0076] In block 602, the client can send a write command to the system cache (e.g., system cache 218 in Figures 2 and 3, system cache 400 in Figure 4). In block 604, the client can signal to the processor (e.g., CPU 104 and processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212 and 214 in Figure 2, and client 300 in Figure 3) to update the stale counter used for data in the system cache. Signaling to the processor can be implemented using various types of signal communication, including, for example, writes to a register (e.g., register 222 in Figures 2 and 3), direct interrupts to the processor, etc. The register can be associated with the stale counter update feature of a standard cache replacement strategy. A write register can set the value of the register, which is configured to indicate to the memory control device whether to update the stale counter. In some embodiments, the client that sends a write memory command in block 602 and signals the processor in block 604 to update the stale counter for data in the system cache can be a processor (e.g., CPU 104, processor 124 in FIG. 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG. 2, and client 300 in FIG. 3) and / or software (e.g., client 300 in FIG. 3), such as an operating system and / or an application.

[0077] In block 606, the memory control device can receive write memory commands. The memory control device can be configured to manage, control, and / or implement memory access, cache maintenance, cache consistency, and / or cache replacement policies for the system cache. In block 608, the memory control device can implement a standard-aware cache replacement policy to write the data of the write memory command into the system cache. The memory control device that receives the write memory command in block 606 and implements the standard-aware cache replacement policy in block 608 can be a processor (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2, and client 300 in Figure 3) and / or a memory controller (e.g., memory controller 220 in Figures 2 and 3).

[0078] Figure 7 illustrates a method 700 for implementing a standard perceptual cache memory replacement strategy based on the value replacement of local counters, according to some embodiments. Referring to Figures 1-7, method 700 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104. Processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 700 is referred to herein as a "memory control device". Blocks 702-714 of method 700 extend the operations that can be performed in block 608 of method 600 as described with reference to FIG. 6.

[0079] In block 702, the memory control device may receive a signal for updating a stale counter for data in the system cache (e.g., system cache 218 in Figures 2 and 3, and system cache 400 in Figure 4). For example, the memory control device may read a register (e.g., register 222 in Figures 2 and 3), receive a direct interrupt, etc., to update the stale counter for data in the system cache. This register may be associated with a stale counter update feature of a standard cache replacement strategy and may have a value configured to indicate to the memory control device whether to update the stale counter. The value of the register may be set, for example, via writing to the register, for updating the stale counter for data in the system cache, as described in block 604 for method 600 (Figure 6). The memory control device may read the value of the register for updating the stale counter. In some embodiments, the memory control device that receives the signal for updating the stale counter of data in the system cache memory in block 702 may be a processor (e.g., CPU 104, processor 124 in FIG1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG2, client 300 in FIG3) and / or a memory controller (e.g., memory controller 220 in FIG2 and FIG3).

[0080] In optional decision block 704, the memory control device may interpret the register value read in block 702 to determine whether the register value indicates that the memory control device should update the stale counter. The value stored in the register may be configured to indicate to the memory control device whether to update the stale counter. For example, the register value may be set to a "1" value to indicate to the memory control device that the stale counter should be updated, and set to a "0" value to indicate to the memory control device that the stale counter should not be updated, and vice versa. In some embodiments, the memory control device may read the value of the register for updating the stale counter. In some embodiments, the memory control device that determines whether the register value indicates to the memory control device to update the stale counter in optional decision block 704 may be a processor and / or a memory controller.

[0081] After receiving a signal in block 702 for updating a stale counter for data in the system cache; or in response to a decision register value instructing the memory control device to update the stale counter (i.e., optional decision block 704 = "Yes"), the memory control device may update the stale counter in block 706. In some embodiments, updating the stale counter in block 706 may be performed when data is written to the system cache (i.e., when data is written to the system cache). The stale counter may include a value stored in memory (e.g., memory 106 and memory 114 in FIG. 1, L2 cache memories 208a, 208b, 208c, 210a, 210b, 210c and L3 cache memory 216 in FIG. 2, system cache memory 218 and temporary register 222 in FIG. 2 and 3, and system cache memory 400 in FIG. 4), which can be read and written by a memory control device. Updating the stale counter can be implemented through any mathematical operation, algorithmic operation, heuristic operation, etc., such as by incrementing and / or decrementing the stale counter. In some embodiments, the memory control device for updating the stale counter in block 706 may be a processor and / or a memory controller.

[0082] In response to a decision register value instructing the memory control device not to update the stale counter (i.e., optional decision block 704 = "No"); or after updating the stale counter in block 706, the memory control device may calculate a replacement value for the data associated with the local counter in block 708. In some embodiments, the memory control device that calculates the replacement value for the data associated with the local counter in block 708 may be a processor and / or a memory controller. The local counter may include the value of the stale counter stored in association with data written to the system cache in response to a previous write memory command. In one example, the memory control device may read one or more local counter values ​​stored together with a cache tag for the memory location targeted by a write memory command received in block 606 of method 600 described with reference to FIG. 6. In another example, the memory control device may read one or more local counter values ​​for a location within a block, partition, whole, and / or any other part of the system cache.

[0083] The obsolescence threshold can be a pre-configured value. For example, the obsolescence threshold can be pre-configured based on a standard cache-aware replacement policy. As another example, the obsolescence threshold can be pre-configured based on the size, status, usage, availability, etc. of the system cache. As another example, the obsolescence threshold can be pre-configured based on the status, usage, power availability, etc. of processors (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2, and client 300 in Figure 3) and / or computing devices (e.g., computing device 100 in Figure 1). As another example, the obsolescence threshold can be pre-configured based on tasks, programs, and / or applications.

[0084] The memory control device can use an obsolescence threshold to calculate a replacement value. For example, the memory control device can use arithmetic operations to generate a replacement value using the value of the local counter and the obsolescence counter value. For example, the memory control device can subtract the value of the local counter from the value of the obsolescence counter to determine the replacement value.

[0085] In decision block 709, the memory control device can determine whether the replacement values ​​of all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same. The memory control device can compare the replacement values ​​calculated in block 708 with each other in decision block 709. For example, the memory control device can determine whether the replacement values ​​are equal based on the comparison. In some embodiments, the memory control device that determines whether the replacement values ​​of all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same in decision block 709 can be a processor and / or a memory controller.

[0086] In response to the determination that the replacement values ​​for all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same (i.e., determination block 709 = "Yes"), in block 711, the memory control device can select a cache memory replacement strategy different from the standard aware cache memory replacement strategy. For example, the memory control device can select nMRU, FIFO, random, etc., cache memory replacement strategies. In some embodiments, the memory control device that selects a cache memory replacement strategy different from the standard aware cache memory replacement strategy in block 711 can be a processor and / or a memory controller.

[0087] After selecting a cache memory replacement strategy different from the standard aware cache memory replacement strategy in block 711, the memory control device can receive a write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 can be a processor and / or a memory controller.

[0088] In response to the fact that the replacement values ​​of all data at a location within a decision block, partition, whole, and / or any other part of the system cache memory are not the same (i.e., decision block 709 = "No"), the memory control device may determine in decision block 710 whether the replacement value exceeds or equals a stale threshold. The memory control device may compare the replacement value calculated in block 708 with the stale threshold to determine whether to replace the data associated with the local counter value. For example, the memory control device may determine whether the replacement value exceeds, equals, or exceeds or equals the stale threshold based on the comparison. In some embodiments, the memory control device that determines whether the replacement value exceeds or equals the stale threshold in decision block 710 may be a processor and / or a memory controller.

[0089] In response to a decision that the replacement value exceeds or equals the stale threshold (i.e., decision block 710 = "Yes"), in block 712 of method 700 (FIG. 7), the memory control device may write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the stale counter into the memory at the location where the replacement value exceeds or equals the stale threshold. The comparison result of the replacement value and the stale threshold in decision block 710 may indicate to the memory control device whether the standard-aware cache memory replacement strategy should replace the data associated with the local counter value used to calculate the replacement value in block 708. For example, in response to a replacement value exceeding or equal to the stale threshold, the memory control device may implement the standard-aware cache memory replacement strategy to replace the data associated with the local counter value with the data of the write memory command. The memory control device may replace the data associated with the local counter value by writing the data of the write memory command into the system cache where the data associated with the local counter is stored. The memory control device can also write the value of an obsolete counter, which serves as a local counter, into the system cache in association with the data of a write command to write to the system cache. For example, the memory control device can write the value of the obsolete counter into a tag location in the system cache associated with the data of the write command to write to the system cache. In some embodiments, the memory control device at the location in block 712 where the replacement value of writing the write command data and the value of the obsolete counter into memory exceeds or equals an obsolete threshold can be a processor and / or a memory controller.

[0090] In response to the determination that the replacement value does not exceed or equal the staleness threshold (i.e., decision block 710 = "No"), in block 714, the memory control device may write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the staleness counter to a compliant location in the memory. The criterion used to determine where to write the write memory command data and the value of the staleness counter to the system cache memory can be any known criterion, such as cache memory placement policy, cache memory replacement policy, cache consistency policy, etc. The memory control device may also write the value of the staleness counter, which is a local counter, to the system cache memory in association with the data of the write memory command to be written to the system cache memory. For example, the memory control device may write the value of the staleness counter to a tag location in the system cache memory associated with the data of the write memory command to be written to the system cache memory. In some embodiments, the memory control device that writes the data of the write memory command and the value of the stale counter to a compliant location in the memory in block 714 may be a processor and / or a memory controller.

[0091] After writing the write memory command data and the stale counter value to a location in memory where the replacement value exceeds or equals the stale threshold in block 712; or after writing the write memory command data and the stale counter value to a compliant location in memory in block 714, the memory control device can receive the write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 can be a processor and / or a memory controller.

[0092] Figure 8 illustrates a method 800 for implementing a standard perceptual cache memory replacement strategy based on the value replacement of local counter data according to some embodiments. Referring to Figures 1-8, method 800 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104. Processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To include alternative configurations enabled in various embodiments, the hardware implementing method 800 is referred to herein as a "memory control device". Blocks 802-814 of method 800 extend the operations that can be performed in block 608 of method 600 as described with reference to FIG. 6.

[0093] In block 802, the memory control device can calculate a replacement value for the data associated with the local counter. In some embodiments, the memory control device that calculates the replacement value for the data associated with the local counter in block 802 may be a processor (e.g., CPU 104, processor 124 in FIG. 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG. 2, client 300 in FIG. 3) and / or a memory controller (e.g., memory controller 220 in FIG. 2 and 3). The local counter may include the value of a stale counter stored in association with data written to the system cache memory (e.g., system cache memory 218 in FIG. 2 and 3, system cache memory 400 in FIG. 4) in response to a previous write memory command. The obsolete counter may include values ​​stored in memory (e.g., memory 106, memory 114 in FIG. 1; L2 cache memories 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in FIG. 2; system cache memory 218, register 222 in FIG. 2 and 3; system cache memory 400 in FIG. 4), which may be readable and writable by a memory control device. In one example, the memory control device may read one or more local counter values ​​stored together with a cache tag of the memory location targeted by a write memory command received in block 606 of method 600 as shown with reference to FIG. 6. In another example, the memory control device may read one or more local counter values ​​of a location within a block, partition, whole, and / or any other part of the system cache memory.

[0094] The obsolescence threshold can be a pre-configured value. For example, the obsolescence threshold can be pre-configured based on a standard cache-aware replacement policy. As another example, the obsolescence threshold can be pre-configured based on the size, status, usage, availability, etc. of the system cache. As another example, the obsolescence threshold can be pre-configured based on the status, usage, power availability, etc. of processors (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2, and client 300 in Figure 3) and / or computing devices (e.g., computing device 100 in Figure 1). As another example, the obsolescence threshold can be pre-configured based on tasks, programs, and / or applications.

[0095] The memory control device can calculate a replacement value using an obsolescence threshold. For example, the memory control device can use arithmetic operations to generate a replacement value using the value of the local counter and the obsolescence counter value. For example, the memory control device can determine the replacement value by subtracting the value of the local counter from the value of the obsolescence counter.

[0096] In decision block 803, the memory control device may determine whether the replacement values ​​of all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same. In this determination, the memory control device may compare the replacement values ​​calculated in block 802 with each other. For example, the memory control device may determine whether the replacement values ​​are equal to each other based on the comparison. In some embodiments, the memory control device that determines whether the replacement values ​​of all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same in decision block 803 may be a processor and / or a memory controller.

[0097] In response to the determination that the replacement values ​​for all data at locations within a block, partition, whole, and / or any other part of the system cache memory are the same (i.e., determination block 803 = "Yes"), in block 805, the memory control device can select a cache memory replacement strategy different from the standard aware cache memory replacement strategy. For example, the memory control device can select an nMRU or FIFO cache memory replacement strategy. In some embodiments, the memory control device that selects a cache memory replacement strategy different from the standard aware cache memory replacement strategy in block 805 can be a processor and / or a memory controller.

[0098] After selecting a cache memory replacement strategy different from the standard aware cache memory replacement strategy in block 805, the memory control device can receive a write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 can be a processor and / or a memory controller.

[0099] In response to the fact that the replacement values ​​of all data at a location within a decision block, partition, whole, and / or any other part of the system cache memory are not the same (i.e., decision block 709 = "No"), the memory control device may determine in decision block 804 whether the replacement value exceeds or equals a stale threshold. The memory control device may compare the replacement value calculated in block 802 with the stale threshold to determine whether to replace the data associated with the local counter value. For example, the memory control device may determine whether the replacement value exceeds, equals, or exceeds or equals the stale threshold based on the comparison. In some embodiments, the memory control device that determines whether the replacement value exceeds or equals the stale threshold in decision block 804 may be a processor and / or a memory controller.

[0100] In response to a decision that the replacement value exceeds or equals the stale threshold (i.e., decision block 804 = "Yes"), in block 806, the memory control device may write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the stale counter to the location in memory where the replacement value exceeds or equals the stale threshold. The comparison result of the replacement value and the stale threshold in decision block 804 may instruct the memory control device whether the standard-aware cache memory replacement strategy should replace the data associated with the local counter value used to calculate the replacement value in block 802. For example, in response to a replacement value exceeding or equal to the stale threshold, the memory control device may implement the standard-aware cache memory replacement strategy to replace the data associated with the local counter value with the data of the write memory command. The memory control device may replace the data associated with the local counter value by writing the data of the write memory command to the location in the system cache memory where the data associated with the local counter is stored. The memory control device can also write the value of an obsolete counter, which serves as a local counter, into the system cache in association with the data of a write command to write to the system cache. For example, the memory control device can write the value of the obsolete counter into a tag location in the system cache associated with the data of the write command to write to the system cache. In some embodiments, the memory control device in block 806 that writes the write command data and the value of the obsolete counter into the memory at a location where the replacement value exceeds or equals an obsolete threshold can be a processor and / or a memory controller.

[0101] In response to the determination that the replacement value does not exceed or equal the stale threshold (i.e., decision block 804 = "No"), in block 808, the memory control device may write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the stale counter to a compliant location in the memory. The criterion used to determine where to write the write memory command data and the stale counter value to the system cache memory can be any known criterion, such as cache memory placement policy, cache memory replacement policy, cache consistency policy, etc. The memory control device may also write the value of the stale counter, which is a local counter, to the system cache memory in association with the data of the write memory command to be written to the system cache memory. For example, the memory control device may write the value of the stale counter to a tag location in the system cache memory associated with the data of the write memory command to be written to the system cache memory. In some embodiments, the memory control device that writes the data of the write memory command and the value of the stale counter to a compliant location in the memory in block 808 may be a processor and / or a memory controller.

[0102] In block 806, the data of the write memory command and the value of the stale counter are written to or as part of a location in memory where the replacement value exceeds or equals the stale threshold; or in block 808, the data of the write memory command and the value of the stale counter are written to or as part of a compliant location in memory. The memory control device can receive a signal for updating the stale counter for data in the system cache. For example, the memory control device can read a register (e.g., register 222 in Figures 2 and 3), receive a direct interrupt, etc., to update the stale counter for data in the system cache in block 810. The register may be associated with a stale counter update feature for a standard-aware cache replacement strategy and may have a value configured to indicate to the memory control device whether to update the stale counter. The value of the register may be set, for example, via writing to the register, for updating the stale counter for data in the system cache, as described with reference to block 604 of Figure 6 for method 600. The memory control device can read the value of the register to update the stale counter. In some embodiments, the memory control device that receives the signal for updating the stale counter for data in the system cache memory in block 810 can be a processor and / or a memory controller.

[0103] In optional decision block 812, the memory control device may determine whether a register value instructs the memory control device to update the stale counter. The value stored in the register may be configured to instruct the memory control device whether to update the stale counter. For example, the register value may be set to a "1" value configured to instruct the memory control device to update the stale counter, and a "0" value configured to instruct the memory control device not to update the stale counter, and vice versa. The memory control device may interpret the register value read in block 810 to determine whether the register value instructs the memory control device to update the stale counter. In some embodiments, the memory control device may read the value of the register for updating the stale counter. In some embodiments, the memory control device that determines whether the register value in optional decision block 812 instructs the memory control device to update the stale counter may be a processor and / or a memory controller.

[0104] After block 810 receives a signal for updating a stale counter for data in the system cache; or in response to a decision register value instructing the memory control device to update the stale counter (i.e., optional decision block 812 = "Yes"), the memory control device may update the stale counter in block 814. In some embodiments, updating the stale counter in block 814 may be performed when data is written to the system cache (i.e., approximately simultaneously) (e.g., in block 806 or 808). Updating the stale counter may be implemented via any mathematical operation, algorithmic operation, heuristic operation, etc., such as by incrementing and / or decrementing the stale counter. In some embodiments, the memory control device updating the stale counter in block 814 may be a processor and / or a memory controller.

[0105] After updating the stale counter in block 814; or in response to a decision register value indicating to the memory control device not to update the stale counter (i.e., optional decision block 812 = "No"), the memory control device may receive a write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 may be a processor and / or a memory controller.

[0106] Figure 9 illustrates a method 900 according to some embodiments for implementing a standard-aware cache memory replacement strategy to replace data by invalidating data based on the value of a local counter. Referring to Figures 1-9, method 900 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104. Processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 900 is referred to herein as a "memory control device". Blocks 702-711, 714, 902, and 904 of method 900 describe operations that can be performed as part of the operations in block 608 of method 600 described with reference to FIG. 6. Blocks 702-711 and 714 can be implemented in a similar manner to the similarly numbered blocks of method 700 described with reference to FIG. 7.

[0107] In response to a decision that the replacement value exceeds or equals the obsolescence threshold (i.e., decision block 710 = "Yes"), in block 902, the memory control device may invalidate the data at the location where the replacement value exceeds or equals the obsolescence threshold. The comparison result between the replacement value and the obsolescence threshold in decision block 710 may instruct the memory control device whether a standard-aware cache memory replacement strategy should replace the data associated with the local counter value used to calculate the replacement value in block 708. For example, in response to a replacement value exceeding or equal to the obsolescence threshold, the memory control device may implement a standard-aware cache memory replacement strategy to replace the data associated with the local counter value with the data of a write memory command. The memory control device may invalidate data using known methods for invalidating data in memory. For example, a memory control device can write a valid / invalid bit value associated with a location in the system cache (e.g., system cache 218 in Figures 2 and 3, system cache 400 in Figure 4), which is associated with a local counter value used to calculate the replacement value in block 708. The valid / invalid bit value can be configured to indicate to the memory control device whether data at that location in the system cache is valid / invalid. In some embodiments, the memory control device that invalidates data at a location in block 902 where the replacement value exceeds or equals a stale threshold can be a processor (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2, client 300 in Figure 3) and / or a memory controller (e.g., memory controller 220 in Figures 2 and 3).

[0108] In block 904, the memory control device can write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the stale counter to an invalid location in the memory. The memory control device can read the valid / invalid bits of the location in the system cache to determine which location has valid / invalid data. The memory control device can replace the data associated with the local counter value by writing the data of the write memory command to the location in the system cache that stores the data associated with the valid / invalid bits. The memory control device can also write the value of the stale counter, which is the local counter, to the system cache in association with the data of the write memory command to be written to the system cache. For example, the memory control device can write the value of the stale counter to the tag location in the system cache associated with the data of the write memory command to be written to the system cache. In some embodiments, the memory control device that writes the data of the write memory command and the value of the stale counter to the invalid location in memory in block 904 may be a processor and / or a memory controller.

[0109] After writing the write memory command data and the stale counter value to the invalid location in memory in block 904; or after writing the write memory command data and the stale counter value to the compliant location in memory in block 714, the memory control device can receive the write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 can be a processor and / or a memory controller.

[0110] Figure 10 illustrates a method 1000 according to some embodiments for implementing a standard-aware cache memory replacement strategy to replace data by invalidating data based on the value of a local counter. Referring to Figures 1-10, method 1000 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104. Processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 1000 is referred to herein as a "memory control device". Blocks 802-805, 808-814, 1002, and 1004 of method 1000 may describe operations that can be performed as part of block 608 of method 600 described with reference to FIG. 6. Blocks 802-805 and 808-814 may be implemented in a manner similar to the similarly numbered blocks of method 900 described herein with reference to FIG. 8.

[0111] In response to a decision that the replacement value exceeds or equals the obsolescence threshold (i.e., decision block 804 = "Yes"), in block 1002, the memory control device may invalidate the data at the location where the replacement value exceeds or equals the obsolescence threshold. The comparison result between the replacement value and the obsolescence threshold in decision block 804 may instruct the memory control device whether a standard-aware cache memory replacement strategy should replace the data associated with the local counter value used to calculate the replacement value in block 802. For example, in response to a replacement value exceeding or equal to the obsolescence threshold, the memory control device may implement a standard-aware cache memory replacement strategy to replace the data associated with the local counter value with the data from a write memory command. The memory control device may invalidate data using known methods for invalidating data in memory. For example, a memory control device can write a value of a valid / invalid bit associated with a location in the system cache (e.g., system cache 218 in Figures 2 and 3, system cache 400 in Figure 4), which is associated with a local counter value used to calculate a replacement value in block 802. The value of the valid / invalid bit can be configured to indicate to the memory control device whether data at that location in the system cache is valid / invalid. In some embodiments, the memory control device that invalidates data at a location in block 1002 where the replacement value exceeds or equals a stale threshold can be a processor (e.g., CPU 104, processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in Figure 2, client 300 in Figure 3) and / or a memory controller (e.g., memory controller 220 in Figures 2 and 3).

[0112] In block 1004, the memory control device may write the data of the write memory command received in block 606 of method 600 (FIG. 6) and the value of the stale counter to an invalid location in the memory. The memory control device may read the valid / invalid bits of the location in the system cache to determine which location has valid / invalid data. The memory control device may replace the data associated with the local counter value by writing the data of the write memory command to the location in the system cache that stores the data associated with the valid / invalid bits. The memory control device may also write the value of the stale counter, which is the local counter, to the system cache in association with the data of the write memory command to be written to the system cache. In some embodiments, updating the stale counter in block 1004 by writing the value of the stale counter, which is the local counter, to the system cache in association with the data of the write memory command may be performed when the data is written to the system cache (i.e., approximately simultaneously). For example, a memory control device may write the value of an aging counter to a tag location in the system cache associated with the data of a write command to the system cache. In some embodiments, the memory control device in block 1004 that writes the data of the write command and the value of the aging counter to an invalid location in the memory may be a processor and / or a memory controller.

[0113] Figure 11 illustrates a method 1100 for implementing a standard aware cache memory replacement strategy according to some embodiments. Referring to Figures 1-11, method 1100 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104, processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) software executing in the processor (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 1100 is referred to herein as the "client" and the "memory control device".

[0114] In block 1102, the client can send a read memory command for the system cache (e.g., system cache 218 in Figures 2 and 3, system cache 400 in Figure 4).

[0115] In block 1104, the client can send a signal to the processor (e.g., CPU 104 and processor 124 in Figure 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212 and 214 in Figure 2, and client 300 in Figure 3) instructing the processor to update the stale counters used for data in the system cache. The client can signal the processor using various types of signal communication, including, for example, writes to registers (e.g., register 222 in Figures 2 and 3), direct interrupts to the processor, etc. The registers can be associated with the stale counter update features of a standard cache-aware replacement policy. Writing to the register can set the value of the register, which is configured to instruct the memory control device whether the memory control device should update the stale counters. In some embodiments, the client that sends a read memory command in block 1102 and signals the processor in block 1104 to update the stale counter for data in the system cache memory can be a processor (e.g., CPU 104, processor 124 in FIG1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG2, client 300 in FIG3) and / or software (e.g., client 300 in FIG3), such as an operating system and / or an application.

[0116] In block 1106, the memory control device can receive read memory commands. The memory control device can be configured to manage, control, and / or implement memory access, cache maintenance, cache consistency, and / or cache replacement strategies for the system cache.

[0117] In block 1108, the memory control device can implement a standard aware cache replacement strategy for writing data of a read memory command into the system cache memory. The memory control device that receives the read memory command in block 1106 and implements the standard aware cache replacement strategy in block 1108 can be a processor (e.g., CPU 104, processor 124 in FIG1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG2, client 300 in FIG3) and / or a memory controller (e.g., memory controller 220 in FIG2 and FIG3).

[0118] Figure 12 illustrates a method 1200 according to some embodiments for implementing a standard-aware cache memory replacement strategy to replace data by invalidating data based on the value of a local counter. Referring to Figures 1-12, method 1200 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104. Processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 1200 is referred to herein as a "memory control device". Blocks 702-706 of method 1200 describe operations that can be performed as part of the operations in block 1108 of method 1100 described with reference to FIG. 11. Blocks 702-706 can be implemented in a similar manner to the similarly numbered blocks of method 700 described with reference to FIG. 7.

[0119] In response to a decision register value indicating that the memory control device should not update the stale counter (i.e., optional decision block 704 = "No"); or after updating the stale counter in block 706, the memory control device can read data from the memory at the location targeted by the read memory command received in block 1106 of method 1100 (FIG. 11) and write the value of the stale counter to the memory at the location targeted by the read memory command received in block 1106 of method 1100 (FIG. 11). The memory control device can read data from the system cache (e.g., system cache 218 in FIG. 2 and 3, system cache 400 in FIG. 4) at the location targeted by the read memory command. The memory control device can also write the value of the stale counter, which is a local counter, to the system cache in association with the data targeted by the read memory command in the system cache. For example, a memory control device can write the value of an obsolete counter to a tag location in the system cache associated with the data targeted by a read memory command in the system cache. In some embodiments, the memory control device that reads data from the location targeted by the read memory command in memory and writes the value of the obsolete counter to the location targeted by the read memory command in memory in block 1202 can be a processor (e.g., CPU 104, processor 124 in FIG. 1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG. 2, and client 300 in FIG. 3) and / or a memory controller (e.g., memory controller 220 in FIG. 2 and 3).

[0120] After reading data from the location targeted by the read memory command in memory and writing the value of the stale counter to the location targeted by the read memory command in memory in block 1202, the memory control device can receive a write memory command in block 606 of method 600, as described with reference to FIG6. The memory control device receiving the write memory command in block 606 can be a processor and / or a memory controller.

[0121] Figure 13 illustrates a method 1300 according to some embodiments for implementing a standard-aware cache memory replacement strategy to replace data by invalidating data based on the value of a local counter. Referring to Figures 1-13, method 1300 can be implemented in: a computing device (e.g., computing device 100 in Figure 1), hardware, and a processor (e.g., CPU in Figure 1). 104, processor 124, processor 202 in Figure 2, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214, and client 300 in Figure 3) and software executing in them (e.g., client 300 in Figure 3), or a combination of processors and dedicated hardware configured with software, including other individual components such as various memory / cache memory (e.g., memory 106 and memory 114 in Figure 1, L2 cache memory 208a, 208b, 208c, 210a, 210b, 210c, L3 cache memory 216 in Figure 2, system cache memory 218 and register 222 in Figures 2 and 3, and system cache memory 400 in Figure 4) and various memory / cache memory controllers (e.g., memory controller 220 in Figures 2 and 3). To cover alternative configurations enabled in various embodiments, the hardware implementing method 1300 is referred to herein as a "memory control device". Blocks 810-814 and 1202 of method 1200 describe operations that can be performed as part of the operations in block 1108 of method 1100 described with reference to FIG. 11. Blocks 810-814 can be implemented in a similar manner to the similarly numbered blocks of method 800 described with reference to FIG. 8.

[0122] In block 1302, the memory control device can read data from the memory at the location targeted by the read memory command received in block 1106 of method 1100 (FIG. 11) and write the stale counter value into the memory at the location targeted by the read memory command received in block 1106 of method 1100 (FIG. 11). The memory control device can read data from the system cache memory (e.g., system cache memory 218 in FIG. 2 and 3, system cache memory 400 in FIG. 4) at the location targeted by the read memory command. The memory control device can also write the value of the stale counter, which is a local counter, into the system cache memory in association with the data targeted by the read memory command in the system cache memory. For example, the memory control device can write the value of the stale counter into the tag location in the system cache memory associated with the data targeted by the read memory command in the system cache memory. In some embodiments, the memory control device that reads data from the location targeted by the read memory command in memory and writes the value of the stale counter to the location targeted by the read memory command in memory in block 1302 can be a processor (e.g., CPU 104, processor 124 in FIG1, processor 202, processor cores 204a, 204b, 204c, 206a, 206b, 206c, processor core clusters 212, 214 in FIG2, client 300 in FIG3) and / or a memory controller (e.g., memory controller 220 in FIG2 and FIG3).

[0123] Systems according to various embodiments (including, but not limited to, the embodiments described above with reference to Figures 1-13) can be implemented in a variety of computing systems, including mobile computing devices, and examples of such systems suitable for use with various embodiments are illustrated in Figure 14. Mobile computing device 1400 may include a processor 1402 coupled to a touchscreen controller 1404 and internal memory 1406. Processor 1402 may be one or more multi-core integrated circuits specified for general or specific processing tasks. Internal memory 1406 may be volatile or non-volatile memory, or secure and / or encrypted memory, or insecure and / or unencrypted memory, or any combination thereof. Examples of memory types that can be utilized include, but are not limited to, DDR, low-power DDR (LPDDR), graphics DDR (GDDR), Wide-Input DDR, RAM, static RAM (SRAM), dynamic RAM (DRAM), parametric RAM (P-RAM), resistive RAM (R-RAM), magnetoresistive RAM (M-RAM), spin-transfer torque RAM (STT-RAM), and embedded DRAM. The touch screen controller 1404 and processor 1402 can also be coupled to the touch screen panel 1412, such as a resistive touch screen, a capacitive touch screen, an infrared touch screen, etc. Furthermore, the display of the mobile computing device 1400 does not need to have touch screen functionality.

[0124] The mobile computing device 1400 may have one or more radio transceivers 1408 (e.g., Peanut, Bluetooth, ZigBee, Wi-Fi, RF radio) and antennas 1410 for transmitting and receiving communications, coupled to each other and / or coupled to the processor 1402. The transceivers 1408 and antennas 1410 may be used with the circuitry described above to implement various wireless transmission protocol stacks and interfaces. The mobile computing device 1400 may include a cellular wireless modem chip 1416 that enables communication via a cellular network and is coupled to the processor.

[0125] The mobile computing device 1400 may include a peripheral device connection interface 1418 coupled to the processor 1402. The peripheral device connection interface 1418 may be specifically configured to accept one type of connection, or it may be configured to accept various types of physical and communication connections (general or proprietary), such as Universal Serial Bus (USB), FireWire, Thunderbolt, or PCIe. The peripheral device connection interface 1418 may also be coupled to a peripheral device port (not shown) with a similar configuration.

[0126] The mobile computing device 1400 may also include a speaker 1414 for providing audio output. The mobile computing device 1400 may also include a housing 1420, constructed of plastic, metal, or a combination of materials, for housing all or some of the components described herein. The mobile computing device 1400 may include a power supply 1422 coupled to the processor 1402, such as a disposable or rechargeable battery. The rechargeable battery may also be coupled to a peripheral device port to receive charging current from a source external to the mobile computing device 1400. The mobile computing device 1400 may also include a physical button 1424 for receiving user input. The mobile computing device 1400 may also include a power button 1426 for turning the mobile computing device 1400 on and off.

[0127] Systems according to various embodiments (including, but not limited to, the embodiments described above with reference to Figures 1-12) can be implemented in various computing systems including a laptop computer 1500, examples of which are shown in Figure 15. Many laptop computers include a touchpad touch surface 1517, which serves as a pointing device for the computer and can therefore receive drag, scroll, and flick gestures, similar to those implemented on computing devices equipped with touchscreen displays and described above. The laptop computer 1500 will generally include a processor 1502 coupled to volatile memory 1512 and a disk drive 1513, such as flash memory. Additionally, the computer 1500 may have one or more antennas 1508 for transmitting and receiving electromagnetic radiation, which may be connected to a wireless data link and / or a cellular telephone transceiver 1516 coupled to the processor 1502. The computer 1500 may also include a floppy disk drive 1514 and a compact optical disc (CD) drive 1515 coupled to the processor 1502. In a laptop configuration, the computer casing includes a touchpad 1517, a keyboard 1518, and a display 1519, all of which are coupled to a processor 1502. Other configurations of the computing device may include a computer mouse or trackball, which are well-known to be coupled to the processor (e.g., via USB input), and may also be used in various embodiments.

[0128] Systems according to various embodiments (including, but not limited to, the embodiments described above with reference to Figures 1-12) can also be implemented in fixed computing systems, such as any of various commercial servers. An exemplary server 1600 is illustrated in Figure 16. Such a server 1600 typically includes one or more multi-core processor elements 1601 coupled to volatile memory 1602 and mass non-volatile memory (e.g., disk drive 1604). As shown in Figure 16, the multi-core processor element 1601 can be added to the server 1600 by inserting it into a rack of elements. The server 1600 may also include a floppy disk drive, CD-ROM, or DVD-ROM drive 1606 coupled to the processor 1601. Server 1600 may also include a network access port 1603 coupled to multi-core processor element 1601 for establishing a network interface connection with network 1605, such as a local area network, Internet, public switched telephone network and / or cellular data network (e.g., CDMA, TDMA, GSM, PCS, 3G, 4G, LTE, 5G or any other type of cellular data network) coupled to other broadcast system computers and servers.

[0129] Examples of embodiments are described in the following paragraphs. Although some of the following examples of embodiments are described in accordance with exemplary systems, devices, or methods, further exemplary embodiments may include: the exemplary system or device discussed in the following paragraphs being implemented as a method for performing operations of the exemplary system or device; the exemplary system, device, or method discussed in the following paragraphs being implemented by a computing device including a processing device configured with processing device-executable instructions to perform operations of the exemplary system, device, or method; a computing device including a memory control device configured to perform operations of the exemplary system, device, or method; the exemplary system, device, or method discussed in the following paragraphs being implemented by a computing device including components for performing functions of the exemplary system, device, or method; and the exemplary system, device, or method discussed in the following paragraphs being implemented as a non-transitory processor-readable storage medium having processor-executable instructions stored thereon configured to cause a processor of a computing device to perform operations of the exemplary system, device, or method.

[0130] Example 1. A method for implementing a standard aware cache replacement strategy via a computing device, comprising the following steps: updating an obsolescence counter; writing the value of a local counter to the system cache in association with the location of associated data in the system cache, wherein when the associated data is written to the system cache, the value of the local counter includes the value of the obsolescence counter; and using the value of the local counter of the associated data to determine whether the associated data is obsolete.

[0131] Example 2. The method of Example 1, wherein updating a stale counter includes: receiving a signal from a client of the computing device, the signal being configured to indicate whether to update the stale counter; determining whether to update the stale counter based on the signal; and updating the stale counter in response to the decision to update the stale counter.

[0132] Example 3. The method of any one of Example 1 or 2, wherein the signal is a register write command, and wherein: receiving the signal from a client of the computing device includes reading a value from a register set by the client; and determining whether to update the stale counter based on the signal includes determining whether to update the stale counter based on a value from the register.

[0133] Example 4. The method of Example 3 also includes the following steps: the client of the computing device sets the value in the register according to a time-based standard.

[0134] Example 5. The method of Example 3 also includes the following steps: the client of the computing device sets the value in the register according to the event-based criteria.

[0135] Example 6. The method of any one of Examples 1-5 also includes the following steps: receiving a memory write command, wherein writing the value of the local counter to the system cache in association with the location of the associated data in the system cache can occur before updating the stale counter, wherein the associated data is the data of the memory write command.

[0136] Example 7. The method of any one of Examples 1-6, wherein using the value of the local counter of the associated data to determine whether the associated data is obsolete includes: using the value of the obsolete counter and the value of the local counter to calculate a replacement value; and determining whether the replacement value exceeds an obsolete threshold, wherein in response to determining that the replacement value exceeds the obsolete threshold, the associated data is determined to be obsolete.

[0137] Example 8. The method of Example 7 also includes the following steps: receiving a memory access command; and writing the data of the memory access command into the system cache at a location where the replacement value exceeds the obsolescence threshold, wherein the data of the memory access command written into the system cache is the associated data.

[0138] Example 9. The method of Example 7 also includes the following steps: receiving a memory write command; invalidating the data at the location where the replacement value exceeds the obsolescence threshold; and writing the data of the memory write command to the location in the system cache containing the invalidated data, wherein the data of the memory write command written to the system cache is the associated data.

[0139] Example 10. The method of any one of Examples 1-9 also includes the following steps: receiving a memory write access command; and in response to determining that no replacement value exceeds the obsolescence threshold, writing the data of the memory write access command to a location in the system cache that conforms to another cache replacement strategy.

[0140] Computer program code or "program code" for execution on a programmable processor to perform operations of various embodiments may be written in a high-level programming language, such as C, C++, C#, Smalltalk, Java, JavaScript, Visual Basic, structured query language (e.g., Transact-SQL), Perl, or other various programming languages. The program code or program stored on a computer-readable storage medium as used in this application may refer to machine language code (e.g., object code) in a format understandable to the processor.

[0141] The foregoing method description and flowchart are provided as illustrative examples only and are not intended to require or imply that the operations of the various embodiments must be performed in the order presented. As those skilled in the art will understand, the operations in the foregoing embodiments can be performed in any order. Words such as "afterwards," "following," "next," etc., are not intended to limit the order of operations; such words are merely used to guide the reader through the description of the method. Furthermore, any reference to a request element in the singular, such as the use of the words "a," "an," or "the," should not be construed as limiting the element to the singular.

[0142] The various illustrative logic blocks, modules, circuits, and algorithmic operations described in conjunction with the various embodiments can be implemented as electronic hardware, computer software, or a combination of both. To clearly illustrate this interchangeability between hardware and software, various illustrative elements, blocks, modules, circuits, and operations have been generally described above in terms of their functionality. Whether this functionality is implemented as hardware or software depends on the specific application and the design constraints imposed on the overall system. Those skilled in the art can implement the described functionality in different ways for each specific application, but such implementation should not be construed as deviating from the scope of the claim.

[0143] The hardware used to implement the various illustrative logics, logic blocks, modules, and circuits described in conjunction with the embodiments disclosed herein may be implemented or performed by a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA) or other programmable logic device, individual gate or transistor logic, discrete hardware elements, or any combination thereof designed to perform the functions described herein. The general-purpose processor may be a microprocessor, but alternatively, the processor may be any known processor, controller, microcontroller, or state machine. The processor may also be implemented as a combination of computing devices, such as a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors combined with a DSP core, or any other such configuration. Alternatively, some operations or methods may be performed by a circuit system specific to a given function.

[0144] In one or more embodiments, the described functionality can be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functionality can be stored as one or more instructions or code on a non-transitory computer-readable medium or a non-transitory processor-readable medium. The operation of the methods or algorithms disclosed herein can be embodied in a processor-executable software module, which can reside on a non-transitory computer-readable or processor-readable storage medium. A non-transitory computer-readable or processor-readable storage medium can be any storage medium accessible by a computer or processor. For example, but not limited to, such non-transitory computer-readable or processor-readable media can include RAM, ROM, EEPROM, flash memory, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store the required program code in the form of instructions or data structures and is accessible by a computer. The magnetic disks and optical disks used herein include CDs, laser discs, optical discs, DVDs, floppy disks, and Blu-ray discs. Magnetic disks typically reproduce data magnetically, while optical discs reproduce data optically via lasers. This combination also falls within the scope of non-transitory computer-readable and processor-readable media. Furthermore, the operation of a method or algorithm may reside as one or any combination of codes and / or instructions on non-transitory processor-readable and / or computer-readable media, and may be incorporated into a computer program product.

[0145] The foregoing description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the claims. Various modifications to these embodiments will be apparent to those skilled in the art, and the general principles defined herein can be applied to other embodiments and implementations without departing from the scope of the claims. Therefore, this application is not intended to be limited to the embodiments and implementations described herein, but is accorded the widest scope consistent with the appended claims and the principles and novel features disclosed herein. [Simplified Explanation of the Diagram]

[0014] The accompanying drawings, which are incorporated herein and constitute a part of this specification, illustrate exemplary embodiments of various embodiments and, together with the general description provided above and the detailed description provided below, serve to explain the features of the requested item.

[0015] FIG1 is a block diagram illustrating an exemplary computing device suitable for implementing various embodiments.

[0016] FIG2 is a component block diagram illustrating an exemplary system-on-a-chip suitable for implementing various embodiments.

[0017] Figures 3A and 3B are program element signal transmission diagrams illustrating an example of a standard sense cache memory replacement strategy according to an embodiment.

[0018] Figure 4 is a memory flowchart illustrating an example of a standard sense cache memory replacement strategy according to an embodiment.

[0019] Figure 5 is a memory flowchart illustrating an example of a standard sense cache memory replacement strategy based on the value of a local counter to replace data according to an embodiment.

[0020] Figure 6 is a flowchart illustrating a method for implementing a standard sense cache replacement strategy for a local counter according to an embodiment.

[0021] Figure 7 is a flowchart illustrating a method for implementing a standard sense cache memory replacement strategy based on the value of a local counter to replace data, according to an embodiment.

[0022] Figure 8 is a flowchart illustrating a method for implementing a standard sense cache memory replacement strategy based on the value of a local counter to replace data, according to an embodiment.

[0023] Figure 9 is a flowchart illustrating a method for implementing a standard sense cache replacement strategy to replace data by invalidating data based on the value of a local counter, according to an embodiment.

[0024] Figure 10 is a flowchart illustrating a method for implementing a standard sense cache replacement strategy to replace data by invalidating data based on the value of a local counter, according to an embodiment.

[0025] Figure 11 is a flowchart illustrating a method for implementing a standard sense cache replacement strategy for a local counter according to an embodiment.

[0026] Figure 12 is a flowchart illustrating a method for implementing a standard sense cache memory replacement strategy based on the value of a local counter to replace data, according to an embodiment.

[0027] Figure 13 is a flowchart illustrating a method for implementing a standard sense cache replacement strategy based on the value of a local counter to replace data according to an embodiment.

[0028] FIG14 is a block diagram illustrating an exemplary mobile computing device suitable for implementing various embodiments.

[0029] FIG15 is a block diagram illustrating an exemplary mobile computing device suitable for implementing various embodiments.

[0030] Figure 16 is a block diagram illustrating an exemplary server suitable for implementing various embodiments. [Biomaterial Storage]

[0147] Domestic storage information (please note in order of storage institution, date, and number): None. International storage information (please note in order of storage country, institution, date, and number): None.

Claims

1. A method for implementing a standard-aware cache replacement strategy via a computing device, comprising the steps of: updating an obsolescence counter; writing a value of a local counter to system cache in association with associated data at a location in system cache, wherein when the associated data is written to system cache, the value of the local counter includes the value of the obsolescence counter; calculating a replacement value using the value of the obsolescence counter and the value of the local counter for the associated data; determining whether all replacement values ​​for a plurality of associated data in a portion of system cache are equal to each other; and, in response to determining that the replacement values ​​for the plurality of associated data in that portion of system cache are not all equal to each other, determining whether the replacement value exceeds an obsolescence threshold, wherein, in response to determining that the replacement value exceeds the obsolescence threshold, the associated data is determined to be obsolete.

2. The method of claim 1, wherein the step of updating the obsolete counter includes the following steps: receiving a signal from a client of the computing device, the signal being configured to indicate whether to update the obsolete counter; determining whether to update the obsolete counter based on the signal; and updating the obsolete counter in response to the decision to update the obsolete counter.

3. As in request item 2, wherein the signal is a register write command, and wherein: The step of receiving the signal from the client of the computing device includes the following steps: reading a value from a register set by the client; and the step of determining whether to update the stale counter based on the signal includes the following steps: determining whether to update the stale counter based on the value from the register.

4. The method of request item 3 also includes the following steps: the client of the computing device sets the value in the register according to a time-based standard.

5. The method of request item 3 also includes the following steps: the client of the computing device sets the value in the register according to an event-based criterion.

6. The method of claim 1 also includes the steps of: receiving a write memory command, wherein writing the value of the local counter and the associated data to the system cache in association with the location in the system cache occurs before updating the stale counter, wherein the associated data is the data of the write memory command.

7. The method of claim 1 also includes the steps of: receiving a memory access command; and writing the data of the memory access command into the system cache at a location where the replacement value exceeds the obsolescence threshold, wherein the data of the memory access command written into the system cache is the associated data.

8. The method of claim 1 also includes the following steps: receiving a write memory command; invalidating data at a location where the replacement value exceeds the obsolescence threshold; and writing the data of the write memory command to a location in the system cache containing the invalidated data, wherein the data of the write memory command written to the system cache is the associated data.

9. The method of request item 1 also includes the following steps: receiving a memory write access command; and in response to determining that no replacement value exceeds the obsolescence threshold, writing the data of the memory write access command to a location in the system cache that conforms to another cache replacement policy.

10. The method of claim 1, wherein calculating the replacement value using the value of the obsolete counter and the value of the local counter of the associated data includes the step of: calculating a difference between the value of the obsolete counter and the value of the local counter.

11. A computing device, comprising: A memory control device configured to: update an obsolescence counter; write a value of a local counter to a location in a system cache associated with data, wherein the value of the local counter includes the value of the obsolescence counter when the associated data is written to the system cache; calculate a replacement value using the value of the obsolescence counter and the value of the local counter for the associated data; determine whether all replacement values ​​for a plurality of associated data in a portion of the system cache are equal to each other; and, in response to determining that the replacement values ​​for the plurality of associated data in that portion of the system cache are not all equal to each other, determine whether the replacement value exceeds an obsolescence threshold, wherein the associated data is determined to be obsolete in response to determining that the replacement value exceeds the obsolescence threshold.

12. The computing device of claim 11, wherein the memory control device is further configured to update the obsolete counter by: receiving a signal from a client of the computing device, the signal being configured to indicate whether to update the obsolete counter; determining whether to update the obsolete counter based on the signal; and updating the obsolete counter in response to the decision to update the obsolete counter.

13. The computing device as described in claim 12, wherein: The signal is a register write command; and the memory control device is also configured to: receive the signal from the client of the computing device by reading a value from a register set by the client; and decide whether to update the stale counter based on the signal by deciding whether to update the stale counter based on the value from the register.

14. The computing device as described in claim 13 also includes a client configured to set the value at the register according to a time-based criterion.

15. The computing device as described in request item 13 also includes a client configured to set the value at the register according to an event-based criterion.

16. The computing device of claim 11, wherein the memory control device is also configured to: receive a write memory command; and write the value of the local counter to the system cache in association with the associated data at the location in the system cache before updating the obsolete counter, wherein the associated data is the data of the write memory command.

17. The computing device of claim 11, wherein the memory control device is further configured to: receive a memory access command; and write data of the memory access command into the system cache at a location where the replacement value exceeds the obsolescence threshold, wherein the data of the memory access command written into the system cache is the associated data.

18. The computing device of claim 11, wherein the memory control device is further configured to: receive a write memory command; invalidate data at a location where the replacement value exceeds the obsolescence threshold; and write the data of the write memory command to a location in the system cache containing the invalidated data, wherein the data of the write memory command written to the system cache is the associated data.

19. The computing device of claim 11, wherein the memory control device is further configured to: receive a memory write access command; and in response to determining that no replacement value exceeds the obsolescence threshold, write the data of the memory write access command to a location in the system cache that conforms to a cache replacement policy different from a standard perceived cache replacement policy.

20. The computing device of claim 11, wherein the memory control device is further configured to: calculate the replacement value as a difference between the value of the obsolete counter and the value of the local counter.

21. A computing device, comprising: Components used to update an outdated counter; The means for writing a value of a local counter to a location in a system cache associated with data, wherein when the associated data is written to the system cache, the value of the local counter includes a value of the obsolescence counter; the means for calculating a replacement value using the value of the obsolescence counter and the value of the local counter of the associated data; the means for determining whether all replacement values ​​for a plurality of associated data in a portion of the system cache are equal to each other; and the means for determining whether the replacement value exceeds an obsolescence threshold in response to determining that the replacement values ​​for the plurality of associated data in that portion of the system cache are not all equal to each other, wherein the associated data is determined to be obsolete in response to determining that the replacement value exceeds the obsolescence threshold.

22. The computing device of claim 21, wherein the components for updating the obsolete counter include: A component for receiving a signal from a client of the computing device, the signal being configured to indicate whether the stale counter should be updated; A component for determining whether to update the obsolete counter based on the signal; and a component for updating the obsolete counter in response to the decision to update the obsolete counter.

23. The computing device as requested in item 22, wherein the signal is a register write command, and wherein: The components for receiving the signal from the client of the computing device include components for reading a value from a register set by the client; and the components for determining whether to update the stale counter based on the signal include components for determining whether to update the stale counter based on the value from the register.

24. The computing device as described in claim 23 also includes: A component for setting the value in the register by the client of the computing device according to a time-based standard or by the client of the computing device according to an event-based standard.

25. The computing device as described in claim 21 also includes: The component for receiving a write memory command, wherein the component for writing the value of the local counter in association with the associated data at the location in the system cache memory is implemented before updating the stale counter, wherein the associated data is the data of the write memory command.

26. The computing device as described in claim 21 also includes: A component used to receive a memory access command; And a component for writing the data of the memory access command into the system cache at a location where the replacement value exceeds the obsolescence threshold, wherein the data of the memory access command written into the system cache is the associated data.

27. The computing device as described in claim 21 also includes: A component for receiving a write memory command; a component for invalidating data at a location where the replacement value exceeds the obsolescence threshold; And a component for writing the data of the write command to a location in the system cache containing invalidated data, wherein the data of the write command to the system cache is the associated data.

28. The computing device as described in claim 21 also includes: A component used to receive a memory write access command; And a component for writing data to a location in the system cache memory that conforms to a cache memory replacement strategy different from a standard perceived cache memory replacement strategy, in response to a decision that no replacement value exceeds the obsolescence threshold.

29. The computing device of claim 21, wherein the components for calculating the replacement value using the value of the obsolete counter and the value of the local counter of the associated data include: A component used to calculate a difference between the value of the old counter and the value of the local counter.

30. A non-transitory processor-readable medium having processor-executable instructions stored thereon, the processor-executable instructions being configured to cause a processing device to perform operations, the operations including: Update an outdated counter; A local counter value is associated with a location in a system cache and written to the system cache, wherein when the associated data is written to the system cache, the local counter value includes a value of an obsolescence counter; a replacement value is calculated using the obsolescence counter value and the local counter value of the associated data; it is determined whether all replacement values ​​for a plurality of associated data in a portion of the system cache are equal to each other; and in response to the determination that the replacement values ​​for the plurality of associated data in that portion of the system cache are not all equal to each other, it is determined whether the replacement value exceeds an obsolescence threshold, wherein in response to the determination that the replacement value exceeds the obsolescence threshold, the associated data is determined to be obsolete.

Citation Information

Patent Citations

  • Apparatus and methods for activity-based management of computer systems

    CN102750604A

  • Computer oriented record administration system

    CN1481533A

  • Memory-based apparatus and method

    US20130097387A1

  • Automatic caching of scan and random access data in computing systems

    US20150088805A1

  • Method for protecting security-relevant data in a cache memory

    US20180081825A1