A dynamic adjustment system and method for memory pools using time-series data.

Abstract

A method for dynamically adjusting the memory pool using time-series data is provided. Historical time-series data on application memory pool usage is collected over a period of time, and each time-series forecasting model is used to process the data to predict the application's allocation size, specifically the expected number of allocations and the expected size of each allocated cell. Furthermore, real-time execution is used to perform scaling, interpolation, and recapitulation to predict the application's allocation size. A further time-series forecasting model is run, trained to predict tuning parameters for improving the memory pool storage area size based on the predicted memory cell size and application profile features associated with the requesting application.

Description

[[Background Art]]

[0001] The present disclosure relates to memory systems and dynamic memory management, and more specifically, to systems and methods for real-time dynamic memory allocation of memory pools that allocate fixed and variable size blocks, and systems and methods for dynamically adjusting memory pools.

[0002] In recent years, many users have encountered performance problems caused by inappropriate memory pool size provisioning. It is a considerable challenge for users that manually adjusting memory pools for each application requires much greater effort. Even when application programmers / system programmers provision a fixed memory pool cell size, it cannot be adapted to each execution of the same application.

[0003] Memory pool adjustment refers to the process of optimizing the allocation and management of memory pools, which are areas of memory separately set aside for specific purposes. The goal of memory pool adjustment is to improve program performance and efficiency by minimizing the amount of time consumed for memory allocation and deallocation.

[0004] In the context of the z / OS operating system, a heap pool refers to a dynamic storage area used to dynamically allocate and deallocate memory during program execution. A heap pool is a type of memory pool, which is a specific area of main storage separately set aside for a specific purpose. A heap memory area is where memory is allocated or deallocated in any order, which occurs, for example, in response to object creation using the (C++) "new" operator or the like.

[0005] The heap memory pool is created when a program is loaded into memory and is used to dynamically allocate memory as needed during program execution. The size of the heap pool can be configured based on the program's requirements. [Overview of the project]

[0006] A system and method for dynamically allocating a memory pool by predicting the number of allocation requests and memory cell size based on time-series data, and applying rules / policies, in order to properly utilize the memory pool storage area.

[0007] Systems and methods for automatically and dynamically provisioning and managing memory pool cell sizes result in improved application performance by increasing the efficiency of memory usage and reducing wasted allocated memory, reducing program costs by dynamically adjusting the size of the memory pool allocated to applications, and reducing the manual effort required for memory pool adjustments for large numbers of applications.

[0008] A system and method for automatically and dynamically provisioning memory pool cell sizes adapted to various program executions of different applications, even when used for the same application.

[0009] In one embodiment, a system is provided for allocating memory in a memory storage area within a computer system. The system comprises a hardware processor associated with memory storing program instructions within the computer system, the hardware processor comprising: a step of detecting one or more applications running on the computer system; the computer system memory having a memory pool storage area for exclusive use by the applications; and for each detected application: a step of running a first machine learning model trained to predict the number of allocation requests for memory cells in the memory pool storage area for the detected application using time-series data obtained from past memory usage by the detected application; a step of running a second machine learning model trained to predict the size of memory cells to be allocated in the memory pool storage area for each detected application using the time-series data obtained from past memory usage by the detected application; and a step of running program instructions that constitute the processor to perform a step of dynamically allocating a corresponding reserved memory pool storage area of ​​a size based on the predicted number of allocations and the predicted memory cell size for each detected application running on the computer system.

[0010] In a further embodiment, a method is provided for allocating memory in a memory storage area within a computer system. The method comprises, in a hardware processor associated with memory within a computer system, the steps of: detecting one or more applications running on the computer system; the computer system memory having a memory pool storage area for exclusive use by the applications; and for each detected application: running a first machine learning model in the hardware processor trained to predict the number of allocation requests for memory cells in the memory pool storage area for the detected application using time-series data obtained from past memory usage by the detected application; running a second machine learning model in the hardware processor trained to predict the size of memory cells to be allocated in the memory pool storage area for each detected application using the time-series data obtained from past memory usage by the detected application; and executing program instructions that configure the processor to dynamically allocate a corresponding reserved memory pool storage area of ​​a size based on the predicted number of allocations and the predicted memory cell size for each detected application running on the computer system.

[0011] A computer-readable storage medium storing a program of machine-executable instructions for performing one or more of the methods described herein may also be provided.

[0012] The following sections will describe in detail the further features and the structure and operation of various embodiments, with reference to the attached drawings. In the drawings, similar reference numerals indicate the same or functionally similar elements. [Brief explanation of the drawing]

[0013] [Figure 1] The present invention illustrates a general block diagram of a simple computer memory pool storage area for an application that is called to dynamically allocate its size.

[0014] [Figure 2] In this embodiment, a system for the dynamic adjustment of a memory pool, such as that shown in Figure 1, is conceptually illustrated.

[0015] [Figure 3] In one embodiment, a system implementation using a simulator is shown in more detail to create a training dataset containing labels for generated tuning parameter values ​​"P," which are used to tag real-time and / or historical data vectors for training a regression model.

[0016] [Figure 4] Figure 3 shows a further implementation of the system implementation, illustrating the overall computer-based method, which includes procedures for running both a time-series prediction model and a rule-based method to predict the memory pool cell size.

[0017] [Figure 5] This document describes a method for handling received historical data according to an embodiment, particularly a method for compressing historical time-series data in order to obtain profile characteristics of an application instance.

[0018] [Figure 6A] This document describes a computer-based system that includes procedures for running both time-series forecasting models and rule-based methods to predict the memory pool cell size of a currently running application.

[0019] [Figure 6B]Shows an alternative embodiment of the computer-based system of Figure 6A, further comprising performing further allocated memory cell size clustering techniques.

[0020] [Figure 7] Shows a method implemented in the computer system of Figure 1 for dynamically adjusting a memory pool using time-series data.

[0021] [Figure 8] Shows a method implemented in the computer system of Figure 1 for training a regression model used to generate or predict adjustment parameters for use in refining memory pool size allocation using time-series data.

[0022] [Figure 9] Shows a method 800 implemented in a simulator executed on the computer system of Figure 1 for generating ground truth labels used in training a regression model.

[0023] [Figure 10] Shows a computing environment including an example environment for execution of at least some of the computer code involved in carrying out the method of the invention, according to embodiments herein. DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

[0024] The following description is intended to illustrate the general principles of the present invention and is not intended to limit the claimed inventive concepts herein. In the following detailed description, numerous details are provided to provide an understanding of computer systems, computer architectures, processors, processor instruction execution pipelines, execution units, and their operating methods, memory, heap memory and stack memory systems, memory pools, etc. However, those skilled in the art will understand that numerous different embodiments of computer systems, computer architectures, processors, processor instruction execution pipelines, execution units, memory, heap memory and stack memory systems, memory pools, etc., and their operating methods can be implemented without their specific details, and that the claims and inventions should not be limited to the systems, assemblies, subassemblies, embodiments, functional units, features, circuits, processes, methods, aspects, and / or details specifically described and shown herein. Furthermore, specific features described herein may be used in combination with other described features in various possible combinations and substitutions.

[0025] Unless otherwise specifically defined herein, all terms are given the broadest possible interpretation, including the meaning implied herein and the meaning understood by those skilled in the art and / or defined in dictionaries, papers, etc. It should also be noted that, as used herein and in the appended claims, the singular forms “a,” “an,” and “the” refer to plural objects unless otherwise specified, and the terms “comprises” and / or “comprising” specify the presence of the described features, integers, stages, actions, elements, and / or components, but do not exclude the presence or addition of one or more features, integers, stages, actions, elements, components, and / or groups thereof.

[0026] The following description omits or briefly describes conventional features of information processing systems, including processors and microprocessor systems and processor architectures, memory and memory management system architectures, which are obvious to those skilled in the art. It is assumed that those skilled in the art are familiar with general processor architectures, particularly processors having execution pipelines that utilize various memory units, such as stacks, heaps, caches, and other memory systems. It should be noted that numbered elements are numbered according to the diagram in which they are introduced, and are often, though not always, referenced by that number in subsequent diagrams.

[0027] According to an aspect of the present invention, a system is provided for allocating memory in a memory storage area within a computer system. The system includes a hardware processor associated with memory storing program instructions within the computer system, the hardware processor executes a program of instructions to configure the processor to: detect one or more applications running on the computer system, the computer system memory has a memory pool storage area for exclusive use by the applications; for each detected application, the hardware processor runs a first machine learning model trained to predict the number of allocation requests for memory cells in the memory pool storage area for the detected application using time-series data obtained from past memory usage by the detected application, and runs a second machine learning model trained to predict the size of memory cells to be allocated in the memory pool storage area for each detected application using time-series data obtained from past memory usage by the detected application. The hardware processor then dynamically allocates a corresponding reserved memory pool storage area of ​​a size based on the predicted number of allocations and the predicted memory cell size for each detected application running on the computer system. Dynamically allocating memory pool storage area size to applications and managing memory pool cell size improves memory usage efficiency, reduces wasted memory pool memory allocation, and thereby lowers program execution costs. Dynamically allocating memory pool storage area size also simplifies program development and improves application performance by reducing the overhead of manual memory management, as allocating too much memory in an application's memory pool is wasteful, while allocating too little memory can lead to performance problems.

[0028] According to an embodiment of the system, the first machine learning model is a time-series prediction model trained using historical data associated with memory pool storage area usage from detected application instances previously executed on the computer system, wherein the historical data including the time-series data includes the number of memory allocations and deallocations in the memory pool storage area for each detected application previously executed. Training the model using time-series data including the number of memory allocations and deallocations in the memory pool storage area for each detected application previously executed results in a reduction of memory and application processing resource waste in the memory pool during application execution.

[0029] In a further embodiment of the system, the second machine learning model is a time-series forecasting model trained with historical data associated with memory pool storage area usage from past detected application instances, wherein the historical data including the time-series data includes the size of the memory cells that are to be allocated in the memory pool storage area for each detected application that has been executed in the past. Training the model with time-series data including the size of the memory cells that are to be allocated in the memory pool storage area for each detected application that has been executed in the past results in a reduction of memory and application processing resource waste in the memory pool during application execution.

[0030] According to one embodiment of the system, prior to the dynamic allocation step, the hardware processor is further configured to apply rules or policies for determining whether to proceed with dynamically allocating the corresponding reserved memory size of memory in the memory pool storage area based on the predicted number of allocations and the predicted memory cell size for the detected application, or not to proceed with the allocation. The applied rules or policies ensure efficient use of memory pool size allocation by avoiding memory allocation in the first instance when it is not considered certain based on the predicted number of allocations and the predicted memory cell size for the detected application. This further results in a reduction of memory and application processing resource waste in the memory pool while the application is running.

[0031] According to one embodiment of the system, the hardware processor is further configured to apply rules or policies to determine, based on the predicted number of allocations and the predicted memory cell size, whether to increase or decrease the amount of memory size allocated in the memory pool storage area for the detected application. The application of rules or policies ensures efficient use of the memory pool size allocated based on the predicted number of allocations and the predicted memory cell size for the detected application, which results in reduced waste of memory and application processing resources in the memory pool while the application is running.

[0032] According to one embodiment of the system, in order to dynamically allocate memory pool storage areas for use by detected applications, the hardware processor is further configured to apply a clustering method to the time-series data obtained from past memory usage by the applications in order to predict the distribution of memory pool storage area size values ​​associated with the detected applications. The application of the rules or policies of the applied clustering method ensures efficient use of the allocated memory pool size based on the predicted number of allocations and predicted memory cell sizes for the detected applications, which results in a reduction of memory and application processing resource waste in the memory pool while the applications are running.

[0033] According to an embodiment of the system, the hardware processor is further configured to run a third machine learning model trained to perform the following steps: generate tuning parameters used to improve the corresponding reserved memory pool storage area size dynamically allocated to the detected application based on one or more current application profile features associated with the detected application and the predicted cell size of that application; and dynamically modify the memory pool storage area size allocated to the detected application in response to the generated tuning parameters. The third machine learning model trained to generate tuning parameters used to improve the corresponding reserved memory pool storage area size dynamically allocated to the detected application and dynamically modify the memory pool storage area size allocated to the detected application in response to the generated tuning parameters further results in a reduction of memory and application processing resource waste in the memory pool while the application is running.

[0034] Figure 1 shows a general block diagram of a simple computer system 10, which includes a control processor or control processing unit (CPU) 11 for executing user applications, and a communication data and address bus 14 communicating with a top-level memory system 12 which includes a memory "heap" or memory pool storage area 15, which is a region of address space reserved for exclusive use by the running application. In embodiments of this specification, the system and method are invoked to dynamically allocate the size of the memory pool storage area 15 for the requesting application during the application's runtime. In a computer system implementation, the top-level memory system 12 may include registers, cache memory, main memory (e.g., random access memory, i.e., RAM, or dynamic random access memory, i.e., DRAM), electronic disks or optical disks, and other storage device memory (not shown). One type of memory shown in Figure 1 is a “heap” memory 15 (hereinafter referred to as a “memory pool” or “memory pool storage area”), which is a region of memory that is a reserved address space memory that can be used by applications running on the computer system 10 when granting memory allocation requests from, for example, an operating system (not shown) running on the computer system. This memory pool 15 consists of multiple fixed-size memory cells or blocks 20 designed to cooperate with and respond to memory manager and other executable program application function calls to program libraries that use allocation mechanisms (e.g., “malloc” and “free” in C, or the operators “new” and “delete” in C++). Within this memory area 15, the computer system 10 may create one or more memory “pools” or “heaps” 15 that are reusable and accessible by each requesting application instance in order to reduce the time it takes for a program to allocate / use / deallocate memory.

[0035] In one embodiment, memory pools may belong to a pool class that specifies a policy on how their memory is managed. Some memory pools are managed manually by heap management functions (e.g., by explicitly returning memory to the memory pool), while others are managed automatically (e.g., using a “garbage collector” mechanism designed to work with multiple pools to automatically reclaim unreachable memory blocks in different pools). In computer system 10, multiple discovered application instances running on computer system 10 can invoke heap management functions such as allocating, accessing, and requesting the memory management system to deallocate or free a number of reserved fixed-size memory pool blocks or cells 20 within the memory pool storage area. These reserved memory pool cells are represented by “handles” or references or object identifiers or “pointers” that contain the addresses of the stored memory blocks or cells they refer to at runtime. When an application requests memory allocation from the memory management system, the system reserves the corresponding memory pool storage area for the application based on the number of allocations and the memory cell size. Similarly, deallocating or freeing memory cells is also managed by the memory management system to ensure efficient use of the memory pool storage area. The size of the memory block or cell 20 of the requesting application is configurable, for example, 1 megabyte (or 1 MB), 20 MB, 100 MB, etc., and therefore the total size of the corresponding reserved memory pool storage area allocated to the requesting application is configurable.

[0036] In one aspect of this disclosure, a system and method are provided for dynamically allocating and adjusting a reserved memory pool storage area of ​​a size determined by using time-series data in order to improve performance and reduce costs.

[0037] Figure 2 shows a computer implementation system 100 for dynamically allocating and fine-tuning the size of a corresponding reserved memory pool storage area 15 for use by an application detected as currently running on the computer system 10 shown in Figure 1 (hereinafter referred to as the "detected application"). As shown in Figure 2, multiple computer system program applications 120 are shown as running on the CPU. In one embodiment, time-series data is acquired and stored for each currently running program application over a period used for dynamic memory adjustment of the corresponding memory pool storage area allocated to the application. In one embodiment, memory pool storage area usage attributes regarding the number of allocations, deallocations, and the size of each reserved memory cell per memory pool storage allocation requested by the detected application 121 are collected from each application as time-series memory usage data over a period such as 7 days, 6 months, 1 year, or longer, for use in an offline process to train several time-series prediction models implemented for dynamic memory pool adjustment. This time-series memory usage data is referred to as historical memory usage by the detected application.

[0038] As shown in Figure 2, based on the detected applications 121 running on the system, time-series memory pool usage data associated with each detected application data is collected over time for each detected application, and the data includes: historical time-series data 125 representing past memory usage, such as the number of memory pool allocation requests equivalent to the number of application instances running on the computer system (for example, running the application 10 times may result in 10 memory pool allocations); and historical time-series data 126 representing past memory usage, such as the size of the reserved storage area of ​​the allocated / deallocated memory pool, such as memory pool cell size requests, such as 20 megabytes, 100 megabytes, etc., as requested by each instance of the application. The historical time-series data 125 can be extracted as a vector obtained from a plot 128 that contains information about the number of allocation requests for memory, i.e., the number of historical allocations and deallocations that occurred over time during the execution of past application instances (e.g., on the X axis) and the size in megabytes of each memory pool allocation request (e.g., on the Y axis). This historical time-series data 125, which contains information about the number of allocation requests for memory from past use of application 121, is input as a data vector into a first machine learning time-series-based predictive model 130 (e.g., a neural network model) trained to predict the number of allocations 135 for instantaneous detected application 122 running on the computer system. In particular, the first machine learning time-series-based predictive model 130 is trained to detect memory usage patterns from any detected memory usage patterns over time, and the predictive model 130 can predict the number of allocations that may be requested while running, which is used to dynamically adjust and predict the number of allocations 135 for the currently detected application that is running.

[0039] Similarly, the historical time series data 126 includes information about the size of memory cells ("memory cell size") requested by applications running on the computing system over a past period. In embodiments, the memory cell size allocated in the memory pool is typically a fixed byte length, however, the fixed memory cell size is adjusted according to the methods of this disclosure. The historical time series data 126 can be extracted from a plot 129 that includes information about the number of allocation requests for memory, i.e., the number of historical allocations and deallocations that occurred over time during the execution of past application instances (e.g., on the X axis) and the memory cell size (e.g., in megabytes) (e.g., on the Y axis) of each past memory pool allocation request, and can be formed as a data vector. The historical time series data 126 representing the memory cell sizes of past memory pool cell allocations, such as those requested by application instances over a past period, is input as a data vector to a second machine learning time series forecasting model 140 trained to predict memory cell size values ​​142 for the current application 122 running on the computer system. A second machine learning time-series memory cell allocation size prediction model 140 is trained to detect memory usage patterns and any detected memory usage patterns, and the second machine learning time-series prediction model 140 predicts the size of the memory pool 142 which is used to dynamically adjust and predict the allocation size (memory pool size) of the currently detected application being run.

[0040] In a further embodiment, as shown in Figure 2, in a further implementation, the output of a second machine learning time series prediction model 140 of predicted allocation size values ​​142 is input to a clustering module 150 that generates a distribution 131 of predicted allocation sizes 132, 133 for each currently detected application running. That is, the clustering base module 150 runs on the computer system to predict one or more allocated memory cell sizes 145 for the currently running application. Using the k-means method applied to the predicted model allocation size output 142, the clustering module 150 determines a distribution 131 of memory cell size allocations 131, such as 10 megabytes, 50 megabytes, and 100 megabytes, that have been allocated by past application instances. For example, the clustering module 150 determines memory allocation size predictions for a first memory cell size 132 (e.g., 10 MB) and a second memory cell size 133 (e.g., 100 MB) based on previous memory request allocations by applications running on the system. In this embodiment, the distribution 131 of different memory cell size prediction clusters 132, 133 may be determined based on memory usage patterns detected as a result of historical memory allocation requests for each application instance that was previously running on the computer system.

[0041] Next, in Figure 2, in the overall flow, based on the predicted number of combined allocations value 135 and the predicted allocation memory cell size value 145, the decision is made in 155 by applying the rule-based adjustment method 155, namely: determining whether or not to dynamically allocate the corresponding reserved memory pool of the predicted memory pool storage area memory cell size value 160 in the first instance based on one or more of the predicted number of allocations, the predicted cell size of the clustered distribution of the predicted memory allocation sizes, and the allocation value, job priority level, and estimated job duration. The rule-based adjustment method applies rules or policies to determine the ongoing action of allocating or not allocating based on one or more factors such as the predicted number of allocations, the predicted cell size of the clustered distribution of the predicted memory allocation sizes, and the allocation value, job priority level, and estimated job duration. When it is decided to proceed, the same or different rules or policies may additionally determine whether to increase or decrease the corresponding predicted memory pool allocated memory cell size 160 based on the presence or occurrence of one or more events or circumstances that ensure an increase or decrease in the applied reserved memory pool storage area allocation size, e.g., per year, due to special promotions, geographical reasons, special customs, etc. In the exemplary embodiment shown in Figure 2, the output predicted memory pool allocated memory cell size 160 is a data vector {10, 50, 100}, where each of the three values ​​corresponds to the allocated cell size distribution 131 determined by the clustering module 150.

[0042] As further shown in Figure 2, the output of the determined rule-based tuning method for the memory pool allocation cell size value 160 may be further input into a regression model 175 for use in refining the dynamically recommended memory pool allocation size to improve memory utilization efficiency by more accurately pre-allocating memory cell sizes for direct use by the requesting application. In an embodiment, the computer system will further collect application-related data of this application instance to generate a profile of the application execution, the application profile features including, but are not limited to, a dataset reference count; an average count of requested allocations over a past period, e.g., last week; a maximum dataset size; an average size of data allocated over a past period, e.g., last week; the duration of previous batch jobs; and the average memory allocation duration over a past period, e.g., last week. Such application profile features may be input into a regression model 175 trained to predict a tuning parameter "P" used to fine-tune the program performance or the predicted memory pool size.

[0043] In particular, considering Figure 2, a trained regression model 175 is run to provide an adjustment parameter output value "P" 190, which is used to modify (improve or fine-tune) the predicted memory pool size 160 and the application profile features associated with the current application, as real-time data mapped to the currently detected application in operation, based on inputs including both time-series-based model predictions as memory pool allocation size 160 and application profile features associated with the current application, in order to provide adjustment parameter output values ​​"P" 190, which are used to modify (improve or fine-tune) the predicted memory pool size 160 to generate the final memory pool allocation size value 195.

[0044] As shown in Figure 2, the use of regression model 175 takes into account the characteristics of the current application running on the computer system, because the current memory usage attributable to the current application instance may change depending on the workload on any given day. Therefore, regression model 175 is trained to additionally take into account the application profile features of the currently running detected application in order to refine the cell size of the memory pool storage area. In an embodiment, the combined predicted allocation size value output 160 and the currently received real-time profile data of the currently running detected application are input to regression model 175 to fine-tune or refine the predicted memory size allocation value 160. In an embodiment, the trained regression model 175 receives both the current predicted memory pool allocation size value output 160 resulting from the application of the rule-based method and additionally receives a real-time data vector 170 containing a sequence of real-time application profile feature data 165 of the currently running application on the system, which includes real-world data of selected features in recent sample time slots. Based on these inputs 160 and 170, the regression model generates an adjustment parameter output value "P" 190 used to modify (improve or fine-tune) the predicted memory pool size 160, which indicates whether to increase or decrease the predicted memory pool size to produce the final memory pool allocation size value 195.

[0045] In a non-limiting embodiment, the regression model 175 is, for example, a neural network model, a decision tree network, or a random forest decision tree network, which is trained offline with time-series data associated with the application for use in generating a tuning parameter value "P" used to improve the cell size, where the data associated with the application includes, but is not limited to, a set of application profile features including dataset reference count, average dataset reference count for the previous week, maximum dataset size, average dataset reference count for the previous week, duration of previous batch jobs, and average duration of previous batch jobs in the previous week. The current profile feature dataset of this application is input into the regression model 175 used to predict the improved tuning parameter "P" 190.

[0046] In operation, for each currently detected application execution 122, system 100 generates a corresponding real-time data vector 165 containing current memory pool usage attributes such as the number of current memory pool allocations and the real-time current memory cell size for the most recent day or hour. For multiple running applications, multiple data vectors 166 are obtained. These multiple vectors are input to simulator system 180 to obtain the best corresponding tuning parameter 225. The regression model 175 is then trained using a data vector 170 consisting of the real-time data vector 165 of the currently running application tagged with a value 225 for the ground truth tuning parameter "P" determined from the simulator. The value 225 for the tuning parameter "P" is determined from the simulator, which acts as a ground truth label obtained from application features associated with past running applications. The regression model 175, such as a neural network decision tree or a random forest decision tree, is then trained using these inputs.

[0047] As further shown in Figure 2, system 100 is configured for offline training of a regression model 175 to generate or predict the adjustment parameter "P" 190 used to adjust the final memory pool allocation size value 195. The operating system can then dynamically configure or allocate the final memory pool allocation size value 195 for each application execution. As shown in Figure 2, for the currently running detected application, a corresponding set of data vectors 166 is generated, which represents the current real-time application memory usage in the computer system. An exemplary real-time data vector 166 is shown below: {3; 200; 40; …} {4; 500; 70; …} {3; 350; 63; …}

[0048] Next, using a simulator, each vector in the data vector set 166 is tagged with a corresponding tuning parameter value "P" 225 obtained from running the simulator 180 to simulate the execution of an application instance, and each of them is executed with a different candidate tuning parameter value. The determined candidate tuning parameter "P" value is determined by the simulator system 180 to characterize the performance or efficiency of the application after running multiple simulations and obtaining multiple simulation results on the simulator 180. That is, for each currently running application 122, the corresponding current real-time data value in the data vector 165 includes the current memory pool usage, including the number of current allocations and the allocated memory cell size for the currently running application. The method then runs each of the multiple data vectors in the data vector set 166 on the simulator 180, which is used to generate a training dataset used to train the regression model 175.

[0049] In particular, looking at the regression model training system 500 in Figure 3, historical time-series data 502 is collected, associated with the execution of each application 121 on the computer system. From the data 502 collected over previous durations or periods, e.g., weeks, months, etc., memory pool usage feature data 510 ("application profile features") extracted or generated from the collected data 502 are generated. In an exemplary embodiment, a set of "N" memory pool usage features 510 associated with the application is extracted or generated. These memory usage feature data 510 form the input to the simulator system for configuring the application to be simulated in the simulation system 180. These application profile feature data 510 are input to the simulator system to simulate the execution of the application under corresponding operating and workload conditions in order to obtain simulated performance results. The memory pool usage feature 510 may include, but is not limited to, the dataset reference count (e.g., feature 1), the average count for the previous week (e.g., feature 2), the maximum dataset size (e.g., feature 3); the average size of datasets since the previous week (e.g., feature 4); the duration of previous batch jobs (e.g., feature 5); and the average job duration for the previous week (e.g., feature 6).

[0050] These collected profile feature data 510 are used as input 510 to a simulator application running in a simulator computer system 180 that simulates the execution of the application to generate an output of the tuning parameter "P". In particular, the feature set data 510 is input to the simulator 180, which is programmed in an offline process to run a simulated application instance and generate a corresponding performance output measurement or value for use as a truth label for supervised regression model machine learning. That is, the simulator system 180 receives the application profile data features 510 as input, runs a simulation of the application under different feature set combinations, and obtains the best performance measurement or value in the instant application's input memory usage feature set 510. This best performance measurement or value is used as a ground truth label 520 for supervised learning of the regression model 175 to generate the memory size allocation tuning parameter "P".

[0051] As further shown, Figure 3 illustrates in more detail the use of the simulator 180 to create a training dataset containing generated labels representing tuning parameter values ​​"P" used to tag real-time and / or historical data vector sets 166 for training a regression model 175. During the collection of historical application profile features 510, the simulator simulates the execution of an application program based on these feature set values ​​to generate ground truth labels 520 for use in supervised regression model learning of the associated parameter "P". The simulator 180 performs a method to determine the value range of "P", which may include samples at regular intervals within the range to obtain a set of "P" values. Feature vectors are combined with different "P" values ​​to obtain a set of test samples. The method then runs (simulates its execution) the test samples to select the best "P" values ​​for that feature dataset (vector). In one embodiment, the method selects sample candidates for "P" for association with a feature vector dataset (e.g., 10 candidates are selected), and each instance of the application having those features is executed (e.g., 10 times), with each execution having a different "P" value. Here, the value of each tuning parameter "P" represents the performance difference or measurement between past simulated performance results when executed based on the current application profile features of the current application instance, including the historical average of the application's profile features in the past, and the current predicted number of assignments and the corresponding memory cell size of the current application instance running on the computer system. Finally, the results of the simulator 180, including the performance and job duration results of each execution program, are used to verify the "P" value and the best "P" value associated with the most efficient execution, depending on the predicted duration, for example, this is selected as the truth label "P" 520 for the association of this application instance's features with this set.Next, as shown in Figure 3, each feature set 510 for the simulated application is tagged with a selected "best" tuning parameter (label) P-value 225 obtained from the application execution on the simulator system 180. Each of the feature sets 510 and the determined tuning parameter "P" label 225 are then input as training data 530 into the regression model 175 for their training.

[0052] An example vector with six (6) application profile features used in the simulator of system 180 is shown below: {10,10,500,200,35,20, P=1.5} {10,11,200,200,21,20,P=1} {7,10,200,200,15,20, P=0.8} {10,6,1000,200,55,20, P=3}

[0053] Once trained on these historical time series data, the regression model 175 can generate tuning parameter values ​​"P" 190 based on the dataset input of any current application profile features.

[0054] Returning to Figure 2, the method then includes the step of obtaining a corresponding tagged vector set 176 to be input into the regression model 175 to generate a value 190 for the current tuning parameter "P" based on the profile feature set data associated with the currently running application, by tagging each corresponding real-time data vector 165 in the set 166 with the best truth label 225 obtained. The simulator 180 generates the majority of the data used to tag the training data input to the regression model. In the case of the exemplary current memory usage vector 166, each of the corresponding data vectors in the set 176 is tagged as a vector with the label 225 for the tuning parameter "P" shown in Figure 2. {3; 200; 40; …}[P(0.5)] {4; 500; 70; …}[P(0.7)] {3; 350; 63; …}[P(1.1)]

[0055] Figure 4 shows a further implementation 550 of the system implementation 500 in Figure 3. As further shown in the system 550 in Figure 4, after the method collects time-series memory usage data 502 of the current application, this data is processed by compression or averaging, etc., to obtain a current associated application profile feature vector 560 corresponding to the currently running application. This current associated application profile feature set 560 is input to a trained regression model 175 to generate a predicted tuning parameter value "P" 190 570 for the current application instance. The regression model 175 is trained to generate a tuning parameter "P" output 190 that represents a difference measure, for example, the performance difference between the currently running application instance (features of an existing job) and the historical features of these same application program instances (historical mean of the feature set). For example, when the regression model generates a tuning parameter value "P" < 1, this indicates that it is not necessary to correct, or may even reduce, the current predicted allocated memory cell size (the workload and data of the currently running application program instance are smaller than the historical average of the application's usage); however, when the regression model generates a tuning parameter value "P" > 1, this indicates that it is necessary to correct, by increasing, the current predicted allocated memory cell size (the current workload and data of the currently running application program instance are larger than the historical average of usage for this application instance in the past). Thus, in Figure 4, considering an exemplary predicted tuning parameter value of 575, where P = 1.2, predicted by regression model 175, this may indicate an increase in the predicted memory pool allocation size of 590.Therefore, for example, considering the predicted memory pool cell size output vector {10, 50, 100}, the value of P=1.2 will be greater than 1, and as a result, the final cell size of the memory pool storage area for this application will increase to {12M, 60M, 120M}, which in 590 means that there will be three allocated heap pools, namely: the first heap pool cell size: 12M; the second heap pool cell size: 60M; and the third heap pool cell size: 120M.

[0056] Figure 5 shows a method for handling received historical time-series data according to an embodiment, in particular a method 200 for compressing historical time-series data to obtain profile features of an application instance. As shown in Figure 5, each collected set of historical time-series data 125, 126 obtained from each plot 128, 129 is analyzed using a method for obtaining an application profile or application "features" used in the refinement or tuning of the memory pool. The historical period from which the historical time-series data is extracted from past detected application instances includes data from previous "N" historical data, and each previous historical data from the historical time-series data includes, but is not limited to, the cell size of the allocated memory pool 202; the corresponding job duration 204; the number of allocations 206; and the total allocation size value 208. For each acquired time-series historical data (of N historical data points), the system compresses the time-series historical data by performing a compression method 200 (e.g., LZ encoding, Huffman coding, arithmetic coding, etc.) to obtain data and information 210 that include, but are not limited to, the average data for the previous day duration 212; the average data for the previous week duration 214; the average data for the previous month duration 216; and the average data for the previous quarter duration 218. In embodiments, other parameter data values ​​220 that include, but are not limited to, the maximum data for the previous day duration; the maximum data for the previous week duration; the maximum data for the previous month duration; and the maximum data for the previous quarter duration are additionally determined by the compression model 200. The periods used in data averaging are not limited to daily or weekly durations, but may include monthly, quarterly, or any other period duration.

[0057] Figure 6A further shows the entire computer-based system 400, including a procedure for running both first and second machine learning time series forecasting models 130, 140 and a rule-based method 155 to predict the memory pool cell size of the currently running application. In the embodiment of Figure 6A, the historical time series data includes time series data that includes allocation numbers 402 associated with memory pool allocations requested by applications running on the computer system, and corresponding allocation sizes 405 for each memory allocation request, i.e., the size in bytes of a memory cell or block of memory, or the size of an object being created by the application. This data is compressed by a data compression model 200 that implements the common data compression technique of Figure 5, so that compressed time series data 412 of allocation numbers and compressed state 415 of allocation sizes can be obtained. The compressed time series data 412 of allocation numbers is input to the first machine learning time series-based forecasting model 130, and the compressed time series data 415 of allocation sizes is input to the second machine learning time series forecasting model 140. Both time prediction models can be conventional recurring neural networks (RNNs) or long short-term memory (LSTMs). The first machine learning time series-based prediction model 130 processes the allocation number time series data 412 and generates a corresponding prediction: predicted allocation number 422. The second machine learning time series prediction model 140 processes the allocation number time series data 415 and generates a corresponding prediction: predicted allocation size 425. Both the predicted allocation number 422 and the predicted allocation size 425 are input to a rule-based method 155 that implements rules or policies to calculate mathematical expectations or determine the total heap pool cell size 160 of the application.

[0058] For example, based on the application or comparison of predicted allocation values ​​and predicted allocation size values ​​to a rule or policy, the computer generates rule-based tuning method output data 160 that represents a rule-based result determination indicating the size of the memory pool that is or is not to be dynamically allocated for each currently running application. This rule-based tuning method output data 160 shows, for example, the heap memory or memory pool cell size (e.g., 10MB, 50MB, 100MB) that is to be dynamically allocated in a first instance, for example, where the output 100MB memory pool allocation corresponds to predicted allocation size cluster 132, and the 50MB allocation corresponds to predicted allocation size cluster 133. For example, the rule-based tuning method 155 analyzes and applies the combined predicated allocation number value 135 and the respective predicted clustered allocation size 145 and other criteria that characterize the application to the rule or policy. Exemplary criteria may include the application or job priority level or the predicted job duration representing the expected runtime of the application. In embodiments, rules or policies may specify memory cell size allocations for certain higher-priority or more critical jobs or applications, or for certain short or long-duration jobs, or alternately avoid dynamic memory pool allocations for lower-priority jobs or jobs with specified long or short durations. These rules / policies may specify or define the most efficient combination of application instances and corresponding size allocations, priorities, and / or expected durations to determine what size of memory pool to allocate as output 160 to the currently running application in a first instance, if any.For example, when a rule-based policy requires memory pool allocation for 10 application instances with a cell size of 10MB, then the predicted allocation number 135 for 6 instances requesting 10MB each may result in no memory pool allocation being provided based on such a rule or policy specifying a threshold number for allocation; however, when a rule-based policy defines the system capacity to accommodate 10 instances of an application, each requesting 10MB, then the predicted allocation number for 16 instances requesting 10MB each may result in a rule-based adjustment output threshold value 160 indicating a recommendation to increase the memory pool allocation for this currently running application based on this rule or policy. For example, when an application is executed only once or a number of times that is a lower threshold from the defined rule, the memory pool will not be allocated.

[0059] Figure 6B further illustrates an alternative computer-based method 450 that includes a procedure for running both the first and second machine learning time series forecasting models 130, 140 and a rule-based method 155 to predict the heap pool cell size. In the embodiment of Figure 6B, the historical time series data includes allocation counts 402, representing a time series of the number of heap memory object allocations requested by the application, and the corresponding size 405 for each memory allocation, i.e., the size in bytes of the block of memory or the size of the object being created by the application. This data can be compressed by a data compression model 200 to obtain compressed time series data 412 for allocation counts and compressed state 415 for allocation sizes. The compressed time series data 412 for allocation counts is shown as input to the first machine learning time series-based forecasting model 130, and the compressed time series data 415 for allocation sizes is shown as input to the second machine learning time series forecasting model 140. The first machine learning time series-based forecasting model 130 processes the allocation count time series data 412 and generates a corresponding forecast: predicted allocation count 422. A second machine learning time series forecasting model 140 processes time series data 415 of allocation counts and generates a corresponding forecast: predicted allocation size 425. In this alternative embodiment, the predicted allocation size 425 based on historical time series data is input to a clustering base module 150 that implements k-means or a similar clustering algorithm for processing them, and determines a clustering distribution based, for example, on a set of requested malloc size values ​​450 called from the requesting application. In an embodiment, the clustering base module 150 may apply k-means to obtain a set or distribution of allocation size values ​​131 based on past memory allocation requests. This is one or more of this set of allocation size values ​​132, 133 that can be input to a rule-based method (regression model) 175 along with allocation counts 422 to generate a predicted heap pool cell size 160.

[0060] Both the predicted number of allocations 422 and the predicted allocation size 425 are input to a rule-based method 155 that calculates a mathematical expectation used to determine the memory cell size 160 of the memory pool storage area.

[0061] The system in Figure 6B can be used to process an exemplary time series of historical data for predicting the size of a memory pool. Here, the exemplary time series data represents a customized batch application that will process daily credit card transactions. The memory usage of the application varies from day to day. In the example, the time series of historical data is used to predict the distribution of the allocation size for this job.

[0062] Figure 7 shows a method 600 implemented in the computer system of Figure 1 for dynamically adjusting a memory pool using time-series data. A first step 602 includes the computer system's detection of applications that are running and using memory allocated in the memory pool storage area of ​​the computer system. Next, in 605, the method extracts current and / or historical time-series data based on the memory usage of the memory pool for each currently running application. In embodiments, current real-time memory usage data is not required for these two prediction models and is merely historical data. As a non-limiting example, this time-series data may be in vector form: {3; 200; 40; …} This includes the number of memory allocation requests allocated to the application (e.g., 3) and the allocation size per request (e.g., 200MB, 40MB, etc.).

[0063] Next, in 611 of Figure 7, in response to the received time-series data vector of the currently running application, the method runs a first trained time-series forecasting model to predict the number of planned allocations requested by the requesting application running on the computer system, based on time-series historical data. Continuing, in 615, the method runs a second trained time-series forecasting model to predict the planned memory allocation size to be allocated in the memory pool storage area for each requesting application, based on time-series historical data. Next, in 620 of Figure 7, the method applies a rule or policy to determine whether to accept and / or modify the predicted allocation size for the requesting application. The applied rule-based method or policy may consider one or more factors, namely: the current predicted amount of the requested memory pool cell size and / or the predicted number of allocations, the assigned priority level of the application, the predicted job duration, and current events or circumstances that could justify increasing or decreasing the applied memory allocation size. Continuing, in 624 of Figure 7, the method determines whether to modify the requested memory pool allocation based on one or more factors.

[0064] If, in step 624, the applied rule or policy is determined to guarantee a modification of the predicted memory pool allocation size, the process then proceeds to step 630, where a further trained time-series forecasting model is run to predict tuning parameters "P" that will be used to refine the predicted allocation size based on the profile features of the current requesting application. These current profile features are represented in data vectors such as {feature 1, feature 2, feature 3, feature 4, feature 5, ..., feature N}, where each value corresponds to a current application profile feature. Based on the predicted tuning parameter values, the method proceeds to step 636 to dynamically allocate the corresponding reserved memory in the requesting application's memory pool based on the predicted size allocation and tuning parameters. The method then returns to step 602 for sequential processing in the computer system.

[0065] Therefore, in this embodiment, data associated with the application (e.g., profile data) is used to refine the cell size. In this embodiment, the method may be used to refine the allocation size of the memory pool or heap based on profile feature data associated with the actual application. For example, when a customer application has promotional activity, the transaction volume and data volume will increase significantly, and the memory size of this event cannot be accurately predicted through time-series data alone. In this embodiment, actual real-time application profile data may be used to refine the adjustment parameter "P".

[0066] Alternatively, returning to 624, if it is determined that the applied rule or policy does not guarantee a modification of the expected memory pool allocation size, the process then proceeds to stage 633, where the computer system dynamically allocates the corresponding reserved memory in the requesting application's memory pool based on the expected size allocation and the expected number of received requests. The process then returns to stage 602 for continuity processing in the computer system.

[0067] Figure 8 shows a method 700 implemented in the computer system of Figure 1 for training a regression model used to generate or predict tuning parameters for use in refining the size allocation of a memory pool using time-series data. A first step 702 includes the computer system detecting applications that are running and that use memory allocated in the memory pool storage area.

[0068] Next, in 705, the method obtains time-series data from historical time-series data for past memory usage of the memory pool by the detected application associated with calculating one or more application profile features. As shown in Figure 5, the historical application profile feature data may be compressed time-series data using a data compression method. Continuing to 708 in Figure 8, the method forms an input data vector containing calculated application profile features for each past requesting application based on historical time-series data associated with past allocation requests received from the requesting application. To run a regression model, in an embodiment, the past profile features are represented as a historical application profile feature data vector, e.g., {10, 10, 500, 200, 35, 20…}, where each value corresponds to a current application profile feature, e.g., dataset reference count (e.g., 10), average count for the previous week (e.g., 10), maximum dataset size (e.g., 50 MB); average size for the previous week (e.g., 200 MB); duration of previous batch jobs (e.g., 10); and average job duration for the previous week (e.g., 20), etc.

[0069] Continuing to Figure 8, 711, for each application instance, based on the historical profile features of each application, the method obtains a ground truth label for each instance of the historical application profile feature data vector for use in supervised learning of a regression model for use in predicting tuning parameters for use in refining the predicted allocated memory size of the currently running application. Next, continuing to Figure 8, 714, each historical application profile feature data vector associated with the request application is tagged with an additionally obtained tuning parameter value "P" based on the historical time series data described above. For example, an application profile feature data vector may be represented as a historical application profile feature data vector such as {10,10,500,200,35,20, P=1.5}. Using each historical application profile feature data vector tagged with an additionally acquired tuning parameter value "P", the method can proceed to 717 and train a regression model using the application profile feature vector and the ground truth tuning parameter label "P" to use in predicting the tuning parameter to determine how much the determined memory allocation in the memory pool of the currently running application will be modified based on the current profile features of the current application.

[0070] Figure 9 shows a method 800 implemented in a simulator running on the computer system in Figure 1 for generating ground truth labels used in training a regression model. The generated ground truth labels are used to train a regression model to generate or predict tuning parameters for use in refining memory pool size allocation determined using historical time-series data related to the requested application. The first step 802 includes determining the value range of the tuning parameter "P" for that application. Next, in 805 of Figure 8, it is performed to generate a sample test application at regular intervals within the range in order to obtain a set of "P" values. Next, in 808, a step is performed to combine a feature vector and different "P" values ​​in the set in order to obtain a set of test application samples. Next, in 811, the test sample application is executed in the program simulator. Continuing to 814, the method determines the corresponding duration for running the test application sample in the simulator. Next, in 820, it is determined whether the current test application sample results in the shortest duration. In step 820, if it is determined that the current test application sample does not result in the minimum duration, the process then returns to 808 to tag the feature vector with a different "P" value, and the process from 811, 814, and 820 is repeated with the newly tagged vector. In step 820, once it is determined that the current test application sample and the new feature vector combined with a different "P" value in the set result in the minimum duration, the process proceeds to 824, where the "P" value associated with the current minimum test sample application duration is recorded. Once all "P" values ​​in the range have been processed in the simulator, in step 828, the "P" values ​​are returned as truth labels to train the regression model described above using the combined feature vector of application profile features.

[0071] The methods shown in Figures 7, 8, and 9, implemented in System 100 of Figure 2, further include, depending on the application, a step of monitoring the actual usage of the allocated memory heap, and a step of providing the actual usage as feedback for modifying or adjusting both the time series forecast and regression models.

[0072] The systems and methods presented herein improve program performance and reduce costs by automatically provisioning and managing memory pool cell sizes. The described approach can significantly reduce the manual effort required for memory pool adjustment across a large number of diverse applications. Furthermore, the approach can automatically provision appropriate memory pool cell sizes adapted to various applications. Moreover, even for the same application, the approach can automatically provision appropriate memory pool cell sizes adapted to each execution. The approach is technically beneficial to application programs regardless of the platform / operating system on which they are deployed.

[0073] Various aspects of this disclosure are described by explanatory text, flowcharts, block diagrams of computer systems, and / or block diagrams of machine logic included in embodiments of computer program products (CPPs). With respect to any flowchart, depending on the technology involved, operations may be performed in a different order than those shown in a given flowchart. For example, again, depending on the technology involved, two operations shown in consecutive flowchart blocks may be performed in reverse order, as a single integrated stage, simultaneously, or with at least partial time overlap.

[0074] Embodiments of a computer program product ("CPP Embodiment" or "CPP") are terms used in this disclosure to describe any set of one or more storage media (also called "mediums") that collectively comprise a set of one or more storage devices that collectively contain machine-readable code corresponding to instructions and / or data for performing computer operations specified in a given CPP claim. A "storage device" is any tangible device capable of holding and storing instructions for use by a computer processor. Computer-readable storage media may be, but are not limited to, electronic storage media, magnetic storage media, optical storage media, electromagnetic storage media, semiconductor storage media, mechanical storage media, or any preferred combination thereof. Some known types of storage devices, including these media, include diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), compact disc read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanically encoded devices (such as pits / lands formed on the main surface of a punch card or disk), or any suitable combination of the foregoing. When the term "computer-readable storage medium" is used in this disclosure, it shall not be interpreted as storage in the form of a transient signal itself, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, optical pulses passing through optical fiber cables, electrical signals communicated through wires, and / or other transmission media.As those skilled in the art will understand, data is typically moved at several intermittent points during the normal operation of a storage device, such as during access, defragmentation, or garbage collection; however, data is not transient while it is stored, and therefore the storage device is not transient.

[0075] As shown in Figure 9, the computing environment 900 includes an example of an environment for executing at least some computer code involved in carrying out the method of the invention, such as code 701 for dynamically allocating the size of a memory pool to be allocated in pool memory for multiple applications running on a computer system according to the method shown in Figures 7 to 9. In addition to block 701, the computing environment 900 includes, for example, a computer 901, a wide area network (WAN) 902, an end user device (EUD) 903, a remote server 904, a public cloud 905, and a private cloud 906. In this embodiment, the computer 901 includes a processor set 910 (including processing circuits 920 and a cache 921), a communication fabric 911, volatile memory 912, persistent storage 913 (including an operating system 922 and block 701 as shown above), a peripheral device set 914 (including a user interface (UI) device set 923, storage 924, and an Internet of Things (IoT) sensor set 925), and a network module 915. The remote server 904 includes the remote database 930. The public cloud 905 includes the gateway 940, the cloud orchestration module 941, the host physical machine set 942, the virtual machine set 943, and the container set 944.

[0076] Computer 901 may take the form of a desktop computer, laptop computer, tablet computer, smartphone, smartwatch, or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device currently known or to be developed in the future that is capable of running programs, accessing networks, or querying databases such as the remote database 930. As is well understood in the field of computer technology, and depending on the technology, the execution of a computer implementation can be distributed across multiple computers and / or multiple locations. However, in this presentation of computing environment 900, in order to keep the presentation as concise as possible, the detailed discussion focuses on a single computer, specifically computer 901. Computer 901 is not shown in the cloud in Figure 9, but it may be located in the cloud. On the other hand, computer 901 is not required to be in the cloud unless it can be definitively shown.

[0077] The processor set 910 includes one or more computer processors of any type currently known or to be developed in the future. The processing circuitry 920 may be distributed across multiple packages, for example, multiple coordinated integrated circuit chips. The processing circuitry 920 may implement multiple processor threads and / or multiple processor cores. The cache 921 is memory located within the processor chip package and is typically used for data or code that should be available for high-speed access by threads or cores running on the processor set 910. The cache memory is typically organized into multiple levels depending on its relative proximity to the processing circuitry. Alternatively, some or all of the cache for the processor set may be located "off-chip". In some computing environments, the processor set 910 may operate with qubits and be designed to perform quantum computing.

[0078] Computer-readable program instructions are typically loaded onto computer 901, causing the processor set 910 of computer 901 to perform a series of operational steps, thereby executing the computer implementation method. Therefore, instructions executed in this manner will instantiate the methods specified in the flowcharts and / or descriptions of the computer implementation methods contained in this document (collectively referred to as the "Methods of the Invention"). These computer-readable program instructions are stored in various types of computer-readable storage media, such as the cache 921 and other storage media described below. The program instructions and associated data are accessed by the processor set 910 to control and direct the execution of the method of the present invention. In the computing environment 900, at least some of the instructions for executing the method of the present invention may be stored in block 200 in persistent storage 913.

[0079] The communication fabric 911 is a signal conduction path that enables various components of the computer 901 to communicate with one another. Typically, this fabric is made up of switches and conductive paths, such as buses, bridges, physical input / output ports, and similar components. Other types of signal communication paths, such as optical fiber communication paths and / or wireless communication paths, may be used.

[0080] Volatile memory 912 is any type of volatile memory currently known or to be developed in the future. Examples include dynamic type random access memory (RAM) or static type RAM. Typically, volatile memory 912 is characterized by random access, but this is not required unless explicitly stated. In computer 901, volatile memory 912 is located in a single package and resides inside computer 901, but alternatively or in addition, volatile memory may be distributed across multiple packages and / or located externally to computer 901.

[0081] The persistent storage 913 is any form of non-volatile storage for a computer, currently known or to be developed in the future. The non-volatility of this storage means that the stored data is maintained regardless of whether power is supplied to the computer 901 and / or directly to the persistent storage 913. The persistent storage 913 may be read-only memory (ROM), but typically at least a portion of the persistent storage allows for writing, deleting, and rewriting of data. Some well-known forms of persistent storage include magnetic disks and solid-state storage devices. The operating system 922 may take several forms, such as various known proprietary operating systems or open-source portable operating system interface (CSI) type operating systems employing a kernel. The code contained in block 200 typically includes at least a portion of computer code involved in performing the method of the present invention.

[0082] The peripheral device set 914 includes a set of peripheral devices for the computer 901. Data communication connections between the computer 901's peripheral devices and other components may be implemented in various ways, such as Bluetooth connections, Near-Field Communication (NFC) connections, connections made by cables (e.g., universal serial bus (USB) type cables), insert-type connections (e.g., secure digital (SD) cards), connections made through local area communication networks, and even connections made through wide area networks such as the internet. In various embodiments, the UI device set 923 may include components such as a display screen, speaker, microphone, wearable devices (e.g., goggles and smartwatches), keyboard, mouse, printer, touchpad, game controller, and haptic devices. Storage 924 is external storage such as an external hard drive, or insertable storage such as an SD card. Storage 924 may be persistent and / or volatile. In some embodiments, storage 924 may take the form of a quantum computing memory device for storing data in the form of qubits. In embodiments where computer 901 is required to have a large amount of storage (for example, computer 901 locally stores and manages a large database), this storage may be provided by peripheral storage devices designed to store very large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 925 consists of sensors that can be used in Internet of Things applications. For example, one sensor may be a thermometer and another may be a motion detector.

[0083] The network module 915 is a collection of computer software, hardware, and firmware that enables computer 901 to communicate with other computers via the WAN 902. The network module 915 may include hardware such as a modem or Wi-Fi signal transceiver, software for packetizing and / or depacketizing data for communication network transmission, and / or web browser software for communicating data over the Internet. In some embodiments, the network control and network forwarding functions of the network module 915 are performed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software-defined networking (SDN)), the control and forwarding functions of the network module 915 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for performing the method of the present invention can typically be downloaded from an external computer or external storage device to computer 901 via a network adapter card or network interface included in the network module 915.

[0084] WAN902 is any wide area network (e.g., the Internet) that can communicate computer data over non-local distances using any currently known or future-developed technology for communicating computer data. In some embodiments, WAN902 may be replaced and / or complemented by a local area network (LAN), such as a Wi-Fi network, designed to communicate data between devices located in a local area. WANs and / or LANs typically include computer hardware such as copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0085] The end-user device (EUD) 903 is any computer system used and controlled by an end-user (e.g., a customer of the company operating computer 901) and can take any of the forms described above in relation to computer 901. Typically, EUD 903 receives useful and valuable data from the operation of computer 901. For example, in a hypothetical case where computer 901 is designed to provide recommendations to the end-user, these recommendations would typically be communicated from the network module 915 of computer 901 to EUD 903 via WAN 902. In this way, EUD 903 can display or otherwise present the recommendations to the end-user. In some embodiments, EUD 903 may be a client device such as a thin client, heavy client, mainframe computer, or desktop computer.

[0086] The remote server 904 is any computer system that provides at least some data and / or functions to computer 901. The remote server 904 may be controlled and used by the same entity that operates computer 901. The remote server 904 represents a machine that collects and stores useful and beneficial data for use by other computers, such as computer 901. For example, in a hypothetical case where computer 901 is designed and programmed to provide recommendations based on historical data, this historical data may be provided to computer 901 from the remote database 930 of the remote server 904.

[0087] Public Cloud 905 is any computer system available for use by multiple entities, providing on-demand availability of computer system resources and / or other computing capabilities, particularly data storage (cloud storage) and computing capabilities, without direct active management by the user. Cloud computing typically leverages resource sharing to achieve coherence and economies of scale. Direct active management of computing resources in Public Cloud 905 is performed by the computer hardware and / or software of the Cloud Orchestration Module 941. The computing resources provided by Public Cloud 905 are typically implemented by virtual computing environments running on various computers that make up the host physical machine set 942, which is the universe of physical computers available in and / or to Public Cloud 905. The virtual computing environment (VCE) typically takes the form of virtual machines from the virtual machine set 943 and / or containers from the container set 944. These VCEs may be stored as images and are understood to be transferable either as images or after VCE instantiation, among and between various physical machine hosts. The cloud orchestration module 941 manages the transfer and storage of images, deploys new VCE instantiations, and manages active instantiations of VCE deployments. The gateway 940 is a collection of computer software, hardware, and firmware that enables the public cloud 905 to communicate over the WAN 902.

[0088] Here, some further explanation of virtualized computing environments (VCEs) is provided. A VCE can be stored as an "image." A new active instance of a VCE can be instantiated from an image. Two well-known types of VCEs are virtual machines and containers. A container is a VCE that uses operating system-level virtualization. This refers to an operating system feature where the kernel allows for the existence of multiple isolated user-space instances called containers. These isolated user-space instances typically behave like actual computers from the perspective of the programs running within them. A computer program running on a typical operating system can utilize all of that computer's resources, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, a program running inside a container can only use the contents of the container and the devices allocated to the container, which is a known feature of containerization.

[0089] The private cloud 906 is similar to the public cloud 905, except that the computing resources are available for use by a single enterprise only. While the private cloud 906 is shown as communicating with the WAN 902, in other embodiments, the private cloud may be completely isolated from the internet and accessible only via a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types), often implemented by different vendors. Each of the multiple clouds remains a separate discrete entity, but the larger hybrid cloud architecture is coupled by standardized or proprietary technologies that enable orchestration, management, and / or data / application portability between the multiple configuration clouds. In this embodiment, both the public cloud 905 and the private cloud 906 are part of a larger hybrid cloud.

[0090] All corresponding structures, materials, functions, and equivalents of elements in the following claims are intended to include any structures, materials, or functions for performing a function in combination with other claimed elements, such as those specifically claimed. The description of the present invention is presented for illustrative and explanatory purposes only and is not intended to exhaust or limit the invention to the disclosed form. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the invention. Embodiments and terminology are selected and described to best illustrate the principles and practical applications of the invention and to enable other those skilled in the art to understand the invention to various embodiments with various modifications suited to the particular intended use.

Claims

1. A hardware processor associated with memory that stores program instructions within a computer system: A procedure for detecting one or more applications running on the computer system, wherein the computer system's memory has a memory pool storage area for exclusive use by the applications; and for each detected application: A procedure to run a first machine learning model trained to predict the number of allocation requests for memory cells in the memory pool storage area for the detected application, using time-series data obtained from past memory usage by the detected application; A procedure for running a second machine learning model trained to predict the size of memory cells to be allocated in the memory pool storage area for each detected application, using the time-series data obtained from the past memory usage by the detected application; and A procedure for dynamically allocating a corresponding reserved memory pool storage area of ​​a size based on the predicted number of allocations and the predicted memory cell size for each detected application running on the computer system. A system for allocating memory in a memory storage area of ​​a computer system, comprising a hardware processor that executes the program instructions that constitute the processor to perform the above.

2. The first machine learning model is a time-series prediction model trained with historical data associated with memory pool storage area usage from detected application instances previously executed on the computer system, wherein the historical data including the time-series data includes the number of memory allocations and deallocations in the memory pool storage area for each detected application previously executed; and The system according to claim 1, wherein the second machine learning model is a time-series prediction model trained with historical data associated with memory pool storage area usage from past detected application instances, the historical data including the time-series data includes the size of the memory cells that are to be allocated in the memory pool storage area for each detected application that has been executed in the past.

3. Prior to the aforementioned dynamically allocated step, the hardware processor further: The system according to claim 1, configured to apply rules or policies for determining whether to proceed with dynamically allocating or not allocating the corresponding reserved memory size of memory in the memory pool storage area based on the predicted number of allocations and the predicted memory cell size of the detected application.

4. In order to dynamically allocate the corresponding reserved size of memory in the memory pool storage area for use by the detected application running on the computer system, the hardware processor further: Based on the predicted number of allocations and the predicted memory cell size, apply a rule or policy to the detected application to determine whether to increase or decrease the amount of memory size allocated in the memory pool storage area. The system according to claim 3, configured as described above.

5. In order to dynamically allocate the corresponding reserved memory pool storage area for use by the detected application, the hardware processor further: To predict the distribution of memory pool storage area size values ​​associated with the detected applications, a clustering method is applied to the time-series data obtained from past memory usage by the applications. The system according to claim 1, configured as described above.

6. The aforementioned hardware processor further: A procedure for generating tuning parameters used to improve the corresponding reserved memory pool storage area size dynamically allocated to the detected application, based on one or more current application profile features associated with the detected application and the predicted cell size of that application; and A procedure for dynamically modifying the memory pool storage area size allocated to the detected application in response to the generated adjustment parameters. The system according to claim 2, configured to run a third machine learning model trained to perform the following:

7. The aforementioned hardware processor further: A procedure for collecting time-series data of historical data, including one or more application profile features associated with the past memory pool storage area usage of the detected application instances that were previously executed on the computer system; and A procedure for training the third machine learning model using supervised machine learning with model training data that includes the collected one or more application profile feature data associated with the past memory pool storage area usage of the detected application instance, and tuning parameter labels associated with the generated tuning parameters. The system according to claim 6, configured to perform the following:

8. The system according to claim 7, wherein the one or more profile features of each request application include one or more selected from dataset reference count, average dataset reference count over a past period; maximum dataset size, average dataset reference count over the past period, batch job duration, and average batch job duration over the past period.

9. A procedure for simulating the execution of each detected application using the application profile features of the requested application; a system performing the simulation executing samples of applications using different combinations of application profile features; and a procedure for determining the tuning parameter labels when training the third machine learning model to generate the tuning parameters used to improve the predicted memory cell size based on the performance differences between the sampled applications. The system according to claim 8, further comprising a system for performing the following.

10. In a hardware processor associated with memory within a computer system, the step of detecting one or more applications running on the computer system, the memory has a memory pool storage area for exclusive use by the applications; and for each detected application: A step of running a first machine learning model on the hardware processor, which has been trained to predict the number of allocation requests for memory cells in the memory pool storage area for the detected application, using time-series data obtained from past memory usage by the detected application; A step of running on the hardware processor a second machine learning model trained to predict the size of memory cells to be allocated in the memory pool storage area for each detected application, using the time-series data obtained from the past memory usage by the detected application; and, For each detected application running on the computer system, the hardware processor dynamically allocates a corresponding reserved memory pool storage area of ​​a size based on the predicted number of allocations for the detected application and the predicted memory cell size. A method for allocating memory in a memory storage area within a computer system, comprising the following:

11. The first machine learning model is a time series forecasting model, and the method further: The step of training the time-series prediction model using the hardware processor and historical data associated with memory pool storage area usage from detected application instances previously executed on the computer system, wherein the historical data including the time-series data includes the number of memory allocations and deallocations in the memory pool storage area for each detected application previously executed. Equipped with; The second machine learning model is a time series forecasting model, and the method further: The step of training the time-series prediction model using the hardware processor with historical data associated with memory pool storage area usage from past detected application instances, wherein the historical data including the time-series data includes the size of the memory cells that are to be allocated in the memory pool storage area for each detected application that has been executed in the past. The method according to claim 10, comprising:

12. Prior to the step of dynamically allocating, the method further: Steps include: applying rules or policies by the hardware processor to first determine whether to proceed with dynamically allocating the corresponding reserved memory size of the memory in the memory pool storage area based on the predicted number of allocations and the predicted memory cell size of the detected application, based on the predicted number of allocations and the predicted memory cell size of the memory; and not proceeding with not allocating the memory. The method according to claim 11, comprising:

13. The step of dynamically allocating the amount of memory in the corresponding reserved memory pool storage area for use by the detected application is: Steps include: applying rules or policies to the detected application based on the predicted number of allocations and the predicted memory cell size, using the hardware processor to determine whether to increase or decrease the amount of memory allocated in the memory pool storage area. The method according to claim 12, having the following characteristics.

14. The step of dynamically allocating a storage area of ​​the corresponding reserved memory pool size for use by the detected application is as follows: The hardware processor applies a clustering method to the time-series data obtained from past memory usage by the detected application in order to predict the distribution of memory pool storage area size values ​​associated with the detected application. The method according to claim 12, having the following characteristics.

15. A step of running a third machine learning model on the hardware processor, which is trained to generate tuning parameters used to improve the memory pool storage area size dynamically allocated to the detected application, based on one or more current application profile features associated with the detected application and the predicted cell size of that application; and Steps to dynamically adjust the size of the memory pool storage area allocated to the detected application using the hardware processor in response to the generated adjustment parameters. The method according to claim 12, further comprising the above.

16. A step of collecting time-series data by the hardware processor, which includes one or more application profile features associated with the past memory pool storage area usage of the detected application instances that were previously executed on the computer system; and The third step involves training the machine learning model using supervised machine learning with model training data that includes the collected application profile feature data associated with the past memory pool storage area usage of the detected application instance, and tuning parameter labels associated with the generated tuning parameters. The method according to claim 15, further comprising:

17. The method according to claim 16, wherein the one or more profile features for each request application include one or more selected from a dataset reference count, an average dataset reference count over a past period; a maximum dataset size, an average dataset reference count over the past period, the duration of a batch job, and the average duration of a batch job over the past period.

18. In the stage where the execution of each detected application is simulated in a program simulator using the application profile features of the requested application, the system performing the simulation executes sample applications using one or more different combinations of application profile features, and The step of determining the tuning parameter labels when training the third machine learning model to generate the tuning parameters used to improve the predicted memory cell size value based on the performance differences between sampled applications. The method according to claim 17, further comprising:

19. A computer program that causes a computer to perform the method according to any one of claims 10 to 18.

20. A computer-readable storage medium recording the computer program described in Claim 19.

Images