Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method for reconfigurable caching, the method comprising: receiving a workload comprising a plurality of requests; classifying a first request of the plurality of requests in a first class; classifying the workload in a second class based on the first class; assigning a priority to the first request based on the first class and the second class; and storing the first request in a cache memory comprising a plurality of blocks responsive to: the first request satisfying a caching condition; the cache memory satisfying a validation condition; and the priority satisfying a priority condition, the priority condition comprises one of: at least one of the plurality of blocks being empty; and the priority of the first request being larger than a smallest block priority of a plurality of block priorities, each of the plurality of block priorities assigned to a block of the plurality of blocks.
This invention relates to reconfigurable caching systems designed to optimize data storage and retrieval in computing environments. The problem addressed is inefficient cache management, where static caching policies fail to adapt to varying workload characteristics, leading to suboptimal performance. The solution involves a dynamic classification and prioritization system that adjusts caching decisions based on real-time workload analysis. The method processes a workload consisting of multiple requests. Each request is classified into a first class, and the entire workload is then classified into a second class based on the first classification. A priority is assigned to each request based on both its individual class and the workload class. The request is stored in a cache memory with multiple blocks only if specific conditions are met: the request must satisfy a caching condition, the cache must satisfy a validation condition, and the request's priority must meet a priority condition. The priority condition is fulfilled if either an empty block is available or the request's priority exceeds the smallest priority among all cached blocks. This ensures that higher-priority requests displace lower-priority ones, dynamically adapting the cache to workload changes. The system improves cache efficiency by balancing immediate needs with long-term performance, reducing unnecessary evictions and enhancing data access speed.
2. The method of claim 1 , wherein classifying the first request comprises: classifying the first request in a random class; arranging the plurality of requests in a request queue; selecting the first request from the request queue, the first request associated with a first plurality of addresses, each of the first plurality of addresses being an integer number; selecting a second request of the plurality of requests from the request queue, the second request associated with a second plurality of addresses, each of the second plurality of addresses being an integer number; classifying the first request in a strided class responsive to a smallest address of the first plurality of addresses being larger than a largest address of the second plurality of addresses by a gap value, the gap value being smaller than a gap threshold; classifying the first request in a sequential class responsive to the smallest address of the first plurality of addresses being larger than the largest address of the second plurality of addresses by 1; and classifying the first request in an overlapped class responsive to a first portion of the first plurality of addresses being the same as a second portion of the second plurality of addresses.
This invention relates to a method for classifying memory access requests in a computing system to optimize memory access patterns. The problem addressed is the inefficient handling of memory requests, which can lead to performance bottlenecks due to suboptimal access patterns. The method involves classifying memory access requests into different categories based on their address patterns to improve memory access efficiency. The method begins by classifying a first memory access request into a random class by default. Multiple requests are then arranged in a request queue. The first request, associated with a set of integer addresses, is selected from the queue. A second request, also associated with a set of integer addresses, is selected from the queue. The first request is classified into a strided class if the smallest address of the first request is larger than the largest address of the second request by a gap value that is smaller than a predefined threshold. The first request is classified into a sequential class if the smallest address of the first request is exactly one unit larger than the largest address of the second request. The first request is classified into an overlapped class if a portion of the addresses in the first request matches a portion of the addresses in the second request. This classification helps in identifying and optimizing different memory access patterns, such as sequential, strided, or overlapping accesses, to enhance system performance.
3. The method of claim 2 , wherein arranging the plurality of requests in the request queue comprises arranging the plurality of requests in a queue with a size of 65 requests.
This invention relates to managing request queues in a computing system to optimize processing efficiency. The problem addressed is the need to balance system performance and resource utilization when handling multiple requests, particularly in environments where request processing must be controlled to prevent system overload or degradation. The method involves arranging a plurality of requests in a request queue, where the queue is specifically configured to hold a fixed size of 65 requests. This fixed-size queue ensures that the system processes requests in a controlled manner, preventing excessive memory usage or processing delays. The queue may be part of a larger system that prioritizes or schedules requests based on predefined criteria, such as request type, urgency, or system load. By limiting the queue to 65 requests, the system maintains stability while efficiently managing incoming workloads. This approach is particularly useful in high-demand computing environments, such as servers, network devices, or distributed systems, where request handling must be optimized for performance and reliability. The fixed queue size helps avoid bottlenecks and ensures predictable processing behavior.
4. The method of claim 2 , wherein classifying the workload in the second class comprises: classifying the workload in a random consumer class responsive to more than 60 percent of the plurality of requests read from a memory unit and more than 70 percent of the plurality of requests classified in the random class; classifying the workload in a sequential producer-consumer class responsive to 40 percent to 60 percent of the plurality of requests read from the memory unit and more than 50 percent of the plurality of requests classified in the sequential class; classifying the workload in a random producer-consumer class responsive to 40 percent to 80 percent of the plurality of requests read from the memory unit and more than 60 percent of the plurality of requests classified in the random class; classifying the workload in an archival consumer class responsive to more than 80 percent of the plurality of requests read from the memory unit and more than 70 percent of the plurality of requests classified in the sequential class; and classifying the workload in a large file generator class responsive to more than 90 percent of the plurality of requests written on the memory unit and more than 60 percent of the plurality of requests classified in the sequential class.
This invention relates to a system for classifying workloads in a memory storage environment to optimize performance. The problem addressed is the need to dynamically categorize different types of data access patterns to improve storage efficiency and resource allocation. The method involves analyzing a plurality of requests to a memory unit and classifying them into specific workload classes based on predefined thresholds for read/write operations and sequential/random access patterns. The classification process includes determining whether a workload belongs to one of several predefined classes. A workload is classified as a random consumer if more than 60% of the requests are read operations and over 70% are random access requests. If 40% to 60% of the requests are read operations and more than 50% are sequential, the workload is classified as a sequential producer-consumer. A workload is classified as a random producer-consumer if 40% to 80% of the requests are read operations and over 60% are random. If more than 80% of the requests are read operations and over 70% are sequential, the workload is classified as an archival consumer. Finally, if more than 90% of the requests are write operations and over 60% are sequential, the workload is classified as a large file generator. This classification system helps storage systems adapt their operations to different workload types, improving performance and resource utilization.
5. The method of claim 4 , wherein assigning the priority to the first request comprises assigning a number to the first request, the number associated with a unique combination of: one of the random class, the strided class, the sequential class, and the overlapped class; one of the random consumer class, the sequential producer-consumer, the random producer-consumer class, the archival consumer class, and the large file generator class; and a request type associated with the first request, the request type comprising a read request and a write request.
This invention relates to a method for assigning priority to data requests in a storage system, addressing the challenge of efficiently managing diverse request types and workload patterns to optimize performance. The method categorizes requests into distinct classes based on their access patterns and operational roles, then assigns a unique numerical priority to each request by combining these classifications with the request type (read or write). The access patterns are classified into four types: random, strided, sequential, and overlapped. Random access involves non-sequential data retrieval, strided access uses fixed intervals, sequential access reads or writes data in order, and overlapped access combines multiple patterns. The operational roles are categorized into five classes: random consumer (random read operations), sequential producer-consumer (ordered read/write operations), random producer-consumer (mixed random read/write), archival consumer (long-term storage access), and large file generator (bulk data writes). The priority assignment process involves mapping each request to a unique combination of these three attributes (access pattern, operational role, and request type) and assigning a corresponding numerical value. This numerical priority enables the system to prioritize requests dynamically, improving resource allocation and reducing latency for critical operations. The method ensures that different workloads are handled according to their specific characteristics, enhancing overall system efficiency.
6. The method of claim 2 , wherein classifying the workload in the second class comprises: classifying the workload in a random consumer class responsive to: more than 60 percent of the plurality of requests read from a memory unit, more than 70 percent of the plurality of requests classified in the random class, less than 15 percent of the plurality of requests classified in the strided class, more than 10 percent of the plurality of requests classified in the sequential class, and more than 10 percent of the plurality of requests classified in the overlapped class; classifying the workload in a sequential producer-consumer class responsive to: 40 percent to 60 percent of the plurality of requests read from the memory unit, less than 30 percent of the plurality of requests classified in the random class, less than 20 percent of the plurality of requests classified in the strided class, more than 50 percent of the plurality of requests classified in the sequential class, and less than 50 percent of the plurality of requests classified in the overlapped class; classifying the workload in a random producer-consumer class responsive to: 40 percent to 80 percent of the plurality of requests read from the memory unit, more than 60 percent of the plurality of requests classified in the random class, less than 30 percent of the plurality of requests classified in the strided class, less than 30 percent of the plurality of requests classified in the sequential class, and less than 10 percent of the plurality of requests classified in the overlapped class; classifying the workload in an archival consumer class responsive to: more than 80 percent of the plurality of requests read from the memory unit, less than 20 percent of the plurality of requests classified in the random class, less than 40 percent of the plurality of requests classified in the strided class, more than 70 percent of the plurality of requests classified in the sequential class, and 20 percent to 90 percent of the plurality of requests classified in the overlapped class; and classifying the workload in a large file generator class responsive to: more than 90 percent of the plurality of requests written on the memory unit, more than 40 percent of the plurality of requests classified in the random class, less than 20 percent of the plurality of requests classified in the strided class, more than 60 percent of the plurality of requests classified in the sequential class, and less than 10 percent of the plurality of requests classified in the overlapped class.
This invention relates to a method for classifying workloads in a memory system based on request patterns to optimize performance. The method analyzes a plurality of requests to a memory unit and categorizes them into specific workload classes based on predefined criteria. The classification involves determining the proportion of requests that are read or written, and the distribution of requests across different access patterns, including random, strided, sequential, and overlapped classes. The workload is classified into one of several classes based on specific thresholds. A random consumer class is identified when over 60% of requests are reads, over 70% are random, under 15% are strided, over 10% are sequential, and over 10% are overlapped. A sequential producer-consumer class is detected when 40-60% of requests are reads, under 30% are random, under 20% are strided, over 50% are sequential, and under 50% are overlapped. A random producer-consumer class is recognized when 40-80% of requests are reads, over 60% are random, under 30% are strided, under 30% are sequential, and under 10% are overlapped. An archival consumer class is identified when over 80% of requests are reads, under 20% are random, under 40% are strided, over 70% are sequential, and 20-90% are overlapped. A large file generator class is determined when over 90% of requests are writes, over 40% are random, under 20% are strided, over 60% are sequential, and under 10% are overlapped. This classification helps in tailoring memory management strategies to improve efficiency and performance.
7. The method of claim 1 , wherein the caching condition comprises the first request not stored in the cache memory.
A system and method for optimizing data retrieval in a computing environment involves dynamically managing cache memory to improve efficiency. The technology addresses the problem of inefficient data access in systems where frequently requested data is not cached, leading to redundant retrieval operations and increased latency. The method includes monitoring data requests, determining whether the requested data meets specific caching conditions, and selectively storing or retrieving data from cache memory based on these conditions. One key condition is whether the requested data is not already stored in the cache, ensuring that only relevant data is cached to maximize efficiency. The system may also track request frequency, data size, or other factors to further refine caching decisions. By dynamically adjusting cache storage based on real-time conditions, the system reduces unnecessary data transfers and improves overall system performance. The method is particularly useful in high-performance computing, cloud storage, and distributed systems where minimizing latency and optimizing resource usage are critical. The invention ensures that cache memory is used effectively, reducing redundant operations and improving response times for frequently accessed data.
8. The method of claim 1 , wherein the validation condition comprises all of the plurality of blocks being valid.
A system and method for validating data integrity in a distributed ledger or blockchain network. The invention addresses the challenge of ensuring that all blocks in a blockchain are valid, which is critical for maintaining trust and security in decentralized systems. The method involves checking a validation condition that requires every block in the plurality of blocks to be cryptographically verified as valid. This includes verifying digital signatures, ensuring proper sequencing, and confirming that each block adheres to the consensus rules of the network. The validation process may involve comparing block hashes, checking transaction validity, and ensuring that no double-spending or tampering has occurred. The system may also include mechanisms for detecting and rejecting invalid blocks, such as those with corrupted data or unauthorized modifications. By enforcing strict validation of all blocks, the invention ensures the integrity and reliability of the blockchain, preventing fraud and maintaining consensus among network participants. The method can be applied to various blockchain-based applications, including cryptocurrency transactions, smart contracts, and decentralized applications (dApps). The invention improves upon existing systems by providing a more robust and comprehensive validation process that minimizes the risk of errors or malicious activity.
9. The method of claim 1 , further comprising: sending the first request to a hard disk drive responsive to the first request tagged uncacheable; and invalidating a block of the plurality of blocks responsive to the first request tagged uncacheable and the first request stored in the block.
This invention relates to data storage systems, specifically methods for managing cache operations in a storage controller. The problem addressed is inefficient handling of uncacheable data requests, which can lead to redundant operations and degraded performance in storage systems. The method involves processing data requests in a storage system where data is stored in blocks. When a first request is received and tagged as uncacheable, the system sends the request directly to a hard disk drive instead of caching it. Additionally, if the uncacheable request is stored in a block of the cache, that block is invalidated to prevent stale data from being used. This ensures that uncacheable data does not occupy cache space unnecessarily, improving system efficiency. The method also includes tracking which blocks contain uncacheable requests to determine when invalidation is required. This approach optimizes cache usage by dynamically managing uncacheable data, reducing unnecessary read/write operations and improving overall storage performance.
10. The method of claim 1 , wherein storing the first request in the cache memory comprises: storing the first request in an empty block responsive to at least one of the plurality of blocks being empty; and storing the first request in a minimal-priority block responsive to the priority of the first request being larger than the smallest block priority, the minimal-priority block associated with the smallest block priority.
This invention relates to a method for managing request storage in a cache memory system, addressing the challenge of efficiently allocating cache space for incoming requests while optimizing priority-based storage. The method involves storing a first request in a cache memory that includes multiple blocks, each associated with a priority level. When at least one block is empty, the first request is stored in an available empty block. If no blocks are empty, the method evaluates the priority of the first request against the smallest block priority in the cache. If the first request's priority is higher than the smallest block priority, it is stored in the block with the lowest priority, effectively replacing the lower-priority request. This approach ensures that higher-priority requests are retained in the cache, improving system performance by prioritizing critical data while efficiently utilizing available memory space. The method dynamically adjusts storage based on request priority, enhancing cache efficiency in systems where request importance varies.
11. The method of claim 10 , further comprising storing data of the minimal-priority block in a memory unit prior to storing the first request in the minimal-priority block.
This invention relates to data processing systems, specifically methods for managing memory storage of data requests. The problem addressed is efficient handling of data requests in systems where memory allocation must prioritize certain operations while ensuring minimal-priority requests are preserved without loss. The invention improves upon prior art by introducing a step where data from a minimal-priority block is temporarily stored in a memory unit before a higher-priority request is allocated to that block. This prevents data loss and ensures minimal-priority operations are not overwritten prematurely. The method involves identifying a minimal-priority block in memory, storing its existing data in a separate memory unit, and then allocating the block to a higher-priority request. The stored data can later be retrieved or processed as needed. This approach is particularly useful in systems where memory resources are constrained, and request prioritization is critical, such as in real-time computing or embedded systems. The invention ensures that lower-priority tasks are not disrupted by higher-priority operations, maintaining system stability and data integrity. The memory unit used for temporary storage may be a dedicated buffer or a segment of available memory, depending on system architecture. The method optimizes memory usage by reallocating blocks efficiently while safeguarding pending operations.
12. A system for reconfigurable caching, the system comprising: a memory having processor-readable instructions stored therein; and a processor configured to access the memory and execute the processor-readable instructions, which, when executed by the processor configures the processor to perform a method, the method comprising: receiving a workload comprising a plurality of requests from a filesystem; classifying a first request of a plurality of requests in a random class; arranging the plurality of requests in a request queue; selecting the first request from the request queue, the first request associated with a first plurality of addresses, each of the first plurality of addresses being an integer number; selecting a second request of the plurality of requests from the request queue, the second request associated with a second plurality of addresses, each of the second plurality of addresses being an integer number; classifying the first request in a strided class responsive to a smallest address of the first plurality of addresses being larger than a largest address of the second plurality of addresses by a gap value, the gap value being smaller than a gap threshold; classifying the first request in a sequential class responsive to the smallest address of the first plurality of addresses being larger than the largest address of the second plurality of addresses by 1; classifying the first request in an overlapped class responsive to a first portion of the first plurality of addresses being the same as a second portion of the second plurality of addresses classifying the workload in a random consumer class responsive to more than 60 percent of the plurality of requests read from a memory unit and more than 70 percent of the plurality of requests classified in the random class; classifying the workload in a sequential producer-consumer class responsive to 40 percent to 60 percent of the plurality of requests read from the memory unit and more than 50 percent of the plurality of requests classified in the sequential class; classifying the workload in a random producer-consumer class responsive to 40 percent to 80 percent of the plurality of requests read from the memory unit and more than 60 percent of the plurality of requests classified in the random class; classifying the workload in an archival consumer class responsive to more than 80 percent of the plurality of requests read from the memory unit and more than 70 percent of the plurality of requests classified in the sequential class; classifying the workload in a large file generator class responsive to more than 90 percent of the plurality of requests written on the memory unit and more than 60 percent of the plurality of requests classified in the sequential class; assigning a priority to the first request based on the classified first request and the classified workload; and storing the first request in a cache memory comprising a plurality of blocks responsive to: the first request not stored in the cache memory; all of the plurality of blocks being valid; and the priority of the first request being larger than a smallest block priority of a plurality of block priorities, each of the plurality of block priorities assigned to a block of the plurality of blocks.
The system is designed for reconfigurable caching to optimize memory access patterns in computing systems. It addresses inefficiencies in traditional caching mechanisms that fail to adapt to varying workload characteristics, leading to suboptimal performance. The system dynamically classifies requests and workloads to improve cache utilization and reduce latency. The system processes a workload comprising multiple requests from a filesystem. Each request is associated with a set of integer addresses. The system classifies individual requests into categories such as random, strided, sequential, or overlapped based on address patterns. For example, a request is classified as strided if its smallest address exceeds the largest address of a preceding request by a gap smaller than a predefined threshold. Similarly, a request is classified as sequential if the smallest address of the first request is exactly one unit larger than the largest address of the preceding request. The system also classifies the entire workload into broader categories like random consumer, sequential producer-consumer, random producer-consumer, archival consumer, or large file generator based on the distribution of read/write operations and the proportion of requests in specific classes. For instance, a workload is classified as random consumer if over 60% of requests are reads and more than 70% are classified as random. Based on these classifications, the system assigns priorities to requests and manages cache storage. If a request is not already in the cache, the system evaluates whether to store it by comparing its priority to the lowest priority block in the cache. If the request's priority is higher, it replaces the lowest-priority block, ensuring that the most relevant data remains in the ca
13. A reconfigurable caching architecture, comprising: a file system; a cache memory comprising a plurality of blocks; a mapping unit configured to: receive a workload comprising a plurality of requests from the file system, the plurality of requests comprising a first request; send the first request to a hard disk drive responsive to the first request tagged uncacheable; and invalidate a block of the plurality of blocks responsive to the first request tagged uncacheable and the first request stored in the block; an analyzing unit coupled to the mapping unit, the analyzing unit configured to classify the first request in a first class; a reconfiguration unit coupled to the analyzing unit, the reconfiguration unit configured to classify the workload in a second class based on the first class; a priority calculation unit coupled to the reconfiguration unit, the priority calculation unit configured to assign a priority to the first request based on the first class and the second class; and a cache managing unit configured to store the first request in the cache memory responsive to: the first request not stored in the cache memory; all of the plurality of blocks being valid; and the priority satisfying a priority condition.
A reconfigurable caching architecture improves data access efficiency in computing systems by dynamically adjusting cache behavior based on workload characteristics. The system addresses inefficiencies in traditional caching mechanisms that fail to adapt to varying access patterns, leading to suboptimal performance and resource utilization. The architecture includes a file system, a cache memory with multiple blocks, and a mapping unit that processes requests from the file system. When a request is tagged as uncacheable, the mapping unit sends it directly to a hard disk drive and invalidates the corresponding cache block if the request is already stored there. An analyzing unit classifies individual requests into a first class based on their attributes, while a reconfiguration unit categorizes the entire workload into a second class using the request classifications. A priority calculation unit then assigns a priority to each request based on both the request and workload classifications. A cache managing unit stores requests in the cache memory only if they are not already cached, all cache blocks are valid, and the request's priority meets a specified condition. This dynamic prioritization ensures that cache resources are allocated efficiently, improving system performance for diverse workloads.
14. The reconfigurable caching architecture of claim 13 , further comprising a queue managing unit configured to arrange the plurality of requests in a request queue, the request queue comprising: the first request associated with a first plurality of addresses, each of the first plurality of addresses being an integer number; and a second request of the plurality of requests associated with a second plurality of addresses, each of the second plurality of addresses being an integer number.
This invention relates to a reconfigurable caching architecture designed to improve data access efficiency in computing systems. The architecture addresses the problem of managing multiple data access requests with varying address patterns, which can lead to inefficiencies in traditional caching systems. The system includes a queue managing unit that organizes incoming requests into a request queue. The queue contains at least two types of requests: a first request associated with a first set of addresses, where each address is an integer value, and a second request associated with a second set of addresses, also consisting of integer values. The queue managing unit ensures that these requests are processed in an orderly manner, optimizing cache performance by handling different address patterns effectively. This approach allows the caching architecture to dynamically adapt to varying workloads, reducing latency and improving overall system efficiency. The system is particularly useful in high-performance computing environments where efficient data access is critical.
15. The reconfigurable caching architecture of claim 14 , wherein the first class comprises: a random class; a strided class responsive to a smallest address of the first plurality of addresses being larger than a largest address of the second plurality of addresses by a gap value, the gap value smaller than a gap threshold; a sequential class responsive to the smallest address of the first plurality of addresses being larger than the largest address of the second plurality of addresses by 1; and an overlapped class responsive to a first portion of the first plurality of addresses being the same as a second portion of the second plurality of addresses.
The invention relates to a reconfigurable caching architecture designed to optimize memory access patterns by dynamically classifying and handling different types of address sequences. The architecture addresses inefficiencies in traditional caching systems that fail to adapt to varying access patterns, leading to suboptimal performance and increased latency. The system categorizes memory access patterns into distinct classes based on address relationships. The random class handles arbitrary, non-sequential accesses. The strided class detects when the smallest address of a new access sequence is larger than the largest address of a previous sequence by a gap value smaller than a predefined threshold, indicating a predictable stride pattern. The sequential class identifies strictly consecutive accesses where the smallest address of the new sequence is exactly one unit larger than the largest address of the previous sequence. The overlapped class manages scenarios where portions of the new and previous address sequences overlap, allowing for efficient reuse of cached data. By dynamically classifying and adapting to these access patterns, the architecture improves cache hit rates, reduces latency, and enhances overall system performance. The reconfigurable nature of the system allows it to adjust to different workloads and memory access behaviors without manual intervention, making it suitable for diverse computing environments.
16. The reconfigurable caching architecture of claim 15 , wherein the second class comprises: a random consumer class responsive to more than 60 percent of the plurality of requests read from a hard disk drive and more than 70 percent of the plurality of requests classified in the random class; a sequential producer-consumer class responsive to 40 percent to 60 percent of the plurality of requests read from the hard disk drive and more than 50 percent of the plurality of requests classified in the sequential class; a random producer-consumer class responsive to 40 percent to 80 percent of the plurality of requests read from the hard disk drive and more than 60 percent of the plurality of requests classified in the random class; an archival consumer class responsive to more than 80 percent of the plurality of requests read from the hard disk drive and more than 70 percent of the plurality of requests classified in the sequential class; and a large file generator class responsive to more than 90 percent of the plurality of requests written on the hard disk drive and more than 60 percent of the plurality of requests classified in the sequential class.
A reconfigurable caching architecture is designed to optimize data storage and retrieval in computing systems by dynamically classifying and managing different types of data access patterns. The architecture categorizes data requests into multiple classes based on their characteristics, such as random or sequential access, read or write operations, and file size. This classification allows the system to allocate cache resources more efficiently, improving performance and reducing latency. The architecture includes a second class of data request types, each with specific thresholds for handling different percentages of requests. The random consumer class processes over 60% of requests read from a hard disk drive and over 70% of requests classified as random. The sequential producer-consumer class handles 40% to 60% of requests read from the hard disk drive and over 50% of requests classified as sequential. The random producer-consumer class manages 40% to 80% of requests read from the hard disk drive and over 60% of requests classified as random. The archival consumer class processes over 80% of requests read from the hard disk drive and over 70% of requests classified as sequential. The large file generator class handles over 90% of requests written to the hard disk drive and over 60% of requests classified as sequential. By dynamically adjusting cache allocation based on these classifications, the system ensures that frequently accessed data is prioritized, reducing the need for repeated disk reads and improving overall system efficiency. This approach is particularly useful in environments with diverse workloads, such as data centers, cloud storage, and enterprise applications.
17. The reconfigurable caching architecture of claim 13 , wherein the priority condition comprises one of: at least one of the plurality of blocks being empty; and the priority of the first request being larger than a smallest block priority of a plurality of block priorities, each of the plurality of block priorities assigned to a block of the plurality of blocks.
A reconfigurable caching architecture is designed to optimize data storage and retrieval in computing systems by dynamically adjusting cache block priorities based on specific conditions. The architecture addresses inefficiencies in traditional caching systems where static priority assignments can lead to suboptimal performance, particularly in scenarios with varying workload demands. The system includes multiple cache blocks, each assigned a priority level to determine their importance in storing data. The architecture evaluates priority conditions to decide whether to reallocate or modify block priorities. One such condition involves checking if at least one of the cache blocks is empty, allowing the system to repurpose unused blocks for higher-priority requests. Another condition compares the priority of an incoming data request against the lowest-priority block in the cache. If the request's priority exceeds this minimum block priority, the system may reassign or replace the lowest-priority block to accommodate the higher-priority request. This dynamic adjustment ensures that critical data is retained while less important data is evicted when necessary, improving overall cache efficiency and performance. The architecture is particularly useful in systems requiring adaptive caching strategies, such as real-time processing or high-performance computing environments.
18. The reconfigurable caching architecture of claim 17 , wherein the cache managing unit is further configured to store data of a minimal-priority block in a hard disk drive prior to storing the first request in the cache memory, the minimal-priority block associated with the smallest block priority.
The invention relates to a reconfigurable caching architecture designed to optimize data storage and retrieval in computing systems. The architecture addresses the challenge of efficiently managing cache memory by dynamically adjusting storage priorities to improve performance and reduce latency. A key component is a cache managing unit that controls data placement and eviction based on priority levels assigned to different data blocks. When the cache memory is full or needs to be reconfigured, the system identifies the data block with the lowest priority (the minimal-priority block) and stores it in a hard disk drive (HDD) before accommodating new data. This ensures that higher-priority data remains accessible in faster cache memory, while lower-priority data is offloaded to slower but higher-capacity storage. The architecture supports dynamic reconfiguration, allowing the cache to adapt to changing workloads and access patterns. By prioritizing data based on usage frequency, importance, or other criteria, the system enhances overall system efficiency and responsiveness. The invention is particularly useful in environments where cache memory is limited and optimal data placement is critical for performance.
19. The reconfigurable caching architecture of claim 13 , wherein the cache memory comprises a solid-state drive.
A reconfigurable caching architecture is designed to enhance data storage and retrieval efficiency in computing systems. The architecture addresses the problem of slow access times and limited flexibility in traditional caching systems, which often rely on volatile memory like DRAM or fixed storage solutions. This invention introduces a dynamic caching system that can adapt to varying workload demands by reconfiguring its cache memory structure. The cache memory in this architecture is implemented using a solid-state drive (SSD), providing non-volatile storage with faster access times compared to traditional hard disk drives (HDDs). The SSD-based cache can be dynamically adjusted in size, allocation, and configuration to optimize performance based on real-time data access patterns. This reconfigurability allows the system to prioritize frequently accessed data, reduce latency, and improve overall system responsiveness. The architecture may also include additional features such as predictive caching, where data likely to be accessed soon is preloaded into the cache, further enhancing efficiency. By leveraging SSD technology, the system achieves a balance between cost, performance, and storage capacity, making it suitable for applications requiring high-speed data access and adaptability.
20. The reconfigurable caching architecture of claim 15 , wherein the priority calculation unit is further configured to assign a priority to the first request by assigning a number to the first request, the number associated with a unique combination of: one of the random class, the strided class, the sequential class, and the overlapped class; one of the random consumer class, the sequential producer-consumer, the random producer-consumer class, the archival consumer class, and the large file generator class; and a request type associated with the first request, the request type comprising a read request and a write request.
This invention relates to a reconfigurable caching architecture designed to optimize data access in computing systems by dynamically prioritizing requests based on their characteristics. The architecture addresses inefficiencies in traditional caching systems that fail to adapt to varying workload patterns, leading to suboptimal performance and resource utilization. The system includes a priority calculation unit that assigns a numerical priority to each data request by analyzing its attributes. The priority is determined by a unique combination of three factors: the request's access pattern class (random, strided, sequential, or overlapped), the request's producer-consumer class (random consumer, sequential producer-consumer, random producer-consumer, archival consumer, or large file generator), and the request type (read or write). This multi-dimensional classification ensures that requests are prioritized based on their impact on system performance, workload balance, and resource contention. By dynamically adjusting priorities, the architecture improves cache efficiency, reduces latency, and enhances throughput for diverse workloads. The system is particularly useful in environments with mixed workloads, where different access patterns and request types compete for cache resources. The priority calculation unit's ability to assign distinct numerical values to each combination of attributes ensures fine-grained control over request scheduling, optimizing overall system performance.
Unknown
November 3, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.