Method, medium and disaggregated memory system for accessing data from a disaggregated memory

Abstract

A freshness and gravity of data operators executed in near-memory computation are provided. This disclosure provides systems and methods for improving bandwidth and latency associated with executing data requests in decomposed memory by utilizing usage indicators (also called usage values) such as the “freshness” of data operators and the processing “gravity” of near-memory computation functions. Examples of the systems and methods disclosed herein generate data operators, including near-memory computation functions, offloaded to the vicinity of decomposed memory nodes, assigning usage values ​​to each data operator based on at least one of: (i) a freshness indicator for each data operator and (ii) a gravity indicator for each near-memory computation function; and assigning data operations to the data operators based on said usage values.

Description

Technical Field

[0001] This disclosure generally relates to decomposed memory. Background Technology

[0002] The traditional approach of moving data to the CPU for computation has become a significant performance bottleneck for emerging horizontally scaled, data-intensive applications because it offers limited data reuse and relatively slow interconnect performance compared to local cache access. Meanwhile, advancements in 3D integration technology have made the concept of coupling computational units close to memory (often referred to as near-memory computing (NMC)), proposed a decade ago, more feasible. Processing directly in memory can significantly reduce data movement issues in data-intensive applications. Summary of the Invention

[0003] According to one aspect of this disclosure, a non-transitory machine-readable medium is provided that stores instructions that cause one or more processors of an electronic device to perform operations, the operations including: loading and unloading data operators to near-memory computation functions near a decomposed memory node; assigning a usage value to each data operator based on at least one of: (i) a freshness indicator for each data operator, the freshness indicator indicating at least one of an amount of time since the data operator was last used or a frequency of use of the data operator; or (ii) a gravity indicator for each of the near-memory computation functions, the gravity indicator being associated with an amount of data to be stored in a particular memory node associated with the near-memory computation function in response to a request, the decomposed memory node including the particular memory node; and assigning data operations to the data operators based on the usage value.

[0004] According to another aspect of this disclosure, a method for accessing data from a decomposed memory is provided, the method comprising: receiving a data request operation associated with a computing node; selecting one or more data operators of a near-memory computing function to perform the data request operation based on at least one of: a freshness indicator associated with the one or more data operators, the freshness indicator indicating at least one of the amount of time since the one or more data operators were last used or the frequency of use of the one or more data operators; or a gravity indicator associated with the near-memory computing function, the gravity indicator being associated with the amount of data to be stored in the memory node associated with the near-memory computing function in response to a request; and at least partially using the one or more data operators to perform the data request operation.

[0005] According to another aspect of this disclosure, a decomposed memory system is provided, comprising: one or more memory nodes storing data; at least one near-memory computation function associated with a first memory node of the one or more memory nodes, the first memory node including one or more data operators; and at least one hardware processor configured to execute instructions stored in memory to: receive a data request operation associated with the computation node; select one or more data operators of the near-memory computation function associated with the memory node of the one or more memory nodes to perform the data request operation based on at least one of: a freshness indicator associated with the one or more data operators, the freshness indicator indicating at least one of the amount of time since the one or more data operators were last used or the frequency of use of the one or more data operators; or a gravity indicator associated with the near-memory computation function, the gravity indicator being associated with the amount of data to be stored in the memory node associated with the near-memory computation function in response to a request; and at least partially use the one or more data operators to perform the data request operation. Attached Figure Description

[0006] This disclosure is described in detail with reference to the following accompanying drawings, based on one or more different embodiments. The drawings are provided for illustrative purposes only and depict only typical or exemplary embodiments.

[0007] Figure 1 The illustration shows an example architecture in which data query operations on decomposed memory can be offloaded to near-memory computation.

[0008] Figure 2 Another example architecture in which the systems and methods described in this paper can be implemented is illustrated.

[0009] Figure 3 The illustration shows an example data operator stack that can be implemented in a decomposed memory.

[0010] Figure 4 This is an illustration of an example of an indicator used to manage the freshness of near-memory computing according to an embodiment of the disclosed technology.

[0011] Figure 5 This is an illustration of an example of a gravity usage indicator for managing near-memory computing according to an embodiment of the disclosed technology.

[0012] Figure 6 This is an example flowchart of a method for routing data query operations to a decomposed memory according to an embodiment disclosed herein.

[0013] Figure 7A block diagram of an example computer system in which the systems and methods described herein can be implemented is shown.

[0014] The accompanying drawings are not exhaustive and do not limit this disclosure to the precise form disclosed. Detailed Implementation

[0015] For years, memory technology has lagged behind processor advancements in latency and power consumption. The demise of Dennard scaling, the slowdown of Moore's Law, and the plateauing of dark silicon computing performance have all contributed to this. Meanwhile, massive amounts of data are being generated across multiple disciplines, such as materials science, chemistry, and health sciences. In traditional systems, these applications result in frequent data movements between the server's memory subsystem and the processor. These frequent data movements within the server negatively impact performance and energy efficiency. System architects have attempted to bridge this gap by introducing memory hierarchies that mitigate some of the drawbacks of off-chip DRAM. However, the limited number of pins on memory packages cannot meet the bandwidth demands of today's multi-core processors.

[0016] Traditional memory hierarchies typically consist of multi-level caches, main memory, and storage devices. For example, a conventional approach processes data after it has been moved up from storage devices to the cache. In contrast, near-memory computing (NMC) aims to process data near its residing location. This data-centric approach places computing units logically and / or physically as close as possible to the storage device where the data resides, attempting to minimize costly data movements. For example, three-dimensional stacks enable processing near memory. By using through-silicon vias (TSVs) to stack logic and memory together, NMC can help reduce memory access latency and power consumption, and provide higher bandwidth.

[0017] Moving computation closer to memory can bypass performance and energy bottlenecks in data movement by circumventing the pin count limitations of memory packages. Non-Memory Capabilities (NMCs) accelerate memory access by performing data operations near memory using data operators, thereby eliminating the overhead of multiple interconnect traversals to and from memory. NMCs connect to memory via a memory interface rather than an interconnect interface. A memory interface can provide latency of tens of nanoseconds, rather than hundreds of nanoseconds (e.g., 300 ns) on an interconnect interface. By using data operators, NMCs can effectively increase bandwidth and reduce latency between memory and compute nodes. By performing operations near memory, the amount of data used to perform data requests that need to be transferred between compute nodes and memory is reduced, effectively increasing interconnect bandwidth and reducing latency compared to requesting all data from memory and performing operations at the compute node. Data operators can take the form of addressing (e.g., pointer chasing), filtering (e.g., data reduction), or more complex computations (e.g., initialization, encryption, compression, projection, etc.). For NMCs where operators are not fixed functions, the number of operators is typically limited and needs to be shared, and they may be superseded by more frequently used operators.

[0018] Data operators can be positioned between the memory and network layers and control how data moves from memory to the network, thereby controlling how data is retrieved from the memory stack. The memory stack can include decomposed memory, a horizontally scaled storage form constructed from a number of storage devices that act as a logical pool of storage, which can be allocated to any server on the network via the network architecture. Client devices can access decomposed memory by establishing connections with one or more data operators. Whenever a client issues a request, the network stack routes the request to the data operator assigned to the client device that initiated the data request.

[0019] Databases are uniquely positioned to leverage decomposed memory to address the problems of inefficient data movement and insufficient DRAM capacity. The NMC implementations disclosed herein may include physically separating query processing from memory buffer management. Traditionally, query processing threads access database tables by reading them from a buffer pool and copying the data to their dedicated workspace. According to the implementations disclosed herein, the buffer pool may be placed on a network-connected decomposed memory, and query processing nodes are provided as needed to run queries by reading data from the network-connected buffer pool. The implementations disclosed herein offer several advantages, such as, but not limited to: (1) reducing data movement by pushing operators down to the decomposed memory, allowing processing nodes to receive only relevant data; and (2) reducing the memory requirements of compute nodes by centralizing the buffer cache in the decomposed memory and eliminating unnecessary data copying to compute nodes.

[0020] Compared to remote memory, decomposed memory systems use memory with network connections that differ from the memory in compute nodes (such as, but not limited to, client devices). Compute nodes in various implementations can be devices that provide temporary storage, networking, memory, and processing resources that can consume decomposed memory instances. This approach allows decomposed memory to scale independently of the system's compute or storage capacity and eliminates the need to over-produce one resource to scale another. In decomposed memory systems, network overhead is a performance bottleneck.

[0021] The embodiments disclosed herein provide systems and methods that can improve the bandwidth and latency associated with accessing data via interconnects attached to a network of decomposed memory, while also reducing the energy associated with accessing data via the interconnects by utilizing usage indicators, such as a “freshness” indicator for each data operator and a “gravity” indicator for the NMC toward the compute node. Each usage indicator can represent a unit of measurement of the appropriateness of the NMC for a given data request, thereby allowing the system hosting the decomposed memory to optimize the overall performance of the system by managing each NMC and data operator within the system. For example, data operators and / or NMCs can be assigned to data requests based on one or more usage indicators, which can provide optimal performance.

[0022] It should be noted that the terms "optimized," "optimal," etc., as used herein, can be used to mean achieving or realizing the most efficient or perfect performance possible. However, those skilled in the art who read this document will recognize that perfection is not always achievable. Therefore, these terms can also encompass achieving or realizing the best possible, most efficient, or most practical performance under given conditions, or achieving or realizing performance superior to that achievable using other settings or parameters.

[0023] Figure 1 The illustration shows an example architecture in which data query operations to the memory can be offloaded to the NMC. Figure 1 This includes multiple computing nodes 105 (e.g., first computing node 105A and second computing node 105B) connected to the partitioned memory 108 via network interface 107. As part of data operations, computing nodes 105 can issue data queries requesting data from the partitioned memory 108. Computing nodes 105 can be implemented as any computing device connected to the partitioned memory 108 via network interface 107. For example, computing node 105 can be a client device. As another example, computing node 105 can be a server with a CPU, memory, and a network interface. In an example implementation, computing node 105 can be implemented as... Figure 7 The computer system 700. In another example, multiple computing nodes can be organized into a cluster, where each cluster represents computing node 105.

[0024] The decomposed memory 108 includes a logic pool of memory 110 (e.g., memory 110A, memory 110B, memory 110N, etc.). Figure 1 Each memory 110 can be an example decomposed memory node on an interconnect structure. For example, multiple decomposed memory nodes 110 can be connected via multiple interconnect structures. Thus, in some examples, decomposed memory 108 can be used as memory decomposed from compute node 105 and can be shared among multiple compute nodes 105. In some cases, decomposed memory can be shared by all nodes. Network interface 107 can be an example of a structure interface.

[0025] The decomposed memory 108 also includes multiple dynamic regions 121 (e.g., a first dynamic region 121A, a second dynamic region 121B, and a third dynamic region 121N). Each dynamic region 121 (also referred to herein as NMC) includes one or more data operators 111 (e.g., a first data operator 111A, a second data operator 111B, a third data operator 111C, a fourth data operator 111E, a fifth data operator 111F, and a sixth data operator 111N). In one example, multiple data operators 111 include query operators, which include: (i) a selection operator configured to filter data based on a set of predicates, (ii) a projection operator configured to reduce the number of returned columns and memory accesses, (iii) an aggregation operator, (iv) a distinguishing operator, (v) a grouping operator configured to combine tuples (e.g., distinguish, group by aggregation), (vi) a regular expression matching operator, (vii) an encryption operator, and (viii) a system support operator configured to process data in place before sending data (e.g., encryption / decryption) and perform system optimization tasks (e.g., data packing) to reduce overall network usage. The data operators 111 can be implemented using ASICs, FPGAs, SmartNICs, ARMs, other processors, etc. In an example implementation, the data operators 111 can be implemented as... Figure 7 An example of a computer system 700.

[0026] In some implementations, each dynamic region 121 includes one or more data storage areas 112 (e.g., data storage area 112A, data storage area 112B, ..., data storage area 112N). Data storage areas 112 may store indicators and policies for assigning, loading, and managing data operators 111 loaded into the corresponding dynamic region 121. For example, data storage area 112 may store a first usage indicator for each data operator 111, which the NMC can use to manage the data operators to execute data requests according to a policy. As another example, data storage area 112 may store a second usage indicator for the corresponding dynamic region 121, which the NMC can use to manage the data operators to execute data requests according to a policy.

[0027] The decomposed memory 108 can be accessed by one or more of a plurality of compute nodes 105. For example, both first compute node 105A and second compute node 105B can access the decomposed memory 108 and / or one of first compute node 105A and second compute node 105B can access the decomposed memory 108. In one example, compute node 105A and compute node 105B can each invoke two data queries in the form of projection and selection, the two data queries being offloaded to the decomposed memory 108 as data operators 111 of corresponding dynamic regions 121, while union and final projection are performed at compute nodes 105A and 105B. In one example, the decomposed memory 108 includes a programming interface that includes a data API for path operations and connection management operations. By connecting the data API to memory 110, the data operators 111 can be offloaded to the decomposed memory 108, thereby effectively acting as a pluggable lineflow processor.

[0028] Data operator pipelines can be built from individual blocks that implement a given data operator and provide a standard interface for composing data operators into a pipeline. The modular nature of pipelines allows operators to be easily replaced and extended (e.g., the concatenation operator). The following section combines... Figure 3 A sample data operator pipeline is provided.

[0029] Figure 2 Another example architecture 200 is illustrated in which the systems and methods described herein can be implemented. Example architecture 200 includes a memory stack 204, a data operator stack 206, and a network stack 202. Data is transmitted from one or more compute nodes (e.g., ...). Figure 1 Compute nodes 105A and 105B are transferred to and from memory stack 204 via network stack 202 and data operator stack 206. Memory stack 204 includes decomposed memory (e.g., ...). Figure 1 The decomposed memory 108 includes a memory pool (e.g., channel 256A, channel 256B, ..., channel 256N) connected to the memory management unit 208 via multiple channels (e.g., channel 256A, channel 256B, ..., channel 256N). Figure 1 The memory 110A, memory 110B, ..., memory 110N). The data operator stack 206 includes multiple data operators 111 (e.g., ...). Figure 1The system includes data operators 111A, 111B, ..., 111N, and one or more data storage areas 112. Multiple data operators 111 are connected to the memory management unit 208 and the network interface 107. The multiple data operators 111 are connected to the memory management unit 208 via multiple channels 236 (e.g., channels 236A, 236B, ..., 236N). Channels 236 may be descriptions of the memory interface, and a data operator stack 206 (e.g., an example of dynamic region 121) is connected to a memory stack 204 via said memory interface. A network stack 202 is configured to decode incoming data streams and transmit the data along with the data to the appropriate data operator 111. The network stack 202 includes a network interface 107. The network interface 107 is connected to the multiple data operators 111 via multiple channels 234 (e.g., channels 234A, 234B, ..., 234N). In one configuration, network interface 107 is an example of a structure interface configured to transmit data to each of a plurality of data operators 111 via a plurality of interconnect structures. The plurality of interconnect structures may be connected to one or more decomposed memory nodes.

[0030] Network stack 202 is configured to send / receive data to / from data operator stack 206. For example, network stack 202 receives data queries (e.g., from compute nodes) and forwards them to data operator stack 206. Network stack 202 manages all connections between compute nodes and multiple data operators 111. Network stack 202 receives / sends data via network interface 107. Network interface 107 allows processors on the network to bypass the operating system and CPU resources to exchange data in main memory. In one example, network interface 107 includes a connectivity protocol that uses zero-copy networking to directly read data from the main memory of one system and write data directly to the main network of another system, thereby improving performance and throughput by freeing up server resources in a parallel high-performance computing (HPC) cluster.

[0031] The operator stack 206 includes the dynamic logic necessary to push data operators down to decomposed memory. Each data operator 111 can be configured to perform NMC (e.g., near-memory processing operations). The data operator stack 206 can process data from multiple compute nodes simultaneously. For example, data operator 111 can handle multiple data queries. Data can be processed in a streaming manner within the operator pipeline, where each stage of processing is fully pipelined, allowing different processing stages within each data operator 111 to occur concurrently. This configuration can be used to leverage both spatial parallelism (e.g., tasks being executed simultaneously by multiple processing units) and pipelined parallelism through concurrent dynamic regions. Pipeline parallelism can refer to multiple operators depending on each other, with the execution of each operator overlapping with other data operators 111. Both of these can improve the overall performance of the system. It is through the operator stack that the system can identify relationships with previously identified structures and perform optimizations for accessing data. Optimizations can include prefetching data to be accessed, caching data in a higher-level cache that will be reused more frequently, and / or pre-computing by speculatively updating metadata to reflect upcoming I / O, buffer allocations, or other parameters associated with the application and data.

[0032] Multiple data operators 111 can be managed via a management operator based on policies and indicators stored in data storage area 112. In the example, the management operator could be one of the operators 111 that is loaded first and configured to manage other subsequently loaded data operators 111 based on its initial loading. The management operator monitors the processing load of other data operators, calculates freshness and gravity (as in...). Figure 4 and Figure 5 (This will be explained in further detail in the discussion), and reacts based on policies. Management operators can also provide programming and user interfaces to other tools and system administration. In another example, a management operator can be a controller, which can be implemented, for example, as... Figure 7 700 computing devices.

[0033] In one example, the managerial operator is the first data operator to initiate (e.g., open, start, go online, etc.). In a configuration where the first data operator to initiate is a managerial operator, the first operator can be called the "bootstrapping operator." The managerial operator remains open throughout the data operations. If the managerial operator crashes, any of the multiple operators can become the managerial operator. For example, if the managerial operator crashes, a non-management operator can become the managerial operator.

[0034] Data operator stack 206 sends / receives data to / from memory stack 204 via multiple connections 236. Memory stack 204 implements memory pool 110 and can be used as general memory, where data is loaded from storage devices as needed. Memory stack 204 is configured to handle memory allocation, address translation, and concurrent access. Memory stack 204 includes a memory management unit 208 for translating addresses to memory. Memory management unit 208 is connected to memory 110 within memory stack 204 via multiple channels (e.g., channels 256A, 256B, 256N, etc.). For example, multiple channels 256 can route memory 110 to access memory management unit 208. Memory can be allocated to each channel in a striped pattern to optimize available bandwidth. Operator stack 206 can interface with memory stack 204 to receive data and metadata from memory stack 204.

[0035] Compute nodes can access decomposed memory by opening a connection to one of the dynamic regions 121 containing one or more data operators 111, each dynamic region capable of containing one of the possible operator pipelines. When a compute node issues a read request, network stack 202 routes the request to a dynamic region in operator stack 206, which contains the data operators 111 assigned to the compute node initiating the request. The read request is forwarded to memory stack 204, which translates the virtual address into a physical address in memory 110 and then issues the actual data request to memory 110. The compute node may have local directory information that can be used to determine the virtual address of the memory to be accessed. The returned data is streamed back to dynamic region 121, where the data operators 110 loaded in the dynamic region are applied to the data. Finally, the obtained data is forwarded to network stack 202 and further sent directly to the compute node.

[0036] Figure 3 The illustration shows an example dynamic region 121 of the data operator stack 106. Figure 3 The illustration shows a generic operator pipeline 330 included in a dynamic region 121, which includes multiple data operators 332A-332N (collectively referred to herein as data operators 332) capable of processing data objects. In one example, the multiple operators 332 may include projection, selection (e.g., predicate selection, regular expression matching), grouping (e.g., distinguish, group, and aggregate), and system support (e.g., encryption / decryption). Figure 3In the illustrative example, several operators include decryption operator 332A, projection operator 332B, selection operator 332C, grouping operator 332D, and system operator 332N. Operator 332 within operator pipeline 330 can vary depending on the requested set of queries to be executed.

[0037] Each operator pipeline is assigned to a corresponding compute node (e.g., compute node 105). Operator pipeline 330 includes one or more data operators 332, each of which provides partial query processing (e.g., processing of data read operations) to the decomposed memory for data operations. Queries can be forwarded to query request handlers in the operator stack via query request handler 302. Query request handler 302 can request a data object associated with the query from the memory stack (e.g., memory stack 204). This can be achieved through addressing, which can allow reading data in both row-based and column-based storage formats based on a given request. In some embodiments, data can also be read in graph format or other representations. Data operators 332 for processing data objects can be pre-compiled into dynamic region 121 and can be deployed (e.g., loaded) into the dynamic region at runtime. Query request handler 302 can submit data objects to one or more data operators 332 according to the query.

[0038] When a query request arrives, it is first forwarded to query request handler 302, which requests data from the memory stack. Simultaneously, any necessary parameters for additional processing are forwarded to data operators 332 in the pipeline. The data from memory is processed in a streaming manner by these data operators. Once processing is complete, the resulting data is sent back to the client via the network stack.

[0039] As an illustrative embodiment, the decryption operator 332A can decrypt data from the memory stack 204 if the data is encrypted. For this operation, the compute node may need to provide a specific key for decrypting the ciphertext to plaintext. These keys can be provided along with the query request. This allows the system to provide an additional level of security, which is important in modern decomposed environments.

[0040] The projection operator 332B can return a subset of data objects. It reads a table from a decomposed memory, parses the incoming data stream based on query parameters describing the tuples and their sizes, and projects only the necessary columns into the pipeline for further processing using annotations. This reduces the amount of data supplied to subsequent stages and ultimately reduces the overall amount of data movement. The projection operator 332B can use annotations to comment on tuples with parameters from the requested query. These parameters can specify which columns are part of the projection, selection, and grouping stages. The projection operator 332B can annotate a subset of data objects and forward it to the selection operator 332C.

[0041] The selection operator 332C can further filter data to significantly reduce the amount of data ultimately sent over the network, thereby reducing I / O overhead. The selection operator 332C can filter data using predicate selection, regular expression matching, vectorization, or other methods. Predicate selection can be performed by comparing the values ​​of attributes of data objects with constants provided in the query. Comments from the projection operator 332B can help determine what is evaluated during the predicate matching phase. Regular expression matching can use string matching via multiple parallel engines in the operator stack 206. The performance of this operator can be dominated by the length of the string, not by the complexity of the regular expression used. Vectorization can be performed by reading data in parallel from multiple channels in the operator stack 206. Individual tuples can be emitted to a set of selection operators operating in parallel. The number of parallel operators can be chosen based on the number of memory channels and the tuple width. Vectorization can be implemented for simpler queries that can be parallelized without data dependencies.

[0042] The grouping operator 332D can perform aggregations and eliminate duplicate entries before sending column entries to client applications and devices. Grouping operator 332D can hash values ​​and store entries in a hash table on a memory stack. In some examples, the hash table can use a cuckoo hash, which has several hash tables that can be consulted in parallel. The cuckoo hash can evict entries from the hash tables and use different functions to insert these entries into separate hash tables to reduce collisions. Grouping operator 332D can group data via aggregation and dump data entries from the hash tables based on the requested aggregation result. Aggregation can produce specific groupings, allowing most of the processing already done in the decomposed node (which can be determined based on the specific application) to be performed without first moving all the data to the client and then fully processing it.

[0043] System operator 332N can prepare data filtered by projection, selection, and grouping operators for transmission to client devices. System operator 332N can also encrypt data as needed or upon request from the client device. System operator 332N can also pack data based on comment columns from projection operator 332B, thereby making more efficient use of available network bandwidth. Packing can use overflow buffers to maintain line rates. In the case of vectorization, a round-robin priority arbiter can be used to combine tuples from each parallel pipeline. System operator 332N can also include a transmitter unit to generate correct header information in the network stack. The transmitter unit can create RDMA commands without information about the final data size, allowing filtering in operators when the final data size is unknown at the time of request. The transmitter unit can also forward data to the network stack for transmission to client applications and devices.

[0044] Figure 4 This is an illustration of an example of the use of indicators for data operators according to an implementation of the disclosed technology. More specifically, Figure 4 A schematic diagram depicts the "freshness" indicator of data operators 411A-411N, wherein the data operators can be... Figure 1 Explanation of the data operators 111A-111N. Figure 4 This includes a memory 410 (e.g., a description of one of the memory 110), multiple computing nodes 105 (e.g., a first computing node 105A, a second computing node 105B, and a third computing node 105N), and data operators 411. The multiple data operators 411 are arranged within a dynamic region 421, which is... Figure 1 Description of any of the dynamic regions 121. Each compute node 105 is communicatively connected to one or more data operators 411 via connection 436. For example, a first compute node 105A is communicatively connected to one or more first data operators via connection 436A, a second compute node 105B is communicatively connected to one or more second data operators via connection 436B, and a third compute node 105N is communicatively connected to one or more third data operators via connection 436N.

[0045] If a data operator has not been used for a sufficient period of time or with sufficient frequency, and other possible operator activity exists, a newer (e.g., recently called) data operator can be substituted to perform the operation. When a data operator is substituted, a call to an unloaded data operator will throw an exception when the data operator is invoked. The old operator can be reloaded, similar to a page fault. Data access can be performed without the operator, but this is much slower if the operation is transparent (e.g., compression / decompression may have to be done on the calling side). If the operation is operator-specific, and the circumstances are insufficient for the operator to be substituted, an exception may be re-raised at the compute node, and the compute node may have to reissue a non-operator-specific request, or it may call the same request to another decomposed memory node.

[0046] If data operators share resources, such as memory or a soft core used to cache data, the cached data can be dumped and cleared after a period of inactivity, and the soft core can be allocated to another data operator (for example, when explicitly requested by the client or when all associated data operators have been deallocated, the shared resource will be safely dumped and cleared).

[0047] Resources that can be attached to data operators can be used to measure the freshness of data operators. "Data operator freshness" is a method of determining how long a data operator has been used or how frequently it is used. When a data operator is widely used, all resources can be assigned and used by the data operator. Recently used data operators can be assigned high freshness compared to other data operators. Data operators that have not been used recently can be assigned low freshness compared to other data operators. Data operators can be sorted according to their most recent or most frequent use. For example, data operators can be sorted from most recently used operators to those that have not been used (e.g., 30 nanoseconds, 1 second, 3 minutes, etc.). As another example, data operators can be sorted from most frequently used to least frequently used. The sorting can be in the order of high freshness, medium freshness, low freshness, etc. Those data operators that are not used or are infrequently used may indicate that these operators are obsolete.

[0048] Figure 5 This is an illustration of an example of an NMC usage instruction according to an implementation of the disclosed technology. More specifically, Figure 5 A schematic diagram depicts the "gravity" indicator generated by dynamic regions between decomposed memory nodes and compute nodes. Figure 5Includes memories 510A and 510B (e.g., description of memory 110, which may be referred to as a decomposed memory node), dynamic regions 521A and 521B (e.g., description of dynamic region 121) (each dynamic region includes multiple operators ( Figure 5 (Not shown in the diagram) and multiple computing nodes 105A and 105B. Each computing node 105 is communicatively connected to dynamic regions 521A and 521B via connections 536 and 538, respectively. For example, a first computing node 105A is communicatively connected to dynamic region 521A via connection 536A and to dynamic region 521B via connection 536B. A second computing node 105B is communicatively connected to dynamic region 521A via connection 538A and to dynamic region 521B via connection 538B.

[0049] In some implementations, if data is copied at a memory location within memory 510, a data request can be routed to a dynamic region 521 corresponding to the memory 510 where the copied data is located, instead of loading new data operators. Copied data refers to data cached in the memory's data cache within memory 510. For example, memory 510 may cache data associated with compute node 105. If such data is copied at memory 510, it can be determined whether the gravity indicator utilizes dynamic region 521 and its data operators to perform data operations on compute node 105. For example, if data associated with a request from compute node 105A is copied to memory 510A (e.g., cached in memory 510A), compute node 105A can direct its data operations to dynamic region 521A for execution via data operators in dynamic region 521A. If the copied data associated with the first compute node 105A is cached at multiple distributed memory nodes (e.g., memory 510A and memory 510B), the gravity indicator can be used to determine the dynamic region to direct the data operation request. For example, a data operation request can be directed to the dynamic region 521 that has the highest gravity indicator compared to other dynamic regions 521. Therefore, the memory 510 can be sorted according to the gravity indicator and used to select the memory with the highest gravity to direct the data request.

[0050] By utilizing copied data instead of loading new data, bandwidth performance is improved, latency is reduced, and energy consumption is reduced, thereby improving computational performance. For example, since data already exists on one of the memories 510 for a given data request operation, compute node 105 does not need to request cached data. As a result, the bandwidth of the interconnects between compute node 105 and memory 510 (e.g., connection 536 and / or connection 538) is effectively increased (e.g., accelerated) because the interconnects can be used for other data exchanges. The bandwidth is effectively increased to above the actual bandwidth of the interconnects, for example, the bandwidth available if dynamic region 521 is not used for data operations and all data operations are performed at compute node 105. Without dynamic region 521, it might be necessary to request and exchange all the data required for each data operation from memory 510. Furthermore, since cached data can be used to perform data request operations, dynamic region 521 can utilize copied data to perform operations closer to memory 510. As a result, latency caused by data exchange on the interconnects can be reduced, thereby effectively increasing processing time and reducing latency.

[0051] Increased effective bandwidth can depend on data operators. For example, if a data operator is implemented for pointer chasing, the operator will not need to pass through an interconnect interface, which may have a latency of hundreds of nanoseconds. Instead, the pointer chasing operation can be performed on a lower-latency memory interface, thereby reducing latency and effectively increasing bandwidth. As another example, if a data operator is implemented for filtering, less bit data needs to be transmitted over the network, allowing more data requests to be made over the network. In yet another example, if a data operator is implemented for computation closer to memory rather than on a compute node, the resources of that compute node can be freed up to perform other operations, etc.

[0052] Gravity indicator generated between the corresponding computing node 105 and the corresponding memory 510 due to the corresponding dynamic region 521 ( The following calculation can be performed:

[0053] Equation 1

[0054] in, S i This indicates the decomposed memory serving compute node 105. i The corresponding memory in memory 510. C j This refers to the corresponding compute node 105 that issues a data request operation for the decomposed memory. SD l Indicates residing in memory Si On the computing node C j The amount or size of addressable data related to the data request (e.g., in bytes, such as megabytes, gigabytes, etc.). CD m Indicates residing on a computing node C j The above can be attributed to memory S i The amount or size of addressable data. AccelBW DI This indicates the effective (e.g., accelerated) bandwidth of memory 510 when dynamic region 521 is used for corresponding data requests, and AccelBW Dm This represents the effective bandwidth of the corresponding compute node 105. (Variable) g The processing factor is a constant (sometimes called gravity or gravitational constant) of the corresponding dynamic region 521 and is proportional to the amount of processing to be performed by the corresponding dynamic region 521 for a given data request. Therefore, similar to gravity, by... SD l (For example, analogous to the mass of memory 510) multiplied by CD m (For example, analogous to the mass of compute node 105) to calculate Similar to gravity, where the product of the masses of two objects divided by the radial distance between them... SD l and CD m product divided by AccelBW DI multiplied by the reciprocal AccelBW Dm The product of the reciprocals of the product. Then multiply the result by the treatment factor (g).

[0055] exist Figure 5 In the illustrative example, memory 510A may be a memory with a function attributable to a computing node. C j The corresponding data request SD l memory size S i In this example, the first compute node 105A may be a node on which data is stored. CD m Size of the compute node C j The effective bandwidth of the 510A memory is AccelBW DI And the effective bandwidth of the first compute node 105A is AccelBWDm Therefore, the gravity indicator generated by the dynamic region 521A from memory 510A to the first computing node 105A. The calculation can be performed using Equation 1 above. Gravity indicators between memory 510A and other computing nodes, as well as between other computing nodes and memory 510B, can be calculated in a similar manner.

[0056] Gravity can be expressed as a force directed toward a separate region (e.g., an address) hosted by memory 510 (e.g., a decomposed memory node). Addressable regions can be tracked by partitioning the address space of memory 510 and mapping data request sources to separate regions. That is, for example, mapping data request sources for given data to separate regions within memory 510 where the data is addressed. As a specific number of requests are fulfilled throughout history or per unit time, a gravity indicator can be determined between the compute node and a given region of memory 510 due to the dynamic region 521 corresponding to memory 510. Multiple data operators can serve each addressed region, thus the aggregate gravity indicator of dynamic region 521, as well as the individual gravity of each data operator, can be tracked.

[0057] Figure 6 This is an example flowchart of a method 600 for routing data requests to a decomposed memory node according to an embodiment disclosed herein. Method 600 can be provided by a compute node (e.g., Figure 1 The compute node 105) performs the operation to determine which decomposed memory node (e.g., ) to direct the data request to. Figure 1 The memory 110 is booted. As described above, each decomposed memory node may include a corresponding dynamic region (e.g., data operator 111) having multiple data operators (e.g., data operator 111). Figure 1 The dynamic region 121). Method 600 includes using indicators such as freshness indicators and gravity indicators to manage the decomposed memory nodes for performing data operations related to data requests. At a high level, method 600 includes identifying the NMC with the highest gravity for data requests issued by compute nodes to the decomposed memory, and identifying the data operator with the highest freshness. Method 600 manages the decomposed memory based on the identified NMC and the data operator used to compete for data requests.

[0058] Method 600 will now be described with reference to a single decomposed memory node and its corresponding NMC. However, a given compute node may execute similar methods associated with each decomposed memory node in parallel or sequentially.

[0059] At block 602, a data request is generated by the compute node. For example, the compute node may receive some inputs defining operations, which it uses to determine multiple data operations, such as a data request operation and a data processing operation. The data request operation may be sent to a decomposed memory for accessing data associated with the operation. In another example, the NMC may be used to perform some or all of the data processing operations on the requested data. Therefore, in some examples, block 602 may include determining the data processing operation together with or separately from the data request operation.

[0060] At block 604, method 600 includes determining whether a data operator exists. For example, block 604 includes determining whether a data operator is loaded into the NMC of the decomposed memory node. Here, the compute node determines whether the data operator exists in the NMC and can be used to perform data operations related to the data request in block 602. If no data operator is loaded into the NMC, method 600 proceeds to block 606, in which the data operator is loaded into the NMC.

[0061] The determination at box 604 can be performed in several different ways. For example, a data operator can operate on a decomposed memory node, and if it is known that a possible data operator is assigned to a decomposed memory node and it is not loaded into the NMC, the determination at box 604 will be negative. As another example, an explicit call to a data operator can be made, and if the called data operator is not loaded into the NMC, an alert will be issued, and the determination at box 604 will be negative. As yet another example, if the data requested is encrypted, and the data may be inaccessible if a data operator for performing decryption is not loaded, the determination at box 604 will be negative. These are just some examples; other ways of determining whether a data operator is loaded are also possible.

[0062] If a data operator exists, method 600 proceeds to block 608 to determine whether the data associated with the data request in block 602 has been copied to the decomposed memory node. For example, the compute node checks whether the decomposed memory node where the data operator from block 604 exists has cached the data associated with fulfilling the data request in block 602. In an example implementation, the compute node may maintain a data table indicating where it can issue a data request. Therefore, the compute node can verify that the indicated decomposed memory node has fulfilled the relevant data. If the relevant data has not been copied, method 600 proceeds to block 616 to access the data according to the data request.

[0063] If the compute node determines that the data has been copied, the method proceeds to box 610 to determine whether the data operator identified in box 604 is fresh. For example, the compute node determines a freshness indicator for each of a plurality of data operators. If the data operator from box 604 has not been used for a certain amount of time or has not been used at a sufficient frequency, the method proceeds to box 612. For example, the method includes accessing a sort of freshness indicators associated with each data operator from data storage 611 (e.g., data storage 112) and checking whether the data operator from box 604 has the highest freshness indicator. If the freshness indicator of the data operator is the highest in the sort, method 600 proceeds to box 614. Otherwise, method 600 proceeds to box 612 and selects the data operator with the highest freshness. For example, box 612 may include replacing the data operator identified in box 604 with a data operator having a higher freshness indicator. The freshness indicator may be determined, for example, in parallel with box 610, in parallel with method 600, or before box 602.

[0064] At box 614, method 600 includes selecting the decomposed memory node with the highest gravity indicator. For example, using Equation 1 above, the gravity indicator between the compute node and each decomposed memory node, generated due to the NMC corresponding to the decomposed memory node, can be determined for the data request at box 602. That is, the amount of data cached at each decomposed memory node in relation to the data request can be used to determine the gravity indicator for each node. Similarly, the amount of data associated with a data request at a compute node can be used to determine the compute node's... The effective bandwidth resulting from each NMC can be used to determine the value from the perspective of each decomposed memory node. And determine from the perspective of computing nodes The gravity indicators for each NMC can be sorted in the data storage area 613 (e.g., data storage area 112) associated with each NMC and decomposed memory node. The compute node accesses the data storage area 613 and selects the decomposed memory with the highest gravity. The gravity indicators can be determined, for example, in parallel with block 614, in parallel with method 600, or before block 602.

[0065] At box 616, the data operator selected in box 610 (or box 612) loads the copied data onto the NMC associated with the selected decomposed memory node selected in box 614 and performs data operations based on the data request from box 602. At box 618, the freshness indicator of the data operator is updated, and the gravity indicator of the NMC is updated. For example, the freshness indicator and gravity indicator can be determined based on the updated variables used in box 616. The updated indicators can then be pushed to data storage areas 611 and 613 to update the corresponding indicators.

[0066] The descriptions and methods above are provided as illustrative examples only and are not intended to require or imply that the operations of the various embodiments must be performed in the presented order. As those skilled in the art will understand, the order of operations in illustrative method 600 can be performed in any order. For example, block 608 may be performed before block 604, after blocks 610 and / or 612, etc. As another example, block 614 may be performed before or in parallel with blocks 610 and / or 612. Words such as "after," "then," and "next" are not intended to limit the order of operations; these words are used only as examples to guide the reader through the description of the methods.

[0067] Figure 7 A block diagram depicts an example computer system 700 in which various embodiments described herein may be implemented. Computer system 700 may be an example implementation of architecture 100 or any component thereof. Computer system 700 includes a bus 702 or other communication mechanism for transmitting information, and one or more hardware processors 704 coupled to bus 702 for processing information. The hardware processors 704 may be, for example, one or more general-purpose microprocessors.

[0068] Computer system 700 also includes main memory 706 (such as random access memory (RAM), cache, and / or other dynamic storage devices) coupled to bus 702 for storing information and instructions to be executed by processor 704 (e.g., instructions for executing method 600). Main memory 706 can also be used to store temporary variables or other intermediate information during the execution of instructions to be executed by processor 704. When such instructions are stored in storage media accessible to processor 704, computer system 700 becomes a dedicated machine defined for executing the operations specified in the instructions.

[0069] The computer system 700 further includes a read-only memory (ROM) 708 or other static storage device coupled to the bus 702 for storing static information and instructions of the processor 704. Storage devices 710, such as disks, optical discs, or USB thumb drives (flash drives), are provided and coupled to the bus 702 for storing information and instructions.

[0070] Computer system 700 can be coupled to display 712, such as a liquid crystal display (LCD) (or touchscreen), via bus 702 for displaying information to a computer user. Input device 714, including alphanumeric keys and other keys, is coupled to bus 702 for transmitting information and command selections to processor 704. Another type of user input device is cursor control 716, such as a mouse, trackball, or arrow keys, for transmitting directional information and command selections to processor 704 and for controlling cursor movement on display 712. In some embodiments, the same directional information and command selections as those of the cursor control can be implemented via receiving touch on a touchscreen without a cursor.

[0071] The computing system 700 may include a user interface module for implementing a GUI, which may be stored as executable software code executed by (multiple) computing devices in a mass storage device. By way of example, this module and other modules may include components such as software components, object-oriented software components, class components, and task components; processes; functions; attributes; programs; subroutines; program code segments; drivers; firmware; microcode; circuits; data; databases; data structures; tables; arrays; and variables.

[0072] Generally, terms such as “component,” “engine,” “system,” “database,” and “data storage area” as used herein can refer to logic implemented in hardware or firmware, or to a set of software instructions written in programming languages ​​such as Java, C, or C++, which may have entry and exit points. Software components can be compiled and linked into an executable program, installed in a dynamic link library, or written in an interpreted programming language such as BASIC, Perl, or Python. It should be understood that software components can be invoked from other components or from themselves, and / or can be invoked in response to detected events or interrupts. Software components configured to execute on a computing device can be provided on computer-readable media such as optical discs, digital video discs, flash drives, magnetic disks, or any other tangible media, or can be provided as digital downloads (and can be stored originally in a compressed or installable format that needs to be installed, decompressed, or decrypted before execution). Such software code can be stored, in part or in whole, on a memory device executing the computing device for execution by the computing device. Software instructions can be embedded in firmware such as EPROM. It will be further understood that hardware components may include connection logic units such as gates and flip-flops, and / or may include programmable units such as programmable gate arrays or processors.

[0073] Computer system 700 may implement the techniques described herein using custom hardwired logic, one or more ASICs or FPGAs, firmware, and / or program logic, which, when combined with the computer system, makes computer system 700 a special-purpose machine or programs it to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system 700 in response to processor(s) 704 executing one or more sequences of one or more instructions contained in main memory 706. Such instructions may be read into main memory 706 from another storage medium, such as storage device 710. Execution of the instruction sequence contained in main memory 706 causes processor(s) 704 to perform the process steps described herein. In alternative embodiments, hardwired circuitry may be used instead of or in combination with software instructions.

[0074] As used herein, the term "non-transitory media" and similar terms refer to any medium that stores data and / or instructions that enable a machine to operate in a particular manner. Such non-transitory media can include non-volatile media and / or volatile media. Non-volatile media include, for example, optical discs or magnetic disks, such as storage device 710. Volatile media include dynamic memory, such as main memory 706. Common forms of non-transitory media include, for example, floppy disks, floppy disks, hard disks, solid-state drives, magnetic tape or any other magnetic data storage media, CD-ROMs, any other optical data storage media, any physical media with a perforated pattern, RAM, PROMs and EPROMs, flash EPROMs, NVRAMs, any other memory chips or cartridges, and networking versions of these media.

[0075] Non-transient media differ from transmission media but can be used in conjunction with them. Transmission media participate in the information transfer between non-transient media. For example, transmission media include coaxial cables, copper wires, and optical fibers, including conductors containing bus 702. Transmission media can also take the form of sound waves or light waves, such as those generated during radio wave and infrared data communication.

[0076] Computer system 700 also includes a communication interface 718 coupled to bus 702. Communication interface 718 provides bidirectional data communication coupled to one or more network links connected to one or more local networks. For example, communication interface 718 may be an Integrated Services Digital Network (ISDN) card, a cable modem, a satellite modem, or a modem for providing data communication connectivity to a corresponding type of telephone line. As another example, communication interface 718 may be a local area network (LAN) card for providing data communication connectivity to a compatible LAN (or a WAN component communicating with a WAN). Wireless links may also be implemented. In any such implementation, communication interface 718 transmits and receives electrical, electromagnetic, or optical signals carrying streams of digital data representing various types of information.

[0077] Network links typically provide data communication to other data devices via one or more networks. For example, a network link can provide a connection from a local network to a host computer or to a data device operated by an Internet Service Provider (ISP). The ISP, in turn, provides data communication services through a global packet data communication network now commonly referred to as the "Internet." Both local networks and the Internet use electrical, electromagnetic, or optical signals that carry digital data streams. Signals through various networks, as well as signals on network links and signals through communication interface 718 (which carries digital data to and from computer system 700), are example forms of transmission media.

[0078] Computer system 700 can send messages and receive data, including program code, through multiple networks, network links, and communication interfaces 718. In the Internet example, the server can transmit application request code through the Internet, ISP, local network, and communication interface 718. Received code can be executed by processor 704 and / or stored in storage device 710 or other non-volatile storage for later execution upon receipt.

[0079] Each of the processes, methods, and algorithms described in the preceding sections can be implemented in code components executed by one or more computer systems or computer processors, including computer hardware, and can be fully or partially automated by these code components. The one or more computer systems or computer processors can also operate to support the execution of related operations in a “cloud computing” environment or as “Software as a Service (SaaS)”. These processes and algorithms can be implemented, partially or fully, in a dedicated circuit. The various features and processes described above can be used independently of each other or can be combined in various ways. Different combinations and sub-combinations are intended to fall within the scope of this disclosure, and certain method blocks or process blocks may be omitted in some embodiments. The methods and processes described herein are not limited to any particular order, and blocks or states associated with these methods and processes can be executed in a suitable other order, or can be executed in parallel, or can be executed in some other way. Blocks or states can be added to or removed from the disclosed example embodiments. The execution of certain operations or processes can be distributed across computer systems or computer processors, so that they are not confined to a single machine but deployed across multiple machines.

[0080] As used herein, circuits can be implemented using any form of hardware, software, or a combination thereof. For example, one or more processors, controllers, ASICs, PLAs, PALs, CPLDs, FPGAs, logic components, software routines, or other mechanisms can be implemented to constitute a circuit. In implementations, the various circuits described herein can be implemented as discrete circuits, or the described functions and features can be shared partially or wholly among one or more circuits. Although various features or functional elements can be described or claimed individually as separate circuits, these features and functions can also be shared within one or more common circuits, and such description should not require or imply the need for separate circuits to implement such features or functions. In cases where software is used to implement the circuit wholly or partially, such software can be implemented to operate in conjunction with a computing or processing system (such as computer system 700) capable of performing the functions described with respect to the software.

[0081] As used herein, the term “or” can be interpreted in an inclusive or exclusive sense. Furthermore, descriptions of resources, operations, or structures in the singular form should not be construed as excluding the plural. Unless expressly stated otherwise, or understood otherwise in the context in which they are used, conditional language (among others, such as “can,” “could,” “might,” or “may”) is generally intended to convey that certain embodiments include certain features, elements, and / or steps that are not included in other embodiments.

[0082] Unless otherwise expressly stated, the terms and phrases used in this document, and their variations thereof, should be interpreted as open-ended rather than restrictive. Adjectives and similar terms such as “conventional,” “traditional,” “normal,” “standard,” and “known” should not be interpreted as limiting the described items to items available for a given period of time or prior to a given time, but should be understood to encompass conventional, traditional, normal, or standard techniques that may be available or known at any time now or in the future. In some cases, the presence of broad words and phrases (such as “one or more,” “at least,” “but not limited to,” or other similar phrases) should not be interpreted as indicating an intention or requirement for a narrower scope where such broad phrases may not exist.

Claims

1. A non-transitory machine-readable medium storing instructions that cause one or more processors of an electronic device to perform operations comprising: loading data operators of a near-memory computing function proximate to a disaggregated memory node; assigning a usage value to each data operator based on at least one of: (i) a freshness indicator for each data operator, the freshness indicator indicating at least one of an amount of time since the data operator was last used or a frequency of usage of the data operator; or (ii) a gravity indicator for each of the near-memory computing functions, the gravity indicator associated with an amount of data stored in a particular memory node associated with the near-memory computing function in response to a request, the disaggregated memory node comprising the particular memory node; and allocating a data operation to the data operators based on the usage values.

2. The non-transitory machine readable medium of claim 1, wherein, The usage values are based on both (i) a freshness indicator for each data operator and (ii) a gravity indicator for each of the near-memory computing functions.

3. The non-transitory machine readable medium of claim 1, wherein, The gravity indicator for each of the near-memory computing functions is based on at least one of an amount of data at a disaggregated memory node associated with the respective near-memory computing function or an effective bandwidth of a respective disaggregated memory node due to the near-memory computing function.

4. The non-transitory machine readable medium of claim 1, wherein, The gravity indicator for each of the near-memory computing functions is based on replicated data at a respective disaggregated memory node associated with the each near-memory computing function.

5. The non-transitory machine readable medium of claim 1, wherein, The gravity indicator for each of the near-memory computing functions is based on a constant for each respective near-memory computing, the constant proportional to an amount of processing on each respective near-memory computing.

6. A method for accessing data from a disaggregated memory, the method comprising: receiving a data request operation associated with a computing node; selecting one or more data operators of a near-memory computing function to perform the data request operation based on at least one of: a freshness indicator associated with the one or more data operators, the freshness indicator indicating at least one of an amount of time since the one or more data operators were last used or a frequency of usage of the one or more data operators; or a gravity indicator associated with the near-memory computing function, the gravity indicator associated with an amount of data stored in the memory node associated with the near-memory computing function in response to a request; and performing the data request operation using, at least in part, the one or more data operators.

7. The method of claim 6, wherein, The one or more data operators of the near-memory compute function associated with the memory node of the disaggregated memory are selected to perform the data request operation based on both the freshness indicator associated with the one or more data operators and a gravity indicator associated with the near-memory compute function.

8. The method of claim 6, wherein, The gravity indicator associated with the near-memory compute function is based on an amount of data related to the data request operation cached at a respective memory node, an amount of data related to the data request operation cached at the compute node, an effective bandwidth produced by the respective memory node due to the near-memory compute function, and an effective bandwidth produced by the compute node due to the near-memory compute function.

9. The method of claim 8, wherein, The gravity indicator associated with the near-memory compute function is determined as follows: wherein is a gravity indicator between the respective memory node and the respective compute node due to the near-memory compute function, is an amount of data related to the data request operation buffered at the respective memory node , is an amount of data related to the data request operation buffered at the respective compute node , is an effective bandwidth of the near-memory compute function due to the respective memory node , is an effective bandwidth of the near-memory compute function due to the respective compute node , and g is a constant proportional to an amount of processing performed by the near-memory compute function.

10. The method of claim 6, wherein, The disaggregated memory includes a plurality of memory nodes, each memory node associated with a respective near-memory compute function of a plurality of near-memory compute functions, wherein each near-memory compute function includes a plurality of data operators.

11. The method of claim 10, further comprising: determining that data related to performing the data request operation is replicated on a first memory node of the plurality of memory nodes; and identifying a near-memory compute function associated with the first memory node having the highest gravity indicator; wherein the selected one or more data operators are included in the identified near-memory compute function.

12. The method of claim 10, further comprising: identifying at least one data operator having a highest freshness indicator; wherein the selected one or more data operators include the identified at least one data operator.

13. A disaggregated memory system, comprising: one or more memory nodes storing data; at least one near-memory compute function associated with a first memory node of the one or more memory nodes, the first memory node including one or more data operators; and at least one hardware processor configured to execute instructions stored in memory to: receive a data request operation associated with a compute node; select one or more data operators of a near-memory compute function associated with a memory node of the one or more memory nodes to perform the data request operation based on at least one of: a freshness indicator associated with the one or more data operators, the freshness indicator indicating at least one of an amount of time since the one or more data operators were last used or a frequency of use of the one or more data operators; or a gravity indicator associated with the near-memory compute function, the gravity indicator associated with an amount of data stored in the memory node associated with the near-memory compute function in response to a request; and perform the data request operation using, at least in part, the one or more data operators.

14. The disaggregated memory system of claim 13, wherein, the at least one hardware processor is further configured to execute the instructions to: selecting the one or more data operators of the in-memory compute function associated with the memory node of the disaggregated memory to perform the data request operation based on both the freshness indicator associated with the one or more data operators and a gravity indicator associated with each in-memory compute function.

15. The disaggregated memory system of claim 13, wherein, The gravity indicator associated with the in-memory compute function is based on an amount of data related to the data request operation cached at a respective memory node of the one or more memory nodes, an amount of data related to the data request operation cached at the compute node, an effective bandwidth of the respective memory node due to the in-memory compute function, and an effective bandwidth of the compute node due to the in-memory compute function.

16. The disaggregated memory system of claim 15, wherein, The gravity indicator associated with the in-memory compute function is determined as follows: in, It is the computing node With the corresponding memory node The gravity indicator generated between them due to the near-memory calculation function. It is cached in the corresponding memory node The amount of data associated with the data request operation at the location. It is cached on the compute node The amount of data associated with the data request operation at the location. The near-memory computation function is due to the corresponding memory node. The resulting effective bandwidth, It is the computing node The effective bandwidth resulting from the near-memory computation function, and g It is a constant proportional to the amount of processing performed by the near-memory computation function.

17. The disaggregated memory system of claim 13, wherein, The one or more memory nodes include a plurality of memory nodes, each memory node associated with a respective in-memory compute function of a plurality of in-memory compute functions, wherein each in-memory compute function includes a plurality of data operators.

18. The disaggregated memory system of claim 17, wherein, The at least one hardware processor is further configured to execute the instructions to: determine that data related to performing the data request operation is replicated on a first memory node of the plurality of memory nodes; and identify an in-memory compute function associated with the first memory node having the highest gravity indicator; wherein the selected one or more data operators are included in the identified in-memory compute function.

19. The exploded memory system of claim 17, wherein, The at least one hardware processor is further configured to execute the instructions to: identify at least one data operator having a highest freshness indicator; wherein the selected one or more data operators include the identified at least one data operator.

Images