Memory Allocation Extension of Microservices

Abstract

A computer-implemented method (300) for extending the memory allocation of microservices, wherein the method is executed on a microservice orchestrator (110) and comprises: Providing (301) a categorization analysis for input / output operation patterns of microservice containers (125, 126, 135, 136) in storage systems; Categorizing (302) a microservice container based on categorization analysis, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and Providing (309) the categorization in conjunction with the input / output operations of microservice containers to a storage system for use in the memory allocation of the input / output operations.

Description

TECHNICAL FIELD

[0001] The present disclosure relates to microservices memory allocation, and more particularly to extending memory allocation based on data exchange between microservice orchestrators and block storage controllers. BACKGROUND

[0002] Microservices are a software development mechanism designed to decouple applications from their implementations. This design philosophy has several advantages, particularly promoting modularity, scalability, and architecture-independent design. In recent years, containerization has become increasingly popular as a means of implementing and orchestrating microservice-oriented architectures. For example, Kubernetes ®(KUBERNETES is a trademark of the Linux Foundation) is an open-source container orchestration system for automating the deployment, scaling, and management of applications. It works with a range of container tools, including DOCKER. ® (DOCKER is a trademark of Docker, Inc.).

[0003] Docker is a tool that packages applications into something similar to lightweight virtual machines. These applications can become environment-agnostic. An example of something that can be containerized is a database. For such databases, the associated storage can be specified. In Kubernetes, the container storage interface is used to implement a provisioning layer from which volumes can be created. Volumes can be provisioned and made accessible to nodes and running snapshot operations.

[0004] The document US 2010 / 0 165 072 A1 describes a conference control device comprising a communication processing unit that performs transmission / reception processing of conference information including voice information and image information between the conference control device and a plurality of video conference terminals via a network; an information collecting unit that collects information about connection paths between the conference control device and the respective video conference terminals; a grouping unit that sorts the plurality of video conference terminals into a plurality of groups based on information about the connection paths collected by the information collecting unit; a band monitoring unit that monitors a usage band of the communication processing unit in accordance with each group;and a bandwidth control unit that, when the group whose usage band is smaller than a predetermined value is detected by the band monitoring unit, controls the bandwidth of the video conference terminals belonging to the group;

[0005] Document US 8 271 757 B1 describes technologies for implementing Container Space Management (CSM) in a data storage system. Performance can be improved by ensuring that the maximum number of drive spindles is available for I / O loads. This can be achieved by distributing data evenly across all drive spindles, even if the drive spindles are located in different logical drives.

[0006] Document US 8,442,311 B1 describes a method and apparatus for encoding an image. A decomposition circuit comprises a set of pixel filters used to identify image pixels, background pixels, and text pixels of the image. An image encoding circuit comprises a lossy discrete transform encoder for encoding the image pixels, a lossless constant color encoder for encoding the background pixels, and a lossless discrete color encoder for encoding the text pixels. SUMMARY OF THE INVENTION

[0007] According to one aspect of the present disclosure, a computer-implemented method for memory allocation augmentation of microservices is provided, the method executed on a microservice orchestrator and comprising: categorizing a microservice container, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and providing the categorization in association with the input / output operations of microservice containers to a memory system for use in memory allocation of the input / output operations.

[0008] Various data characteristics can impact optimal storage location for data in a storage system. For example, variable compressibility, application workloads such as random or sequential access patterns, and so on can impact optimal storage location for data. Another example would be knowledge passed by the microservice container regarding how long the container is likely to exist. Containers that are provisioned briefly and then deleted can delay garbage collection until all memory for the container is no longer needed. Providing a categorization of microservice container input / output operations to the storage controller, where the categorization is based on predicted memory behavior, enables optimized memory allocation and garbage collection.

[0009] The method may include providing a categorization analysis for analyzing input / output operation patterns in storage systems to categorize an underlying microservice image and to categorize contexts of microservice containers, wherein the categorization analysis is used to categorize a microservice container. The input / output operation patterns in storage systems may include storage characteristics of input / output operations that impact the efficiency of memory allocation and garbage collection. Analyzing the input / output operation patterns may use machine learning techniques for grouping into different usage patterns.

[0010] The method may include: receiving input / output operations from microservice containers issued by the microservice container; and analyzing the input / output operations with the categorization analysis to establish or modify (e.g., modify) a categorization for the microservice container.

[0011] Analyzing input / output operations with categorization analysis to establish or modify categorization for the microservices container may include: initially categorizing the microservices container based on the categorization of the underlying microservices image; and adjusting the initial categorization based on a context of the microservices container. The categorization of the underlying microservices image may be based on historical memory behavior, expected time the container exists, and / or a user-configured categorization.

[0012] Customizing the initial categorization based on a microservice container context may include user-based labeling of microservice containers to support categorization.

[0013] Adjusting the initial categorization based on the microservice container's context may include higher-level context analysis based on classifying the microservice container as belonging to a group of containers and the group's historical storage behavior. The group may be a capsule in the form of a collection of microservice containers colocated on hardware and sharing resources, or the group may be a service in which capsules collaborate.

[0014] Analyzing input / output operations with categorization analysis to establish or modify categorization for the microservice container may involve continuously analyzing input / output operations of a microservice container and updating the categorization. This allows the categorization to be modified on the fly in response to a container process's workload.

[0015] Machine learning categorization techniques can be used to identify a category that is highly relevant to a microservices container's performance profile.

[0016] Providing the categorization associated with the input / output operations of microservice containers to a storage system for use in allocating memory for the input / output operations may include describing each input / output operation or group of input / output operations with the categorization details. This may also include passing the categorization to a garbage collection algorithm on the underlying storage system.

[0017] According to another aspect of the present disclosure, a computer-implemented method for memory allocation augmentation of microservices is provided, the method being executed on a memory controller and comprising: receiving input / output operations of microservice containers with an associated categorization, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and using the associated categorization to optimize memory allocation for the input / output operations and / or optimize garbage collection performance.

[0018] Receiving input / output operations from microservice containers with an associated categorization may include describing or tagging a group or individual input / output operation with memory characteristics. The memory characteristics may define a memory behavior profile that specifies a required form of memory allocation for optimal storage and garbage collection.

[0019] Using the associated categorization to optimize memory allocation for input / output operations and / or to optimize garbage collection performance may attempt to find a best storage location for data and choose compression through in-line array compression or pool compression depending on the expected behavior of the category.

[0020] According to another aspect of the present disclosure, a system for memory allocation extension of microservices to a microservice orchestrator is provided, comprising: a processor and memory configured to provide computer program instructions to the processor to perform the function of components: a container categorization component for categorizing a microservice container, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and a categorization provisioning component for providing the categorization in association with the input / output operations of microservice containers to a memory system for use in memory allocation of the input / output operations.

[0021] The system may include a categorization analysis component for providing a categorization analysis for analyzing input / output operation patterns in storage systems to categorize an underlying microservice image and to categorize contexts of microservice containers, wherein the categorization analysis is used to categorize a microservice container.

[0022] The system may include: a receiving component for receiving input / output operations from microservice containers issued by the microservice container; and an analyzing component for analyzing the input / output operations with the categorization analyzing component to establish or modify a categorization for the microservice container.

[0023] The analysis component may include: a container image categorization component for initially categorizing the microservice container based on the categorization of the underlying microservice image; and a context categorization component for adjusting the initial categorization based on a context of the microservice container.

[0024] According to another aspect of the present disclosure, a system for memory allocation extension of microservices on a memory controller is provided, comprising: a processor and a memory configured to provide computer program instructions to the processor to perform the function of components: a category receive component for receiving input / output operations from microservice containers with an associated categorization, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and a memory allocation component comprising a category apply component for using the associated categorization to optimize memory allocation of the input / output operations.

[0025] The system may include a garbage collection component having a category application component for using the associated categorization to optimize garbage collection performance.

[0026] According to another aspect of the present disclosure, a computer program product for memory allocation augmentation of microservices is provided, the computer program product comprising a computer-readable storage medium having program instructions embodied thereon, the program instructions executable by a processor on a microservice orchestrator to cause the processor to: categorize a microservice container, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and providing the categorization in association with the input / output operations of microservice containers to a memory system for use in memory allocation of the input / output operations.

[0027] According to another aspect of the present disclosure, a computer program product for memory allocation augmentation of microservices is provided, the computer program product comprising a computer-readable storage medium having program instructions embodied thereon, the program instructions executable by a processor at a memory controller to cause the processor to: receive input / output operations from microservice containers with an associated categorization, the categorization defining a predicted memory behavior of the input / output operations of microservice containers; and use the associated categorization to optimize memory allocation for the input / output operations and / or to optimize garbage collection performance. BRIEF DESCRIPTION OF THE DRAWINGS Fig. 1 is a block diagram illustrating a microservices orchestrator and a storage controller in which the described methods and systems may be implemented, according to at least one embodiment. Fig. 2 is a flowchart illustrating a method performed on a microservices orchestrator and a storage controller according to at least one embodiment. Fig. 3 is a flowchart illustrating one aspect of a method performed on a microservices orchestrator according to at least one embodiment. Fig. 4 is a flowchart illustrating one aspect of a method performed at a memory controller according to at least one embodiment. Fig. 5 is a block diagram illustrating an aspect of a system including a microservice orchestrator, according to at least one embodiment. Fig. 6 is a block diagram illustrating an aspect of a system including a memory controller according to at least one embodiment. Fig. 7 is a block diagram illustrating a computer system or cloud server in which the present disclosure may be implemented according to at least one embodiment. Fig. 8 is a schematic diagram of a cloud computing environment in which the present disclosure may be implemented according to at least one embodiment. Fig. 9 is a diagram illustrating model layers of a cloud computing environment in which the present disclosure may be implemented according to at least one embodiment. DETAILED DESCRIPTION

[0028] In file systems, storage space for a file can be allocated on the fly by a storage allocator. In block storage, provisioning can be performed by allocating the entire amount of capacity required for a volume in one pass (full allocation) or by allocating the capacity required at that time. Such provisioning can use forward lookup structures to point to the storage space where the data is stored. This can be similar to how file systems "point" to specific data using a forward lookup structure. Thin provisioning can be used as the basis for sophisticated storage efficiency tools such as compression or deduplication.

[0029] When data is written to a disk, certain actions may occur. These actions may include writing the user data to physical space after allocating memory. The actions may further include updating the forward lookup structure. If a data item is already pointed to, the reference count for that data item is decremented. These actions may also include indicating candidates for garbage collection, where a reference count for a specified data item is zero, and where the data is considered no longer valid. Data invalidation may be determined at least in part based on reference counts.

[0030] When data is read, certain actions can occur. These actions can include accessing the forward lookup structure to determine where the requested data is located in the physical space. These actions can also include returning to zero if no location is found. If a location is found, the data can be returned to the location of the physical space.

[0031] Other actions may include deduplication and garbage collection. Deduplication can be implemented by allowing forward lookup references to point to other forward lookup structures (which in turn point to data). In these cases, the reference count for a single data item can be greater than 1. Garbage collection is a mechanism that combines invalidated capacity into reusable regions. When a small amount of data is written to the storage system and subsequently overwritten, there is no guarantee that the overwrite will fit into the same memory space as what was originally written. For this reason, one implementation is to write to clean regions. This workload is tuned to the theoretically optimal performance patterns of the underlying storage media.Live data must be transferred from these "dirty" areas, which are subject to overwrites or UNMAPs (invalidations), to clean areas. Once all data has been written to a new area, the previously dirty area can be reused.

[0032] The combination of container orchestrators and storage controllers can enable greater flexibility for user applications. However, the storage requirements for a given container may be unknown. One solution to this is to perform blanket overprovisioning and rely on the thin-provisioning capabilities of the underlying storage units to ensure acceptable inefficiency. For example, if there is overallocation in a block storage system and none of it is used, the underlying storage required for the root node of the forward lookup metadata structure is used, but cannot use any further storage. This structure can range in size from kilobytes to megabytes, whereas a pool on the order of petabytes makes such overhead negligible.

[0033] The described method and system categorize microservice containers and the underlying images they rely on. The categorization is based on the behavior of the microservice image and the context of the container's current usage. These details are fed into the storage system to predict how the container's input / output operations are likely to behave. The storage system allocates memory, attempting to allocate memory to ranges that minimize garbage collection overhead.

[0034] Container input / output operation patterns affect efficient memory allocation and garbage collection of invalidated capacity in a storage system. Input / output operation patterns can be categorized based on storage characteristics that affect their storage behavior, including garbage collection behavior.

[0035] Containers can be categorized based on their input / output operation patterns using various selection criteria, which can be grouped into different usage patterns using machine learning techniques. These selection criteria can include, for example, how sequential or direct the data pattern is, how long-lived the operations and the entire container will be, how compressible the data is, and so on. Application-oriented concepts can also be used to categorize the impact of slow input / output operations on a particular process (for example, how long a processor is blocked waiting for input / output operations). The density of invalidations can be used based on a "working set" of data from a workload subject to high input / output.

[0036] When a microservice is started, it is initially categorized by the behavior of that microservice's image. This can be detected by reporting historical behavior, which indicates variability in the storage characteristics of the container image. The current context of the container may also be important and therefore applied to the current container. For example, an image used to create a container specifically for databases may have very different behaviors based on the usage context. Therefore, additional categorizers based on the context can be used. Furthermore, the container process can be further analyzed by moving it from category to category based on a deviation or expected deviation in the behavior of a current module.This may occur due to the impact of a user's workload, and continued analysis may allow for spontaneous changes in categorization.

[0037] The subject matter of the present disclosure is particularly pointed out and distinctly claimed in the concluding portion of the specification. The present disclosure, both as to organization and method of operation, together with objects, features, and advantages, is best understood by reference to the following detailed description and the accompanying drawings.

[0038] It should be understood that, for the sake of clarity and illustration, the elements shown in the figures are not necessarily drawn to scale. For example, the dimensions of some elements may be exaggerated relative to others for clarity. Furthermore, reference numerals may be repeated in the figures where deemed appropriate to indicate corresponding or analogous features.

[0039] With reference to Fig. 1 shows a block diagram of an exemplary embodiment of a system 100 in which the described method and system can be implemented. The system 100 includes a microservice orchestrator 110 and storage controllers 150, 160 of storage systems used by the microservice orchestrator 110.

[0040] A microservice orchestrator 110 (e.g., a Kubernetes system) can provide a platform for automating the use, scaling, and operations of microservice containers across groups of hosts. Cloud services can offer a microservice orchestrator 110 as a platform or infrastructure as a service (PaaS or IaaS), on which the microservice orchestrator 110 can be deployed as a service providing a platform.

[0041] The microservice orchestrator 110 may include individual nodes 120, 130 and a master node 140 or a group. The master node 140 is the control unit that manages the workload and direct data transfer across the system and includes a container provisioning and node control 141. The master node 140 includes a storage provisioning component 143 that acts as a container storage interface where volumes can be created and provisioned.

[0042] Nodes 120, 130 are machines with node agents 121, 131 and in which containers 125, 126, 135, 136 are deployed by a container runtime. A microservice image is a file consisting of multiple layers used to execute code in a container. An image is created from the instructions for a complete and executable version of an application, and when an image is executed by a container runtime, it becomes one or more instances of that container. Each node 120, 130 may include a storage driver 123, 133 for data communication with the storage provisioning component 143 of the main node 140 and the storage controllers 150, 160.

[0043] A memory controller 150, 160 includes a memory allocation component 152, 162 for allocating memory in a heterogeneous memory 154, 164, and the memory allocation component 152, 162 interfaces with the memory provisioning component 143 of a head node 140 of a microservice orchestrator 110. Each memory controller 150, 160 also includes a garbage collection component 153, 163 for reclaiming memory space.

[0044] The described method and system provide categorization of microservice container input / output operations to a memory controller 150, 160 to assist the memory allocation component 152, 162 and the garbage collection component 153, 163 in executing optimally for the characteristics of the container's input / output operations. Nodes 120, 130 include a categorization layer 122, 132 that interacts with a categorization analysis component 142 of the main node 140, which in turn interacts with a categorization analysis interface 151, 161 of the memory controller 150, 160.

[0045] With reference to Fig. 2, a block diagram 200 shows an exemplary embodiment of the data flow between a node 120 and a master node 140 of a microservice orchestrator 110 and to a storage controller 150.

[0046] Input / output operations are issued 201 by a container at a node 120, and categorization analyses of the operations are collected by the individual node and passed 202 through the node categorization layer 122 to the categorization analysis component 142 of the master node to provide and customize the categorization of a container.

[0047] The categorization analysis component 142 of the master node informs the individual node about the categorization to which a particular container belongs, and the individual node informs the master node about any changes to input / output patterns associated with a container, thereby enabling the master node to change categorizations accordingly.

[0048] The categorization analysis component 142 of the master node receives 204 a notification from a node layer of an input / output pattern for a container, categorizes 205 the container operations, and returns 206 a notification to the node categorization layer 122. The master node 140 may send 205 container categorization information to the storage controller 150, where it is received 207 for reference when container input / output operations are received from the nodes 120.

[0049] The container at node 120 may receive details from the categorization analysis layer 142 of the head node and may send 203 the input / output operations for the container with the categorization information to the storage controller 150. Since the categorization information may already have been provided by the head node to the storage controller, for example in the form of storage profiles, the container's input / output operations may simply be tagged to identify the categorization information (i.e., a storage profile).

[0050] The memory controller 150 may receive the incoming input / output operations for the container with the categorization information 208. The input / output operations are allocated memory based on the container categorization 209 and are written to the back-end memory 210.

[0051] In an alternative implementation, individual nodes can provide categorization information for a specific container to the storage controller. The manner in which the categorization is transmitted can be implemented in various ways by a microservices layer. The categorization information can describe a storage profile of storage characteristics or behaviors that is received and understood by the storage controller for application during container input / output operations.

[0052] With reference to Fig. 3, a flowchart 300 shows an exemplary embodiment of an aspect of the described method executed on a microservice orchestrator 110.

[0053] In an operation 301, categorization analysis functionality is provided to the microservice orchestrator 110 for analyzing input / output operation patterns in storage systems. In an operation 302, the microservice orchestrator 110 uses the categorization analysis to analyze an underlying microservice image and microservice container contexts based on historical behavior patterns. The categorization analysis is used to categorize a runtime microservice container, where a microservice container is an instance of a microservice image with a current context.

[0054] Input / output operation patterns in storage systems can include one or more of the following storage characteristics: incompressible data, highly compressible data, ephemeral data, long-lived data, random access pattern data, sequential access pattern data, fully allocated space, and applications waiting for profiles for operations. Analyzing the input / output operation patterns can use machine learning techniques to group the characteristics into distinct behavior patterns that can be categorized. These can be considered storage profiles for the containers.

[0055] In some embodiments, storage characteristics are collected using one or more methods. Such methods identify whether a workload is sequential / direct. Determining a workload's compressibility and determining data lifetime are performed through sampling. The lifetime of a particular container can also be easily determined by the microservice orchestrator based on availability upon deletion.

[0056] In some embodiments, an explicit user label is used to classify a container as having certain properties (e.g., one or more properties). This labeling may be performed at the classifier level under the assumption that the labeling or classification explicitly resembles a previous historical process. In some embodiments, labeling is performed at the property level, explicitly stating how long a container is likely to exist and what its input / output properties are. For example, if it is known that to run a database for a particular workload and a similar expected workload, it will be created using a different database, this may be confirmed to benefit from previous history created using otherwise unrelated container images.Knowing how long a container is likely to exist is also considered or input into the classification, as the duration allows for a determination of when to delete all data associated with the container (i.e., a point is determined at which everything is subject to UNMAPs, which affects storage behavior).

[0057] In an operation 303, the microservice orchestrator 110 transfers the associated details of the various categorizations or storage profiles from the container orchestrator to the storage controller. Transferring the various categorizations can inform the storage controller how different categories or storage profiles are likely to behave and enable the storage controller to make the best allocation decisions for efficient storage and garbage collection. The behavior can be specified based on patterns of historical actions, operations, characteristics, and other relevant and appropriate information regarding the container, the data contained in the container storage profiles, storage profiles, and / or operations or schedules of operations to be performed on one or more containers, and the data in the container.

[0058] In an operation 304, the microservice orchestrator 110 receives microservice container input / output operations issued by the microservice container during runtime and memory characteristics of input / output operations. In an operation 305, the microservice orchestrator 110 then analyzes 305 the input / output operations with the categorization analysis to establish a categorization for the microservice container. In some embodiments where a categorization for the microservice container has already been established, the method may modify the categorization for the microservice container based on changes in one or more of the operations, the memory profile, and / or any other appropriate or relevant data.Categorization is performed on the fly to accommodate a long-running process, which may result in a change in categorization due to the impact of a user's workload. A microservice container categorization defines predicted memory behavior for microservice container input / output operations and is therefore used for efficient memory allocation and optimal garbage collection.

[0059] In an operation 306, during the categorization process, the microservice orchestrator 110 initially categorizes the microservice container based on the categorization of the underlying microservice image. The categorization of the underlying microservice image may be based on historical storage behavior. Behavior of previous containers based on the microservice image may be analyzed to determine their behavior patterns. For example, there may be a microservice image that has a sequential workload that performs well with traditional hard disk storage (HDD) over 90% of the time. 10% of the time, the image performs well with a direct workload that performs well with a solid-state disk (SSD). It may not be possible to determine from the categorization mechanisms whether the direct workload is being used.With history available, the variability of a particular image can be identified and whether better storage is needed based on historical behavior. The history can also provide behavioral probabilities that can be used to compare the workload or image to two or more patterns of historical behavior or profiles.

[0060] Alternatively, the categorization of the underlying microservices image can be based on a user-configured categorization. If a user observes poor memory behavior, a user-defined configuration can be used to fine-tune the behavior.

[0061] In an operation 307, the microservice orchestrator 110 performs an adjustment 307 of the initial categorization based on a current context of the microservice container. This leverages the context-based categorization and may include user-based tagging of microservice containers to support the categorization. This may also include higher-level context analysis based on which other services are connected to the storage service. In some embodiments, higher-level context analysis is based on a classification of the microservice container as belonging to a group of containers and the historical behavior patterns of the group. The group may be a capsule in the form of a collection of microservice containers colocated on hardware and sharing resources, and / or the group may be a service in which capsules collaborate.

[0062] The microservice orchestrator 110 can achieve categorization of a container for a context in the following ways, although various methods may be appropriate. When a container is spun up, it typically does so within a broader application context. A capsule is a collection of containers coexisting on hardware and intended to share resources, and a service is a broader classifier and specifies capsules that work together. When a service or capsule is created, any storage that uses containers can be classified as part of a particular service or part of a particular capsule and can have the historical behavior of those contexts associated with them. Machine learning categorization techniques can be used to identify what is most relevant to the performance profile of a particular container.Containers can typically also be associated with labels, which in turn can be used to aid classification. Topological approaches can be used when attempting to classify a container. If a particular service is viewed as a collection of nodes (possibly with different node types based on usage context), with capsule / service membership determining edges, a particular container can be classified by graph analysis algorithms based on what it is connected to. Based on this, it is possible to determine what the container's behavior will be based on, based on the behavior of the nearest historical match. Various network motif classification mechanisms have been investigated using bioinformatics techniques, and one of their most common applications is identifying similar structures in bioinformatics networks.Machine learning categorization techniques can be used to identify a category that is highly relevant to the performance profile of the microservices container.

[0063] In an operation 308, the microservice orchestrator 110 includes a continuous analysis of input / output operations of a microservice container to update the categorization. In some embodiments, categorization analyses are collected from a single node for a current container process in the microservice orchestrator. For example, a node may provide information about whether a current workload is substantially direct or substantially sequential. The container orchestrator may be informed of the input / output patterns occurring on a particular container and may compile this into the categorization. A container may be subject to the nature of a user's workload, which may change.For example, it may start essentially sequentially when data is first written, but may become highly direct / transactional as different user workloads are activated. This support allows a container's categorization to change.

[0064] In an operation 309, the microservice orchestrator 110 provides the categorization information associated with the input / output operations of microservice containers from a single node of the container orchestrator to a storage system for use in allocating memory for the input / output operations. For example, input / output operations may be tagged with the categorization. This may include describing each input / output operation or group of input / output operations with the categorization details. This may also include passing the categorization to a garbage collection algorithm on the underlying storage system.

[0065] With reference to Fig. 4, a flowchart 400 shows an exemplary embodiment of an aspect of the described method performed on a memory controller 150.

[0066] In an operation 401, the storage controller 150 receives general category information, for example, as a shared list of categories, from a container orchestrator. These categories can be described in terms of their characteristics: for example, in simple terms, as a category for long-lived, incompressible data; a category for short-lived, highly compressible data. These can be shared in advance or described on the fly by the microservice orchestrator when creating categories.

[0067] In an operation 402, the memory controller 150 receives input / output operations from microservice containers with an associated categorization that defines a predicted memory behavior of the input / output operations of microservice containers. In some embodiments, the input / output operations are received and, upon receipt, analyzed to determine a category associated with one or more of the input / output operations. The associated characterization may define a predicted memory behavior of the input / output operations that indicates a corresponding predicted memory behavior of the microservice container. In some embodiments, the memory controller receives input / output operations associated with a plurality of categorizations.

[0068] In an operation 403, the memory controller passes the categorization to the memory allocation and garbage collection components of the memory system. This informs the memory controller that a particular input / output operation belongs to a category and, consequently, that the input / output operation is likely to have a particular behavior.

[0069] The categorization information can be passed to the memory allocation and garbage collection algorithms on the underlying storage system via an interface protocol. This can be done either to describe a group of input / output operations by tagging input / output operations with certain well-known service characteristics, or by including these details in the individual input / output operations. For example, a header / footer of the data frame can describe the categorization.

[0070] In an operation 404, the memory controller 150 provides optimized storage space for the data of the container's input / output operations based on the predicted behavior provided by the categorization. The categorization details involved may include arbitrariness metrics, expected data longevity metrics, metrics for whether the system in question is waiting for input / output operations, and what the expected working set looks like for a given group of input / output operations. The garbage collection and space allocation algorithm can then plan to find the best storage space for data with the additionally provided data.

[0071] In an operation 405, the memory controller 150 receives or identifies changes to the categorization. The memory controller 150 can then spontaneously update categorizations during a container process, with the memory allocator and garbage collector components responding accordingly. The memory allocator can be informed of any changes to a microservice's categorization and will attempt to respond accordingly. This can be extended to the garbage collector selection behavior, because if garbage collection areas belong to a particular class of microservices, these areas can be moved to an appropriate new level of memory allocation.

[0072] Below are some memory allocation techniques that can be used based on the categorization information provided with the container's input / output operations. In some cases, these memory allocation techniques can allocate high-performance memory only when requested.

[0073] Additionally, if a user observes poor storage behavior, a user-defined approach can be provided to fine-tune the behavior. For example, if an image has a workload that means a workload is not stored on high-performance storage but is suitable for that storage, and a single workload can be tuned to influence that workload being manually assigned to the highest-performing storage, this is a useful feature. Therefore, a user configuration can be provided to influence storage optimization.

[0074] The categorization of storage patterns can include arbitrariness metrics, expected data longevity metrics, whether the system in question waits for input / output operations, what the expected working set looks like for a given set of input / output operations, input / output size metrics, required resiliency, and other storage characteristics that affect storage and garbage collection optimization. Compressibility

[0075] Variable compressibility can affect the ideal storage location where data should be stored. This may include, for example, choosing compression through in-line array compression or pool compression, depending on the expected behavior of the category. For example, in-line hardware compression achieved through arrays has a maximum compressibility support of approximately 4:1, whereas compressibility implemented through a data reduction pool of the same product has a compressibility of more than 10:1, albeit at the cost of additional latency.

[0076] The orchestrator can inform the storage controller that the container being created is likely to produce incompressible data. The storage controller can then decide not to attempt to compress input / output operations associated with the container, but instead reserve compression bandwidth for input / output operations that are more likely to be compressible.

[0077] The orchestrator can inform the storage controller that the container being created is likely to create highly compressible data. In systems with limited compression bandwidth, this may be the optimal choice for storage space savings. The storage controller will preferentially allocate compression bandwidth to these data areas of the container. Short-lived and long-lived data

[0078] Other features that can aid garbage collection include the concept of deferring garbage collection through a concept known as "slack space." This is the belief that if there is enough free capacity to be utilized, garbage collection becomes more cost-effective over time as more invalidations are received. Thus, the amount of work required to free a given area becomes more cost-effective. This behavior depends heavily on the storage space of the data. If an application's data is spread across many different areas and these areas are shared with long-lived data, the long-lived data must be moved even if all short-lived data has been invalidated.

[0079] The orchestrator can inform the storage controller that the container is likely to have a short lifetime, meaning the data will likely be discarded soon. This can be used to attempt to group short-lived data by allocating it to separate areas for these shorter-lived areas. For systems where there is no input / output latency bottleneck, slower storage can be chosen (for example, hard disk drives instead of expensive but fast solid-state disk options).

[0080] The storage controller allocates general extents to short-lived data areas and decides to avoid garbage collection on these extents until they are almost empty. This means that short-lived data is not mixed with long-lived data, and the predicted cycle of exclusions frees the extents instead of requiring a deep garbage collection. Because no garbage collection occurs on these extents, less write bandwidth is used for garbage collection, improving both performance and the lifetime of the storage media.

[0081] The orchestrator can inform the storage controller that it is likely to have a very long lifetime. The storage controller allocates common extents to long-lived data areas. By avoiding mixing with short-lived areas, unnecessary garbage collection is avoided to free the short-lived areas. This results in less write bandwidth being used for garbage collection, which in turn improves the performance and longevity of storage media. Fully assigned

[0082] For particularly aggressive workloads, the memory controller may allocate data ranges to fully allocated areas (i.e., non-log-structured arrays), as the overhead of garbage collection for these can be excessive. This results in optimized performance. Direct and sequential write operations

[0083] Different application workloads have different characteristics; a database may have a highly direct access pattern, whereas a backup task may have a highly sequential access pattern. These impact how garbage collection is likely to be performed. Typically, a sequential overwrite pattern results in easier garbage collection because consecutive memory areas can be freed. Garbage collection is often more difficult for a direct overwrite pattern because comparatively larger amounts of memory can be moved to reclaim a significant amount of memory. For example, sequential overwrites may have a pattern such as: [XXXXXXXXXX] [OOOOOOOOOO] [XXXXXXXXXX] [XXXXXXXXXX] [NNNNNNNNNN] [FFFFFFFFFF]

[0084] In this example, F = free; X = used; O = overwritten data; N = new data. Here, the entire area containing the overwrites can be reclaimed without having to move any data. In this example, direct overwrites can have a pattern such as: [XOXOXXOXXX] [XXOXOXXOXX] [XOXOXXXXXX] [XXOXXOXXXX] [NNNNNNNNNN] [FFFFFFFFFF]

[0085] In this example, four ranges are moved to retrieve one range value of data. This problem becomes more severe as the physical range increases. For systems that have significant direct input / output patterns compared to sequential patterns, selecting the memory that best matches this behavior may result in a more optimal response than choosing the fastest available memory.

[0086] The orchestrator can inform the storage controller that the container is likely to have a random access pattern. The storage controller assigns these data areas to extents that are likely to provide optimal performance for this workload (e.g., solid-state disks). The result is that these systems experience improved performance.

[0087] The orchestrator can inform the storage controller that the container is likely to have a sequential access pattern. The storage controller allocates these data areas to extents that are likely to provide optimal performance for this workload (possibly disk drives). The result is that storage is allocated to more optimal candidates for the workload, thereby both improving performance for the disk drives and leaving more free capacity on solid-state disks for use by workloads that benefit most. Wait for input / output operations

[0088] The orchestrator can inform the storage controller that the container will likely have to wait for significant amounts of time for input / output operations. The storage controller can allocate faster storage media to these areas, optimizing workflows on the containers. Working set of workload

[0089] A particular workload may have a working set, which is the data area that receives large-scale input / output operations. The working set applies the concept that while there may be a total data area of ​​10 PB, several hundred TB actually undergo large-scale input / output.

[0090] If you have two different workloads, both with random access patterns and both impacting essentially the same amount of data, if these workloads were stored together in the same backend storage space, they would overwrite each other at essentially the same rate. This optimizes garbage collection because, statistically, storage space would be freed at approximately the same time.

[0091] This is compared to a workload that is mixed sequential with a direct portion. This is roughly like using two significantly different working set sizes. One will tend to overwrite its portion of a given range long before the other. Therefore, keeping similar working sets together makes garbage collection more efficient.

[0092] These optimizations are achieved through analysis focused on the container / image. A virtual machine-focused solution may be too coarse and may not adequately describe the set of applications running on it. An application-focused solution may be too detailed, lacking context, and difficult to integrate into the input / output path for that application.

[0093] In all of these cases, containers with variable lifetimes can lead to the failure of approaches designed to describe applications or virtual machines. By focusing on a specific image and, where appropriate, the broad usage context, heterogeneous behavior on a single virtual machine and application behavior that can vary greatly depending on the context can be captured. The context in which the method operates is a task-centric environment. This insight captures the most useful information for the storage system and can contribute to storage efficiency.

[0094] The advantages of such a system are that it should lead to optimized memory usage, which in turn reduces garbage collection overhead. This offloads storage systems and provides better host performance for input / output operations.

[0095] With reference to Fig. 5 shows a block diagram of an exemplary embodiment of a microservice orchestrator 110 with a categorization analysis component 142 of a master node 152 and a categorization layer 132 of a node. These are shown on a single system, but may be distributed across multiple systems, and include at least one processor 501, a hardware module, or circuitry for performing the functions of the described components, which may be software units executing on the at least one processor. Multiple processors executing parallel processing threads may be provided, enabling parallel processing of some or all of the functions of the components. A memory 502 may be configured to provide computer instructions 503 to the at least one processor 501 to perform the functionality of the components.

[0096] The categorization analysis component 142 may provide categorization analysis for analyzing input / output operation patterns in storage systems to categorize an underlying microservice image and to categorize microservice container contexts. The categorization analysis is used to categorize a microservice container during runtime.

[0097] The categorization analysis component 142 may include a receiving component 511 for receiving microservice container input / output operations issued by the microservice container during runtime, and an analysis component 520 for analyzing the input / output operations to modify (e.g., establish or modify) a categorization for the microservice container. The analysis component 520 may include a container image categorization component 521 for initially categorizing the microservice container based on the categorization of the underlying microservice image; and a context categorization component 522 for adapting the initial categorization based on a context of the microservice container.

[0098] The categorization analysis component 142 may include a container categorization component 512 for categorizing a microservice container, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers. This may be sent to the categorization layer 132 of the node executing the container. The categorization layer 142 may include a category provisioning component 530 for providing the categorization associated with the input / output operations of microservice containers to a memory system for use in allocating memory for the input / output operations.

[0099] With reference to Fig. 6 shows a block diagram of an exemplary embodiment of a memory controller 150, including a categorization analysis interface 151, a memory allocation component 152, and a garbage collection component 153. The memory controller 150 may include at least one processor 601, a hardware module, or circuitry for performing the functions of the described components, which may be software units executing on the at least one processor. Multiple processors executing parallel processing threads may be provided, enabling parallel processing of some or all of the functions of the components. A memory 602 may be configured to provide computer instructions 603 to the at least one processor 601 to perform the functionality of the components.

[0100] The categorization analysis interface 151 may include a category receiving component 610 for receiving input / output operations of microservice containers with an associated categorization that defines a predicted memory behavior of the input / output operations of microservice containers.

[0101] The memory allocation component 152 may include a category application component 620 for using the associated categorization to optimize memory allocation for the input / output operations.

[0102] The garbage collection component 153 may include a category application component 630 for using the associated categorization to optimize garbage collection performance.

[0103] Fig. 7 illustrates a block diagram of components of a computing unit of the system 100 of FIG. Fig. 1, such as the microservice orchestrator 110 or the storage controller 150. It should be clear that Fig. 7 provides an illustration of one implementation and does not imply limitations on the environments in which various embodiments may be implemented. Many modifications may be made to the illustrated environment.

[0104] The computing device may include one or more processors 702, one or more computer-readable RAMs 704, one or more computer-readable ROMs 706, one or more computer-readable storage media 708, device drivers 712, a read / write drive or interface 714, and a network adapter or interface 716, all interconnected via a communications structure 718. The communications structure 718 may be implemented using any architecture designed for passing data and / or controlling information between processors (such as microprocessors, communications and network processors, etc.), system memory, peripheral devices, and any other hardware components in the system.

[0105] For example, one or more operating systems 710 and / or application programs 711 are stored on one or more of the computer-readable storage media 708 for execution by one or more of the processors 702 via one or more of the respective RAMs 704 (which typically include cache memory). In the illustrated embodiment, each of the computer-readable storage media 708 may be a magnetic disk storage device of an internal hard drive, a CD-ROM, a DVD, a memory stick, a magnetic tape, a magnetic disk, an optical disk drive, a semiconductor storage device such as RAM, ROM, EPROM, flash memory, or any other computer-readable storage medium capable of storing a computer program and digital information in accordance with embodiments of the present disclosure.

[0106] The computing device may also include a read / write drive or interface 714 for reading from or writing to one or more computer-readable storage media 726. The application programs 711 on the computing device may be stored on one or more of the portable computer-readable storage media 726, read via the respective read / write drive or interface 714, and loaded into the respective computer-readable storage media 708.

[0107] The computing device may further include a network adapter or network interface 716, such as a TCP / IP adapter card or a wireless communications adapter. The application programs 711 on the computing device may be downloaded to the computing device from an external computer or external storage device via a network (e.g., the Internet, a local area network, or other wide area or wireless networks) and the network adapter or interface 716. From the network adapter or interface 716, the programs may be loaded into the computer-readable storage media 708. The network may include copper cables, fiber optic cables, wireless transmission, routers, firewalls, switching units, gateway computers, and edge servers.

[0108] The computing device may further include a display screen 720, a keyboard or keypad 722, and a computer mouse or touchpad 724. Device drivers 712 interface with the display screen 720 for imaging, the keyboard or keypad 722, the computer mouse or touchpad 724, and / or the display screen 720 for print capture for alphanumeric character input and user selections. The device drivers 712, the read / write drive or interface 714, and the network adapter or interface 716 may comprise hardware and software stored in the computer-readable storage media 708 and / or the ROM 706.

[0109] The present disclosure may be embodied as a system, a method, and / or a computer program product at any possible level of technical detail integration. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions stored thereon for causing a processor to perform aspects of the present disclosure.

[0110] The computer-readable storage medium may be any physical device capable of retaining and storing instructions for use by a device to execute instructions. The computer-readable storage medium may be, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of the computer-readable storage medium includes the following: a portable computer diskette, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM).Flash memory), a static random access memory (SRAM), a portable CD-ROM, a DVD, a memory stick, a floppy disk, a mechanically encoded device such as punched cards or raised structures in a groove on which instructions are stored, and any suitable combination of the foregoing. A computer-readable storage medium, as used herein, should not be construed as containing transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission media (e.g., pulses of light carried through a fiber optic cable), or electrical signals carried through a wire.

[0111] Computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to respective computing / processing units or to an external computer or storage unit via a network such as the Internet, a local area network, a wide area network, and / or a wireless network. The network may include copper transmission cables, fiber optic transmission lines, wireless transmission, routers, firewalls, switching units, gateway computers, and / or edge servers. A network adapter card or network interface in each computing / processing unit receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium within the respective computing / processing unit.

[0112] Computer-readable program instructions for performing operations of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, integrated circuit configuration data, or either source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk, C++, or the like, and procedural programming languages ​​such as the "C" programming language or similar programming languages.The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, over the Internet using an Internet service provider).In some embodiments, electronic circuits, including, for example, programmable logic circuits, field programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), may execute the computer-readable program instructions by utilizing state information of the computer-readable program instructions to personalize the electronic circuits to perform aspects of the present disclosure.

[0113] Aspects of the present disclosure are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the disclosure. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, may be implemented using computer-readable program instructions.

[0114] These computer-readable program instructions may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device to produce a machine such that the instructions executing via the processor of the computer or other programmable data processing device produce a means for implementing the functions / steps specified in the flowchart and / or block diagram block(s).These computer-readable program instructions may also be stored on a computer-readable storage medium that can direct a computer, a programmable data processing apparatus, and / or other devices to function in a particular manner, such that the computer-readable storage medium having instructions stored thereon comprises an article of manufacture, including instructions that implement aspects of the function / step specified in the block(s) of the flowchart and / or block diagrams.

[0115] The computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operations to be performed on the computer, other programmable apparatus, or other device to produce a computer-implemented process such that the instructions executing on the computer, other programmable apparatus, or other device implement the functions / steps specified in the block(s) of flowchart and / or block diagrams.

[0116] The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions comprising one or more executable instructions for implementing the particular logical function(s). In some alternative implementations, the functions specified in the blocks may occur in a different order than shown in the figures. For example, two blocks shown consecutively may actually execute substantially in parallel, or the blocks may sometimes execute in the reverse order, depending on the functionality involved.It is further to be understood that each block of the block diagrams and / or flowchart illustrations, and combinations of blocks in the block diagrams and / or flowchart illustrations, may be implemented by special purpose hardware-based systems that perform the specified functions or acts, or by combinations of special purpose hardware and computer instructions. Cloud Computing

[0117] Although this disclosure includes a detailed description of cloud computing, it should be understood that implementation of the teachings herein is not limited to a cloud computing environment. Rather, embodiments of the present disclosure may be implemented in conjunction with any type of computing environment now known or later developed.

[0118] Cloud computing is a service delivery model for enabling seamless, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with a service provider. This cloud model can include at least five characteristics, at least three service models, and at least four usage models. The properties are as follows:

[0119] On-demand self-service: A cloud user can unilaterally and automatically provision data processing functions such as server time and network storage as needed, without requiring human interaction with the service provider.

[0120] Broad Network Access: Functions are available over a network and accessed through standard mechanisms that support use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0121] Resource pooling: The provider's computing resources are pooled to serve multiple users using a multi-tenant model, with various physical and virtual resources dynamically allocated and reassigned as needed. There is a perceived location independence, as the user generally has no control or knowledge over the exact location of the provided resources, but may be able to specify a location at a higher level of abstraction (e.g., country, state, or data center).

[0122] Rapid Elasticity: Features can be deployed quickly and elastically for rapid horizontal scaling out, in some cases automatically, and released quickly for rapid scale-in. To the user, the features available for deployment often appear unlimited, and they can be purchased in any quantity at any time.

[0123] Measured Service: Cloud systems automatically control and optimize resource usage by leveraging a metering function at a certain level of abstraction appropriate for the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource consumption can be monitored, controlled, and reported, creating transparency for both the provider and the user of the service. The service models are as follows:

[0124] Software as a Service (SaaS): The functionality provided to the user is to use the provider's applications running on a cloud infrastructure. The applications are accessible from various client devices via a thin client interface such as a web browser (e.g., a web-based email). The user does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application functions, with the possible exception of limited user-specific application configuration settings.

[0125] Platform as a Service (PaaS): The functionality provided to the user is to deploy applications created or obtained by the user, using programming languages ​​and tools supported by the provider, into the cloud infrastructure. The user does not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but has control over the deployed applications and possibly over configurations of the application hosting environment.

[0126] Infrastructure as a Service (IaaS): The functionality provided to the user consists of providing processing, storage, networking, and other basic computing resources, allowing the user to deploy and run any software, including operating systems and applications. The user does not manage or control the underlying cloud infrastructure, but has control over operating systems, storage, deployed applications, and potentially limited control over selected network components (e.g., host firewalls). The usage models are as follows:

[0127] Private Cloud: The cloud infrastructure is operated exclusively for an organization. It can be managed by the organization or a third party and can be located on or off-premises.

[0128] Community Cloud: The cloud infrastructure is shared by multiple organizations and supports a specific community with common problems (e.g., considering objectives, security requirements, policies, and compliance). It can be managed by the organizations or a third party and can be located on-premises or off-premises.

[0129] Public Cloud: The cloud infrastructure is made available to the general public or a large industry group and is owned by an organization that sells cloud services.

[0130] Hybrid Cloud: The cloud infrastructure is a composition of two or more clouds (private, community, or public) that remain separate entities but are interconnected by a standardized or proprietary technology that enables data and application portability (e.g., cloud targeting for load balancing between clouds).

[0131] A cloud computing environment is service-oriented, with an emphasis on statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is an infrastructure containing a network of interconnected nodes.

[0132] With reference to Fig. 8, an illustrative cloud computing environment 50 is shown. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 with which local computing devices used by users of the cloud, such as personal digital assistant (PDA) or mobile phone 54A, desktop computer 54B, laptop computer 54C, and / or vehicle computer system 54N, can exchange data. The nodes 10 can exchange data with each other. They can be physically or virtually grouped in one or more networks (not shown), such as private, community, public, or hybrid clouds, as described hereinabove, or a combination thereof. Thus, the cloud computing environment 50 has the ability to offer infrastructure, platforms, and / or software as services for which a cloud user does not need to maintain any resources on a local computing device. It should be understood that the Fig. 8 are intended to be illustrative, and that the computing nodes 10 and the cloud computing environment 50 can communicate with any type of computerized device over any type of network and / or a network-addressable connection (e.g., using a web browser).

[0133] With reference to Fig. 9 shows a group of functional abstraction layers used by the cloud computing environment 50 ( Fig. 8). It should be clear from the outset that the Fig. The components, layers, and functions shown in Figure 9 are intended to be illustrative, and embodiments of the disclosure are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0134] A hardware and software layer 60 includes hardware and software components. Examples of hardware components include: mainframes 61; servers based on a RISC (Reduced Instruction Set Computer) architecture 62; servers 63; blade servers 64; storage devices 65; and networks and networked components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0135] A virtualization layer 70 provides an abstraction layer from which the following example virtual entities may be provided: virtual servers 71; virtual storage 72; virtual networks 73, including virtual private networks; virtual applications and operating systems 74; and virtual clients 75.

[0136] In one example, a management layer 80 may provide the functions described below. Resource provisioning 81 provides for dynamic procurement of computing resources and other resources used to perform tasks within the cloud computing environment. Metering and pricing 82 enable cost tracking and billing or invoicing for the use of resources within the cloud computing environment. In one example, these resources may include licenses for application software. A security function provides identity verification for cloud users and tasks, as well as protection for data and other resources. A user portal 83 provides access to the cloud computing environment for users and system administrators.Service Level Management (84) ensures the allocation and management of cloud computing resources so that required service levels are met. Service Level Agreement (SLA) planning and contract fulfillment (85) provides advance agreement for and procurement of cloud computing resources for which future demand is expected according to an SLA.

[0137] A workload layer 90 provides examples of functionality for which the cloud computing environment can be utilized. Examples of workloads and functions that can be provided from this layer include: mapping and navigation 91; software development and lifecycle management 92; virtual training delivery 93; data analytics processing 94; transaction processing 95; and container storage optimization processing 96.

[0138] The descriptions of the various embodiments of the present disclosure have been prepared for the purpose of illustration, but are by no means intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the described embodiments. The terminology used herein has been chosen to best explain the principles of the embodiments, practical application, or technical improvement over technologies found in the marketplace, or to enable others skilled in the art to understand the embodiments disclosed herein.

[0139] Improvements and modifications may be made to the foregoing without departing from the scope of the present disclosure.

Claims

[1] A computer-implemented method (300) for memory allocation expansion of microservices, the method being executed on a microservice orchestrator (110) and comprising: Providing (301) a categorization analysis for input / output operation patterns of microservice containers (125, 126, 135, 136) in storage systems; Categorizing (302) a microservice container based on the categorization analysis, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and Providing (309) the categorization associated with the input / output operations of microservice containers to a storage system for use in memory allocation of the input / output operations. [2] The method (300) of claim 1, wherein input / output operation patterns in memory systems include memory characteristics of input / output operations that affect memory allocation and garbage collection. [3] The method (300) of claim 1, wherein analyzing input / output operation patterns uses machine learning techniques to group into different usage patterns. [4] The method (300) of claim 1, comprising: Receiving (304) input / output operations from microservice containers issued by the microservice container (125, 126, 135, 136); and Analyzing (305) the input / output operations with the categorization analysis to modify a categorization for the microservice container. [5] The method (300) of claim 4, wherein analyzing (305) the input / output operations with the categorization analysis to modify a categorization for the microservice container (125, 126, 135, 136) comprises: Continuous analysis (308) of input / output operations of a microservice container and updating the categorization. [6] The method (300) of claim 4, wherein the categorization is identified by a machine learning categorization technique as being relevant to a performance profile of the microservice container (125, 126, 135, 136). [7] The method (300) of claim 4, wherein analyzing the input / output operations with the categorization analysis to modify a categorization for the microservice container (125, 126, 135, 136) comprises: initially categorizing (306) the microservice container (125, 126, 135, 136) based on the categorization of an associated microservice image; and Adapting (307) the initial categorization based on a context of the microservice container (125, 126, 135, 136). [8] The method (300) of claim 7, wherein the categorization of the associated microservices image is based on historical storage behavior and on categorization configured by a user. [9] The method (300) of claim 7, wherein adapting (307) the initial categorization based on a context of the microservice container (125, 126, 135, 136) comprises user-based labeling of microservice containers to support the categorization. [10] The method (300) of claim 7, wherein adapting (307) the initial categorization based on a context of the microservice container (125, 126, 135, 136) comprises a higher-level context analysis based on a classification of the microservice container as belonging to a group of containers and a historical storage behavior belonging to the group. [11] The method (300) of claim 10, wherein the group is a capsule in the form of a collection of microservice containers (125, 126, 135, 136) that are aggregated on hardware and share resources. [12] The method (300) of claim 1, wherein providing (309) the categorization associated with the input / output operations of microservice containers (125, 126, 135, 136) to a storage system for use in memory allocation of the input / output operations comprises describing each input / output operation with one or more categorization details. [13] The method (300) of claim 1, wherein providing (309) the categorization associated with the input / output operations of microservice containers (125, 126, 135, 136) to a storage system for use in memory allocation of the input / output operations comprises passing the categorization to a garbage collection algorithm on an associated storage system. [14] A system (100) for memory allocation expansion of microservices on a microservice orchestrator (110), comprising: a processor (501, 702); and a memory (502, 704) connected to the processor and comprising computer program instructions that, when executed by the processor, cause the processor to perform operations comprising: Providing (301) a categorization analysis for input / output operation patterns of microservice containers (125, 126, 135, 136) in storage systems; Categorizing (302) a microservice container based on the categorization analysis, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and Providing (309) the categorization associated with the input / output operations of microservice containers to a storage system for use in memory allocation of the input / output operations. [15] The system (100) of claim 14, wherein the operations further comprise: Receiving (304) input / output operations from microservice containers issued by the microservice container (125, 126, 135, 136); and Analyzing (305) the input / output operations with the categorization analysis component (142) to modify a categorization for the microservice container. [16] The system (100) of claim 15, wherein the operations further comprise: initially categorizing (306) the microservice container (125, 126, 135, 136) based on the categorization of an associated microservice image; and Adjusting (307) the initial categorization based on a context of the microservice container. [17] A computer program product for a memory allocation extension of microservices, the computer program product comprising a computer-readable storage medium having program instructions embodied thereon, the program instructions being executable by a processor (501, 702) on a microservice orchestrator (110) to cause the processor to perform operations comprising: Providing (301) a categorization analysis for input / output operation patterns of microservice containers (125, 126, 135, 136) in storage systems; Categorizing (302) a microservice container, wherein the categorization defines a predicted memory behavior of the input / output operations of microservice containers; and Providing (309) the categorization associated with the input / output operations of microservice containers to a storage system for use in memory allocation of the input / output operations. [18] The computer program product of claim 17, wherein the operations further comprise: Receiving (304) input / output operations from microservice containers issued by the microservice container (125, 126, 135, 136); and Analyzing (305) the input / output operations with the categorization analysis to modify a categorization for the microservice container. [19] The computer program product of claim 18, wherein analyzing (305) the input / output operations with the categorization analysis to modify a categorization for the microservice container (125, 126, 135, 136) further comprises: Continuous analysis (308) of input / output operations of a microservice container and updating the categorization. [20] The computer program product of claim 18, wherein the operations further comprise: initially categorizing (306) the microservice container (125, 126, 135, 136) based on the categorization of an associated microservice image; and Adjusting (307) the initial categorization based on a context of the microservice container.

Images