Classifying and sampling execution efficiency of software libraries

Abstract

The execution of the instructions includes obtaining the software objects and loading the instructions into memory, and storing a workload type attribute for each software object. The execution includes deploying first hardware instructions during runtime to trigger operations of a firmware process to sample instructions from a set of instructions of one or more software objects executed by one or more processors of the computing system at each of a plurality of timed preconfigured intervals. The operations include deploying second hardware instructions to obtain the samples from the firmware process and store them in memory. The operations include generating execution parameters associated with each sample based on analyzing the stored samples. The operations include determining access to a software library in the computing system by the workload type attribute. The operations automatically implement actions related to at least one software object in the computing system.

Description

Background Technology

[0001] One or more aspects generally involve facilitating processing within a computing environment, and in particular, improving such processing.

[0002] A computer system can execute multiple programs simultaneously. While executing various programs, program code can call software libraries to perform basic functions. Software libraries contain reusable routines, consisting of instruction sets loaded into memory. Although the operating system (OS) may track how often programs access the central processing unit (CPU), tracking how often software libraries access the CPU is not easy because software libraries can be called by multiple programs. Summary of the Invention

[0003] By providing a computer program product, the shortcomings of the prior art are overcome, and additional advantages are provided. The computer program product includes a collection of one or more computer-readable storage media and program instructions co-stored in the collection of one or more computer-readable storage media for causing at least one computing device to perform computer operations. The computer operations include obtaining one or more software objects, each software object including a workload type attribute and a software library including an instruction set. The computer operations include loading the instruction set of each software object into the memory of the computing system and storing the workload type attribute of each software object as metadata of the software library of that software object. During the operation of the computing system, the computer operations include deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction sets of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured time interval. The computer operations include deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The computer operations include generating execution parameters associated with each sample based on analysis of the stored samples. The computer operations include utilizing the execution parameters and metadata to determine access to the software library in the computing system via the workload type attribute. Based on deterministic access, computer operation includes automatically performing actions related to at least one software object in the computing system.

[0004] By providing a computer-implemented method, the shortcomings of existing technologies are overcome, and additional advantages are provided. The method includes obtaining one or more software objects, each software object including a workload type attribute and a software library including an instruction set. The method includes loading the instruction set of each software object into the memory of a computing system, and storing the workload type attribute of each software object as metadata of the software library of that software object. During runtime of the computing system, the method includes deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction set of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured timing interval. The method includes deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The method includes generating execution parameters associated with each sample based on analysis of the stored samples. The method includes utilizing the execution parameters and metadata to determine access to the software library in the computing system via the workload type attribute. Based on the determined access, the method includes automatically implementing actions associated with at least one software object in the computing system.

[0005] This invention provides a system that overcomes the shortcomings of existing technologies and offers additional advantages. The system includes: a memory, one or more processors communicating with the memory, and program instructions executable by the one or more processors via the memory to perform a method. The method includes obtaining one or more software objects, each software object including a workload type attribute and a software library including a set of instructions. The method includes loading the instruction set of each software object into the memory of a computing system and storing the workload type attribute of each software object as metadata of the software library of that software object. During runtime of the computing system, the method includes deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction sets of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured timing interval. The method includes deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The method includes generating execution parameters associated with each sample based on analysis of the stored samples. The method includes utilizing the execution parameters and metadata to determine access to a software library in the computing system via the workload type attribute. Based on the determined access, the method includes automatically implementing actions associated with at least one software object in the computing system.

[0006] This document describes and claims protection for computer-implemented methods, computer systems, and computer program products related to one or more aspects. Each embodiment of the computer program product may be an embodiment of each computer system and / or each computer-implemented method, and vice versa. Moreover, each embodiment is separable from and optional of each other. Furthermore, embodiments may be combined with each other. Each embodiment of the computer program product may be combined with aspects and / or embodiments of each computer system and / or computer-implemented method, and vice versa. Furthermore, this document also describes and claims protection for services related to one or more aspects.

[0007] Additional features and advantages are achieved through the techniques described herein. Other embodiments and aspects are described in detail herein and are considered part of the claimed aspects. Attached Figure Description

[0008] One or more aspects are specifically pointed out and clearly claimed by way of example in the claims at the end of the specification. The foregoing and objectives, features, and advantages of one or more aspects will become apparent from the following detailed description taken in conjunction with the accompanying drawings: Figure 1 An example of a computing environment for incorporating and using one or more aspects of this disclosure is described; Figure 2 Depicting one or more aspects of the invention Figure 1 An instance of further details of the processor set; Figure 3 An example of a computing environment for incorporating and using one or more aspects of this disclosure is described; Figures 4A-4B Certain components of a computing environment for incorporating and using one or more aspects of this disclosure are described; Figure 5 A workflow comprising various aspects is described according to one or more aspects of this disclosure; Figures 6A-6B Another example of a computing environment for incorporating and using one or more aspects of this disclosure is described. Detailed Implementation

[0009] Examples in this paper include computer program products, computer-implemented methods, and computing systems, wherein program code executing on one or more processors generates and provides data that enables continuous and efficient processing within a computing architecture, including distributed computing architectures such as cloud computing environments. In the examples presented herein, the data generated by the program code relates to the execution efficiency of software libraries. In these examples, machine code (e.g., firmware) and program code categorize instructions residing on disk or in memory, and these categorizations are provided in samples that can be tabulated for reporting and / or used to implement processing decisions that maintain the effectiveness and efficiency of the computing environment.

[0010] The code examples in this paper can categorize and sample the execution efficiency of software libraries, and use this data to adjust cloud consumer access attributes and / or the performance of libraries and computing environments. Based on software utilization, the code can allocate and / or reclaim resources to support the services provided by these libraries. Therefore, by generating data reflecting usage, the code can effectively manage computing system resources and optimize processing within the environment.

[0011] In some examples, program code executing on one or more processors can categorize software libraries and sample their execution frequencies. Software libraries executing on the system may include predefined attributes specifying workload categories. In some examples, the software library vendor may pre-configure these attributes, which are installed along with the software in the processing environment. For example, when program code (e.g., a program loader) fetches a software library, it can read attributes, including workload category details, from the library and apply the workload categories to the memory where the library is loaded. When the application executes the software, machine code (e.g., firmware) can sample the execution instructions and obtain instruction details, storing them in a sample along with workload category details. Samples can be collected by program code executing on the machine (e.g., resources of the computing environment). For example, in a distributed computing environment where a scheduler manages a set of associated services, executes activities such as routing requests to these services, and manages their configurations at runtime, the scheduler can run units of work from work queues and create interrupts. Based on these interrupts, the program code uses job step timing to collect samples (if samples are available). The program code can collect various samples in this way, either at predefined intervals, over time, or based on predefined triggers, and the program code can count the samples collected on a per-workload-category basis (based on library attributes). The program code can then aggregate these counts into a System Management Facility (SMF) record.

[0012] The examples in this paper implement the functionality described in a transparent manner and within the scope of the existing technical architecture of the system without adversely affecting system performance. As will be described in more detail herein, the examples enable program code and / or machine code to classify metadata associated with system memory loaded instructions. In a non-limiting example, a translation table may store memory metadata, including metadata associated with software libraries. An example of a computing system using tables in this manner, specifically a DAT (Dynamic Address Translation) table, is the z / Architecture instruction set architecture described in the publication entitled "z / Architecture Principles of Operation," IBM Publication No. SA22-7832-13, 14th Edition, May 2022, which is incorporated herein by reference in its entirety. However, the z / Architecture instruction set architecture is only an example architecture; other architectures and / or other types of computing environments of IBM and / or other entities may include and / or use one or more aspects of the invention. z / Architecture and IBM are trademarks or registered trademarks of IBM in at least one jurisdiction.

[0013] Examples in this document include computer-implemented methods, computer program products, and computer systems, where program code and / or machine code determine the frequency of execution of a software library (e.g., CPU or processor access) and can utilize this information to generate reports and / or adjust the resources of the computing system. Computer operation includes sampling at predetermined intervals in the firmware. In some examples, each program has allocated workload categories stored in memory (e.g., a DAT structure), which are determined by a binder at link time. At (e.g., a second) interval, the program code can collect samples (e.g., the initial interval is a scheduling interval that occurs in response to an interrupt, as described herein). The program code can aggregate these samples to generate a report on how much relative time (percentage) is spent in each workload category and can also utilize this data to (e.g., automatically) adjust system resources.

[0014] The examples in this paper are inevitably linked to computation and involve practical applications. When an operating system tracks and categorizes execution time based on software libraries, it can report CPU usage based on the software library or group of software libraries and optimize processing by allocating and reclaiming resources based on usage. Furthermore, this data can be used to allocate resources to software in distributed computing environments, including cloud computing environments. The examples in this paper focus on generating execution time-related data based on software libraries and using this data to maintain and / or improve the performance of distributed computing systems, including practical applications of allocating resources in a way that optimizes processing. These examples are inevitably linked to computation, at least because the use of software libraries and the allocation and utilization of resources to maintain processing efficiency and effectiveness are elements unique to computation.

[0015] The examples presented in this paper significantly provide a method for generating and utilizing execution-time-related data based on software libraries to maintain and / or improve the performance of distributed computing systems, unlike other approaches. As will be discussed here, unlike existing methods, the method proposed in this paper for generating and utilizing execution-time-related data based on software libraries does not degrade the performance of the computing system. In many of the examples in this paper, to generate this data, the program code samples instructions, including at predefined intervals, to provide a view of the running workload of the computing environment's processing resources. These samples, collected over time, provide a representative view of the software running the system at a frequency that does not impede performance, but provides a representative distribution of the samples over each interval. Existing methods degrade the performance of computing systems to provide data that could be more refined but is not more suitable for the practical applications discussed in this paper. For example, in some existing methods that are improved upon in the examples in this paper, a software library might track how much CPU time is spent during operation with changes to the software library code based on the running services of the computing system to determine how long the software accesses the CPU between two points in the software library. This existing method degrades production because it not only requires adding code to collect and report the data, but the services of this method also utilize additional processing resources to run. Conversely, the examples in this paper enable program code and / or machine code to transparently obtain and generate CPU usage data from software libraries without modifying the software libraries or degrading system performance.

[0016] Examples disclosed herein include computer-implemented methods, computer program products, and computer systems. Certain computer program products disclosed herein include a collection of one or more computer-readable storage media and program instructions co-stored in the collection of one or more computer-readable storage media for causing at least one computing device to perform computer operations. The computer operations include obtaining one or more software objects, each software object including a workload type attribute and a software library including a set of instructions. The computer operations include loading the instruction set of each software object into the memory of the computing system and storing the workload type attribute of each software object as metadata of the software library of that software object. During runtime of the computing system, the computer operations include deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction sets of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured time interval. The computer operations include deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The computer operations include generating execution parameters associated with each sample based on analysis of the stored samples. The computer operations include utilizing the execution parameters and metadata to determine access to the software library in the computing system via the workload type attribute. Based on the determined access, the computer operations include automatically implementing actions associated with at least one software object in the computing system. Therefore, the examples in this paper enable program code and / or machine code to transparently obtain and generate CPU usage data from software libraries without modifying the software libraries or degrading system performance.

[0017] Additionally or alternatively, computer operations may include generating one or more software objects. This generation may include, for each software object, retrieving object code from a software library from a storage medium, analyzing the object code to determine workload type attributes, and using a binder to link the object code to the workload type attributes, wherein the object code having the linked workload type attributes comprises the software object. Including attributes of the software object allows these attributes to be loaded when the software is deployed, which allows the attributes to be retained within the system's existing architecture (e.g., as metadata). This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information enables this granular detail to be implemented in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance).

[0018] Additionally or alternatively, the workload type attribute can indicate the workload category of a software library. As mentioned above, including attributes in software objects so that they can be loaded when the software is deployed allows the attribute to be preserved (e.g., as metadata) within the system's existing architecture. This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information makes it possible to implement this granular detail in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance). Workload categories are software attributes that are particularly helpful in resource allocation decisions.

[0019] Alternatively, deploying second hardware instructions to obtain samples from the firmware process and store them in memory may involve determining that an interrupt has occurred. Based on the determination that an interrupt has occurred, control of the second firmware process to issue and retrieve instructions to collect pending samples. The sampling of software access information is transparent to the system because the examples herein can be implemented within existing technical architectures, and because sampling can utilize existing interrupts when they are available and trigger the interrupt itself when they are unavailable, any adverse impact on system performance is limited.

[0020] Additionally or alternatively, this action includes generating and transmitting a report based on the generated execution parameters. As mentioned above, the execution parameters provide information about software object access, enabling resource allocation and other processing decisions to be made in an optimized manner.

[0021] Additionally or alternatively, this action may include automatically adjusting the allocation of computing system resources based on the generated execution parameters. Adjusting the allocation can optimize the computing system and improve performance.

[0022] Additionally or alternatively, storing workload type attributes may include storing the workload type attributes in a dynamic address translation table. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially sacrificing performance.

[0023] Alternatively, a second hardware instruction may control a second firmware process to obtain and store samples from the firmware process at a second predetermined time interval. By leveraging existing elements of the architecture to store information that aids in optimization, the example presented in this paper improves performance without initially compromising performance.

[0024] Additionally or alternatively, the execution parameters for each software library may each include an indication of the amount of time a processor in one or more processors of the computing system may access the software library. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially compromising it.

[0025] Alternatively, the second firmware process may determine at each second predetermined interval whether it has acquired a sample during the second predetermined interval, and based on the determination that a sample has been acquired, the process may increment a count associated with the workload category in the sample. The sampling of software access information is transparent to the system because the examples herein can be implemented within existing technical architectures, and because the sampling can utilize existing interrupts when they are available and trigger interrupts themselves when they are unavailable, thus limiting any adverse impact on system performance.

[0026] In some examples, the computer implementation of this paper includes obtaining one or more software objects, each software object including a workload type attribute and a software library including an instruction set. The method includes loading the instruction set of each software object into the memory of the computing system and storing the workload type attribute of each software object as metadata of the software library of that software object. During runtime of the computing system, the method includes deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction sets of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured timing interval. The method includes deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The method includes generating execution parameters associated with each sample based on analysis of the stored samples. The method includes utilizing the execution parameters and metadata to determine access to the software library in the computing system via the workload type attribute. Based on the determined access, the method includes automatically implementing actions associated with at least one software object in the computing system. Therefore, the examples in this paper enable program code and / or machine code to transparently obtain and generate data related to CPU usage data on the software library without modifying the software library and without degrading system performance.

[0027] Additionally or alternatively, the method may include generating one or more software objects. This generation may include, for each software object, obtaining object code from a software library from a storage medium, analyzing the object code to determine workload type attributes, and using a binder to link the object code to the workload type attributes, wherein the object code having the linked workload type attributes includes the software object. Including attributes of the software object allows these attributes to be loaded when the software is deployed, which allows the attributes to be retained within the system's existing architecture (e.g., as metadata). This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information enables this granular detail to be implemented in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance).

[0028] Additionally or alternatively, the workload type attribute can indicate the workload category of a software library. As mentioned above, including attributes in software objects so that they can be loaded when the software is deployed allows the attribute to be preserved (e.g., as metadata) within the system's existing architecture. This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information makes it possible to implement this granular detail in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance). Workload categories are software attributes that are particularly helpful in resource allocation decisions.

[0029] Alternatively, deploying second hardware instructions to obtain samples from the firmware process and store them in memory may involve determining that an interrupt has occurred. Based on the determination that an interrupt has occurred, control of the second firmware process to issue and retrieve instructions to collect pending samples. The sampling of software access information is transparent to the system because the examples herein can be implemented within existing technical architectures, and because sampling can utilize existing interrupts when they are available and trigger the interrupt itself when they are unavailable, any adverse impact on system performance is limited.

[0030] Additionally or alternatively, this action includes generating and transmitting a report based on the generated execution parameters. As mentioned above, the execution parameters provide information about software object access, enabling resource allocation and other processing decisions to be made in an optimized manner.

[0031] Additionally or alternatively, this action may include automatically adjusting the allocation of computing system resources based on the generated execution parameters. Adjusting the allocation can optimize the computing system and improve performance.

[0032] Additionally or alternatively, storing workload type attributes may include storing the workload type attributes in a dynamic address translation table. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially sacrificing performance.

[0033] Alternatively, a second hardware instruction may control a second firmware process to obtain and store samples from the firmware process at a second predetermined time interval. By leveraging existing elements of the architecture to store information that aids in optimization, the example presented in this paper improves performance without initially compromising performance.

[0034] Additionally or alternatively, the execution parameters for each software library may each include an indication of the amount of time a processor or computing system in one or more processors accesses the software library. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially sacrificing performance.

[0035] Alternatively, the second firmware process may determine at each second predetermined interval whether the firmware process has acquired a sample during the second predetermined interval, and based on the determination that a sample has been acquired, the process may increment a count associated with the workload category in the sample. The sampling of software access information is transparent to the system because the examples herein can be implemented within existing technical architectures, and because the sampling can utilize existing interrupts when they are available and trigger interrupts themselves when they are unavailable, any adverse impact on system performance is limited.

[0036] The computer system described herein may include memory, one or more processors communicating with the memory, and program instructions executable by one or more processors via the memory to perform a method. The method includes obtaining one or more software objects, each software object including a workload type attribute and a software library including an instruction set. The method includes loading the instruction set of each software object into the memory of the computing system and storing the workload type attribute of each software object as metadata of the software library of that software object. During runtime of the computing system, the method includes deploying first hardware instructions to trigger a firmware process to sample instructions from the instruction sets of one or more software objects executed by one or more processors of the computing system during each time interval of a pre-configured time interval. The method includes deploying second hardware instructions to obtain samples from the firmware process and store them in the memory. The method includes generating execution parameters associated with each sample based on analysis of the stored samples. The method includes using the execution parameters and metadata to determine access to a software library in the computing system via the workload type attribute. Based on the determined access, the method includes automatically implementing actions associated with at least one software object in the computing system. Therefore, the examples in this paper enable program code and / or machine code to transparently obtain and generate CPU usage data from software libraries without modifying the software libraries or degrading system performance.

[0037] Additionally or alternatively, the method may include generating one or more software objects. This generation may include, for each software object, obtaining object code from a software library from a storage medium, analyzing the object code to determine workload type attributes, and using a binder to link the object code to the workload type attributes, wherein the object code having the linked workload type attributes includes the software object. Including attributes of the software object allows these attributes to be loaded when the software is deployed, which allows the attributes to be retained within the system's existing architecture (e.g., as metadata). This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information enables this granular detail to be implemented in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance).

[0038] Additionally or alternatively, the workload type attribute can indicate the workload category of a software library. As mentioned above, including attributes in software objects so that they can be loaded when the software is deployed allows the attribute to be preserved (e.g., as metadata) within the system's existing architecture. This enables program code to obtain access information based on software attributes without degrading system performance. The availability of attribute information makes it possible to implement this granular detail in reporting and allows management mechanisms within the system to utilize this information in resource allocation (e.g., to optimize performance). Workload categories are software attributes that are particularly helpful in resource allocation decisions.

[0039] Alternatively, deploying second hardware instructions to obtain samples from the firmware process and store them in memory may involve determining that an interrupt has occurred. Based on the determination that an interrupt has occurred, control of the second firmware process to issue and retrieve instructions to collect pending samples. The sampling of software access information is transparent to the system because the example here can be implemented within existing technical architectures, and because sampling can utilize existing interrupts when they are available and trigger the interrupt itself when they are unavailable, any adverse impact on system performance is limited.

[0040] Additionally or alternatively, this action includes generating and transmitting a report based on the generated execution parameters. As mentioned above, the execution parameters provide information about software object access, enabling resource allocation and other processing decisions to be made in an optimized manner.

[0041] Additionally or alternatively, this action may include automatically adjusting the allocation of computing system resources based on the generated execution parameters. Adjusting the allocation can optimize the computing system and improve performance.

[0042] Additionally or alternatively, storing workload type attributes may include storing the workload type attributes in a dynamic address translation table. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially sacrificing performance.

[0043] Alternatively, a second hardware instruction may control a second firmware process to obtain and store samples from the firmware process at a second predetermined time interval. By leveraging existing elements of the architecture to store information that aids in optimization, the example presented in this paper improves performance without initially compromising performance.

[0044] Additionally or alternatively, the execution parameters for each software library may each include an indication of the amount of time a processor or computing system in one or more processors accesses the software library. By leveraging existing elements of the architecture to store information that aids in optimization, the examples in this paper improve performance without initially sacrificing performance.

[0045] Alternatively, the second firmware process may determine at each second predetermined interval whether it has acquired a sample during the second predetermined interval, and based on the determination that a sample has been acquired, the process may increment a count associated with the workload category in the sample. The sampling of software access information is transparent to the system because the example here can be implemented within existing technical architectures, and because the sampling can utilize existing interrupts when they are available and trigger interrupts themselves when they are unavailable, any adverse impact on system performance is limited.

[0046] This document describes and claims protection for computer-implemented methods, computer systems, and computer program products related to one or more aspects. Each embodiment of the computer program product may be an embodiment of each computer system and / or each computer-implemented method, and vice versa. Moreover, each embodiment is separable from and optional of each other. Furthermore, embodiments may be combined with each other. Each embodiment of the computer program product may be combined with aspects and / or embodiments of each computer system and / or computer-implemented method, and vice versa.

[0047] One or more aspects of this disclosure are incorporated into, executed by, and / or used by a computing environment. As an example, a computing environment can be of various architectures and types, including but not limited to: personal computing, client-server, distributed, virtual, simulation, partitioned, non-partitioned, cloud-based, quantum, grid, time-sharing, clustered, peer-to-peer, wearable, mobile, having one or more nodes, having one or more processors, and / or any other type of environment and / or configuration capable of executing processes (or multiple processes), said process execution including control mode processing with selective control mode processing and / or one or more other aspects of this disclosure. Aspects of this disclosure are not limited to a particular architecture or environment.

[0048] Various aspects of this disclosure are described by narrative text, flowcharts, block diagrams of computer systems, and / or block diagrams of machine logic included in embodiments of a computer program product (CPP). Regarding any flowchart, depending on the technology involved, operations may be performed in a different order than that shown in a given flowchart. For example, again according to the technology involved, two operations shown in consecutive flowchart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that at least partially overlaps in time.

[0049] Computer Program Product Embodiment (“CPP Embodiment” or “CPP”) is a term used in this disclosure to describe any collection of one or more storage media (also referred to as “media”) collectively included in a collection of one or more storage devices, the collection of one or more storage devices collectively including 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 used by a computer processor. Without limitation, a computer-readable storage medium can be an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination of the foregoing. Some known types of storage devices that include these media include: magnetic disks, 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 disc (DVD), memory sticks, floppy disks, mechanical encoding devices (such as punch cards or pits / platforms formed in the main surface of the disk), or any suitable combination of the foregoing. Computer-readable storage media, as used in this disclosure, should not be construed as storing transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, optical pulses through fiber optic cables, electrical signals transmitted through wires, and / or other transmission media. As those skilled in the art will understand, data is typically moved at certain incidental points in time during the normal operation of the storage device, such as during access, defragmentation, or garbage collection; however, this does not make the storage device transient, because the data is not transient when it is stored.

[0050] Reference Figure 1An example of a computing environment for executing, combining, and / or using one or more aspects of this disclosure is described. In one example, computing environment 100 includes an example of an environment for executing at least some computer code involved in executing methods such as generating processing (e.g., CPU) data 150 (also referred to herein as block 150) that reflects software usage (without compromising performance or implementing changes to the technical architecture). In addition to block 150, computing environment 100 includes, for example, a computer 101, a wide area network (WAN) 102, an end-user equipment (EUD) 103, a remote server 104, a public cloud 105, and a private cloud 106. In this embodiment, computer 101 includes a processor set 110 (including processing circuitry 120 and a cache 121), communication infrastructure 111, volatile memory 112, persistent storage device 113 (including an operating system 122 and block 150, as described above), a peripheral device set 114 (including a user interface (UI) device set 123, a storage device 124, and an Internet of Things (IoT) sensor set 125), and a network module 115. Remote server 104 includes remote database 130. Public cloud 105 includes gateway 140, cloud coordination module 141, host physical machine set 142, virtual machine set 143, and container set 144.

[0051] Computer 101 can 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 now known or to be developed in the future capable of running programs, accessing networks, or querying databases such as remote database 130. As is well known in the field of computer technology, and depending on the technology, the performance of a computer-implemented method can be distributed across multiple computers and / or multiple locations. On the other hand, in this presentation of computing environment 100, the detailed discussion focuses on a single computer, specifically computer 101, to keep the presentation as simple as possible. Computer 101 can reside in the cloud, even... Figure 1 It is not shown in the cloud, and on the other hand, computer 101 does not need to be in the cloud unless it can be indicated with certainty to any extent.

[0052] Processor assembly 110 includes one or more computer processors of any type now known or to be developed in the future. Processing circuitry 120 may be distributed across multiple packages, such as multiple cooperating integrated circuit chips. Processing circuitry 120 may implement multiple processor threads and / or multiple processor cores. Cache 121 is memory located within the processor chip package and is typically used for data or code that should be readily accessible by the threads or cores running on processor assembly 110. Cache memory is typically organized into multiple levels based on its relative proximity to the processing circuitry. Alternatively, some or all of the cache in the processor assembly may be located “off-chip.” In some computing environments, processor assembly 110 may be designed to work with qubits and perform quantum computing.

[0053] Computer-readable program instructions are typically loaded onto computer 101 to cause the processor set 110 of computer 101 to perform a series of operational steps to implement a computer-implemented method, such that the instructions thus executed instantiate the method specified in the flowcharts and / or descriptive descriptions of the computer-implemented method included in this document (collectively, the “method of the invention”). These computer-readable program instructions are stored in various types of computer-readable storage media, such as cache 121 and other storage media discussed below. The program instructions and associated data are accessed by the processor set 110 to control and direct the execution of the method of the invention. In computing environment 100, at least some of the instructions for performing the method of the invention may be stored in block 150 of permanent storage device 113, in block 400.

[0054] Communication structure 111 is a signal transmission path that allows the various components of computer 101 to communicate with each other. Typically, this structure consists of switches and conductive paths, such as switches and conductive paths that form buses, bridges, physical input / output ports, etc. Other types of signal communication paths can be used, such as fiber optic communication paths and / or wireless communication paths.

[0055] Volatile memory 112 is any type of volatile memory now known or to be developed in the future. Examples include dynamic random access memory (RAM) or static RAM. Typically, volatile memory 112 is characterized by random access, but this is not necessary unless explicitly stated otherwise. In computer 101, volatile memory 112 is located in a single package and is internal to computer 101; however, alternatively or additionally, volatile memory may be distributed across multiple packages and / or located externally relative to computer 101.

[0056] The persistent storage device 113 is any form of non-volatile memory for a computer, now known or to be developed in the future. The non-volatility of this memory means that the stored data is retained regardless of whether power is supplied to the computer 101 and / or directly to the persistent storage device 113. The persistent storage device 113 may be a read-only memory (ROM), but typically at least a portion of the persistent memory allows data to be written, deleted, and rewritten. Some common forms of persistent storage include hard disks and solid-state storage devices. The operating system 122 may take several forms, such as various known proprietary operating systems or operating systems employing an open-source portable operating system interface type with a kernel. The code included in block 150 generally includes at least some of the computer code involved in performing the methods of the present invention.

[0057] Peripheral device set 114 includes a set of peripheral devices for computer 101. Data communication connections between peripheral devices and other components of computer 101 can be implemented in various ways, such as Bluetooth connectivity, near field communication (NFC) connectivity, connections made by cables (such as Universal Serial Bus (USB) type cables), plug-in 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, UI device set 123 may include components such as displays, speakers, microphones, wearable devices (such as goggles and smartwatches), keyboards, mice, printers, touchpads, game controllers, and haptic devices. Storage device 124 is an external storage device, such as an external hard drive, or a pluggable storage device, such as an SD card. Storage device 124 can be permanent and / or volatile. In some embodiments, storage device 124 may take the form of a quantum computing storage device for storing data in the form of qubits. In embodiments where computer 101 requires substantial storage (e.g., where computer 101 locally stores and manages a large database), this storage can be provided by peripheral storage devices designed for storing very large amounts of data, such as a Storage Area Network (SAN) shared by multiple geographically distributed computers. The IoT sensor set 125 comprises sensors that can be used in IoT applications. For example, one sensor could be a thermometer, while another could be a motion detector.

[0058] Network module 115 is a collection of computer software, hardware, and firmware that allows computer 101 to communicate with other computers via WAN 102. Network module 115 may include hardware such as a modem or Wi-Fi transceiver, software for packetizing and / or depacketizing data transmitted over the communication network, and / or web browser software for transmitting data over the Internet. In some embodiments, the network control and network forwarding functions of network module 115 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 network module 115 are performed on physically separate devices, such that the control function manages several different network hardware devices. Computer-readable program instructions for performing the methods of the present invention can typically be downloaded to computer 101 from an external computer or external storage device via a network adapter card or network interface included in network module 115.

[0059] WAN 102 is any wide area network (e.g., the Internet) capable of transmitting computer data over non-local distances using any technology known now or developed in the future for transmitting computer data. In some embodiments, WAN 102 may be replaced by and / or supplemented by a local area network (LAN) designed to transmit data between devices located in a local area, such as a Wi-Fi network. WANs and / or LANs typically include computer hardware such as copper transmission cables, fiber optic transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0060] End User Equipment (EUD) 103 is any computer system used and controlled by an end user (e.g., a customer of the enterprise operating computer 101) and can take any of the forms discussed above in conjunction with computer 101. EUD 103 typically receives useful and available data from the operation of computer 101. For example, assuming computer 101 is designed to provide recommendations to an end user, these recommendations are typically transmitted from network module 115 of computer 101 to EUD 103 via WAN 102. In this way, EUD 103 can display or otherwise present recommendations to the end user. In some embodiments, EUD 103 can be client equipment such as a thin client, heavy client, mainframe, desktop computer, etc.

[0061] Remote server 104 is any computer system that provides at least some data and / or functionality to computer 101. Remote server 104 can be controlled and used by the same entity operating computer 101. Remote server 104 represents a machine that collects and stores useful and available data used by other computers, such as computer 101. For example, if computer 101 is designed and programmed to provide recommendations based on historical data, that historical data can be provided to computer 101 from a remote database 130 of remote server 104.

[0062] Public cloud 105 is any computer system that can be used by multiple entities, providing on-demand availability of computer system resources and / or other computing capabilities (particularly data storage (cloud storage) and computing power) without the need for direct, active management by users. Cloud computing typically leverages resource sharing to achieve scalability consistency and economy. Direct and active management of the computing resources of public cloud 105 is performed by the computer hardware and / or software of cloud coordination module 141. The computing resources provided by public cloud 105 are typically implemented by virtual computing environments running on various computers constituting the host physical machine set 142, which is the entirety of physical computers in and / or available to the public cloud 105. Virtual computing environments (VCEs) typically take the form of virtual machines from virtual machine set 143 and / or containers from container set 144. It should be understood that these VCEs can be stored as images and can be transferred between various physical machine hosts as images or after the VCEs are instantiated. Cloud coordination module 141 manages the transfer and storage of images, deploys new instantiations of VCEs, and manages the active instantiation of VCE deployments. Gateway 140 is a collection of computer software, hardware, and firmware that allow public cloud 105 to communicate via WAN 102.

[0063] Now, we will provide some further explanation of Virtualized Computing Environments (VCEs). A VCE can be stored as an "image." A new active instance of a VCE can be instantiated from this image. Two common 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 multiple isolated user-space instances, called containers, to exist. From the perspective of the programs running within them, these isolated user-space instances typically appear as actual computers. Computer programs running on a regular operating system can utilize all the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running within a container can only use the contents of the container and the devices allocated to the container; this is a characteristic known as containerization.

[0064] Private cloud 106 is similar to public cloud 105, except that computing resources are available only to a single enterprise. While private cloud 106 is depicted as communicating with WAN 102, in other embodiments, private cloud may be completely disconnected 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) typically implemented by different vendors. Each of the multiple clouds remains a separate and discrete entity, but the larger hybrid cloud architecture is bound together by standardization or proprietary technology that enables coordination, management, and / or data / application portability across the multiple component clouds. In this embodiment, public cloud 105 and private cloud 106 are both part of a larger hybrid cloud.

[0065] Cloud computing services and / or microservices Figure 1 (Not shown separately): Private cloud 106 and public cloud 105 are programmed and configured to deliver cloud computing services and / or microservices (unless otherwise indicated, the term "microservice" should be interpreted to include the larger "service" regardless of size). Cloud services are infrastructure, platforms, or software typically hosted by a third-party provider and available to users via the Internet. Cloud services facilitate the flow of user data from front-end clients (e.g., client servers, tablets, desktop computers, laptops) via the Internet to and from the provider's systems. In some embodiments, cloud services may be configured and orchestrated according to a "as-a-service" technology paradigm, where something is presented to internal or external customers as a cloud computing service. As-a-service provision typically provides various endpoints with which customers interface. These endpoints are typically based on a set of APIs. One type of as-a-service provision is Platform as a Service (PaaS), where a service provider provides, instantiates, runs, and manages modular code packages that customers can use to instantiate computing platforms and one or more applications without the complexity of building and maintaining the infrastructure typically associated with these things. Another type is Software as a Service (SaaS), where software is centrally hosted and distributed on a subscription basis. SaaS is also known as on-demand software, web-based software, or web-hosted software. The four technical subfields involved in cloud services are: deployment, integration, on-demand, and virtual private networks (VPNs).

[0066] The computing environment described above is merely one example of a computing environment used in conjunction with, executing, and / or using one or more aspects of this disclosure. Other examples are possible. For instance, in one or more embodiments, Figure 1 One or more components / modules / blocks are not included in the computing environment and / or are not used in one or more aspects of this disclosure. Furthermore, in one or more embodiments, additional and / or other components / modules / blocks may be used. Other variations are possible.

[0067] In one example, (e.g., processor set 110) the processor includes multiple functional components (or subsets thereof) for executing instructions. Figure 2 As shown, in one example, processor 200 includes, for example, an instruction fetching component 201 for fetching instructions to be executed; an instruction decoding / operand fetching component 202 for decoding the fetched instructions and obtaining operands of the decoded instructions; one or more instruction execution components 204 for executing the decoded instructions; a memory access component 206 for accessing memory as necessary for instruction execution; and a write-back component 208 for providing the results of the executed instructions. One or more components may access and / or use one or more registers 210 during instruction processing. Furthermore, one or more components may access and / or use processing code to generate processing (e.g., CPU) data reflecting the software's usage (without compromising performance or implementing changes to the technical architecture) and automatically implement changes 150 based on this data. Additionally, fewer and / or other components may be used in one or more aspects of this disclosure.

[0068] As described above, in the examples presented herein, program code that executes one or more processors and / or firmware generates and retains data and / or metadata related to the access of one or more processors to software libraries. The program code may utilize the data and metadata, for example, for allocation and processing to optimize resource usage within the computing environment. In the description of functionality in the examples presented herein, certain aspects are presented as separate modules. This configuration is a non-limiting example and is provided for illustrative purposes to facilitate understanding. In various examples, various functionalities may be combined into one or more modules.

[0069] Figure 3 The diagram illustrates various aspects of the program code, which may include software and / or hardware for tracking processor access to software libraries. However, to achieve such tracking and analysis, software libraries are generated and installed from program code with categorization attributes, which can be determined by... Figure 3The process described herein utilizes, for example, when program code executing on one or more processors generates a software library, during a binding operation where the object code groups are linked together, the program code generates the software library from existing object code and adds one or more classification attributes. As mentioned above, the functionality described herein is implemented transparently and does not degrade the processing; therefore, there are no changes to the instructions or object code. The program code implements attributes such that these classification attributes are in the software library and thus available to the loader. When the program code (e.g., including the loader) loads the software library into the computing environment, from disk to memory, the program code including the loader applies the classification attributes to the memory where the software library instructions are loaded. Thus, classification becomes part of the metadata associated with memory (e.g., in a DAT table). When the firmware samples instructions, the firmware records a sample of the currently running instructions every cycle (e.g., a pre-configured cycle, which may be milliseconds). This sample includes classification attributes from memory (e.g., from DAT table entries associated with the address of the running instruction). Sampling can be managed by program code including a scheduler that virtualizes and allocates access to the CPU for various programs running on the system. During scheduler operation, the scheduler can query whether new samples have been acquired, and if so, the scheduler will receive the sample buffer. The scheduler can use the categorical attributes from the sample buffer to increment the count set (e.g., the count can depend on the categorical attributes, where there is a separate count for each categorical attribute). Depending on the type of granularity that will help inform and / or automate resource decisions, the program code can subdivide this data by program and / or address space. In a non-limiting example of an IBM z system, provided for illustrative purposes only, the program code may periodically collect this data (e.g., collect it into SMF records) and integrate it into reports for use in allocating z / OS software and / or performing system performance analysis.

[0070] refer to Figure 3 This is a block diagram 300 illustrating program code executing on one or more processors that interprets and / or generates usage efficiency data based on processor access to software libraries, hereinafter referred to herein as software usage determination component 165. Software usage determination component 165 may include hardware, software, or a combination thereof. Herein, software usage component 165 includes, but is not limited to, classification tool 210, extraction tool 220, monitoring and analysis tool 230, and reporting tool 240. As described above, the various functions are presented as modules for illustrative purposes only, and this is a non-limiting configuration of the aspects described herein.

[0071] In some examples herein, the program code of classification tool 210 obtains software objects and associates workload class identifiers with them. Software objects may include a set of software library instructions. The software objects and workload class identifiers may be manually implemented into the objects by a user (e.g., a software developer / software vendor) and / or automatically derived based on software characteristics. For example, a software vendor and / or process may generate source code, compile the source code to generate object code, and provide the object code along with a workload class identifier indicating the type of workload associated with the object code to classification tool 210. As mentioned, as illustrative and non-limiting examples, such workload types may include databases, analytics, artificial intelligence (AI) / cognitive / machine learning (ML) inference, web / content hosting, Internet of Things (IoT) / data streaming, mobile application / device backends, and security. Classification tool 210 may bind the object code and workload class identifier together to generate software objects labeled with the workload class identifier. The functionality of the program code including classification tool 210 is referenced herein. Figure 4A To describe in more detail.

[0072] Once the software object is generated (and tagged with a workload class identifier), the program code including extraction tool 220 can load instructions from a storage location (e.g., storage device 113, storage device 124, or another internal / external storage location) into the memory (e.g., memory 112) of the computing system (e.g., computer 101). In some examples, extraction tool 220 loads the software object (including the associated workload class identifier) ​​generated by classification tool 210 into memory for execution. The program code including extraction tool 220 is referenced herein. Figure 4A To describe in more detail.

[0073] During runtime, program code including monitoring and analysis tool 230 samples instructions executed by one or more processors, generates execution parameters associated with the sample, and may store the execution parameters in a storage location. In some examples, the program code of monitoring and analysis tool 230 utilizes a firmware sampling routine to periodically collect samples of instructions executed by the processors and utilizes a job collection timing routine to periodically instruct one or more processors to return samples when they are available, or to return no samples when none are available. When the program code of monitoring and analysis tool 230 obtains samples, in order to perform analysis (and interpretation) functions in this regard, the program code calculates the corresponding execution parameters for each available sample collected by the firmware sampling routine. In some examples, the program code provides these calculations to program code including reporting tool 240, which typically reports the execution parameters of one or more workload category identifiers to another user, computing system, or a combination thereof. For example, the program code of the reporting tool may provide the result of triggering the processor to change resource allocation to provide more resources to software libraries that the CPU accesses more frequently. The program code of monitoring and analysis tool 230 and the program code of reporting tool 240 are referenced herein. Figure 4B To describe in more detail.

[0074] As previously described, block diagram 200 illustrates an example implementation of software usage determination component 165, and other implementations of software usage determination component 165 are also envisioned. For example, software usage determination component 165 is depicted as having a classification tool 210, an extraction tool 220, a monitoring and analysis tool 230, and a reporting tool 240, and software usage determination component 165 can be implemented with fewer or more hardware / software components.

[0075] Figures 4A-4B Also shown is an embodiment Figure 2 The software described herein uses various aspects of component 165. As mentioned above, functionality is represented as individual components for illustrative purposes only and not to imply any limitation on configuration possibilities. References Figure 4A Resources (e.g., users, software vendors, devices) generate source code 302 and provide it to a compiler or assembler 304. The compiler / assembler 304 compiles the source code 302 to generate object code 306. In some examples, object code 306 does not need to generate new object code, but instead uses existing, readily available object code, which is program code that runs on one or more processors within the computing environment and can be obtained from a storage location (e.g., a database) accessible to those processors.

[0076] In the example presented herein, the program code implements a link between target code 306 and workload class information 312. As described above, implementing workload information within an existing architecture allows one or more program codes and machine code to determine the processor's software library usage without degrading performance or implementing changes to the existing system architecture. To link workload class information 312 with target code 306, the program code can utilize binder 308 to link target code 306 and generate software object 310 (or program object, which may include software libraries with workload type attributes). For example, software object 310 may include a set of software library instructions and workload class information 312. Workload class information 312 may include a workload class identifier 314 indicating the type of workload associated with software object 310 (e.g., analytics, security, AI / ML, etc.). Figure 4A As shown, in one implementation, program code executing on one or more processors can set the workload category identifier 314 to a value (e.g., an integer value "XX") indicating a specific workload type among multiple workload types. Although Figure 4A The workload category identifier 314 is described as having an integer data type, but other data types (e.g., alphanumeric data type, string data type, etc.) may also be considered.

[0077] Creating software objects (e.g., software libraries) with labeled workload category identifiers allows the program code in the examples presented in this paper to transparently collect CPU usage information about the software library without requiring code changes in the object code or the software library itself. In some examples, the program code generates software objects that include software library instructions and workload category identifiers. As explained in this paper, based on classifier inclusion, the program code or machine code can sample the objects to measure the execution frequency of software libraries with the same workload category type compared to software libraries associated with other workload category types. Based on these results, the program code allocating resources to various services and processes can adjust the allocation on a workload category basis to take execution frequency into account.

[0078] like Figure 4A As shown, the program code including extraction tool 220 includes program code containing extraction component 316 (e.g., software). As described above, the program object includes software libraries and workload type attributes. Although the program code including the extraction tool copies library instructions into memory, the extraction tool can maintain the workload type by copying it into a table (which can be separate from the memory where the instructions are loaded and from which the instructions are executed). Figure 4AAs shown, the program code executing on one or more processors loads instructions from software object 310 from a storage location (e.g., disk) into memory (e.g., memory 112) (block 318). In some examples, software object 310 is mounted at the computing system when the program code stores it in a storage location accessible to the computing system. The program code including extraction component 316 copies the software instructions from the storage location into memory (block 318). During the copy operation, the program code including extraction component 316 may also copy a workload class identifier 314 associated with software object 310 to the same memory location as the software instructions. For example, extraction component 316 may update the Dynamic Address Translation (DAT) table entry 320 associated with the memory containing the instructions to allocate the desired workload class identifier 314 to memory. The program code can load software object 310 into memory so that the software can be executed by the resources of the computing system, including by one or more processors. When the program code samples software object 310, the sampling includes the workload class identifier.

[0079] Based on the execution frequency of libraries, scheduler 322 can alter resource allocation within the computing system. The OS utilizes methods such as... Figure 4A Scheduler 322, as shown in Figure B, allocates work in the computing system to processors. Such work may include units of work, tasks, threads running programs (e.g., instructions), or combinations thereof. Scheduler 322 may, for example, add work to work queue 324 in priority order. When the computing system is running, additional work may be generated and added to work queue 324, the additional work may be run, and the additional work may be removed from work queue 324. When a work is completed, the unit of work may be removed or reused for a new job. Figure 4A B illustrates a scheduler 322 scheduling work (e.g., instructions) from one or more work queues 324 to processors. The scheduler 322 can run on each processor and can obtain work from the corresponding work queue 324 for execution. In some examples, when the scheduler 322 obtains work for execution on a processor, a firmware sampling routine 326 (enabled by the OS) periodically samples (e.g., every n milliseconds) the currently running instructions executing on the processor. The firmware sampling routine 326 can gain control from the processor(s) whenever a predetermined time instance is indicated by a firmware sampling timer 328. In some examples, the firmware sampling routine 326 is a millicode sampling routine configured to periodically sample the currently running instructions. The firmware sampling timer 328 can have a millisecond sampling rate such that the firmware sampling routine 326 is invoked every N milliseconds. The sampling rate of the firmware sampling timer 328 can vary in different examples. By sampling at set intervals, program code (e.g., firmware, millicode) performs sampling in a manner that improves consistent processing speed and loading.

[0080] As described above, in the examples presented herein, the software and hardware components of the technical environment can work together to determine the execution frequency of the software library and to implement configuration and allocation changes as needed to optimize the system and its resources based on the execution frequency. The hardware component involved in the workflow described herein is a firmware sampling timer 328, which can be configured with a sampling rate such that the firmware sampling routine 326 receives control from the processor at consistent intervals. In some cases, this interval is configured to be greater than the scheduler's maximum time slice (e.g., the scheduler may fetch instructions every N microseconds or nanoseconds), allowing the software to use the determining component 165 to generate a representative sample distribution of the software library's execution parameters over a period of time while avoiding system performance degradation.

[0081] When firmware sampling routine 326 receives control, the program code executing the currently running instruction can pause instruction execution. Firmware sampling routine 326 can record the memory location of the instruction (e.g., instruction address) and other information, such as workload category information 312 associated with the instruction's memory location (including workload category identifier 314), main address space number, and status description (e.g., addressing mode, DAT status, indication of whether the system is running in a problem, or hypervisor status, etc.), as illustrative and non-limiting examples. Firmware sampling routine 326 can store samples in a storage location such as workload accounting region 330. In some examples, workload accounting region 330 is virtual memory that has been reserved from the address space for storing samples.

[0082] Due to the timing of the sampling performed by the firmware, in some examples, the firmware sampling routine 326 can record new samples before the OS obtains previous samples. In this case, the program code can overwrite the old samples. The machine code of the firmware sampling routine 326 can save a count of samples or a count of lost samples so that the OS can analyze the data to determine whether sample data has been lost. The machine code of the firmware sampling routine 326 can also generate a list of samples since the last request from the operating system and provide this list to the OS and / or the program code that requested the information.

[0083] The execution frequency of the library is determined based on analysis of samples obtained from firmware routines. (Reference) Figure 4BOnce the firmware sampling routine 326 has sampled the instruction, the processor (which has received the request to execute the initial instruction from the program code) can continue executing the work (e.g., the instruction) scheduled by the scheduler 322. Each work unit can indicate which instruction address was last executed or which instruction address continues work. As described above, instruction execution can be paused when the firmware receives a sample; therefore, in some instances, the program code (executing on one or more processors) executes work until an interrupt occurs. These interrupts can be regular and controlled by a (CPU) timer via the scheduler 322. The CPU timer (set by the scheduler) causes the computing system to interrupt after a predetermined time period (e.g., a value on the order of microseconds). Therefore, if a predetermined time period (e.g., 150 microseconds) has elapsed and another interrupt (e.g., processing from an input / output (I / O) request) has not yet been taken, the computing system can take an interrupt. In some examples, the CPU timer has a value less than the firmware sampling routine frequency to ensure that the scheduler receives the maximum number of samples. In some instances, the CPU timer has a value greater than the firmware sampling routine frequency.

[0084] like Figure 4B As shown, when a CPU timer causes an interrupt, the job step timing routine 332 (e.g., a scheduler routine) can record statistics from the previous schedule. If a sample is available, the job step timing routine 332 can also issue new CPU instructions to collect the sample (e.g., from workload accounting region 330). If a sample is unavailable, in some examples, the job step timing routine 332 takes no additional action, and the scheduler 322 continues to schedule jobs from work queue 324. In some examples, when a sample is unavailable, the CPU instructions are in hardware (as opposed to in microcode). However, if a sample is available, the job step timing routine 332 can acquire the sample and increment the count set using the workload category information 312 associated with that sample.

[0085] Workload category type information is retained in the system from installation to execution, allowing the execution frequency to be determined based on the workload category type. For this purpose, each count in this set of counts can be associated with a corresponding workload category type. The job step timing routine 332 can increment the count associated with the workload category identifier 314 from the workload category information 312. The job step timing routine 332 can also subdivide the count by program or address space. The job step timing routine 332 can store the count information in the workload accounting area 330. As described above, the examples in this paper utilize existing aspects of the computing system's technical architecture to achieve transparent deployment and processing-agnostic execution.

[0086] like Figure 4BAs shown, the job step timing routine 332 can track missing samples. For example, if the sample count is greater than one or the missing sample count is greater than zero, the job step timing routine 332 can determine the number of samples that are not classified into the workload category, and this information can be used to help with debugging.

[0087] Once the software usage is determined, the program code can report results, which can be utilized, including automatically, to adjust resource allocation. Reporting is also included. Figure 4B The diagram illustrates that reporting tool 240 can use System Management Facility (SMF) component 334 to report count information over a period of time. In some examples, program code including SMF component 334 can periodically retrieve count information and store it in database 336.

[0088] In some examples, the program code including SMF component 334 may periodically aggregate data in the address space buffer and generate a total system count for each workload category type. For example, if the reporting interval is 15 minutes and there are 16 workload levels, the program code of SMF component 334 may report 16 counts in each 15-minute interval record. In another embodiment, the program code of SMF component 334 may generate records for each address space. These records may include counts for all workload categories. The program code of SMF component 334 may generate these records periodically (e.g., every 15 minutes) or at the end of a job.

[0089] Accurate resource utilization information helps in the effective management of distributed computing systems, including cloud computing systems. This information includes the amount of CPU time spent in certain software libraries. Program code executing on one or more processors in a computer system can use previously generated records stored in a database to determine the amount of CPU time spent in certain software libraries and / or to determine system utilization information. For example, the program code can determine how much CPU resources a program running on the computing system used for a given interval, what percentage of CPU resources can be attributed to a set of workload categories, and / or combinations thereof. When generating this utilization information, the program code can automatically reallocate resources to maintain or improve processing efficiency, and / or automatically generate alerts to a resource allocator that suggest methods to improve resource utilization and / or processing efficiency based on data.

[0090] Figure 5Workflow 400, illustrating various aspects of examples herein, specifically illustrates the determination of software access and / or system utilization information in a computing environment. Workflow 400 can be executed by program code and / or machine code including the software utilization determination component 165 shown herein. Workflow 400 begins when program code executing on one or more processors obtains a software library object (e.g., software object 310). The software library object includes a workload category identifier (e.g., workload category identifier 314) (402). The program code loads the software library object, including the workload category identifier, into the memory of the computing system (404). While the computing system is running, the program code can schedule instructions from a work queue (e.g., work queue 324) (e.g., via scheduler 322) to processors in the computing system (406). The program code determines whether a firmware sampling timer (e.g., firmware sampling timer 328) satisfies a predetermined condition (408). This condition may include whether a predetermined amount of time has elapsed.

[0091] If the firmware sampling timer is determined to meet a predetermined condition, the program code (e.g., via firmware sampling routine 326) collects and interprets samples of the currently running instructions (along with their associated workload category identifiers) and stores them in a storage location (410). If the firmware sampling timer is determined not to meet a predetermined condition, the program code continues to schedule instructions (e.g., via scheduler 322) (406).

[0092] When program code schedules instructions from a work queue (e.g., work queue 324) to a processor in a computing system (406), the program code may also determine whether the conditions for invoking job step timing are met (412). For example, hardware may generate an interrupt (e.g., from a CPU timer, I / O event, or a combination thereof) and provide control to the operating system interrupt handler. When this occurs, control returns to the scheduler, and job step timing is invoked. Based on the met condition (an interrupt occurs to enable sampling), the program code determines via job step timing whether sampling is available (414). For example, when job step timing is invoked, the processor may be instructed to check for samples. If the program code determines that samples are available, it calculates one or more parameters associated with the workload category of the sample and stores the parameters in a storage location (e.g., workload calculation area 330) (416). If the program code determines that samples are not available, it may continue scheduling instructions (e.g., via scheduler 322) (406). In some examples, the program code uses sampled data to automatically reconfigure processing resources within the computing system, allocating resources to software objects that have a high number of accesses compared to other software objects. Additionally, the program code can allocate resources based on the category with the most access.

[0093] While the foregoing relates to embodiments of the present invention, other and further embodiments of the present invention may be designed without departing from the basic scope of the present invention, and the scope of the present invention is defined by the appended claims.

[0094] Although this document describes one or more examples of computing environments for combining and using one or more aspects of this disclosure, Figures 6A-6B Another embodiment of a computing environment for combining and using one or more aspects of this disclosure is described.

[0095] First refer to Figure 6A In this example, computing environment 36 includes, for example, a native central processing unit (CPU) 37 based on an architecture having an instruction set architecture, memory 38, and one or more input / output devices and / or interfaces 39 coupled to each other via, for example, one or more buses 40 and / or other connections.

[0096] The native central processing unit 37 includes one or more native registers 41, such as one or more general-purpose registers and / or one or more special-purpose registers used during processing within the environment. These registers include information representing the state of the environment at any given point in time.

[0097] In addition, the native central processing unit 37 executes instructions and code stored in memory 38. In a particular example, the central processing unit executes emulator code 42 stored in memory 38, which enables a computing environment configured in one architecture to emulate another architecture (different from the first architecture) and to execute software and instructions developed based on the other architecture.

[0098] refer to Figure 6B Further details relating to emulator code 42 are described. Client instructions 43 stored in memory 38 include software instructions (e.g., machine instructions) developed to execute on an architecture other than the native CPU 37. For example, client instructions 43 could be designed to execute on a processor based on a different instruction set architecture, but instead are emulated on the native central processing unit 37, which could be, for example, an instruction set architecture. In one example, emulator code 42 includes an instruction fetch routine 44 to fetch one or more client instructions 43 from memory 38, and optionally provides a native buffer for the fetched instructions. It also includes an instruction translation routine 45 to determine the type of the fetched client instruction and translate the client instruction into one or more corresponding native instructions 46. This translation includes, for example, identifying the function to be performed by the client instruction and selecting one or more native instructions(s) to perform that function.

[0099] Furthermore, emulator code 42 includes emulation control routine 47 to cause native instructions to be executed. Emulation control routine 47 can cause the native central processing unit 37 to execute a native instruction routine that emulates one or more previously obtained client instructions, and upon completion of such execution, return control to the instruction fetch routine to emulate the fetching of the next client instruction or a set of client instructions. Execution of native instructions 46 may include loading data from memory 38 into a register; storing data from a register back into memory; or performing some type of arithmetic or logical operation determined by a translation routine.

[0100] For example, each routine is implemented in software, which is stored in memory and executed by the native central processing unit 37. In other examples, one or more routines or operations are implemented in firmware, hardware, software, or some combination thereof. The registers of the emulated processor can be emulated using the native central processing unit register 41 or by using locations in memory 38. In embodiments, client instructions 43, native instructions 46, and emulator code 42 can reside in the same memory or can be distributed across different memory devices.

[0101] According to one or more aspects of this disclosure, example instructions that can be emulated are firmware sampling instructions and other instructions discussed herein. Other instructions are also possible.

[0102] The computing environments described herein are merely examples of computing environments that can be used. One or more aspects of this disclosure can be used with many types of environments. The computing environments provided herein are merely examples. Each computing environment can be configured to include one or more aspects of this disclosure. For example, each can be configured to implement control mode processing and / or execute one or more other aspects of this disclosure. Software and hardware performance is improved by eliminating additional code and execution time and preventing errors (e.g., avoiding zero initialization of unused fields).

[0103] In addition to the above, one or more aspects such as providing, supplying, deploying, managing, and servicing customer environment management can be provided by a service provider. For example, a service provider can create, maintain, support, etc., the computer code and / or computer infrastructure that performs one or more aspects for one or more customers. In return, the service provider can receive payments from customers, for example, under subscription and / or fee agreements. Alternatively or alternatively, the service provider can receive payments from selling advertising content to one or more third parties.

[0104] In one aspect, an application can be deployed to execute one or more embodiments. As an example, application deployment includes providing computer infrastructure operable to execute one or more embodiments.

[0105] On the other hand, computing infrastructure can be deployed, including integrating computer-readable code into a computing system, wherein the code combined with the computing system is capable of executing one or more embodiments.

[0106] On the other hand, a process for integrating computing infrastructure can be provided, including integrating computer-readable code into a computer system. The computer system includes a computer-readable medium, wherein the computer medium includes one or more embodiments. The code integrated with the computer system is capable of executing one or more embodiments.

[0107] This document describes various aspects and embodiments. Furthermore, many variations are possible without departing from the spirit of the aspects of this disclosure. It should be noted that, unless otherwise inconsistent, each aspect or feature described and / or claimed herein, and its variations, may be combined with any other aspect or feature.

[0108] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting. As used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will also be understood that the terms “comprising” and / or “including” as used in this specification specify the presence of the stated features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0109] If present, all means or steps plus functional elements in the following claims are intended to include corresponding structures, materials, actions, and equivalents for performing functions in combination with other claimed elements of the particular claim. Descriptions of one or more embodiments have been presented for purposes of illustration and description, but such description is not intended to be exhaustive or limited to the forms disclosed. Many modifications and variations will be apparent to those skilled in the art. The embodiments were chosen and described in order to best explain various aspects and practical applications, and to enable others skilled in the art to understand the various embodiments with various modifications suitable for the particular intended use.

Claims

1. A computer program product, comprising: A collection of one or more computer-readable storage media; as well as Program instructions, collectively stored in the collection of one or more computer-readable storage media, are used to cause at least one computing device to perform computer operations, said computer operations including: Obtain one or more software objects, each software object including a workload type attribute and a software library including a set of instructions; The instruction set of each software object is loaded into the memory of the computing system, and the workload type attribute of each software object is stored as metadata of the software library of the software object; During the operation of the computing system, a first hardware instruction is deployed to trigger a firmware process to sample instructions from the instruction set of the one or more software objects executed by one or more processes of the computing system during each of the pre-configured time intervals; Deploy a second hardware instruction to obtain a sample from the firmware process and store it in the memory; Based on the analysis of the stored samples, execution parameters associated with each sample are generated; The execution parameters and metadata are used to determine access to the software library in the computing system via a workload type attribute; and Based on the determination of the access, actions related to at least one software object in the computing system are automatically implemented.

2. The computer program product according to claim 1, wherein the computer operation further includes: The generation of the one or more software objects includes: For each software object, Obtain the object code of the software library from the storage medium; Analyze the target code to determine workload type attributes; and The target code is linked to the workload type attribute using a binder, wherein the target code having the linked workload type attribute includes the software object.

3. The computer program product according to claim 1 or 2, wherein, The workload type attribute indicates the workload category of the software library.

4. The computer program product according to any one of claims 1 to 3, wherein, Deploying the second hardware instructions to obtain a sample from the firmware process and storing it in the memory includes: It has been confirmed that an interruption has occurred; Based on the determination that the interruption has occurred, the control second firmware process issues and extracts instructions to collect pending samples.

5. The computer program product according to any one of claims 1 to 4, wherein, The action includes generating and sending a report based on the generated execution parameters.

6. The computer program product according to any one of claims 1 to 5, wherein, The action includes: automatically adjusting the allocation of resources in the computing system based on the generated execution parameters.

7. The computer program product according to any one of claims 1 to 6, wherein, Storing the workload type attribute includes storing the workload type attribute in a dynamic address translation table.

8. The computer program product according to any one of claims 1 to 7, wherein, The second hardware instruction controls the second firmware process to obtain and store the sample from the firmware process at a second predetermined interval.

9. The computer program product according to any one of claims 1 to 8, wherein, The execution parameters for each software library include an indication of the amount of time a processor from one or more processors of the computing system accesses the software library.

10. The computer program product according to claim 8, wherein, The second firmware process determines at each second predetermined interval whether the firmware process has acquired a sample during the second predetermined interval, and wherein, based on the determination that the sample has been acquired, a count associated with the workload category in the sample is incremented.

11. A computer system, comprising: At least one computing device; A collection of one or more computer-readable storage media; as well as Program instructions, collectively stored in the collection of the one or more computer-readable storage media, are used to cause the at least one computing device to perform computer operations, the computer operations including: Obtain one or more software objects, each software object including a workload type attribute and a software library including a set of instructions; The instruction set of each software object is loaded into the memory of the computing system, and the workload type attribute of each software object is stored as metadata of the software library of the software object; During the operation of the computing system, a first hardware instruction is deployed to trigger a firmware process to sample instructions from the instruction set of the one or more software objects executed by one or more processors of the computing system during each of the pre-configured time intervals. Deploy a second hardware instruction to obtain a sample from the firmware process and store it in the memory; Based on the analysis of the stored samples, execution parameters associated with each sample are generated; The execution parameters and metadata are used to determine access to the software library in the computing system via a workload type attribute; and Based on the determination of the access, actions related to at least one software object in the computing system are automatically implemented.

12. The computer system according to claim 11, wherein the computer operation further includes: The generation of the one or more software objects includes: For each software object, Obtain the object code of the software library from the storage medium; Analyze the target code to determine workload type attributes; and The target code is linked to the workload type attribute using a binder, wherein the target code having the linked workload type attribute includes the software object.

13. The computer system according to claim 11 or 12, wherein, The workload type attribute indicates the workload category of the software library.

14. The computer system according to any one of claims 11 to 13, wherein, Deploying the second hardware instructions to obtain a sample from the firmware process and storing it in the memory includes: It has been confirmed that an interruption has occurred; Based on the determination that the interruption has occurred, the control second firmware process issues and extracts instructions to collect pending samples.

15. The computer system according to any one of claims 11 to 14, wherein, The action includes generating and sending a report based on the generated execution parameters.

16. The computer system according to any one of claims 11 to 15, wherein, The action includes: automatically adjusting the allocation of resources in the computing system based on the generated execution parameters.

17. The computer system according to any one of claims 11 to 16, wherein, Storing the workload type attribute includes storing the workload type attribute in a dynamic address translation table.

18. The computer system according to any one of claims 11 to 17, wherein, The second hardware instruction controls the second firmware process to obtain and store the sample from the firmware process at a second predetermined interval.

19. The computer system according to any one of claims 11 to 18, wherein, The execution parameters for each software library include an indication of the amount of time a processor from one or more processors of the computing system accesses the software library.

20. A computer-implemented method, comprising: Requesting the execution of instructions to perform an action defined by the instructions, wherein executing the instructions includes: Obtain one or more software objects, each software object including a workload type attribute and a software library including a set of instructions; The instruction set of each software object is loaded into the memory of the computing system, and the workload type attribute of each software object is stored as metadata of the software library of the software object; During the operation of the computing system, a first hardware instruction is deployed to trigger a firmware process to sample instructions from the instruction set of the one or more software objects executed by one or more processors of the computing system during each of the pre-configured time intervals. Deploy a second hardware instruction to obtain a sample from the firmware process and store it in the memory; Based on the analysis of the stored samples, execution parameters associated with each sample are generated; The execution parameters and metadata are used to determine access to the software library in the computing system via a workload type attribute; and Based on the determination of the access, actions related to at least one software object in the computing system are automatically implemented.

Images