Patent Description:
In the field of computer storage, a system may include a host and one or more storage devices connected to (e.g., communicably coupled to) the host. Such computer storage systems have become increasingly popular, in part, for allowing many different users to share the computing resources of the system. Storage requirements have increased over time as the number of users of such systems and the number and complexity of applications running on such systems have increased.

Accordingly, there may be a need for methods, systems, and devices that are suitable for improving the use of storage devices in storage systems.

The present background section is intended to provide context only, and the disclosure of any embodiment or concept in this section does not constitute an admission that said embodiment or concept is prior art.

<CIT> discloses data layout optimization on processing in memory architecture for executing a neural network model.

<NPL>, relates to Processing-in-Memory for Energy-Efficient Neural Network Training.

<CIT> discloses a dual-mode computer framework supporting in-memory computation.

Aspects of some embodiments of the present disclosure relate to computer storage systems, and provide improvements to computational storage.

According to some embodiments of the present disclosure, there is provided a method for performing computations near memory, the method including receiving, at a storage device, first data associated with a first data set, the first data having a first format, receiving, at a processor core of the storage device, a request to perform a function on the first data, the function including a first operation and a second operation, performing, by a first processor-core acceleration engine of the storage device, the first operation on the first data, based on first processor-core custom instructions, to generate first result data, and performing, by a first extra-processor-core circuit of the storage device, the second operation on the first result data, based on the first processor-core custom instructions.

The storage device may be configured to receive the request to perform the function via a communication protocol.

The first data may include first page data corresponding to a first database page, the first operation may include a decoding operation for determining the first format based on the first page data or a page rule-checking operation, the first result data may include column data extracted, by the first processor-core acceleration engine, from the first page data, and the first extra-processor-core circuit may include a scan engine.

The storage device may include a scheduler, the first extra-processor-core circuit may include a first scan engine associated with a pool of scan engines, the pool of scan engines further including a second scan engine, the first result data may include column data corresponding to the first data, and the scheduler may cause the first scan engine to perform the second operation on a first portion of a column associated with the column data, and the second scan engine to perform the second operation on a second portion of the column.

The method may further include receiving, at the storage device, second data associated with a second data set, the second data having a second format, receiving a request to perform the function on the second data, and performing, by a second processor-core acceleration engine, the first operation on the second data, based on at least one second processor-core custom instruction, to generate second result data.

The method may further include performing, by the first extra-processor-core circuit of the storage device, the second operation on the second result data, based on the second processor-core custom instruction.

The request may be received via an application programming interface (API) of the storage device, the first operation may include at least one of a parsing operation or a decoding operation, and the second operation may include a scan operation.

According to one or more other embodiments of the present disclosure, there is provided a system for performing computations near memory, the system including a processor core storing first processor-core custom instructions and including a first processor-core acceleration engine, and a first extra-processor-core circuit communicatively coupled to the processor core, wherein the processor core is configured to receive first data associated with a first data set, the first data having a first format, receive a request to perform a function on the first data, the function including a first operation and a second operation, cause the first processor-core acceleration engine to perform the first operation on the first data, based on the first processor-core custom instructions, to generate first result data, and cause the first extra-processor-core circuit to perform the second operation on the first result data, based on the first processor-core custom instructions.

The processor core may be configured to receive the request to perform the function via a communication protocol.

The first data includes first page data corresponding to a first database page, the first operation includes a decoding operation for determining the first format based on the first page data or a page rule-checking operation, the first result data includes column data extracted, by the first processor-core acceleration engine, from the first page data, and the first extra-processor-core circuit includes a scan engine.

The system may further include a scheduler coupled to the processor core, the first extra-processor-core circuit may include a first scan engine associated with a pool of scan engines, the pool of scan engines further including a second scan engine, the first result data may include column data corresponding to the first data, and the scheduler may cause the first scan engine to perform the second operation on a first portion of a column associated with the column data, and the second scan engine to perform the second operation on a second portion of the column.

The processor core may be configured to receive second data associated with a second data set, the second data having a second format, receive a request to perform the function on the second data, and cause a second processor-core acceleration engine to perform the first operation on the second data, based on at least one second processor-core custom instruction, to generate second result data.

The processor core may be configured to cause the first extra-processor-core circuit to perform the second operation on the second result data, based on the second processor-core custom instruction.

The request may be received via an application programming interface (API) coupled to the processor core, the first operation may include at least one of a parsing operation or a decoding operation, and the second operation may include a scan operation.

According to one or more other embodiments of the present disclosure, there is provided a storage device for performing computations near memory, the storage device including a processor core storing first processor-core custom instructions and including a first processor-core acceleration engine, and a first extra-processor-core circuit communicatively coupled to the processor core, wherein the storage device is configured to receive first data associated with a first data set, the first data having a first format, receive a request to perform a function on the first data, the function including a first operation and a second operation, and cause the first processor-core acceleration engine to perform the first operation on the first data, based on the first processor-core custom instructions, to generate first result data, and cause the first extra-processor-core circuit to perform the second operation on the first result data, based on the first processor-core custom instructions.

The storage device may further include a scheduler coupled to the processor core, the first extra-processor-core circuit may include a first scan engine associated with a pool of scan engines, the pool of scan engines including a second scan engine, the first result data may include column data corresponding to the first data, and the scheduler may cause the first scan engine to perform the second operation on a first portion of a column associated with the column data, and the second scan engine to perform the second operation on a second portion of the column.

The storage device may be configured to receive second data associated with a second data set, the second data having a second format, receive a request to perform the function on the second data, and cause a second processor-core acceleration engine to perform the first operation on the second data, based on at least one second processor-core custom instruction, to generate second result data.

Non-limiting and non-exhaustive embodiments of the present disclosure are described with reference to the following figures, wherein like reference numerals refer to like parts throughout the various views unless otherwise specified.

Corresponding reference characters indicate corresponding components throughout the several views of the drawings. Skilled artisans will appreciate that elements in the figures are illustrated for simplicity and clarity, and have not necessarily been drawn to scale. For example, the dimensions of some of the elements, layers, and regions in the figures may be exaggerated relative to other elements, layers, and regions to help to improve clarity and understanding of various embodiments. Also, common but well-understood elements and parts not related to the description of the embodiments might not be shown to facilitate a less obstructed view of these various embodiments and to make the description clear.

Aspects of the present disclosure and methods of accomplishing the same may be understood more readily by reference to the detailed description of some embodiments and the accompanying drawings. Hereinafter, embodiments will be described in more detail with reference to the accompanying drawings. The described embodiments, however, may be embodied in various different forms, and should not be construed as being limited to only the illustrated embodiments herein. Rather, these embodiments are provided as examples so that this disclosure will be thorough and complete, and will fully convey aspects of the present disclosure to those skilled in the art. Accordingly, description of processes, elements, and techniques that are not necessary to those having ordinary skill in the art for a complete understanding of the aspects and features of the present disclosure may be omitted.

Unless otherwise noted, like reference numerals, characters, or combinations thereof denote like elements throughout the attached drawings and the written description, and thus, descriptions thereof will not be repeated. Further, parts not related to the description of the embodiments might not be shown to make the description clear.

In the detailed description, for the purposes of explanation, numerous specific details are set forth to provide a thorough understanding of various embodiments. It is apparent, however, that various embodiments may be practiced without these specific details or with one or more equivalent arrangements.

It will be understood that, although the terms "zeroth," "first," "second," "third," etc., may be used herein to describe various elements, components, regions, layers and/or sections, these elements, components, regions, layers and/or sections should not be limited by these terms.

It will be understood that when an element or component is referred to as being "on," "connected to," or "coupled to" another element or component, it can be directly on, connected to, or coupled to the other element or component, or one or more intervening elements or components may be present. However, "directly connected/directly coupled" refers to one component directly connecting or coupling another component without an intermediate component. Meanwhile, other expressions describing relationships between components such as "between," "immediately between" or "adjacent to" and "directly adjacent to" may be construed similarly. In addition, it will also be understood that when an element or component is referred to as being "between" two elements or components, it can be the only element or component between the two elements or components, or one or more intervening elements or components may also be present.

It will be further understood that the terms "comprises," "comprising," "have," "having," "includes," and "including," when used in this specification, specify the presence of the stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. As used herein, each of the terms "or" and "and/or" includes any and all combinations of one or more of the associated listed items.

For the purposes of this disclosure, expressions such as "at least one of," when preceding a list of elements, modify the entire list of elements and do not modify the individual elements of the list. For example, "at least one of X, Y, and Z" and "at least one selected from the group consisting of X, Y, and Z" may be construed as X only, Y only, Z only, or any combination of two or more of X, Y, and Z, such as, for instance, XYZ, XYY, YZ, and ZZ.

Any of the components or any combination of the components described (e.g., in any system diagrams included herein) may be used to perform one or more of the operations of any flow chart included herein. Further, (i) the operations are merely examples, and may involve various additional operations not explicitly covered, and (ii) the temporal order of the operations may be varied.

The electronic or electric devices and/or any other relevant devices or components according to embodiments of the present disclosure described herein may be implemented utilizing any suitable hardware, firmware (e.g. an application-specific integrated circuit), software, or a combination of software, firmware, and hardware. For example, the various components of these devices may be formed on one integrated circuit (IC) chip or on separate IC chips. Further, the various components of these devices may be implemented on a flexible printed circuit film, a tape carrier package (TCP), a printed circuit board (PCB), or formed on one substrate.

Further, the various components of these devices may be a process or thread, running on one or more processors, in one or more computing devices, executing computer program instructions and interacting with other system components for performing the various functionalities described herein. The computer program instructions are stored in a memory which may be implemented in a computing device using a standard memory device, such as, for example, a random access memory (RAM). The computer program instructions may also be stored in other non-transitory computer readable media such as, for example, a CD-ROM, flash drive, or the like. Also, a person of skill in the art should recognize that the functionality of various computing devices may be combined or integrated into a single computing device, or the functionality of a particular computing device may be distributed across one or more other computing devices without departing from the of the embodiments of the present disclosure.

Unless otherwise defined, all terms (including technical and scientific terms) used herein have the same meaning as commonly understood by one of ordinary skill in the art to which the present inventive concept belongs.

As mentioned above, in the field of computer storage, a system may include a host and one or more storage devices communicably coupled to the host. The storage devices may be configured to perform functions for applications running on the host. For example, the storage devices may be computational storage devices. As used herein, a "computational storage device" is a storage device that includes a processing circuit, in addition to a storage device controller, for performing functions near memory. The processing circuit may include (e.g., may be) a hardware logic circuit (e.g., an application specific integrated circuit (ASIC) or a field programable gate array (FPGA)). The processing circuit may be configured to perform a function for the applications running on the host. For example, the system may be configured to enable the applications to select a storage-device method for performing a function, instead of a host-processor method for performing the function. For example, the storage-device method may be more efficient at performing the function than the host-processor method (or a general-purpose embedded processor method) due to the hardware logic circuits of the storage device, which can process data faster than the software logic of the host processor. For example, host-processors and general-purpose embedded processors may not be optimal for throughput and power consumption.

However, in some cases, hardware logic circuits may not be sufficiently flexible to process different formats and different functions. For example, storage devices have limited sizes, which can accommodate a limited number of different hardware logic circuits. Furthermore, hardware may not be as easily modified as software. Thus, a given storage device may not be capable of performing a sufficient variety of functions or may not be capable of performing functions on a sufficient variety of data formats.

Aspects of some embodiments of the present disclosure provide for a storage device utilizing a combination of software instructions and hardware acceleration engines near memory to accelerate the performance of functions at the storage device while offering more flexibility than methods utilizing only hardware logic circuits to perform functions at the storage device. Aspects of some embodiments of the present disclosure offer improvements and advantages over performing functions with a general-purpose host processor or with only general-purpose embedded processors, such as faster processing that consumes less power and lower latency. Aspects of some embodiments of the present disclosure also offer improvements and advantages over performing functions with only function-specific hardware in a computational storage device, such flexibility to perform a greater variety of functions on a greater variety of data formats.

<FIG> is a system diagram depicting an architecture for processing formatted data in computational storage, according to some embodiments of the present disclosure.

Referring to <FIG>, a system <NUM> for processing formatted data may include a host <NUM> and a storage device <NUM> (e.g., a computational storage device). The host <NUM> may include a host processor <NUM> (e.g., a central processing unit (CPU) and/or a graphics processing unit (GPU)). The host <NUM> and the storage device <NUM> may be associated with a system memory <NUM>. For example, the system memory <NUM> may include data stored in the system <NUM> on behalf of users (e.g., end users and/or service providers) of the system <NUM>. In some embodiments, host <NUM> may be external to the storage device <NUM> (e.g., the storage device <NUM> may be remote from the host <NUM>). For example, the storage device <NUM> may be a networked device communicably coupled to the host <NUM> via a communications link that is compatible with one or more of the following protocols: Representational State Transfer (REST)/inter-process communication (IPC)/Remote Procedure Call (RPC) over non-volatile memory express (NVMe)/NVMe over Fabrics (NVMe-oF)/Compute Express Link (CXL)/Peripheral Component Interconnect Express (PCIe)/Remote Direct Memory Access (RDMA)/Transmission Control Protocol (TCP)/Internet Protocol (IP), etc..

In some embodiments, the system memory <NUM> may include formatted data. For example, the system <NUM> may provide database page processing for a variety of different data page formats. Database page processing is a function used for database scan acceleration in computational storage. A "database page," as used herein, is a data structure including fields associated with types of data in a data set.

Conventional database-search acceleration hardware in computational storage only supports particular database formats because the page processing is implemented in hardware (e.g., ASIC, FPGA, and/or the like). Accordingly, such conventional databases may not be sufficiently flexible to handle requests from a variety of users. Also, such conventional databases may not be sufficiently adaptable. For example, if a page format is changed in the future by a database version update, hardware-based page processing may not support the new page format. Changing the hardware to work with the new page format may be a costly process. As discussed above, in some embodiments of the present disclosure, database page processing may be implemented in the system <NUM> to provide flexibility and adaptability for performing database scan acceleration functions.

The formatted data includes a database page <NUM>. The system <NUM> performs database page processing with respect to a first database page 10a. The first database page 10a is associated with a first data set and may have a first format FM1. The first data set may be data stored on behalf of a particular user. The system <NUM> may also be capable of performing database page processing with respect to a second database page 10b, in addition to the first database page 10a. The second database page 10b may be associated with a second data set and may have a second format FM2. The second data set may be data stored on behalf of another particular user. The first format FM1 and the second format FM2 may be different formats. For example, the first database page 10a may have first database page columns 14a and first database page rows 12a (e.g., first tuples). The second database page 10b may have second database page columns 14b and second database page rows 12b (e.g., second tuples). As can be seen in <FIG>, the rows and columns of the first database page 10a and the second database page 10b may have different formats. The system <NUM> may perform an operation (e.g., a decode operation) on page data PD corresponding to the first database page 10a and/or the second database page 10b to identify relevant data (e.g., relevant data requested by a user).

In some embodiments, the storage device <NUM> may include a processor core <NUM>. The processor core <NUM> may be coupled to an application programming interface (API) <NUM>. The processor core <NUM> may be coupled to a page buffer <NUM>. Although the API <NUM> and the page buffer <NUM> are depicted as being within the processor core <NUM>, it should be understood that the API <NUM> and/or the page buffer <NUM> may be external to the processor core <NUM>. The processor core <NUM> may receive a request (e.g., a command or instructions) to perform a function FN from the host <NUM>. The processor core <NUM> may receive the instructions to perform the function FN by way of the API <NUM>. The processor core <NUM> may receive the page data PD by way of a page buffer <NUM>.

The processor core <NUM> may include (e.g., may store) a processor-core custom-instruction set <NUM>. The processor-core custom-instruction set <NUM> may include one or more processor-core custom instructions. For example, the processor-core custom-instruction set <NUM> may include one or more processor-core custom instructions CI (individually depicted as CI1-CIn (where n is a positive integer). In some embodiments, the processor-core custom instructions CI may be run on a general-purpose-processor portion of the processor core <NUM>. For example, the processor core <NUM> may have an architecture including a general-purpose embedded processor, such as an Advanced Reduced Instruction Set Computing (RISC) Machine (ARM) architecture, a RISC-V architecture, or a Tensilica architecture. The processor core <NUM> may include one or more processor-core acceleration engines <NUM> (individually depicted as 240a-240n). The processor-core acceleration engines <NUM> may be hardware circuits (e.g., portions of a hardware circuit) used to implement the processor-core custom instructions CI. For example, first processor-core custom instructions CI1 may cause a first processor-core acceleration engine 240a to perform one or more operations associated with the function FN. Second processor-core custom instructions CI2 may cause a second processor-core acceleration engine 240b to perform one or more operations associated with the function FN. In some embodiments, the processor-core acceleration engines <NUM> may be utilized by the storage device <NUM> to perform generalized (e.g., general) acceleration operations. For example, the generalized acceleration operations performed by the processor-core acceleration engines <NUM> may be operations that are common to a variety of functions (e.g., compare operations, addition operations, subtract operations, multiplication operations, decoding operations, parsing operations, graph-traversing operations, linked-list operations, parallel-comparison operations, and/or the like). The generalized acceleration operations may each have a decode stage, an execute stage, and a writeback stage. For example, at a decode stage of a compare operation, the processor-core custom instructions CI and/or one or more processor-core acceleration engines <NUM> may decode an instruction to determine that the operation is a compare operation. At the execute stage, one or more processor-core acceleration engines <NUM> may perform the compare operation. At the writeback stage, one or more processor-core acceleration engines <NUM> may generate result data for further processing by another component of the storage device <NUM>. In the case of database page processing, a processor-core acceleration engine returns column data <NUM> as result data for further processing.

As used herein, "custom instructions" refer to software instructions stored on the storage device <NUM>, which are specific to the storage device <NUM> and cause the hardware logic circuits (e.g., the acceleration engines) of the storage device <NUM> to perform operations associated with requested functions.

<FIG> is a diagram depicting predefined instructions associated with an example function. <FIG> is a diagram depicting custom instructions associated with the example function, according to some embodiments of the present disclosure.

Referring to <FIG>, the host processor <NUM> could be utilized to perform the function FN based on predefined instructions. For example, the function FN could include a comparison operation to compare item A (e.g., the last name "Kim") with one hundred results from column B (e.g., a column listing the last names of all employees of a company). Using predefined (e.g., basic) instructions common to general-purpose processors, the host processor <NUM> could perform one hundred predefined compare operations OP (e.g., CMP1-CMP100) one at a time.

Referring to <FIG>, a processor-core acceleration engine <NUM> of the storage device <NUM> could be utilized to perform the function FN based on custom instructions CI. For example, the processor-core acceleration engine <NUM> could be implemented to process all one hundred operations substantially at once, based on a single custom instruction CI operation OP (e.g., a comparison custom instruction CI_CMP). Accordingly, the custom instructions CI may be utilized to direct the processing of functions within the storage device <NUM> such that functions may be performed more efficiently than with a general-purpose processor, such as a CPU or GPU. Furthermore, multiple custom instructions CI may be stored on the storage device <NUM> (e.g., at a general-purpose processing portion of the processing core <NUM>) to allow flexibility in causing different acceleration engines within the storage device <NUM> to handle different operations corresponding to different functions and different data formats.

Referring back to <FIG>, the storage device <NUM> may include a pool of scan engines <NUM>. The pool of scan engines <NUM> may include one or more scan engines. For example, the pool of scan engines <NUM> may include a first scan engine 220a and a second scan engine (e.g., an n-th scan engine 220n). The scan engines may perform further processing operations on the result data generated by the processor-core acceleration engines <NUM>. For example, the first scan engine 220a may perform a scan operation on a portion of the page data PD corresponding to a first column, and an n-th scan engine 220n may perform a scan operation on a portion of the page data PD corresponding to an n-th column. The scan engines may be external to the processor core <NUM> and may be referred to as extra-processor-core circuits. In some embodiments, the extra-processor-core circuits may be hardware logic circuits that are utilized to perform more complex and/or heavy algorithms (e.g., function-specific accelerations) than the processor-core acceleration engines <NUM>. It should be understood that, in some embodiments, some hardware logic circuits that are utilized to perform function-specific accelerations may be included within the processor core <NUM>. For example, it should be understood that, in some embodiments, the circuits described as extra-processor-core circuits herein may not be limited to being located outside of the processor core <NUM>.

Conventionally, each scan engine is assigned to only one column or to no columns of a database page. In some cases, less than all scan engines are utilized for some scan operations. For example, some scan engines may be in an idle state during a scan operation if there are fewer columns than scan engines. In some cases, scan engines may not be capable of handling a column having an index greater than the number of scan engines.

To resolve such problems, in some embodiments of the present disclosure, the storage device <NUM> may include a scheduler <NUM> to assign any scan engine 220a-n to any column.

<FIG> is a diagram depicting a scheduling of scan engines, according to some embodiments of the present disclosure.

Referring to <FIG>, the scheduler <NUM> may be utilized with the pool of scan engines <NUM>, including scan engines 220a-f, to improve the efficiency of database page processing. In some embodiments, the scheduler <NUM> may assign any scan engine 220a-f to any column associated with a database page <NUM>, based on a rule for computational efficiency <NUM>. For example, instead of using only one scan engine per column, the scheduler <NUM> may assign the first scan engine 220a to perform a scan operation on data corresponding to a portion A of a first column 14a1 and may assign another scan engine (e.g. a third scan engine 220c) to perform a scan operation on data corresponding to a portion C of the first column 14a1. Similarly, the scheduler <NUM> may assign a second scan engine 220b to perform a scan operation on data corresponding to a portion B of a second column 14a2 and may assign another scan engine (e.g., a fourth scan engine 220d) to perform a scan operation on data corresponding to a portion D of the second column 14a2.

Referring back to <FIG>, in some embodiments, the storage device <NUM> may include a local memory <NUM>. The local memory <NUM> may be used to store page data PD (e.g., PDa-n) corresponding to different formats for processing later. The local memory <NUM> may include a non-volatile memory.

Accordingly, database page processing, according to some embodiments of the present disclosure, may include one or more of the following operations. The host <NUM> may send a request (e.g., a command or instructions) to the storage device <NUM> to perform the function FN on page data PD associated with the first database page 10a having the first format FM1. The function FN may be a scan function. The scan function may include multiple operations (e.g., the scan function may be performed by way of multiple smaller operations). For example, the scan function may include a decode operation and a compare operation.

The storage device <NUM> may receive the request to perform the function FN at the processor core <NUM> by way of the API <NUM>. The storage device <NUM> may receive the page data PD associated with the first database page 10a at the page buffer <NUM>. The storage device <NUM> may use the processor-core custom-instruction set <NUM> to direct the performance of the decode operation and the compare operation to different processing circuits within the storage device <NUM>. For example, the first processor-core custom instructions CI1 may cause the first processor-core acceleration engine 240a to perform the decode operation for determining the first format FM1 from the page data PD corresponding to the first database page 10a. The first processor-core acceleration engine 240a may generate result data based on the first processor-core custom instructions CI1. For example, the first processor-core acceleration engine 240a (or another processor-core acceleration engine <NUM>) may extract column data <NUM> from the page data PD based on the decode operation. In some embodiments, the first processor-core acceleration engine 240a (or one or more other processor-core acceleration engines <NUM>) may perform a page rule-checking operation (e.g., to validate the page data).

The first processor-core custom instructions CI1 may also cause an extra-processor-core circuit (e.g., the first scan engine 220a) to perform the compare operation based on (e.g., on) the column data <NUM>. Additionally, the scheduler <NUM> may cause the first scan engine 220a to perform the compare operation in conjunction with an n-th scan engine 220n for improved efficiency.

<FIG> is a system diagram depicting an architecture for processing a variety of functions in computational storage, according to some embodiments of the present disclosure.

Referring to <FIG>, the storage device <NUM>, according to some embodiments of the present disclosure, may enable flexibility in processing a variety of functions near memory. In such embodiments, the storage device may include a co-processor <NUM>. The co-processor <NUM> may be coupled to the processor core <NUM> and may include one or more co-processor acceleration engines <NUM> (e.g., individually depicted as 340a-n). The processor core <NUM> and the co-processor <NUM> may correspond to a processing unit <NUM> of the storage device <NUM>. The co-processor acceleration engines <NUM> may correspond to a co-processor custom-instruction set <NUM>. The co-processor custom-instruction set <NUM> may include one or more co-processor custom instructions CCI (e.g., individually depicted as CCI1-n). In some embodiments, the co-processor custom-instruction set <NUM> may be stored in the processor core <NUM> (e.g., at a general-purpose processing portion of the processor core <NUM>).

As discussed above with respect to <FIG>, the processor-core acceleration engines <NUM> may be utilized by the storage device <NUM> to perform generalized (e.g., general) acceleration operations. For example, the generalized acceleration operations performed by the processor-core acceleration engines <NUM> may be operations that are common to a variety of functions (e.g., compare operations, addition operations, subtract operations, multiplication operations, decoding operations, graph-traversing operations, linked-list operations, parallel-comparison operations, and/or the like). The generalized acceleration operations may each have a decode stage, an execute stage, and a writeback stage.

Similar to the extra-processor-core circuit (e.g., the scan engines) discussed above with respect to <FIG>, the co-processor acceleration engines <NUM> may be hardware logic circuits that are utilized, in combination with the co-processor custom-instruction set <NUM>, to perform more complex and/or heavy algorithms (e.g., function-specific accelerations) than the processor-core acceleration engines <NUM>. For example, the co-processor acceleration engines <NUM> may be bigger acceleration engines, which are capable of performing complex algorithms, such as compression algorithms, decompression algorithms, artificial intelligence (AI) neural-network training algorithms, and AI inferencing-engine algorithms.

In some embodiments, the storage device <NUM> may include a data transfer bus <NUM> to transfer information between the host <NUM>, the processor core <NUM>, and the co-processor <NUM>. For example, the data transfer bus <NUM> may communicate requests, commands, instructions, results, and status updates between the components of the system <NUM>. In some embodiments, the data transfer bus <NUM> may include (e.g., may be) an advanced eXtensible Interface (AXI) Fabric.

Accordingly, a processing (e.g., a performance) of a variety of functions according to some embodiments of the present disclosure, may include one or more of the following operations. The host <NUM> may send a request (e.g., a command or instructions) to the storage device <NUM> to perform a function FN on data <NUM>. The function FN may be a first function FN1. For example, the first function FN1 may be a video processing function. The first function FN1 may include multiple operations (e.g., the video processing function may be performed by way of multiple smaller operations). For example, the first function FN1 may include simple acceleration operations that are common to multiple functions associated with the storage device <NUM> and may include function-specific operations. The processor core <NUM> may receive the request to perform the first function FN1 by way of the data transfer bus <NUM> and/or the API <NUM>. The processor core <NUM> may receive the data <NUM> by way of a data buffer <NUM>.

As similarly discussed above with respect to <FIG>, the storage device <NUM> may use the processor-core custom-instruction set <NUM> to direct the performance of operations associated with the first function FN1 to different processing circuits within the storage device <NUM>. For example, the first processor-core custom instructions CI1 may cause one or more of the processor-core acceleration engines <NUM> to perform a first operation associated with the first function FN1 on the data <NUM>. The processor-core acceleration engines <NUM> may generate processor-core result data <NUM> based on the first processor-core custom instructions CI1. Similarly, the storage device <NUM> may use the co-processor custom-instruction set <NUM> to direct the performance of operations associated with the first function FN1 to different co-processor acceleration engines <NUM>. For example, first co-processor custom instructions CCI1 may cause a first co-processor acceleration engine 340a to perform a second operation, associated with the first function FN1, based on (e.g., on) the processor-core result data <NUM>, to generate co-processor result data <NUM>. The co-processor result data <NUM> may be sent to the processor core <NUM> or to the data transfer bus <NUM> for further processing.

Similarly, the host <NUM> may send instructions to the storage device <NUM> to perform a second function FN2 on the data <NUM>. The data <NUM> may be the same data as or different data from the data <NUM> on which the first function FN1 was performed. For example, the second function FN2 may be a compression function. The second function FN2 may include multiple operations (e.g., the compression function may be performed by way of multiple smaller operations). For example, the second function FN2 may include simple acceleration operations that are common to multiple functions associated with the storage device <NUM> and may include function-specific operations. For example, one or more operations (e.g., one or more generalized acceleration operations) associated with the first function FN1 may also be associated with the second function FN2, and one or more operations (e.g., one or more function-specific operations) may not be associated with the first function FN1. The processor core <NUM> may receive the instructions to perform the second function FN2 by way of the data transfer bus <NUM> and/or the API <NUM>. The processor core <NUM> may receive the data <NUM> by way of the data buffer <NUM>.

As similarly discussed above with respect to the first function FN1, the storage device <NUM> may use the processor-core custom-instruction set <NUM> to direct the performance of operations associated with the second function FN2 to different processing circuits within the storage device <NUM>. For example, the second processor-core custom instructions CI2 may cause one or more of the processor-core acceleration engines <NUM> to perform a first operation associated with the second function F2 on the data <NUM>. The processor-core acceleration engines <NUM> may generate processor-core result data <NUM> based on the second processor-core custom instructions CI2. Similarly, the storage device <NUM> may use the co-processor custom-instruction set <NUM> to direct the performance of operations associated with the second function FN2 to different co-processor acceleration engines <NUM>. For example, second co-processor custom instructions CCI2 may cause a second co-processor acceleration engine 340b to perform a second operation, associated with the second function FN2, based on (e.g., on) the processor-core result data <NUM>, to generate co-processor result data <NUM>. The co-processor result data <NUM> may be sent to the processor core <NUM> or to the data transfer bus <NUM> for further processing.

<FIG> is a flowchart depicting a method of processing formatted data in computational storage, according to some embodiments of the present disclosure.

Referring to <FIG>, a method <NUM> of processing formatted data in computational storage may include the following example operations. A storage device <NUM> may receive first data (e.g., page data PD) (see <FIG>) associated with a first data set, and having a first format FM1 (operation <NUM>). A processor core <NUM> of the storage device <NUM> may receive a request (e.g., a command or instructions) from a host <NUM> to perform a function FN on the first data (operation <NUM>). A first processor-core acceleration engine 240a may perform a first operation, associated with the function FN, on the first data, based on first processor-core custom instructions CI1, to generate first result data (e.g., column data <NUM>) (operation <NUM>). A first scan engine 220a of the storage device <NUM> may perform a second operation, associated with the function FN, on the first result data (e.g., column data <NUM>), based on the first processor-core custom instructions CI1 (operation <NUM>).

<FIG> is a flowchart depicting a method of processing a variety of functions in computational storage, according to some embodiments of the present disclosure.

Referring to <FIG>, a method <NUM> of processing a variety of functions in computational storage may include the following example operations. A processor core <NUM> of a storage device <NUM> may receive a request (e.g., a command or instructions) to perform a first function FN1 on first data (operation <NUM>). A first processor-core acceleration engine 240a may perform a first operation, associated with the first function FN1, on the first data, based on first processor-core custom instructions CI1, to generate first result data (e.g., processor-core result data <NUM>) (operation <NUM>). A first co-processor acceleration engine 340a of the storage device <NUM> may perform a second operation, associated with the first function FN1, on the first result data (e.g., processor-core result data <NUM>), based on first co-processor custom instructions CCI1 (operation <NUM>).

Claim 1:
A method (<NUM>) for performing computations near memory, the method (<NUM>) comprising:
receiving (<NUM>), at a storage device (<NUM>), first data (PD) associated with a first data set, the first data (PD) having a first format (FM1);
receiving (<NUM>), at a processor core (<NUM>) of the storage device (<NUM>), a request to perform a function (FN) on the first data (PD), the function (FN) comprising a first operation and a second operation;
performing (<NUM>), by a first processor-core acceleration engine (240a) of the storage device (<NUM>), the first operation on the first data (PD), based on first processor-core custom instructions (CI1), to generate first result data; and
performing (<NUM>), by a first extra-processor-core circuit of the storage device (<NUM>), the second operation on the first result data, based on the first processor-core custom instructions (CI1),
characterised in that:
the first data (PD) comprises first page data corresponding to a first database page (10a);
the first operation comprises a decoding operation for determining the first format (FM1) based on the first page data or a page rule-checking operation;
the first result data comprises column data (<NUM>) extracted, by the first processor-core acceleration engine (240a), from the first page data; and
the first extra-processor-core circuit comprises a scan engine (<NUM>).