Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method comprising: accessing code to be compiled, wherein the code comprises a plurality of instances of an allocation operator for memory allocation; and compiling the accessed code into a set of compiled instructions that are configured to: associate a first memory pool of a non-uniform memory architecture (NUMA) memory with a first instance of a class referenced by a first thread executing on a first processing element, wherein the first memory pool is associated with a first thread scoped variable unique to the first thread; associate a second memory pool of the NUMA memory with a second instance of the class referenced by a second thread executing on a second processing element, wherein the second memory pool is associated with a second thread scoped variable unique to the second thread, and wherein the first memory pool has a different memory architecture than the second memory pool; allocate memory from the first memory pool for instances of the allocation operator on a per object basis for one or more objects associated with the first instance of the class referenced by the first thread using the first thread scoped variable; and allocate memory from the second memory pool for instances of the allocation operator on a per object basis for one or more objects associated with the second instance of the class referenced by the second thread using the second thread scoped variable.
A method for optimized memory allocation involves compiling code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
2. The method of claim 1 , wherein the first processing element is a processor.
A method for optimized memory allocation involves compiling code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processor. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
3. The method of claim 1 , wherein the first processing element is a processor core.
A method for optimized memory allocation involves compiling code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processor core. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
4. The method of claim 1 , wherein the first memory pool is allocated based on proximity of the first memory pool to the first processing element.
A method for optimized memory allocation involves compiling code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element, where this first memory pool is chosen based on its physical proximity to the first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
5. The method of claim 1 , wherein the NUMA memory comprises a plurality of memory modules and the first and second processing elements are reconfigurable.
A method for optimized memory allocation involves compiling code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system, comprising multiple memory modules, with a specific instance of a class being handled by a first thread executing on a reconfigurable first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool, also from the multiple memory modules, is similarly associated with a second instance of the same class referenced by a second thread executing on a reconfigurable second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
6. The method of claim 1 , wherein the code is compatible with C++ code.
A method for optimized memory allocation involves compiling C++ compatible code containing multiple memory allocation operators. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
7. The method of claim 1 , wherein the allocation operator is a modified new operator.
A method for optimized memory allocation involves compiling code containing multiple instances of a modified `new` operator for memory allocation. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
8. The method of claim 7 , wherein the modified new operator is based on a template configured for overloading allocation.
A method for optimized memory allocation involves compiling code containing multiple instances of a modified `new` operator, which is based on a template configured for overloading allocation. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
9. The method of claim 1 , wherein the allocation operator is a modified delete operator.
This method involves removing or deleting things in a specific way (a "modified delete operator") as part of a larger process described earlier. Essentially, it's about carefully taking stuff out to make something else work better.
10. The method of claim 9 , wherein the modified delete operator is based on a template configured for overloading allocation.
A method for optimized memory allocation involves compiling code containing multiple instances of a modified `delete` operator, which is based on a template configured for overloading allocation. The compilation process generates instructions configured to: first, associate a dedicated memory pool from a Non-Uniform Memory Architecture (NUMA) system with a specific instance of a class being handled by a first thread on a first processing element. This first memory pool is uniquely linked to a variable scoped to that first thread. Second, a different NUMA memory pool is similarly associated with a second instance of the same class referenced by a second thread on a second processing element, also linked to a unique thread-scoped variable. Crucially, the first and second memory pools have distinct underlying memory architectures. Subsequently, memory is allocated from the first pool for objects related to the first class instance and thread using its unique variable, and similarly from the second pool for objects related to the second class instance and thread using its unique variable, on a per-object basis.
11. A non-transitory computer-readable storage medium comprising instructions stored thereon, the instructions configured to cause a computer system to: execute, on a first processing element, compiled code corresponding to an operator enabling NUMA aware allocation of memory, the compiled code referencing a first instance of a class; determine that an execution occurs on the first processing element and identify a first NUMA node as local to the first processing element, in response to execution of the compiled code corresponding to the operator enabling NUMA aware allocation of memory, wherein the first NUMA node is associated with a first variable unique to the first processing element; initialize, on the first NUMA node, a first memory pool comprising one or more objects associated with the first instance of the class in response to the operator enabling the NUMA aware allocation of memory and using the first variable; execute, on a second processing element, compiled code corresponding to the operator enabling NUMA aware allocation of memory, the compiled code referencing a second instance of a class; determine that an execution occurs on the second processing element and identify a second NUMA node as local to the second processing element, in response to execution of the compiled code corresponding to the operator enabling NUMA aware allocation of memory, wherein the second NUMA node is associated with a second variable unique to the second processing element, and initialize, on the second NUMA node, a second memory pool comprising one or more objects associated with the first instance of the class in response to the operator enabling the NUMA aware allocation of memory and using the second variable.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform NUMA-aware memory allocation. This involves: executing compiled code (corresponding to a NUMA-aware allocation operator) on a first processing element, which references a first class instance. Upon execution, the system determines it's running on the first processing element and identifies a local NUMA node, associating it with a variable unique to that processing element. It then initializes a first memory pool on this local NUMA node for objects related to the first class instance, using the unique variable. Separately, it executes the same compiled code on a second processing element, determining execution on the second element and identifying a local NUMA node, associating it with a variable unique to the second processing element. It then initializes a second memory pool on this second local NUMA node for objects related to the *first* class instance (as specified in the claim), using the second unique variable.
12. The non-transitory computer-readable storage medium of claim 11 , wherein the plurality of NUMA nodes comprises a plurality of memory modules and the first and second processing elements are reconfigurable.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform NUMA-aware memory allocation, where the NUMA nodes comprise multiple memory modules and the processing elements are reconfigurable. This involves: executing compiled code (corresponding to a NUMA-aware allocation operator) on a first processing element, which references a first class instance. Upon execution, the system determines it's running on the first processing element and identifies a local NUMA node, associating it with a variable unique to that processing element. It then initializes a first memory pool on this local NUMA node for objects related to the first class instance, using the unique variable. Separately, it executes the same compiled code on a second processing element, determining execution on the second element and identifying a local NUMA node, associating it with a variable unique to the second processing element. It then initializes a second memory pool on this second local NUMA node for objects related to the first class instance, using the second unique variable.
13. The non-transitory computer-readable storage medium of claim 11 , wherein the compiled code is compiled C++ code.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform NUMA-aware memory allocation, where the compiled code is compiled C++ code. This involves: executing the compiled C++ code (corresponding to a NUMA-aware allocation operator) on a first processing element, which references a first class instance. Upon execution, the system determines it's running on the first processing element and identifies a local NUMA node, associating it with a variable unique to that processing element. It then initializes a first memory pool on this local NUMA node for objects related to the first class instance, using the unique variable. Separately, it executes the same compiled code on a second processing element, determining execution on the second element and identifying a local NUMA node, associating it with a variable unique to the second processing element. It then initializes a second memory pool on this second local NUMA node for objects related to the first class instance, using the second unique variable.
14. The non-transitory computer-readable storage medium of claim 11 , wherein the operator enabling NUMA aware allocation of memory is a modified new operator.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform NUMA-aware memory allocation, using a modified `new` operator. This involves: executing compiled code (corresponding to the modified `new` operator enabling NUMA-aware allocation) on a first processing element, which references a first class instance. Upon execution, the system determines it's running on the first processing element and identifies a local NUMA node, associating it with a variable unique to that processing element. It then initializes a first memory pool on this local NUMA node for objects related to the first class instance, using the unique variable. Separately, it executes the same compiled code on a second processing element, determining execution on the second element and identifying a local NUMA node, associating it with a variable unique to the second processing element. It then initializes a second memory pool on this second local NUMA node for objects related to the first class instance, using the second unique variable.
15. The non-transitory computer-readable storage medium of claim 14 , wherein the modified new operator is based on a template configured for overloading allocation.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform NUMA-aware memory allocation, using a modified `new` operator based on a template configured for overloading allocation. This involves: executing compiled code (corresponding to the modified `new` operator enabling NUMA-aware allocation) on a first processing element, which references a first class instance. Upon execution, the system determines it's running on the first processing element and identifies a local NUMA node, associating it with a variable unique to that processing element. It then initializes a first memory pool on this local NUMA node for objects related to the first class instance, using the unique variable. Separately, it executes the same compiled code on a second processing element, determining execution on the second element and identifying a local NUMA node, associating it with a variable unique to the second processing element. It then initializes a second memory pool on this second local NUMA node for objects related to the first class instance, using the second unique variable.
16. A method comprising: receiving code to be compiled, the code comprising: a first class; a second class; and a plurality of instances of an operator for memory allocation with respect to at least one of the first class and the second class; and compiling the received code into a set of compiled instructions configured to: associate a first set of memory pools of a first non-uniform memory architecture (NUMA) memory with the first class, wherein the first set of memory pools is associated with a first variable; associate a second set of memory pools of a second NUMA memory with the second class, wherein the second set of memory pools is associated with a second variable, and wherein the first memory pool has a different memory architecture than the second memory pool; allocate memory from a memory pool within the first set of memory pools for instances of the operator for memory allocation with respect to one or more objects associated with the first class using the first variable; and allocate memory from a memory pool within the second set of memory pools for instances of the operator for memory allocation with respect to one or more objects associated with the second class using the second variable.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and memory allocation operators) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable, and similarly from a pool within the second set for objects associated with the second class, using the second variable.
17. The method of claim 16 , wherein the first set of memory pools is within a respective processor's local cache while the second set of memory pools is within a respective processor's shared cache.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and memory allocation operators) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class, where this first set of memory pools resides in a respective processor's local cache. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class, where this second set resides in a respective processor's shared cache. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable, and similarly from a pool within the second set for objects associated with the second class, using the second variable.
18. The method of claim 16 , wherein the allocation of memory from the memory pool within the first set of memory pools is based on NUMA aware allocation comprising a determination of which part of the memory pool within the first set of memory pools to allocate.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and memory allocation operators) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable. This allocation is NUMA-aware and includes determining precisely which part of the memory pool within the first set to use. Similarly, memory is allocated from a pool within the second set for objects associated with the second class, using the second variable.
19. The method of claim 18 , wherein the first set of memory pools comprises a local cache and non local cache relative to a respective processor core.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and memory allocation operators) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class, where this first set of memory pools itself includes both local and non-local cache relative to a respective processor core. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable. This allocation is NUMA-aware and includes determining precisely which part of the memory pool within the first set to use. Similarly, memory is allocated from a pool within the second set for objects associated with the second class, using the second variable.
20. The method of claim 16 , wherein the code is C++ code.
A method for class-aware memory allocation involves receiving C++ code (including a first class, a second class, and memory allocation operators) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable, and similarly from a pool within the second set for objects associated with the second class, using the second variable.
21. The method of claim 16 , wherein the operator enabling class aware allocation of memory is a modified new operator.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and multiple instances of a modified `new` operator for memory allocation) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable, and similarly from a pool within the second set for objects associated with the second class, using the second variable.
22. The method of claim 21 , wherein the modified new operator is based on a template configured for overloading allocation.
A method for class-aware memory allocation involves receiving code (including a first class, a second class, and multiple instances of a modified `new` operator for memory allocation, which is based on a template configured for overloading allocation) and compiling it. The compiled instructions are configured to: first, associate a distinct set of memory pools from a first Non-Uniform Memory Architecture (NUMA) memory with the first class, using a first variable unique to that class. Second, a different set of memory pools from a second NUMA memory is associated with the second class, using a second variable unique to that class. These first and second memory pool sets have different underlying memory architectures. Subsequently, memory is allocated from a pool within the first set for objects associated with the first class, using the first variable, and similarly from a pool within the second set for objects associated with the second class, using the second variable.
23. A non-transitory computer-readable storage medium comprising instructions stored thereon, the instructions configured to cause a computer system to: determine that a first plurality of non-uniform memory architecture (NUMA) nodes from within a first set of memory pools are to be used for memory allocations with respect to a first class and a second plurality of NUMA nodes from within a second set of memory pools are to be used for memory allocations with respect to a second class; execute, on a processing element, compiled code corresponding to an operator enabling class aware allocation of memory, in response to execution of the compiled code corresponding to the operator enabling class aware allocation of memory, determine that the allocation occurs with respect to the first class and identify, using a first variable unique to a first thread executed by the processing element, a first memory pool from within the first set of memory pools to be used for memory allocation with respect to the first class; initialize the NUMA node from with the first set of memory pools in response to the operator enabling class aware allocation of memory; execute, on the processing element, compiled code corresponding to the operator enabling class aware allocation of memory; in response to the execution of compiled code corresponding to the operator enabling class aware allocation of memory, determine that the allocation of the memory occurs with respect to the second class and identify, using a second variable unique to a second thread executed by the processing element, a second memory pool within the second set of memory pools to be used for memory allocation with respect to the second class; and initialize the NUMA node from within the second set of memory pools in response to the operator enabling class aware allocation of memory.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform class-aware, NUMA-optimized memory allocation. This involves: pre-determining that a first group of NUMA nodes within a first set of memory pools will serve memory allocations for a first class, and a second group of NUMA nodes within a second set of memory pools will serve a second class. During runtime, when compiled code (corresponding to an operator enabling class-aware allocation) executes on a processing element, the system determines the allocation is for the first class. It then uses a first variable unique to a first thread (executed by the processing element) to identify a specific first memory pool within the first set of NUMA nodes for the first class, and initializes that NUMA node. Similarly, upon subsequent execution for the same operator, if the allocation is for the second class, it uses a second variable unique to a second thread (executed by the processing element) to identify a second memory pool within the second set of NUMA nodes for the second class, and initializes that NUMA node.
24. The non-transitory computer-readable storage medium of claim 23 , wherein the first plurality of NUMA nodes comprises a plurality of memory modules and the processing element is reconfigurable.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform class-aware, NUMA-optimized memory allocation, where the first group of NUMA nodes comprises multiple memory modules and the processing element is reconfigurable. This involves: pre-determining that a first group of NUMA nodes within a first set of memory pools will serve memory allocations for a first class, and a second group of NUMA nodes from within a second set of memory pools will serve a second class. During runtime, when compiled code (corresponding to an operator enabling class-aware allocation) executes on a reconfigurable processing element, the system determines the allocation is for the first class. It then uses a first variable unique to a first thread (executed by the processing element) to identify a specific first memory pool within the first set of NUMA nodes for the first class, and initializes that NUMA node. Similarly, upon subsequent execution for the same operator, if the allocation is for the second class, it uses a second variable unique to a second thread (executed by the processing element) to identify a second memory pool within the second set of NUMA nodes for the second class, and initializes that NUMA node.
25. The non-transitory computer-readable storage medium of claim 23 , wherein the compiled code is compiled C++ code.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform class-aware, NUMA-optimized memory allocation, where the compiled code is compiled C++ code. This involves: pre-determining that a first group of NUMA nodes within a first set of memory pools will serve memory allocations for a first class, and a second group of NUMA nodes from within a second set of memory pools will serve a second class. During runtime, when compiled C++ code (corresponding to an operator enabling class-aware allocation) executes on a processing element, the system determines the allocation is for the first class. It then uses a first variable unique to a first thread (executed by the processing element) to identify a specific first memory pool within the first set of NUMA nodes for the first class, and initializes that NUMA node. Similarly, upon subsequent execution for the same operator, if the allocation is for the second class, it uses a second variable unique to a second thread (executed by the processing element) to identify a second memory pool within the second set of NUMA nodes for the second class, and initializes that NUMA node.
26. The non-transitory computer-readable storage medium of claim 23 , wherein the operator enabling class aware allocation of memory is a modified new operator.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform class-aware, NUMA-optimized memory allocation, using a modified `new` operator. This involves: pre-determining that a first group of NUMA nodes within a first set of memory pools will serve memory allocations for a first class, and a second group of NUMA nodes from within a second set of memory pools will serve a second class. During runtime, when compiled code (corresponding to a modified `new` operator enabling class-aware allocation) executes on a processing element, the system determines the allocation is for the first class. It then uses a first variable unique to a first thread (executed by the processing element) to identify a specific first memory pool within the first set of NUMA nodes for the first class, and initializes that NUMA node. Similarly, upon subsequent execution for the same operator, if the allocation is for the second class, it uses a second variable unique to a second thread (executed by the processing element) to identify a second memory pool within the second set of NUMA nodes for the second class, and initializes that NUMA node.
27. The non-transitory computer-readable storage medium of claim 26 , wherein the modified new operator is based on a template configured for overloading allocation.
A non-transitory computer-readable storage medium contains instructions that cause a computer system to perform class-aware, NUMA-optimized memory allocation, using a modified `new` operator based on a template configured for overloading allocation. This involves: pre-determining that a first group of NUMA nodes within a first set of memory pools will serve memory allocations for a first class, and a second group of NUMA nodes from within a second set of memory pools will serve a second class. During runtime, when compiled code (corresponding to the modified `new` operator enabling class-aware allocation) executes on a processing element, the system determines the allocation is for the first class. It then uses a first variable unique to a first thread (executed by the processing element) to identify a specific first memory pool within the first set of NUMA nodes for the first class, and initializes that NUMA node. Similarly, upon subsequent execution for the same operator, if the allocation is for the second class, it uses a second variable unique to a second thread (executed by the processing element) to identify a second memory pool within the second set of NUMA nodes for the second class, and initializes that NUMA node.
Unknown
July 28, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.