Hardware for optimizing KV storage performance based on configurable logic and implementation method thereof

By using CRC HASH function and chain address method in KV-SSD hardware, the problem of difficulty in adjusting KV-SSD hardware is solved, performance optimization and resource saving are achieved, and the optimal state of read and write performance is ensured.

CN119003306AActive Publication Date: 2024-11-22PENG TI STORAGE TECH (NANJING) CO LTD
View PDF 2 Cites 0 Cited by

Patent Information

Application Number
CN202411214383.2
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2024-08-31
Publication Date
2024-11-22
Estimated Expiration
2044-08-31

AI Technical Summary

Technical Problem

The existing KV-SSD hardware does not support or operates in a complex manner after actual application, resulting in increased HASH conflict rate and decreased read and write performance.

Method used

CRC is used as the HASH function, supporting 17 options, resolving HASH conflicts through the chain address method, and adjusting the HASH function according to actual needs to adjust the number of Entrys of HEAD ZONE, realizing configurable KV storage performance optimization.

Benefits of technology

Reduces dependence on the CPU, improves read and write performance, reduces space waste, ensures controllability of performance, and can adjust the HASH type at any time according to actual applications to ensure optimal performance.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN119003306A_ABST
    Figure CN119003306A_ABST
Patent Text Reader

Abstract

The invention discloses hardware for optimizing KV storage performance based on configurable logic and an implementation method thereof, and the implementation method comprises the following hardware implementation processes: adopting CRC (Cyclic Redundancy Check) as a HASH function, and supporting 17 selections, namely CRC16-CRC32; a chain address method is adopted to solve the HASH conflict problem, and the same chain is arranged from small to large according to the sizes of keys; the number of Entry of the HEAD ZONE is adjusted by adjusting a HASH function; wherein the Keyinfobuf is a unit which comprises a key and a point to a value pointer. The method is a research developed on the basis of a KV-SSD in a new KV storage form, hardware acceleration is achieved through a configurable logic on the basis of HASH implementation, and the read-write performance can be adjusted in real time according to actual application.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] The present invention relates to the technical field of hardware for optimizing storage performance, and in particular to hardware for optimizing KV storage performance based on configurable logic and an implementation method thereof. Background Art

[0002] Currently, two main implementations of KV storage are LSM-tree (Log-Structured Merge-tree), a data structure commonly used in disk storage systems, particularly key-value stores and database management systems, and HASH (Hash Function, a method for creating a small digital "fingerprint" from any data). The HASH-based KV-SSD (Key-Value Store Solid State Drive), a solid-state storage device specifically designed for key-value storage data structures, is a new type of storage device widely used in key-value storage systems.

[0003] In actual storage read and write applications, software implementation will result in high CPU usage; in hardware implementation, the HASH type is pre-set, and adjustment after actual application is not supported or the operation is complicated, resulting in an increased probability of HASH conflicts or a decrease in read and write performance, which brings inconvenience to actual applications. Summary of the Invention

[0004] The purpose of this section is to summarize some aspects of the embodiments of the present invention and briefly introduce some preferred embodiments. Some simplifications or omissions may be made in this section and the abstract and title of this application to avoid obscuring the purpose of this section, the abstract and the title of the invention, and such simplifications or omissions should not be used to limit the scope of the present invention.

[0005] In view of the above-mentioned problems existing in the existing KV-SSD read-write storage hardware implementation, the present invention is proposed.

[0006] Therefore, the technical problem solved by the present invention is to solve the problem that the existing KV-SSD read-write storage hardware does not support adjustment after actual application or the operation is complicated, resulting in an increased probability of HASH conflict or a decrease in read-write performance.

[0007] To solve the above technical problems, the present invention provides the following technical solutions: hardware for optimizing KV storage performance based on configurable logic, including the following hardware implementation process: using CRC as the HASH function and supporting 17 options, namely CRC16~CRC32; using the chain address method to resolve the HASH conflict problem, and arranging the same chain from small to large according to the size of the key; adjusting the number of entries in the HEAD ZONE by adjusting the HASH function; wherein Key_info_buf is a unit containing the key and a pointer to the value.

[0008] As a preferred solution for hardware based on configurable logic to optimize KV storage performance described in the present invention, the HASH type is adjusted at any time to adjust the length of each chain, thereby adjusting the read and write performance at any time.

[0009] To solve the above technical problems, the present invention also provides the following technical solutions: a hardware implementation method for optimizing KV storage performance based on configurable logic, using the above hardware for optimizing KV storage performance based on configurable logic, including the following implementation steps: S1: preliminarily estimate a HASH type based on the total amount and expected performance of the KV of the namespace; S2: select the HASH type; S3: as the actual KV data is filled into the kv_hash_table, compare the performance and space actually calculated at this time with the performance and space estimated in step S1; S4: select a specific CRC type based on the performance and space selection rules, and repeat step S2 until the performance and space are optimized.

[0010] As a preferred solution of the hardware implementation method for optimizing KV storage performance based on configurable logic described in the present invention, when selecting a specific CRC type based on the performance and space selection rules, when the performance and space estimated in step S1 are higher than the performance and space actually calculated in step S3, a CRC type smaller than that in step S1 is selected; when the performance and space estimated in step S1 are lower than the performance and space actually calculated in step S3, a CRC type larger than that in step S1 is selected.

[0011] The beneficial effects of the present invention are as follows: 1. Reduce dependence on the CPU through hardware implementation; 2. Improved read and write performance through hardware acceleration; 3. Multiple optional HASH types reduce space waste according to actual applications; 4. Multiple optional HASH types can ensure controllable performance; 5. Adjust the HASH type at any time according to the actual application background hardware to ensure the best performance. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for describing the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. Those skilled in the art can also derive other drawings based on these drawings without inventive effort. Among them: Figure 1 This is a schematic diagram of the Kv_hash_table provided by the present invention.

[0013] Figure 2 This is a schematic diagram of the old table provided by the present invention.

[0014] Figure 3 The present invention provides Figure 2 Schematic diagram of the new table obtained by the change.

[0015] Figure 4 The present invention provides a schematic diagram of the implementation process. DETAILED DESCRIPTION

[0016] To make the above-mentioned objects, features, and advantages of the present invention more clearly understood, the following detailed description of the specific embodiments of the present invention is given in conjunction with the accompanying drawings. It is obvious that the described embodiments are only part of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by ordinary persons in this field without creative work should fall within the scope of protection of the present invention.

[0017] It's important to note that HASH stands for hash algorithm, also known as a hash algorithm or hash function. A hash algorithm converts input data of arbitrary length into output data of fixed length. In computer science, hash algorithms are widely used in fields such as data encryption, data integrity verification, and data compression.

[0018] The hash algorithm has the following characteristics: 1. The length of input data can be arbitrary, but the length of output data is fixed.

[0019] 2. Different input data will produce different output data through the hash algorithm.

[0020] 3. The hash algorithm is a one-way function, which means that the corresponding output data can be calculated from the input data, but the original input data cannot be deduced from the output data.

[0021] 4. For the same input data, the output data obtained is fixed and is not affected by the environment or computer platform.

[0022] 5. Hash algorithms are efficient, meaning they have fast computation speeds and can process large amounts of data.

[0023] Common hash algorithms include MD5, SHA-1, SHA-256, etc., which are widely used in data encryption, digital signatures, cryptography and other fields.

[0024] It's important to note that KV-SSD (Key-Value Solid State Drive) is a data storage device based on a solid-state drive (SSD). It supports key-value pair storage and offers advantages such as fast read and write speeds, low power consumption, and low cost. It is widely used in data storage, cloud computing, the Internet of Things, and other fields. KV-SSD uses flash storage media, which offers extremely high read and write speeds and durability, providing higher data storage performance and reliability than traditional mechanical hard drives. KV-SSD also uses a distributed architecture to achieve data sharding and load balancing, improving overall system performance and reliability.

[0025] Hash-based KV-SSDs, as a new type of storage device, are widely used in key-value storage systems. In actual storage read and write applications, software implementations result in high CPU usage. Hardware implementations, however, pre-set hash types make post-application adjustments unsupported or complex, increasing the probability of hash conflicts and reducing read and write performance, creating inconvenience in real-world applications.

[0026] Therefore, the present invention provides hardware for optimizing KV storage performance based on configurable logic, including the following hardware implementation process: 1. Use CRC as the HASH function and support 17 options, namely CRC16~CRC32; It's important to note that CRC, short for Cyclic Redundancy Check, is a commonly used error detection code used to detect errors during data transmission. CRC uses a polynomial remainder method to implement verification. The polynomial is XORed with the data block to generate a checksum, which is then modified to produce the final result. The CRC algorithm can be used to detect errors during data transmission to ensure data integrity and reliability. Different CRC algorithms may use different polynomial coefficients, so different CRC algorithms and polynomial coefficients may be used for different application scenarios.

[0027] 2. Separate Chaining is used to solve the HASH conflict problem, and the same chain is arranged in ascending order of key size. Please refer to Figure 1 ; It should be noted that separate chaining is a method for resolving hash conflicts. In a hash table, when multiple keys map to the same hash bucket, these keys are stored as a linked list or other data structure, allowing each hash bucket to hold multiple key-value pairs. When a key-value pair needs to be looked up or inserted, the hash value of the key-value pair is first calculated. The corresponding hash bucket is then found based on the hash value, and the corresponding key-value pair is finally found or inserted into the linked list of that hash bucket. While separate chaining is simpler to implement than other methods for resolving hash conflicts, it may result in wasted space and reduced query efficiency. However, by using a suitable hash function and appropriately sizing the hash table, the length of the linked list can be minimized, thereby improving the performance of separate chaining. Separate chaining is commonly used to implement data structures such as hash tables, hash sets, and hash maps.

[0028] 3. Adjust the number of entries in the HEAD ZONE by adjusting the HASH function; It should be noted that: ①HEAD ZONE: In some database systems, the HEAD ZONE refers to an area of ​​information on a data block or page used to store metadata. This area usually contains a pointer to the actual location of the data and control information for fast access and management.

[0029] In the file system, HEAD ZONE refers to the file header, which contains the file's metadata, such as file size, creation time, modification time, file owner, permission information, etc.

[0030] ②Entry: In databases and data structures, an entry typically refers to an item in a data structure, consisting of a key and its associated value. In a hash table, each entry corresponds to a key-value pair, and a hash function is used to calculate the hash value of the key to quickly locate the address where the entry is stored.

[0031] In a log file or transaction record, an entry refers to an entry in the record, which contains transaction status information, timestamp, operation type, etc.

[0032] It's important to note that different HASH functions determine the number of entries in the HEAD zone. The length of a single chain also determines read and write performance. Longer chains degrade read and write performance. Therefore, adjusting the HASH function can adjust the number of entries in the HEAD zone, indirectly adjusting the statistical average number of entries in each chain and ultimately adjusting read and write performance.

[0033] In this invention, the "HEAD ZONE" is mainly used to distinguish the first Key_info_buf of each chain in the HASH TABLE from the other Key_info_bufs on the chain. It is divided into two areas: the Head Zone and the Rand Zone. That is, the Head Zone refers to the area consisting of the first Key_info_buf of each chain in the HASH TABLE; the Rand Zone refers to the area consisting of the Key_info_bufs excluding the first Key_info_buf of each chain.

[0034] Among them, Key_info_buf is a unit containing key and pointer to value.

[0035] It should be noted that adjusting the number of entries in the HEAD ZONE by adjusting the HASH function means optimizing the hash table structure according to application requirements. Specifically, this can be achieved through the following methods: a: Change the number of bits in the hash function's output: If the number of entries in the HEAD ZONE needs to increase, design a hash function that produces more different hash values. This usually involves changing the number of bits in the hash function's output to create more unique locations in the same size address space.

[0036] b: Adjust the complexity of the hash function: By increasing the computational complexity of the hash function, the possibility of collision is reduced, allowing more entries to be stored in the HEAD ZONE.

[0037] c: Use a dynamic hash table: In some cases, a dynamic hash table can be designed whose size can be adjusted as needed. When the HEAD ZONE is full, the size of the HEAD ZONE can be expanded and all entries can be rehashed to maintain efficient access speed.

[0038] Specifically, the number of entries in the HEAD ZONE is adjusted by adjusting the HASH function: using CRC as the HASH function, the number of entries in the HEAD ZONE corresponding to different CRCs is different, for example, CRC16 corresponds to 2 16 , CRC32 corresponds to 2 32 By configuring the register, you can select which CRC to use, thereby adjusting the number of entries in the HEAD ZONE. Existing chip technologies select a specific HASH function or use multiple HASHes to avoid HASH conflicts. This invention uses a chain address method to resolve HASH conflicts, and can adjust the number of HEAD ZONE entries using 17 configurable HASH functions.

[0039] Furthermore, to indirectly adjust the statistical average number of each chain and ultimately achieve the goal of adjusting read and write performance, this is achieved using hardware (called a REHASH operation). Through CPU configuration, the old HASH table is given, and then the HASH function type to be used for the new HASH table and the location to be created are specified. The hardware then reads the old HASH table and writes the new HASH table. After all the old data has been read and the new data has been written, a completion signal is sent to the CPU.

[0040] Specifically, the present invention can adjust the HASH type at any time according to actual conditions, thereby adjusting the length of each chain, and ultimately achieving the purpose of adjusting the read and write performance at any time. Figure 2 and Figure 3 As shown, an old HASH table is changed to a new HASH table to achieve the read / write performance and space size that meet your needs.

[0041] It should be noted that the HASH type can be adjusted at any time according to the actual situation. For example, before creating the old HASH Table, the estimated total data volume is 8x2 24 The selected HASH function is CRC24. That is, HEAD ZONE has 2 24 Entry, that is, there are 2 24 chains, then according to the statistical distribution, each chain has an average of 8, and the selected HASH function is CRC25, which becomes 4x2 while the total number remains unchanged. 25 , i.e. a total of 2 25 There are 4 chains in each chain. In this way, the length of each chain can be adjusted by adjusting the HASH type.

[0042] It's important to note that when changing from an old hash table to a new one, the change is the aforementioned REHASH operation. This change is intended to improve read and write performance, shortening the single chain and improving read and write performance. Another goal is to avoid wasting resources. For example, if the initial estimated data size is too large, a large CRC is selected, resulting in a large number of HEADZONGs, some of which may go unused and result in wasted resources.

[0043] For further information, see Figure 4 The present invention also provides a hardware implementation method for optimizing KV storage performance based on configurable logic, which uses the hardware for optimizing KV storage performance based on configurable logic, including the following implementation steps: S1: Preliminarily estimate a hash type based on the total number of KVs in the namespace and expected performance; It should be noted that in computer programming, "namespace" is a mechanism for avoiding naming conflicts and organizing code. Namespace is a way to group related classes, functions, variables, etc. together to make the code more readable, maintainable, and easy to extend.

[0044] By using namespaces, you can assign different namespaces to different parts of your code, ensuring that naming conflicts do not occur. This prevents conflicts even if the same name exists in different libraries or modules. Namespaces allow developers to better manage and organize their code and facilitate code reuse.

[0045] The syntax and usage of namespaces may vary between different programming languages. For example, in C++, the keyword "namespace" is used to define a namespace, and the scope operator "::" is used to access members within the namespace. In C#, the keyword "namespace" is also used to define a namespace, and "." is used to access members within the namespace.

[0046] Using namespaces can improve the modularity and maintainability of code, making the development of large projects more efficient and organized. It is an important organizational and management tool in programming.

[0047] It should be noted that during the estimation process, the length of a chain can be calculated based on the size of the key_info_buf set by the user, the time required to access a key_info_buf, the time required for HASH operations and the module for comparing KEY sizes, and the desired performance. Then, based on the total amount of data, the number of chains can be calculated, thereby completing the HASH type estimation.

[0048] S2: Select HASH type; S3: As actual KV data is added to the kv_hash_table, the calculated performance and space are compared with the performance and space estimated in step S1 to assess whether the performance or space is optimal. Specifically, the performance meets the requirements and any space is wasted. It's important to note that kv_hash_table is a common data structure, a key-value storage mechanism often used to implement hash tables. In programming, a hash table is an array that uses a hash function to index data and is used to store key-value pairs. Each key is converted into a number (hash value) through a hash function. This number is used to index a location in the array, allowing quick access to the value stored at that location.

[0049] The main features of kv_hash_table include: a. Key-value pair storage: Each element is a key-value pair, where the key is used to uniquely identify a value.

[0050] b. Hash function: used to convert a key into a hash value, which is used to determine the storage location in the array.

[0051] c. Array: A hash table is usually implemented as an array, where each slot in the array corresponds to a possible hash value.

[0052] d. Conflict Resolution: When two keys produce the same hash value, it is called a conflict. Conflict resolution strategies include the chain address method (using a linked list to store key-value pairs with the same hash value) and the open address method (searching for an empty slot to store the key-value pair).

[0053] e. Dynamic expansion: To maintain efficient performance, the hash table may dynamically expand as the number of elements increases, that is, increase the size of the array.

[0054] f. Iteration: kv_hash_table usually provides an iterator to traverse all key-value pairs.

[0055] Different programming languages ​​and libraries may use different implementations and APIs for kv_hash_table or similar structures. For example, in C++, you can use std::unordered_map or std::map, both of which are key-value pair containers implemented based on hash tables. In Python, the dict type is a hash table for storing key-value pairs.

[0056] The benefit of using kv_hash_table is the ability to quickly find, insert, and delete key-value pairs, especially when processing large amounts of data, it provides relatively high data storage and retrieval efficiency.

[0057] It's important to note that when considering performance alone, the greater the performance, the better; when considering space alone, the smaller the space, the better. However, performance and space are mutually exclusive: greater performance inevitably results in greater space consumption, and smaller space also results in reduced performance. Therefore, choosing the optimal strategy is to minimize space while still meeting your performance requirements.

[0058] Further explanation of the optimal strategy: 1. The performance evaluation standard is the read and write speed, i.e., QPS (query per second), which is measured by the time it takes to read and write a key_info_buf. The unit is the time unit.

[0059] 2. The space evaluation standard is the size of the space occupied by the data, that is, the data size in KB / GB / TB, etc.

[0060] 3. Step S1 estimates performance and space requirements. However, when the application reaches step S3, the actual performance and space requirements are calculated. Comparing these with the estimates in step S1 reveals whether there is any space or performance waste.

[0061] For example, in step S1, the estimated performance is 10us to read a key_info_buf with a 100MB storage space. However, in step S3, the actual calculated performance is 5us to read a key_info_buf, and the total amount of stored data is only 80MB. For the user, 10us and 80MB are sufficient, so 5us is somewhat wasted. The CRC can be adjusted to make a single chain longer and the total number of chains smaller, reducing the performance to 10us. Since the KI_BUF of the HEAD_ZONE is a continuous address, reducing the number of chains also saves space in the HEAD_ZONE. Since the total data size is known in step S3, the required space for the RAND_ZONE can be calculated, thus reducing the original 100MB to 80MB.

[0062] S4: Select a specific CRC type based on the performance and space selection rules, and repeat step S2 until the performance and space are optimized. If the performance is sufficient, use a smaller CRC type to save resources. If the performance is too low and needs to be improved, choose a larger CRC type, and finally select a solution with the best performance and resources.

[0063] Specifically, when selecting a specific CRC type based on the performance and space selection rules, when the performance is too high, a smaller CRC type is selected, and when the performance is too low, a larger CRC type is selected. That is, when the performance and space estimated in step S1 are higher than the performance and space actually calculated in step S3, a smaller CRC type is selected compared to step S1; when the performance and space estimated in step S1 are lower than the performance and space actually calculated in step S3, a larger CRC type is selected compared to step S1.

[0064] It's important to note that the criteria for selecting a CRC type are typically based on system performance requirements and data length. "Too high performance" and "too low performance" here refer to the system's requirements for data transmission speed and error detection capabilities. "Small" and "Large" CRC types refer to the number of CRC bits.

[0065] Smaller CRC types: These typically refer to CRC types with fewer bits, such as CRC-12 and CRC-24. These CRC types have the advantage of fast calculation speed and are suitable for high-speed data transmission. However, they can detect fewer error types and may not be able to detect some complex error patterns.

[0066] Larger CRC types, such as CRC-32, have more bits and can detect more error types, including complex error patterns. These CRC types provide stronger error detection capabilities, but are slower to calculate, potentially affecting data throughput.

[0067] The specific judgment criteria are as follows: a. Overperformance: When the system's data transmission speed is much faster than the user's target data transmission speed, you can choose a CRC type with fewer bits. This is because fewer bits means fewer entries in the Headzone, that is, fewer chains in the hashtable. In this case, you can adjust the size of the data space.

[0068] b. Performance is too low: When the system's data transmission speed is much lower than the user's target data transmission speed, a CRC type with more bits can be selected. This is because more bits means more Headzone entries, that is, more hashtable chains. In this way, while the total amount of data remains unchanged, the number of key_info_bufs in a single chain decreases, which can improve performance.

[0069] c. Small CRC type: This is typically used in scenarios where data transfer rates are not very high but storage space is very high (for example, only relatively fragmented and discontinuous space is available). Because a small CRC type has fewer chains and more entries per chain, there are fewer headzones and more randzones. The headzone entries require relatively contiguous storage space, while the randzone key_info_buf can require any discontinuous address space.

[0070] d. Larger CRC type: This is typically used in scenarios where high data transmission rates are required but storage space is not (i.e., both continuous and discontinuous storage can be provided). Because a larger CRC type, with more chains and a smaller number of chains, can meet the requirements of a higher transmission rate.

[0071] It is suitable for scenarios with extremely high requirements for data integrity, such as large storage systems and mission-critical control systems.

[0072] The present invention is based on a configurable HASH algorithm, which optimizes performance and resources from a hardware perspective. In practical applications, the strategy can be adjusted at any time based on actual needs, avoiding resource waste or performance degradation caused by pre-application estimation errors or subsequent development changes.

[0073] The present invention is based on the research of a new KV storage form, KV-SSD. Based on the implementation of HASH, hardware acceleration is achieved through a configurable logic, and the read and write performance can be adjusted in real time according to the actual application.

[0074] In actual operation, for example, in a read operation, the CPU only needs to send a read command and KEY to the hardware module, and the hardware can autonomously perform a HASH operation, find the corresponding HEAD ZONE based on the result of the HASH operation, and implement the hardware reading the key_info_buf on the chain and performing a comparison. If a match or mismatch is found, it will be fed back to the CPU, thus avoiding the CPU from performing a HASH operation, and sequentially reading the key_info_buf and comparison operations on the chain, freeing up the CPU.

[0075] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit the present invention. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention may be modified or replaced by equivalents without departing from the spirit and scope of the technical solutions of the present invention, which should all be included in the scope of the claims of the present invention.

Claims

1. Hardware based on configurable logic to optimize KV storage performance, characterized by: The hardware implementation process includes the following: Use CRC as the HASH function and support 17 options, namely CRC16~CRC32; The chain address method is used to solve the HASH conflict problem, and the same chain is arranged from small to large according to the size of the key; Adjust the number of entries in the HEAD ZONE by adjusting the HASH function; Among them, Key_info_buf is a unit containing key and pointer to value.

2. The hardware for optimizing KV storage performance based on configurable logic according to claim 1, characterized in that: Adjust the HASH type at any time to adjust the length of each chain, thereby adjusting the read and write performance at any time.

3. A hardware implementation method for optimizing KV storage performance based on configurable logic, characterized in that: The hardware for optimizing KV storage performance based on configurable logic as described in any one of claims 1 or 2 includes the following implementation steps: S1: Preliminarily estimate a HASH type based on the total amount of KV in the namespace and the expected performance; S2: Select HASH type; S3: As the actual KV data is filled into kv_hash_table, the performance and space actually calculated at this time are compared with the performance and space estimated in step S1; S4: Select a specific CRC type based on the selection rules of performance and space, and repeat step S2 until the performance and space are optimized.

4. The hardware implementation method for optimizing KV storage performance based on configurable logic according to claim 3 is characterized in that: When selecting a specific CRC type based on the performance and space selection rules, when the performance and space estimated in step S1 are higher than the performance and space actually calculated in step S3, select a CRC type smaller than step S1; when the performance and space estimated in step S1 are lower than the performance and space actually calculated in step S3, select a CRC type larger than step S1.

Citation Information

Patent Citations

  • KV pair rapid write architecture based on hash calculation

    CN116483739A

  • Data processing method and device, computer program product, equipment and storage medium

    CN118519964A