Patent Publication Number: US-8527960-B2

Title: Combining method parameter traces with other traces

Description:
BACKGROUND 
     Software applications running in a distributed application server environment may have a plurality of concurrent users accessing the servers and applications. This can result in performance and scalability problems with the servers and applications running on the servers. Performance monitoring, profiling and debugging tools can monitor software applications running on the servers to determine resource consumption information. 
     Software profiling is a technique for measuring where software application programs consume resources (e.g., central processing unit (CPU) computation times, memory accesses). A profiling tool or profiler can analyze the resource consumption of an application running on a server and provide profiling data based thereon. For example, a Java profiler can support a broad set of Java virtual machines (JVMs). The Java profiler can provide comprehensive profiling of a Java application running on the JVM. 
     SUMMARY 
     Implementations of the present disclosure provide computer-implemented methods for combining profiling traces. In some implementations, a method includes executing an application, generating a method parameter trace, the method parameter trace providing one or more parameter values corresponding to one or more methods called during execution of the application, generating an event trace, the event trace identifying one or more events occurring during execution of the application, and combining the method parameter trace and the event trace to provide a profile of events occurring during each of the one or more methods based on the one or more parameter values. 
     In some implementations, the event trace comprises an allocation trace, the one or more events including one or more allocations occurring during execution of the application. In such implementations, combining the method parameter trace and the event trace can include ordering the method parameter trace relative to the allocation trace, and combining the method parameter trace and the allocation trace to determine allocations occurring during each of the one or more methods based on the one or more parameter values. 
     In some implementations, the allocation trace provides information about one or more threads in which each of the one or more allocations occurred. 
     In some implementations, the method further includes generating an allocation record in the allocation trace, the allocation record corresponding to an allocation occurring in a thread, and generating a method entry record in the method parameter trace, the method entry record corresponding to a method entered during the thread, wherein the allocation record is generated before the method entry record is generated when the allocation occurs prior to the method is entered in the thread, and the allocation record is generated after the method entry record when the allocation occurs after the method is entered in the thread. 
     In some implementations, the method further includes generating a method exit record in the method parameter trace, the method exit record corresponding to a method exited during the thread, wherein the allocation record is generated before the method exit record is generated when the allocation occurs during the method, and the allocation record is generated after the method exit record when the allocation occurs after the method is exited. 
     In some implementations, the event trace includes a time-based sampling trace comprising a plurality of stack traces sampled at a fixed interval during execution of the application. In such implementations, combining the method parameter trace and the event trace can include identifying a subset of stack trace samples, each stack trace sample of the subset of stack trace samples having been sampled during execution of a subject method of the one or more methods, and corresponding to a specific parameter value, and correlating the subset of stack trace samples to the subject method. 
     In some implementations, the method further includes marking a thread during which a method including a to be traced method parameter is called to provide a marked thread, and deleting stack trace samples that correspond to the marked thread. 
     The present disclosure also provides a computer-readable storage medium coupled to one or more processors and having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations in accordance with implementations of the methods provided herein. 
     The present disclosure further provides a system for implementing the methods provided herein. The system includes at least a server including one or more processors, and a computer-readable storage medium coupled to the one or more processors having instructions stored thereon which, when executed by the one or more processors, cause the one or more processors to perform operations in accordance with implementations of the methods provided herein. 
     It is appreciated that methods in accordance with the present disclosure can include any combination of the aspects and features described herein. That is to say that methods in accordance with the present disclosure are not limited to the combinations of aspects and features specifically described herein, but also include any combination of the aspects and features provided. 
     The details of one or more implementations of the present disclosure are set forth in the accompanying drawings and the description below. Other features and advantages of the present disclosure will be apparent from the description and drawings, and from the claims. 
    
    
     
       DESCRIPTION OF DRAWINGS 
         FIG. 1  is a diagram of an exemplar network architecture that can be used in accordance with implementations of the present disclosure. 
         FIG. 2  is a block diagram of an exemplar system that includes a profiler. 
         FIG. 3  is a block diagram of an exemplar profiler included in an exemplar back-end virtual machine (VM). 
         FIG. 4  is a flowchart illustrating exemplar steps that can be executed by a front-end profiler on a client for a profiling session. 
         FIG. 5  is a screen-shot illustrating an exemplar profiler perspective for a VM. 
         FIG. 6  is a screen-shot illustrating an exemplar graphical user interface (GUI) used to configure a profiler and start a profiling session. 
         FIG. 7  is a screen-shot illustrating an exemplar method statistic view included in a profiler perspective. 
         FIG. 8  is a screen-shot illustrating an exemplar GUI used to configure a profiler and start an alternative profiling session. 
         FIG. 9  is a screen-shot illustrating an alternative exemplar method statistic view included in a profiler perspective. 
         FIG. 10  is a flowchart illustrating exemplar steps that can be executed to generate a method parameter trace in accordance with implementations of the present disclosure. 
         FIG. 11  is a flowchart illustrating exemplar steps that can be executed to combine profiling traces in accordance with implementations of the present disclosure. 
         FIG. 12  is a schematic illustration of exemplar computer systems that can be used to execute implementations of the present disclosure. 
     
    
    
     Like reference symbols in the various drawings indicate like elements. 
     DETAILED DESCRIPTION 
     Implementations of the present disclosure are generally directed to generating a plurality of traces based on profiling an executing application, and combining the traces to provide a combined trace. Each of the plurality of traces is generated based on profiling data that is collected during execution of the application. The plurality of traces can include, but are not limited to, a method parameter trace and event traces. The event traces can include, but are not limited to, allocation traces, time-based sampling traces and/or input/output traces. In some implementations, the combined trace can include a combination of a method parameter trace and an event trace. The combined trace can provide additional insight into the execution of the application. 
     Referring now to  FIG. 1 , a schematic illustration of an exemplar system  100  in accordance with implementations of the present disclosure can include a plurality of clients  108 ,  110 , and a computer system  114 . The computer system  114  can include a server  102  and a database  104 . In some implementations, the system  100  may represent a client/server system supporting multiple computer systems (e.g., computer system  114 ) including one or more clients (e.g., clients  108 ,  110 ) and/or one or more servers (e.g., server  102 ) that are connectively coupled for communication with one another over a network  106 . In some implementations, the clients (e.g., clients  108 ,  110 ) may be directly connected to the one or more servers (e.g., server  102 ) (without connecting by way of network  106 ). 
     The clients  108 ,  110  can represent various forms of processing devices including, but not limited to, a desktop computer, a laptop computer, a handheld computer, a personal digital assistant (PDA), a cellular telephone, a network appliance, a camera, a smart phone, an enhanced general packet radio service (EGPRS) mobile phone, a media player, a navigation device, an email device, a game console, or a combination of any two or more of these data processing devices or other data processing devices. Each client  108 ,  110  may access application software on the server  102 . 
     The server  102  can represent various forms of servers including, but not limited to a web server, an application server, a proxy server, a network server, or a server farm. For example, the server  102  can be an application server that executes software accessed by clients  108 ,  110 . In operation, multiple clients (e.g., clients  108 ,  110 ) can communicate with the server  102  by way of network  106 . In some implementations, a user can invoke applications available on the server  102  in a web browser running on a client (e.g., clients  108 ,  110 ). Each application can individually access data from one or more repository resources (e.g., database  104 ). For example, the server  102  can access database  104 . 
     In some implementations, the client devices  108 ,  110  may communicate wirelessly through a communication interface (not shown), which may include digital signal processing circuitry where necessary. The communication interface may provide for communications under various modes or protocols, such as GSM voice calls, SMS, EMS, or MMS messaging, CDMA, TDMA, PDC, WCDMA, CDMA2000, or GPRS, among others. For example, the communication may occur through a radio-frequency transceiver (not shown). In addition, short-range communication may occur, such as using a Bluetooth, WiFi, or other such transceiver. 
     In some implementations, the system  100  can be a distributed client/server system that spans one or more networks such as network  106 . The network  106  can be a large computer network, such as a local area network (LAN), wide area network (WAN), the Internet, a cellular network, or a combination thereof connecting any number of mobile clients, fixed clients, and servers. In some implementations, each client (e.g., clients  108 ,  110 ) can communicate with the server  102  via a virtual private network (VPN), Secure Shell (SSH) tunnel, or other secure network connection. In some implementations, the network  106  can include the Internet, a wireless service network and may include the Public Switched Telephone Network (PSTN). In other implementations, the network  106  may include a corporate network (e.g., an intranet) and one or more wireless access points. 
     Each client (e.g., clients  108 ,  110 ) can establish its own session with the server  102 . Each session can be semi-permanent as it can be established at one point in time and torn down at another. Each session can involve two-way information exchange between the computer system  114  and each individual client  108 ,  110 . For example, a Hypertext Transfer Protocol (HTTP) session enables the association of information with individual users. A session can be stateful where at least one of the communicating parts (e.g., the server  102  or the client (e.g., clients  108 ,  110 )) can save information about the session history in order to be able to communicate. Alternatively, stateless communication includes independent requests with associated responses. 
     Multiple clients (e.g., clients  108 ,  110 ) can communicate via network  106  with the server  102 . In order to run an application each client (e.g., clients  108 ,  110 ) can establish a corresponding session with the application server  102 . In some implementations, a user can initiate a profiling session for an application running on the server  102  using the client  108 . The client  108  can establish the profiling session with the server  102 . The profiling session can profile an application running on a Java virtual machine (JVM) on the server  102 . For example, a profiler, included on the server  102 , can record and store profiling data for a profiling session in the database  104  for analysis by the user running the profiling session from the client  108 . In some implementations, the profiling data can be stored in a file system on the server  102 . The profiler can also send the profiling data to the client  108  for analysis by the user. The client  108  can display the profiling data recorded for the application running on the JVM in a graphical user interface (GUI) displayed on display device  108   a  on the client  108 . 
     As used herein, the term profiling data generally refers to map data and event data. Map data can include a mapping between numeric identifiers and VM structure entities such as stack traces, thread names, classes, methods, and class loaders, for example. Event data directly relates to profiled actions occurring in a VM. Exemplar actions can include the start of threads, object allocations (e.g., for the allocation trace), method enter events, method exit events, and the actual method parameters (e.g., for the method parameter trace), sampled thread stack traces (e.g., for the performance trace), and/or garbage collection events. The map data can be referenced in the event data. Consequently, instead of writing explicit class specifications, method specifications, and complete stack traces within the event data, only the corresponding numeric identifier need be written. In this manner, the amount of event information (from a memory perspective) can be drastically reduced. 
       FIG. 2  is a block diagram of an exemplar system  200  that includes a profiler. The system  200  is implemented as a client/server system, an example of which can include system  100  of  FIG. 1 . The exemplar system  200  can be implemented using client  108 , network  106  and computer system  114  that includes server  102  and database  104 . 
     For example, the profiler can analyze the resource consumption of an application running on a JVM. In some implementations, the application can be a standalone Java application. In some implementations, the application can be a complex enterprise application that can utilize a plurality of resources. For example, the profiler can be the JVM Profiler provided by SAP AG. 
     The profiler can include two components: a profiler front-end component (front-end profiler  212   a ) and a profiler back-end component (back-end profiler  212   b ). The back-end profiler  212   b  can be integrated into a back-end virtual machine (VM)  218 . In some implementations, a native application can be provided as a front-end, the native application understanding the profiling protocol of the back-end. In some implementations, the front-end profiler  212   a  can be integrated into a front-end VM  220 . For example, the back-end VM and the front-end VM can each be a JVM provided by SAP AG. The JVM can run one or more applications integrated with the back-end profiler  212   b  in the back-end VM  218  and provides for connection to the front-end profiler  212   a . The back-end profiler  212   b  can provide profiling data for one or more applications running on the back-end VM  218 . The front-end profiler  212   a  can provide a visual representation of the profiling data provided by the back-end profiler  212   b  (e.g., client  108  can include front-end profiler  212   a  and display device  108   a  can display the profiling data to a user in a GUI). 
     For example, a back-end profiler for a JVM can expose profiling data from a Java application executing on a back-end VM. The back-end profiler can use a Java Virtual Machine Tool Interface (JVMTI) to collect profiling data from the JVM. In some implementations, the JVM can provide an interface to load the back-end profiler (e.g., as an agent) into the JVM process. In some scenarios, a proprietary implementation can directly integrate the back-end profiler into the JVM. For example, the SAP® JVM can include a proprietary back-end profiler directly integrated into the back-end VM. 
     In some implementations, during a profiling session, a user can directly connect to the VM that includes the profiler (e.g., back-end VM  218  that includes back-end profiler  212   b ). The user can interactively request profiling data be sent from the back-end profiler  212   b  to the front-end profiler  212   a . Profilers  212   a ,  212   b  can communicate with each other using client application programming interface (API)  222  and server API  224 , respectively. For example, computer system  114  can establish a socket connection between the back-end profiler  212   b  and front-end profiler  212   a . The profilers  212   a ,  212   b  can be located on physically different machines (e.g., client  108  and server  102 , respectively). The profiling data can be transferred from the back-end profiler  212   b  to the front-end profiler  212   a  (e.g., by way of a socket connection or the transfer of one or more files). The front-end profiler  212   a  can receive the profiling data and prepare it for analysis and display to a user. For example, the front-end profiler  212   a  can display the profiling data in a GUI on display device  108   a . In some implementations, the profiling data can be transferred using a file transfer. 
     In some implementations, the computer system  114  may directly connect to client  108  without the use of network  106 . In some implementations, the front-end VM  220  and back-end VM  218  including profiler  212   a  and profiler  212   b , respectively, may run on the same machine where client  108 , server  102  and database  104  are included on the same physical machine. 
     The front-end profiler  212   a  can be a stand alone application that can communicate with the back-end profiler  212   b  included in the back-end VM  218  without the need for a front-end VM. More specifically, a front-end profiler may be a stand-alone program or application that is compatible with a back-end profiler. In some implementations, the front-end VM  220  can run the front-end profiler stand-alone application. The front-end profiler stand-alone application can analyze additional stand-alone applications running on the front-end VM  220 . The front-end profiler stand-alone application can also analyze applications running on the back-end VM  218 . 
     In some implementations, the profilers  212   a ,  212   b  can be integral parts of VMs  220 ,  218 , respectively. This can allow for “on-demand” examination of applications running on the back-end VM  218 . Because the VMs  220 ,  218  include profilers  212   a ,  212   b , respectively, profiling can occur during runtime without the need to restart the VMs  220 ,  218 . Including a profiler in a VM reduces the memory usage typically required, thereby minimizing the memory overhead of the computer system (e.g., computer system  114 ). 
     The server API  224  can start and stop the VM included in the back-end VM  218  that includes the application for profiling. The back-end profiler  212   b  can record the profiling data for the application running on the back-end VM  218 . In some implementations, the back-end profiler  212   b  can store the profiling data as one or more profiling files in the database  104 . In some implementations, the back-end profiler  212   b  can send the profiling data to the front-end profiler  212   a  for further processing. For example, an SAP® JVM&#39;s debug connection can connect the client  108  to the server  102  to communicate profiling data from the back-end profiler  212   b  to the front-end profiler  212   a  using server API  224  and client API  222 , respectively. 
     In some implementations, a developer can use a multi-language software development environment to implement, test and debug a software project. The software development environment can be an open architecture software development platform that includes an integrated development environment (IDE) and a plug-in system. The plug-in system can allow extensions to the IDE with the ability to integrate custom tools. The plug-in system can provide a framework for integrating user-made applications and infrastructure components. For example, a front-end profiler that includes a user interface can be provided as a plug-in to the software development platform. For example, the front-end profiler can be an Eclipse plug-in that can be integrated into an Eclipse platform. The Eclipse platform can provide an IDE for implementing, testing and debugging Java based software development projects. An Eclipse platform that includes a front-end profiler plug-in can additionally provide profiling of Java based software development projects. For example, the front-end profiler  212   a  can be a plug-in to a software development platform running on the front-end VM  220 . 
     A remote profiling session can occur when a host or server (e.g., server  102 ) that includes the application for profiling is remotely located from the client (e.g., client  108 ) running the application that initiates the profiling session. For example, system  200  shows an exemplar remote profiling session where the back-end VM  218  is running an application that includes the back-end profiler  212   b  and the client  108  initiates the profiling session from the front-end VM  220 , which includes front-end profiler  212   a . In a remote profiling session, opening a debugging port to the back-end VM  218  can switch the back-end VM  218  into a profiling mode. Using client  108 , a user can connect to the back-end VM  218  for profiling by connecting to the debugging port. As shown in  FIG. 2 , the back-end profiler  212   b  is an integral part of the back-end VM  218 . As described above, this can allow the back-end VM  218  to be switched into a profiling mode “on demand” during execution of the back-end VM application without the need to restart the back-end VM application. 
     In some implementations, a local profiling session can occur when the application for profiling and the application that initiates the profiling session are located on the same host or server (e.g., the same physical machine). The local profiling session can perform simultaneous source code implementation, testing, debugging and profiling. The host can include a local display device that displays a GUI to a user. The GUI can allow the user the ability to control and configure the profiling session. 
     In some implementations, a user can perform a remote or local profiling session in an online or interactive mode. In an online profiling session, a front-end profiler (e.g., front-end profiler  212   a ) can initiate a profiling session with a back-end profiler (e.g., back-end profiler  212   b ). For example, a user interacting with a GUI displayed on display device  108   a  can start and stop the profiling session as well as interact with the back-end profiler  212   b  during the profiling session. The interaction can include configuring and controlling the profiling session as well as receiving profiling data. The user can request the resultant profiling data from the back-end profiler  212   b  for display on the display device  108   a . The back-end profiler  212   b  can open a debugging port to the back-end VM  218  when the front-end profiler  212   a  initiates an online profiling session with the back-end profiler  212   b . The back-end VM  218  can then wait for a connection. The front-end VM  220  that includes the front-end profiler  212   a  can connect to the debugging port using client API  222  and server API  224  by way of network  106 . 
     In some implementations, in an online profiling session, a user may optionally store the profiling data received from the back-end VM in a local file (e.g., a file located on the client  108  as part of a local file system or repository). The user can access the locally stored profiling data file at any time after the completion of the profiling session. 
     In some implementations, a user can perform a remote or local profiling session in an offline or non-interactive mode. In an offline profiling session, a front-end profiler (e.g., front-end profiler  212   a ) can initiate a profiling session with a back-end profiler (e.g., back-end profiler  212   b ) but there is no interaction between the front-end profiler (e.g., front-end profiler  212   a ) and the back-end profiler (e.g., back-end profiler  212   b ) during the profiling session. For example, the system  200  can provide an interface to couple the front-end VM  220  to the back-end VM  218  using the server API  224  in order to start and stop the profiling session. The back-end VM  218  that includes the back-end profiler  212   b  can store the profiling data in the database  104 , and/or a file. For example, a user interacting with a GUI displayed on the display device  108   a  can start and stop the profiling session. Once complete, the user can request the profiling data stored in the file in the database  104  from the computer system  114  (e.g., the user can interact with a GUI displayed on display device  108   a  to initiate the request). The client  108  can receive the profiling data file and display its contents to the user on display device  108   a.    
     In an offline profiling session, storing profiling data for the profiling session in a profiling file on database  104  can enable a user to retrieve profiling data for a back-end VM (e.g., back-end VM  218 ) at any point after the profiling session is complete. For example, the stored profiling data can be retrieved from the database  104  whether or not the back-end VM (e.g., back-end VM  218 ) is running. 
       FIG. 3  is a block diagram of an exemplar profiler (e.g., back-end profiler  212   b ) included in an exemplar back-end VM (e.g., back-end VM  218 ). The back-end profiler  212   b  can include a plurality of profiler modules, filters and frameworks. The back-end profiler  212   b  can include an allocation trace module  316 , a method parameter trace module  324  and additional trace modules  322 . Each profiler trace module can capture a stream of events that match the criteria of the module (e.g., an allocation trace module can record all memory allocation events in the profiled application). 
     The back-end profiler  212   b  can include a controller framework  302 . In some implementations, the controller framework  302  can start and stop profiling sessions as well as traces during a profiling session. The controller framework  302  can allow a user to select specific back-end profiler options and settings for a profiling session. For example, the front-end profiler  212   a  can display a GUI to the user on display device  108   a  that displays the options and settings for the back-end profiler  212   b . The user, interacting with the GUI, can select specific back-end profiler options and settings for a profiling session. 
     The back-end profiler settings can include functional settings and filter settings. Functional profiler settings can determine the functional area of the application code to profile. For example, a functional profiler setting can specify the types of traces to perform for the profiling session (e.g., an allocation trace, a method parameter trace, and/or a performance trace). Filter profiler settings can define a validity scope (e.g., user, session, thread, VM, etc.) for the functional profiler setting for the profiling session. For example, referring to  FIG. 2 , a user, operating client  108 , can start an allocation trace in the back-end profiler  212   b . The validity scope of the profiling session can be for the user. 
     The profiler options can include specific monitoring, debugging and analysis functions. For example, profiler options can include memory debugging (e.g., memory leak detection), performance analysis (e.g., hotspot identification), synchronization monitoring, and application debugging (e.g., called method detection). By way of non-limiting example, the profiling functions can include one or more sub-functions (e.g., heap dump, time-based sampling, memory-based sampling, allocation trace, method parameter trace, garbage collection trace, etc.). Allocation analysis can identify and isolate memory related problems in an application. Allocation analysis can be used for memory debugging. 
     Performance analysis can monitor an application&#39;s behavior using information gathered as the application executes. Performance analysis can determine which parts of an application can be optimized for speed. In some implementations, performance analysis can indicate where within the application spent its time during execution thereof. Performance analysis can indicate which methods called other methods while the application executes. The profiling data gathered during a performance analysis can indicate which areas of the application are slower than expected. Performance hotspots (or bottlenecks) can be code segments in the application that can contribute significantly to overall application execution time. In some implementations, a performance hotspot can slow down or halt application execution. Identification of performance hot spots enables improvement of the code segment to improve the overall performance of the code at runtime. 
     In some implementations, the controller framework  302  may include a profiler evaluation module  302   a  for analyzing profiling data. The server API  224  can obtain the complete profiling data for a profiling session. The profiler evaluation module  302   a  can analyze the complete profiling data for the profiling session and generate problem oriented, condensed profiling data for the profiling session. The server API  224  can also obtain the condensed profiling data from the back-end VM  218 . A user may use the condensed profiling data to identify one or more problematic areas in a profiled application. For example, a profiling session can perform a performance analysis on an application using a time-based sampling approach. The time-based sampling approach for performance analysis can be referred to as a statistical analysis. In some implementations, a profiling session can perform a performance analysis on an application using one or more actual events in the application (e.g., a method call) as indicators for tracing the execution path of the application. 
     In some implementations, the back-end provides low-level profiling data to the front-end for higher-level evaluation of the profiling data at the front-end. For example, the server  102  can provide the raw profiling data to the client  108 . The client  108  can process the raw profiling data to provide a high-level evaluation thereof. In other implementations, the profiler evaluation module  302   a  can analyze the complete profiling data for a profiling session. The profiler evaluation module  302   a  can generate condensed profiling data directed towards the identified time-consuming methods within the profiled application. The server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the condensed profiling data from the back-end VM  218 . The client  108  can display the condensed profiling data to a user in a GUI on the display device  108   a.    
     In some implementations, a user can use the controller framework  302  to start and stop profiling sessions, and to enable profiler traces for a session. For example, the user can determine one or more profiler traces to enable during a profiling session. In a single profiling session, the user may enable an allocation trace that uses the allocation trace module  316  and a method parameter trace that uses the method parameter trace module  324 . 
     In some implementations, the controller framework  302  can enable the server  102  to specify a thread filter  304 . The thread filter  304  can include names and identifiers associated with a profiling session for a particular thread (e.g., a thread executing on the back-end VM  218 ) and can indicate the existence of one or more profiler traces for the profiling session. For example, the names and identifiers can be a client identifier, a user identifier, a profiling session identifier, a request identifier, an application name and a component name. By way of non-limiting example, the thread filter  304  can filter out specific events in the profiling data (e.g., all allocations from a specified thread). In some implementations, the controller framework  302  can “tag” the names and identifiers to the thread. The server can set the current thread state using the information in the thread filter  304 . 
     Class filters  308  can limit the recording of profiling data for a particular trace to a designated method within a class included in the class filters  308 . For example, when enabling an allocation trace in a profiling session, a user can enable a profiler to record allocation trace data for Java object allocations, which refer to instances of the java.lang.HashMap class. The java.lang.HashMap class can be included in the class filter  308 . 
     A buffer framework  306  can compress or decompress profiling data. The compressed or decompressed profiling data can be communicated (e.g., sent to the client  108 ) or stored (e.g., placed in a profiling file and stored in database  104 ). For example, in an offline profiling session, the buffer framework  306  can compress profiling data for storage as a profiling file in database  104 . When requested by a client (e.g., client  108 ), the buffer framework  306  can decompress the profiling data in the profiling file for communication back to the client (e.g., client  108 ) and subsequent viewing of the profiling data by a user in a GUI on a display device (e.g., display device  108   a ). 
     Communication framework  312  can facilitate the communication of profiling data and information between and within various components (e.g., elements, modules, systems, servers, VMs, etc.) included in the computer system  114 . Additionally, the communication framework  312  can determine and facilitate the storing of profiling data (e.g., profiling data in a profiling file stored in database  104 ). 
     An identification (ID) service  310  can assign a numerical identifier to an alphanumeric name. For example, the ID service  310  can assign a numeric identification value to a class name (e.g., java.lang.HashMap class can be assigned the number “101”) creating a numeric ID tag for the class. A numerical identifier can also be assigned to a method, a class and/or a class loader. For example, because a class, a method and/or class loader are not just specified by their name (e.g., there can be more classes of the same name, if they are loaded by different class loaders), using just a name to ID mapping would not allow to differentiate between different class, method or class loader of the same name. In some implementations, a mapping packet can map and group classes, methods and/or class loaders according to their numerical ID tags (e.g., their assigned numerical values). In some implementations, the ID service  310  can assign numeric IDs to threads. An object identification (ID) service  314  can assign numeric IDs to objects. The use of numeric IDs can result in improved efficiency and speed during a profiling session as objects, threads, methods and classes can be sorted, grouped and compared using the numeric IDs instead of an alphanumeric name. The use of numeric IDs can also result in decreased memory consumption during a profiling session. 
     A method parameter trace module  324  can trace the values of method parameters. For example, a method parameter trace can check if specific parameter values used in a method lead to excessively long execution times for the method. Additionally, a method parameter trace can provide an overview of the parameter values used by the method during the execution of the application in a profiling session. 
     In some implementations, and as noted above, the raw profiling data can be provided to the front-end from the back-end for higher-level processing. For example, the front-end can process the profiling data to group one or more consecutive methods in a stack trace into a component, and categorize the trace data at the stack level. For example, when a profiling session includes a time-based sampled allocation trace, the memory allocation quantity can be attributed to a stack trace. In other implementations, the higher-level processing can occur at the back-end. For example, a component statistic module  326  can group one or more consecutive methods in a stack trace into a component. A component can be a specific application programming interface (API) used by the application. Examples of components can be Java components that can include, but are not limited to, a persistence API, a security API, a portal API and a servlet API. The methods in the stack trace can be grouped into components based on a defined “entry method” for the component. The component statistic module  326  can then categorize the trace data at the stack level. The stack trace including methods can be grouped into components, where one or more consecutive methods can be placed into one component group. Each component group can provide allocation statistics for the API associated with the component. 
     A garbage collection trace module  320  can trace garbage collection (GC) events in an application. For example, a Java runtime environment can use a garbage collector to perform garbage collection to reclaim no longer needed memory allocated to an object. Once the garbage collector determines that the object is no longer accessible (e.g., when there is no longer any references to it stored in any variables, the fields of objects, or the elements of any arrays), the garbage collector can reclaim the allocated memory. For example, when a Java application no longer references a particular object, a heap space occupied by the object can be recycled so that the heap space can be made available for subsequently created objects. 
     As discussed in further detail below, the profiling data into sub-regions or snapshots. A snapshot can be a specific timeframe or interval where profiling data was collected. For example, a user can create a snapshot by selecting a corresponding entry within a context menu of a profiling trace entry in a profile view. As another example, the profiling data can be read at the front-end (e.g., after finishing a dialog step) and the user can input a command to create a snapshot. In response, the front-end can send a command to the back-end to create a snapshot of the profiling data. Consequently, the back-end inserts a snapshot marker into the original profiling data. In the case where the user would like to create a sub-snapshot (e.g., a snapshot within a snapshot), or the user would like to create a snapshot from an arbitrary time period, the front-end can identify the corresponding sections, or sub-regions in the original profiling data, and can read the profiling data for that section. 
     Analysis of profiling data can identify the impact on system performance of individual software modules in an application. For example, profiling data can indicate the percentage of overall runtime for a software module in an application. Optimization of the software modules that contribute a large percentage of the overall runtime can result in marked system improvements with minimal changes. Profiling data can also indicate where within the software module optimization can be performed to improve the module&#39;s overall performance in the system. 
     For example, time-based sampling can provide an overview of methods in an application that consume the most CPU resources. Time-based sampling can provide a stack trace of the currently active thread at regular intervals. Analysis of time-based sampling can identify a method that consumes a large number of CPU or system resources. For example, the consumption of a large number of system resources by the method can be the result of an expensive method call. For example, the consumption of a large number of system resources by the method can also be the result of calling the method often. A method statistic trace, which can be included in a module with trace modules  322 , for example, can determine the number of times a particular method is called. The method statistic trace together with time-based sampling can provide a time method trace that can calculate the average runtime of a specific method (e.g., the “cumulative time” divided by the method count). 
     For example, memory-based sampling can provide an overview of methods in an application that consume the most memory resources. Memory-based sampling can provide a stack trace after memory is allocated on a memory heap. Memory-based sampling can identify the methods that allocate the largest number of bytes on the memory heap. 
     Input/output (I/O) based sampling can provide an overview of I/O operations performed and I/O resources used by methods in an application. For example, operating a network connection at its maximum bandwidth can consume a large percentage of I/O resources. An I/O trace, which can be included in a module with trace modules  322 , for example, can trace the timing of I/O operations in a method. The I/O trace can provide data about I/O operations, as well as data about a file being written and/or the network address/port being used. Analysis of the I/O trace data can provide information about I/O operations that can include, but is not limited to, the amount of data transmitted by an I/O operation, the amount of CPU resources used by an I/O operation, and the number of I/O operations performed by a method. The analysis of the I/O trace data can identify I/O operations that transmit an excessive amount of data. The analysis of the I/O trace data can identify I/O operations that consume an excessive number of CPU resources. The analysis of the I/O trace data can identify if a method performs an excessive number of I/O operations. 
     Synchronization monitoring of a software application can provide information related to multithreading and concurrency. For example, problems associated with multithreading and concurrency can include, but are limited to, deadlocks, race conditions, thread starvation and scalability. In some implementations, a monitor trace, which can be included in a module with trace modules  322 , for example, can identify deadlock and scalability issues in an application by acquiring information about the locks used in a VM. Synchronization monitoring can provide an overview of the most contented locks within an application. In this manner, a user can be made aware of which threads are waiting (e.g., threads that explicitly call wait( ) on a Java object/monitor) and which threads are blocked (e.g., threads that want to enter a monitor section), as well as how long the threads are typically waiting and/or blocked. Further information can be provided with regard to the waiting and/or blocked threads. For example, culprit threads can be identified, a culprit thread being a thread that is holding the desired locks. 
     In some implementations, software profiling can provide additional application debugging functionality. For example, a method count trace, which can be included in a module with trace modules  322 , for example, can provide the number of calls to a particular method. An execution line trace, which can be included in a module with trace modules  322 , for example, can provide information regarding the number of lines of executed and unexecuted application source code. A method call trace, which can be included in a module with trace modules  322 , for example, can provide the methods called by an application. 
     In some implementations, a method trace can be implemented to trace an application debugging process. The method trace, which can be included in a module with trace modules  322 , for example, can trace the application program flow to a designated point in the source code. The method trace can provide information as to how the application program reached the designated point in the source code. 
     Referring to  FIGS. 1 and 2 , the client  108  can provide a GUI to a user for display on display device  108   a  that can allow the user to start, stop and control profiling sessions in the back-end profiler  212   b  using the client API  222  in communication with the server API  224  by way of network  106 . Additionally, the server API  224  can provide the client API  222  by way of network  106  profiling data to display to the user in a GUI on the display device  108   a . The user can access and evaluate the displayed profiling data. In some implementations, a guided mode can identify problem areas indicated by the profiling data. In some implementations, the profiling data can be stored as a profiling file in the database  104  in the computer system  114 . In some implementations, the profiling data can be stored as a file in a file system included on the client  108 . Storing of the profiling data can allow for subsequent retrieval and analysis. 
     The client  108  and the client  110  can connect to the computer system  114  by way of the network  106 . In some implementations, the back-end profiler  212   b  can perform in compliance with both the client  108  and the client  110 , simultaneously, while remaining multiple client compliant. The back-end profiler  212   b  can restrict profiling sessions to particular clients, while the server  102  can assign the current client information to its respective thread. 
       FIG. 4  is a flowchart illustrating exemplar steps  400  that can be executed by a front-end profiler on a client (e.g., front-end profiler  212   a  on client  108  in  FIG. 2 ) for a profiling session. In step  402 , it is determined whether the profiling session will be an online (e.g., interactive mode) profiling session. If the profiling session is to be an online profiling session, interactive profiling is performed in step  404 . The profiling data can be analyzed during the profiling session in optional step  405 . The online profiling session continues until stopped. In step  406 , it is determined whether the online profiling session is to be stopped. Whether the online profiling session is to be stopped can be determined based on a user input at the front-end. If the online profiling session is not to be stopped, the interactive profiling continues in step  404 . If the online profiling session is to be stopped, the profiling data can be analyzed by the front-end profiler in step  407 . 
     If, in step  402 , if it is determined that the profiling session is not an online profiling session, offline (e.g., non-interactive) profiling is performed in step  408 . The offline profiling session continues until stopped. In step  410 , it is determined whether the offline profiling session is to be stopped. Whether the offline profiling session is to be stopped can be determined based on a user input at the front-end. If the offline profiling session is not to be stopped, the offline profiling session continues in step  408 . If the offline profiling session is to be stopped, the front-end profiler requests the profiling data in step  412 . In step  407 , the profiling data can be analyzed by the front-end profiler. In step  414 , which can be provided as an option, the profiling data can be stored locally in the client for future use by the front-end profiler (e.g., front-end profiler  212   a ). 
     In some implementations, a front-end profiler can provide a user with tools for analyzing profiling data (e.g., resource consumption information) gathered by a back-end profiler. The tools can be included in the front-end profiler. The tools can provide a GUI to the user (e.g., referring to  FIGS. 1 and 2 , a GUI can be displayed on display device  108   a ). The GUI can allow the user to select criteria for grouping and managing the profiling data in an efficient and meaningful way in order to simplify the analysis of the profiling data. 
     For example, the IDE of the software development platform (e.g., Eclipse) can be structured into a plurality of perspectives. As used herein, the term perspective refers to a visual container for a set of views and editors for the associated development task that can properly structure and arrange the views, and can be analogous to a page within a book, for example. Examples of perspectives can include, but are not limited to, a perspective for implementing a software application, a debug perspective for debugging functionality, a test perspective for implementing software application testing, and a profiler perspective for profiling functionality. The platform can associate a development task (e.g., source code implementation, debugging, testing, profiling) with a dedicated perspective. The development framework can provide an interface for combining user-made perspectives together with their related content. For example, the development framework can provide a GUI to display to a user on a display device that can combine a profiler perspective with profiling data. 
     The IDE of the software development platform (e.g., Eclipse) can provide the functionality to execute or debug a software application by providing one configuration framework for executing the application and another configuration framework for debugging the application. Both configuration frameworks can describe the selected application (e.g., a main class to start, start-up parameters, etc.). Another configuration framework can be included to profile an application, and provides a user interface framework that can start a profiling session. 
     In some implementations, multiple configuration framework types can be provided. Example configuration framework types can include an application configuration framework, a profiling file analysis configuration framework, and a remote profiling configuration framework. The application configuration framework can specify an application (e.g., a Java application) for profiling together with profiling parameters. For example, the application configuration framework can enable a user to execute an application with a profiling session already started. A user can profile the application directly from the start of execution of the application. 
     Referring now to  FIG. 5 , a screen-shot  500  illustrates an exemplar profiler perspective for a VM. As described above, a development framework can provide a GUI to display to a user on a display device, as illustrated by the screen-shot of  FIG. 5 , for example, that can combine a profiler perspective with profiling data. The screen-shot of  FIG. 5  illustrates a portion of an exemplar profiling lifecycle  502 , for which a snapshot is provided between a starting point  504  (e.g., at 1 minute, 40 seconds) and an ending point  506  (e.g., at 5 minutes). The snapshot functionality is described in further detail below. The profiler perspective can include a profiler view  508  for a profiling session (e.g., the Example profiling session). 
     Referring again to  FIG. 2 , the profiling file analysis configuration framework can provide a user with a GUI on a display device (e.g., display device  108   a ) in order for the user to specify a profiling file for display. As previously described, a profiling file can include collected profiling data. The profiling file can be in a database on a server (e.g., database  104 ) or in a file system on a client (e.g., client  108 ). For example, the IDE can save profiling data from an interactive profiling session in a profiling file on the client that includes the IDE (e.g., client  108 ). For example, profiling data from a non-interactive profiling session can be saved in a profiling file included in a database (e.g., database  104 ) included on a server (e.g., server  102 ). For example, the front-end profiler  212   a  can provide the back-end profiler  212   b  specific profiling parameters that enable traces to begin directly on the start-up of the application for profiling in the back-end VM  218 . The profiling data can be stored in a profiling file on database  104 . A user on a client (e.g., client  108 ) can view the profiling file on a display device (e.g., display device  108   a ) by generating a profiling file analysis configuration framework. 
     With further reference to  FIG. 2 , the remote profiling configuration framework can allow a user to specify a connection (e.g., a host name and port number) to the VM (e.g., back-end VM  218 ) for profiling. For example, as previously described, a back-end profiler (e.g., back-end profiler  212   b ) can open a debugging port to a back-end VM (e.g., back-end VM  218 ) when a front-end profiler (e.g., front-end profiler  212   a ) initiates an online profiling session with the back-end profiler (e.g., back-end profiler  212   b ). 
     Referring now to  FIG. 6 , a screen-shot  600  illustrates an exemplar GUI that can be used to configure a profiler and start a profiling session. For example, and with co-reference to  FIG. 2 , a user can select to profile an application (e.g., Java application: Example  602 ) running on the back-end VM  218  using back-end profiler  212   b . The user can select to analyze the performance behavior of the application (e.g., the user can select Performance Hotspot Analysis  604 ). The performance behavior of the application can involve method calls and execution paths, which can consume the majority of the CPU resources. The profiling data can include the method calls and execution paths used by the application. In order to profile the application, a user can create an application configuration framework in an IDE running on a client (e.g., client  108 ). As described, the application configuration framework can allow the user to execute the application with a profiling session already started. The user can profile the application directly from the start of execution of the application. Within the application configuration framework, a user can specify a class containing the main method of the application and enable a performance hotspot analysis profiling trace. The performance hotspot analysis profiling trace can provide the user with information that can indicate performance hotspots within the application. 
     Analysis options  606  can include information such as a user name or identifier option  606   a , a session name or identifier option  606   b , a request name or identifier option  606   c  and an application name or identifier option  606   d . For example, the analysis options  606  can indicate the user, session, requester or application that can start a profiling session. A server (e.g., server  102 ) can tag one or more threads running on a VM (e.g., back-end VM  218 ) with the analysis options  606 . When a profiling session is started (e.g., a user on client  108  interfaces with a GUI on display device  108   a  to enable the front-end profiler  212   a  to initiate a profiling session), a thread filer (e.g., thread filter  304  in  FIG. 3 ) included in the a back-end profiler (e.g., back-end profiler  212   b ) can process the analysis options  606 . The thread filter (e.g., thread filter  304 ) and the back-end profiler (e.g., back-end profiler  212   b ) can determine, for example, if the user name or identifier option  606   a  matches the user of the client  108 . 
     In some implementations, the analysis options  606  can be alphanumeric names associated with each option (e.g., options  606   a - d ). In some implementations, an abbreviated numeric identifier can be used for each option (e.g., options  606   a - d ) where each abbreviated numeric entry corresponds to a longer alphanumeric entry for the options  606   a - d.    
     Referring again to  FIG. 2 , once a server (e.g., server  102 ) begins the execution of an application in a VM (e.g., back-end VM  218 ), a back-end profiler (e.g., back-end profiler  212   b ) can monitor at regular intervals what the application is executing. For example, back-end profiler  212   b  can record profiling data that includes a complete stack trace for all threads running in the application on the back-end VM  218 . The server API  224  by way of network  106  and client API  222  can transfer the profiling data to the front-end profiler  212   a . For example, in order to obtain an accurate view of the performance behavior of the application, the back-end profiler  212   b  can perform and record a stack trace computation every ten milliseconds. This can result in the back-end profiler  212   b  recording and transferring a large amount of profiling data to the front-end profiler  212   a  especially when the application is large and executes for a prolonged period. 
     In some implementations, the front-end profiler  212   a  can maintain profiling data it receives in main memory on the client  108 . In some implementations, if the front-end profiler  212   a  receives a large amount of profiling data compared to the available amount of main memory on the client  108 , the front-end profiler  212   a  may store the profiling data in a file on the file system of the client  108 . In this case, some statistical or aggregated profiling data values (e.g., the profiling session duration time) may be presented to the user on a real-time basis in a dedicated profile view (e.g., profile view  508  in  FIG. 5 ) included in the IDE of the software development environment on the client  108 . The remaining profiling data can be stored in a file on the file system of the client  108  for later viewing and analysis by the user in a GUI on display device  108   a.    
     Referring now to  FIG. 7 , a screen-shot  700  illustrates an exemplar method statistic view  702  included in a profiler perspective. The method statistic view  702  can be used to identify performance hotspots, and provides an overview of the methods that consume the most CPU resources of an application. As described above, a performance hotspot analysis can dump a stack trace of the currently active threads at regular intervals (e.g., every 10 milliseconds). For each method, the front-end profiler (e.g., front-end profiler  212   a ) can calculate the percentage of how often a method appears on the top of the stack trace. This percentage can be the self-time for the method. The front-end profiler (e.g., front-end profiler  212   a ) can use the method self-time to estimate the amount of time the application spends processing the method. Additionally, for each method, the front-end profiler (e.g., front-end profiler  212   a ) can calculate the percentage of how often a method appears at any location in the stack trace. This percentage can be the total time for the method and can denote the amount of time the application spends processing the method, which includes any calls the method made to other methods. 
     In the example of  FIG. 7 , a user can select a called methods (hierarchical) entry point. A profiler perspective on a front-end profiler (e.g., front-end profiler  212   a ) can open the method statistic view  702 . The method statistic view  702  can include a hierarchical list of methods called during the snapshot of the performance analysis (e.g., a method statistic of a performance hotspot statistic). The method statistic view  702  can list the called methods based on the total run time of each of the called methods during the snapshot of the performance analysis. 
     For example, a profiler can create a statistic view for each entry point. The profiler can determine the statistics for display in the statistic view by parsing original profiling data included in a profiling file. For example, a profiling file can be stored on a file system of a client (e.g., client  108 ) running a front-end profiler (e.g., front-end profiler  212   a ). A front-end profiler (e.g., front-end profiler  212   a ) can parse original profiling data in the profiling file, determine requested data for display in a statistic view based on the entry point for the snapshot, and provide the requested data for the statistic view. The requested data for the statistic view can be stored in main memory for use by the front-end profiler (e.g., front-end profiler  212   a ) and can be stored in a file on the file system. When the front-end profiler (e.g., front-end profiler  212   a ) closes the statistic view, the front-end profiler (e.g., front-end profiler  212   a ) can delete the profiling data for the statistic view from the main memory of the client, leaving the stored data for the statistic view in a file on the file system. If the front-end profiler (e.g., front-end profiler  212   a ) reopens the statistic view, the front-end profiler (e.g., front-end profiler  212   a ) can read the data for the statistic view from the stored file without the need to parse the original profiling file. 
     For example, original profiling data received by a front-end profiler (e.g., front-end profiler  212   a ) from a back-end profiler (e.g., back-end profiler  212   b ) can include stack trace information for all threads running on a VM (e.g., back-end VM  218 ). The back-end profiler (e.g., back-end profiler  212   b ) can sample and record the stack thread information for a stack trace at pre-defined intervals (e.g., every 10 msecs). More specifically, a stack trace includes several stack frames, each stack frame including the individual methods and corresponding line numbers. When the states of the threads are sampled, a complete stack trace is determined for each individual thread. This occurs at the pre-defined interval (e.g., every 10 msecs) depending on the underlying operating system. In order to determine the runtimes of the individual methods, the pre-defined interval is accounted to each stack frame (e.g., the actual method and corresponding line number) of a stack trace. More specifically, the runtime of a method is separated into a self time and a total time. The self time indicates the time spent directly within a specific method, whereas the total time indicates the time spent within a specific method plus the time spent in called methods. Accordingly, if a sampled stack trace is determined, the pre-defined interval (e.g., every 10 msecs) is accounted to the total runtimes of each individual stack frame. The method at the top of the stack trace includes the pre-defined interval added to its self time. 
     The above-described process can be time consuming dependent on the amount of profiling data. The amount of profiling data can depend on the size of the application running on the VM (e.g., back-end VM  218 ) along with the amount of time the application is running while being profiled. However, the amount of memory required for storing the resultant method statistic can be significantly smaller than the amount of memory required for storing the original profiling data. 
     The original profiling data provides the complete stack trace for each individual thread. The method statistic can include aggregated data from the original profiling data. The method statistic can provide an overview of the total runtime for each method. Referring again to  FIG. 7 , an examplar method statistic view  702  in a profiler perspective is shown. For example, a front-end profiler (e.g., front-end profiler  212   a ) can display to a user the method statistic view  702  on a display device (e.g., display device  108   a ) on a client (e.g., client  108 ). The front-end profiler (e.g., front-end profiler  212   a ) can store the aggregated data of the method statistic in main memory to a file located on the client (e.g., client  108 ). When the user closes the method statistic view  702 , the aggregated data of the method statistic can be removed from main memory on the client (e.g., client  108 ) but can still remain on the client (e.g., client  108 ) in a file on the file system of the client (e.g., client  108 ). When the user selects the method statistic entry point, the front-end profiler (e.g., front-end profiler  212   a ) can display the method statistic view  702  on the display device (e.g., display device  108   a ) to the user. The front-end profiler (e.g., front-end profiler  212   a ) can obtain the aggregated data of the method statistic from the stored file on the file system of the client (e.g., client  108 ) without the need to recreate the method statistic from the data included in the original profiling file. This can save the front-end profiler (e.g., front-end profiler  212   a ) a significant amount of processing time. 
     In some implementations, the front-end profiler (e.g., front-end profiler  212   a ) can store the aggregated data for the method statistic along with the method statistic view. Storing the method statistic view can include storing the last state of the view prior to the user closing the view (e.g., storing the sort directions, the selection state, the expanded state of trees, etc.). When the user selects the method statistic entry point, the front-end profiler (e.g., front-end profiler  212   a ) can display the method statistic view (e.g., method statistic view  702 ) on the display device (e.g., display device  108   a ) to the user in the state that the view was in when the user previously closed the view. 
     In some implementations, a front-end profiler (e.g., front-end profiler  212   a ) can store profiling data for a profiling session in a file system on a client (e.g., client  108 ). When a user closes the IDE of the software development platform (e.g., Eclipse), the profiling data can remain in the file on the file system. Additionally, the state of the IDE when closed can also be saved. When the user reopens the IDE, the complete state of the GUI for the IDE can be restored (e.g., profiling sessions, opened views, view states, available statistics, etc.) along with the profiling data for the profiling session. 
     Referring now to  FIG. 8 , a screen-shot  800  illustrates an exemplar graphical user interface (GUI) used to configure a profiler and start an alternative profiling session. For example, and with co-reference to  FIG. 2 , a user can select to profile an application (e.g., Java application: Example  802 ) running on the back-end VM  218  using back-end profiler  212   b . The user can select to analyze application execution to identify memory related problems (e.g., the user can select Allocation Analysis  804 ). In order to profile the application, the user can create an application configuration framework in an IDE running on a client (e.g. client  108 ). As described, the application configuration framework can allow the user to execute the application with a profiling session already started. The user can profile the application directly from the start of execution of the application. Within the application configuration framework, a user can specify a class containing the main method of the application and enable an allocation analysis profiling trace. The allocation analysis profiling trace can provide the user with information related to the memory consumption by the application. 
     Referring now to  FIG. 9 , a screen-shot  900  illustrates an alternative exemplar method statistic view  902  included in a profiler perspective is shown. Once the profiling session is complete, a user can select a view for a method statistic. A profiler perspective on a front-end profiler (e.g., front-end profiler  212   a ) can open the method statistic view  902 . The method statistic view  902  can display the methods in an application that performed memory allocations during the profiling session. 
     In some implementations, a profiler perspective can present a plurality of views to a user. Each view can include specific statistics about a profiling session. A front-end profiler (e.g., front-end profiler  212   a ) can uniquely identify and describe the statistics in the view. The unique identification of the statistics can allow a user to navigate from one statistic to other statistics. 
     For example, using an arbitrary number of navigation steps, a user can start at a first statistic in a first view. The front-end profiler (e.g., front-end profiler  212   a ) can generate the first statistic from a first set of first profiling events identified in the profiling data. The user can select an arbitrary number of displayed entries for the first statistic from the first view. The user can navigate to a second statistic in a second view. The front-end profiler (e.g., front-end profiler  212   a ) can generate the second statistic for the second view from a second set of second profiling events. The second set of second profiling events can include the first profiling events minus the constraints introduced by the selection of the items from the first statistic in the first view. A user can continue to select an arbitrary number of displayed entries from one view and navigate to a next view. The front-end profiler (e.g., front-end profiler  212   a ) can efficiently describe the statistic for each view in an abstract and unique manner to reflect the path to the statistic. 
     In some implementations, a resource name can uniquely describe a statistic for a profiler in an abstract manner. The resource name can include one or more resource name elements. A resource name element can describe a constraint or filter used to determine the set of profiling events. 
     For example, a profiling session can produce profiling data that refers to memory allocation events. The front-end profiler (e.g., front-end profiler  212   a ) can generate a method statistic from a first set of first profiling events identified in the profiling data. A view for the method statistic can display to a user all methods in which memory allocations occurred.  FIG. 9  shows an exemplar method statistic view  902 . The front-end profiler (e.g., front-end profiler  212   a ) can apply a type of filter to the profiling data that filters out all methods in which memory allocations occurred. The resource name for the method statistic can include a single resource name element (e.g., “Method Statistic”). The user can select a method from the method statistic view (e.g., java.util.AbstractList.Iterator( )) and navigate to a view for an allocated object statistic for the selected method. The allocated object statistic view can show the type (e.g., class) of allocated objects created by the selected method as well as allocated objects created by one or more methods called from the selected method. The resource name for the allocated object statistic can include the resource name elements of the parent statistic plus additional resource name elements. For example, the resource name for the allocated object statistic can include the resource name element for the method statistic (e.g., “Method Statistic”), a filter resource name element for the selected methods (e.g., “java.util.AbstractList.Iterator( )”), and a resource name element for the allocated object statistic (e.g., “Allocated Object Statistic”). 
     The user can select one or more allocated object types from the allocated object statistic view (e.g., allocated objects for string functions) and navigate to a view for a thread statistic. The thread statistic view can show the threads where the objects selected from the allocated object statistic are allocated. For example, the resource name for the thread statistic can begin with the resource name elements of the parent statistic (the view that the user selections originated from (e.g., the allocated object statistic)). Additionally, a filter resource name element for the allocated object statistic (e.g., “String Functions”) and a resource name element for the thread statistic (e.g., “Thread Statistic”)) can be appended to the resource name elements of the parent statistic. 
     As shown in the above examples, a naming scheme for a resource name can directly reflect the navigation steps of the user (e.g., resource name: Method Statistic_java.util.AbstractList.Iterator( )_Allocated Object Statistic_String Functions_Thread Statistic). The resource name can uniquely describe a statistic. For example, a user can compare profiling statistics by comparing the resource elements in their resource names. In this manner, a user can identify identical profiling statistics. 
     For example, a front-end profiler (e.g., front-end profiler  212   a ) can create a third profiling statistic from a selection within a second profiling statistic where the second profiling statistic was created by a selection from within a first profiling statistic. In some implementations, the front-end profiler (e.g., front-end profiler  212   a ) can create the third profiling statistic by starting with the original profiling data and creating the first profiling statistic by applying a first filter for the first profiling statistic to the original profiling data. Applying the first filter for the first profiling statistic to the original profiling data can filter out profiling events in the original profiling data that do not meet the requirement for selection for the first profiling statistic. This results in a first set of profiling events. The front-end profiler (e.g., front-end profiler  212   a ) can create a second profiling statistic from the first profiling statistic by applying a second filter for the second profiling statistic to the first set of profiling events resulting in a second set of profiling events. The front-end profiler (e.g., front-end profiler  212   a ) can create the third profiling statistic from the second profiling statistic by applying a third filter for the third profiling statistic to the second set of profiling events resulting in a third set of profiling events. If a user chooses a navigation depth through the profiling data of n times, the profiling data and resultant profiling events are parsed n times. This can consume a large amount of system resources. 
     In some implementations, a software component for creating profiling statistics can be included in a front-end profiler (e.g., front-end profiler  212   a ). The profiling statistic creator software component can parse a resource name to compute the filter constraints used to create a view for a statistic described by the resource name. For example, a resource name can include one or more resource name elements for filtering threads. The profiling statistic creator software component can parse the resource name, extract all filter elements from the resource name and create a single thread filter. Additionally, the profiling statistic creator software component can parse the resource name and group resource name elements of the same type to create a single filter. In this case, if a user has chosen a navigation depth through the profiling data of n times, the profiling statistic creator software component can parse the profiling events once, check each profiling event and determine if all of the filter types apply to the profiling event. Additionally, the profiling statistic creator software component can group resource name elements of the same type to create a single filter for each type in order to create the profiling statistic. 
     In some implementations, a JVM profiler can profile a Java application running on a local or remote host. Within a remote profiling session, a user can directly connect to the JVM. The user can interactively configure the profiling session and request profiling data. For example, the user can request a class statistic and directly see a view of the class statistic on a display device on the local host that includes a front-end profiler (which can be a plug-in to a software development environment (e.g., Eclipse)). As previously described, the profiling events for a statistic can be used as an input for additional requests for statistics. 
     Referring again to  FIG. 9 , and as discussed above, a profiler can be implemented to track the resource consumption and collect corresponding profiling data for an executing application. The profiling data can be collected at the method level (e.g., data regarding memory usage and CPU processing time corresponding to each method called in an executing application can be collected). In some implementations, a profiler can trace the values of method parameters. For example, a method comprises a number of byte code instructions which the application executes. A method can include one or more parameters. An application can call a method to perform a specified task and provides parameter values for the called method. For example, when a Java VM calls a method (e.g., java.util.Arrays.toString(Object[ ] array)), the caller (e.g., a method) provides the values of the method parameters to the called method (e.g., the caller provides the object array as a first parameter for the static method). A method can be called directly or indirectly. More specifically, a directly called method is a method that is called by the application, and an indirectly called method is called within an executing method (i.e., a method that is nested within another method). 
     Referring to  FIG. 3 , a user can specify a method and corresponding parameters for tracing by the MPT module  324  included in the back-end profiler  212   b . More specifically, the back-end profiler  212   b  can trace the values of method parameters used in the identified method. A MPT can provide an overview of the values of method parameters used by a method during execution of an application. By way of one non-limiting example, the user can use the results of a MPT to check if specific values of a method parameter used by the method lead to particularly long application execution times. 
     As another non-limiting example, a MPT enables a user to specify a particular method (e.g., java.util.Arrays.toString(Object[ ] array)) for tracing along with the specific method parameter for tracing (e.g., the object array: Object[ ] array). The parameter of a method can be determined by its position within a corresponding method signature. More specifically, a method is commonly identified by a unique method signature that includes the method name, and the number, types and order of its parameters. For example, position “1” can be used to indicate the object array parameter (e.g., the object array: Object[ ] array) for the method (e.g., java.util.Arrays.toString(Object[ ] array)). A VM (e.g., a Java VM) can report the value of the indicated trace parameter to the MPT each time the application calls the specific method. 
     Referring to  FIG. 3 , the MPT module  324  can include a set of MPT specifications. The MPT specifications can describe which parameters (the selected parameters) of which methods (the selected methods) are to be traced for a particular profiling session. Additionally, the MPT specifications can describe how to transform the resultant method parameter trace values of the selected parameters for the selected methods in order to obtain one or more values to report to the user. For example, the front-end profiler  212   a  can display a GUI to the user on display device  108   a  that enables the user to select one or more methods for tracing and to select one or more parameters used by the selected methods for method parameter tracing. Additionally, the user can specify the transformations, if any, the MPT can apply to the resultant traced method parameter values for reporting back to the user (e.g., in the GUI of the front-end profiler  212   a ). The MPT specifications can be generated based on this user input. 
     The MPT module  324  can provide the MPT specifications to the back-end VM  218 . Each time the back-end VM  218  calls a selected method, the back-end VM  218  can apply the applicable MPT specifications for the selected parameters to the current parameter values of the selected method. The server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the resultant traced method parameter values from the back-end VM  218  The front-end profiler  212   a  can send the user-defined MPT specifications (e.g., a method name, a parameter index, and one or more modifiers) to the back-end profiler  212   b . When the back-end VM  218  executes a method, the back-end VM  218  can check if the method and its parameters are to be traced. If the back-end VM  218  determines the method should be traced, the back-end VM  218  can apply one or more modifiers to the parameter values. The back-end VM  218  can report the resultant parameter values in a method entry event. For example, the user can create a MPT specification by specifying the method name: “java.util.HashMap.get(java.lang.Object)java.lang.Object” as the method to trace. The user specifies the first parameter as the parameter to trace. The user specifies the modifier “toString( )java.lang.String” as the traced parameter value modifier. Each time the back-end VM  218  executes the “HashMap.get” method, a method entry event is sent to the front-end profiler  212   a  (e.g., where the data can be written to a file on the file system of the client  108 ). The back-end VM  218  applies the “toString( )” method modifier to the traced parameter value (e.g., the Object parameter). The back-end VM  218  executes the “toString( )” method on the actual parameter and provides the return value of that method as a parameter value. 
     In some implementations, when a VM (e.g., back-end VM  218 ) calls a selected method, the VM (e.g., back-end VM  218 ) can record, as an entry event, a timestamp and CPU thread time when entering the method. In some implementations, when the VM (e.g., back-end VM  218 ) calls a selected method, the VM (e.g., back-end VM  218 ) can record, as an entry event, a current stack trace when entering the method. For example, the front-end profiler  212   a  can display a GUI to the user on display device  108   a  that enables the user to select one or more entry events for reporting during a profiling session. The selections can be included in the MPT specifications in the MPT module  324 . For example, each time the back-end VM  218  calls a selected method, the back-end VM  218  can apply the applicable MPT specifications for entry events for the selected method. The server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the resultant entry event data as a single entity from the back-end VM  218 . 
     In some implementations, when a VM (e.g., back-end VM  218 ) exits a selected method, the VM (e.g., back-end VM  218 ) can record, as an exit event, a timestamp and CPU thread time when exiting the method. In some implementations, when the VM (e.g., back-end VM  218 ) calls a selected method, the VM (e.g., back-end VM  218 ) can record, as an exit event, a current stack trace when exiting the method. For example, the front-end profiler  212   a  can display a GUI to the user on display device  108   a  that enables the user to select one or more exit events for reporting during a profiling session. The selections can be included in the MPT specifications in the MPT module  324 . For example, each time the back-end VM  218  exits a selected method, the back-end VM  218  can apply the applicable MPT specifications for exit events for the selected method. The server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the resultant exit event data as a single entity from the back-end VM  218 . 
     In some implementations, when the VM (e.g., back-end VM  218 ) reports both entry events and exit events that include a timestamp, the timestamps can be used to determine the duration of the method call that used specific parameters. In some implementations, when the VM (e.g., back-end VM  218 ) reports both entry events and exit events that include a CPU thread time, the CPU thread times can be used to determine the duration of the method call that used specific parameters. 
     A user can use a method signature as a method specification for an MPT specification. In some implementations, a user can use a complete method signature to select a method for method parameter tracing. A complete method signature (e.g., example.Arrays.run(example.Value[ ])example.Result) can include a full package name for the input parameter types (e.g., example.Value[ ]) and a full package name for the return parameter types (e.g., example.Result). In some implementations, a method signature may not specify a method completely, as different class loaders may load the method class (e.g., the Arrays class) resulting in different implementations of the same method. A class loader dynamically loads classes into the VM. Additionally, the input parameter type (e.g., Value) and the return parameter type (e.g., Result) in the class (e.g., Arrays) in the differently implemented methods may have only their names in common as they may have different super classes, implement different interfaces, and have different methods and fields. 
     In some implementations, a user is not able to specify a class loader for a method selected for method parameter tracing. For example, the MPT module  324  may not differentiate between the differently implemented methods when specifying a method to trace. In some implementations, when the VM (e.g., back-end VM  218 ) reports the value of a selected method parameter, the VM (e.g., back-end VM  218 ) can differentiate between the differently implemented methods. For example, the VM (e.g., back-end VM  218 ) can tag each different class loader object with a different integer value (e.g., a class loader index value). When reporting the value of a selected method parameter, the VM (e.g., back-end VM  218 ) can include the integer value of the class loader (e.g., the class loader index value) to differentiate between the differently implemented methods For each class loader known by the VM (e.g., back-end VM  218 ), a mapping between a numeric value and the class loader definition (e.g., the fully qualified name of the class loader&#39;s class) can be reported to the front-end profiler  212   a . When the VM (e.g., back-end VM  218 ) reports a method entry event, the called method is reported. A method definition can be associated with mapping information (e.g., a numeric value corresponds to a method definition). The method definition can include the method name and the numeric value of the class loader responsible for loading the method. The VM (e.g., back-end VM  218 ) can report the numeric value of the method definition along with the method entry event. 
     In some implementations, a user can use the method signature (e.g., example.Arrays.run(Value[ ])Result) that includes a class name for the input parameter types (e.g., Value[ ]) and a class name for the return parameter types (e.g., Result) to select a method for method parameter tracing. By way of non-limiting example, a profiler executing the parameter trace can trace all methods that take an array of objects of a class named “Value” (which may be defined in any package) and return an object of a class named “Result”. Selecting a method with this method signature for method parameter tracing can result in the tracing of a plurality of methods (e.g., example.Arrays.run(Value[ ])Result, example.Arrays.run(example.Value[ ])another.pkg.Result, example.Arrays.run(example.Value[ ])example.Result). 
     In some implementations, classes that are included in the default package class for the method may not include a package class specifier (e.g., the method signature “example.Arrays.run(Value[ ])Result” need not include the class specifier “example” for the array of objects of the “Value” class or the “Result” class). In some implementations, when using covariant return types, a method signature may omit a return class type (e.g., example.Arrays.run(Value[ ])). A user can use the position of the return type in the method signature to specify the parameter to trace (e.g., an index value representing the position of the return type in the method signature). For example, in order to specify the parameter for tracing as the objects of the “Value” class, a user can specify “1” to select the first return parameter. 
     In some implementations, a user may trace a method that is not a static method (a non-static method). In this case, the non-static method includes an additional, not explicitly defined (implicit) method parameter (e.g., the “this” parameter). For example, the implicit parameter (e.g., the “this” parameter) can represent an object on which the method is called (e.g., the receiver). In order to trace the implicit method parameter (e.g., the “this” parameter) the user can specify a “0” (e.g., an index value for the method signature) to select the implicit the method parameter. In a Java application, for example, a non-static method is called within the context of a Java object (e.g., “this” denotes the Java object the non-static method is executed on). For example, for a class “java.util.HashMap” and a method “get(Object)” within the class, “MyObject” is an instance of the “java.util.HashMap” class. When MyObject.get(Object) is called, “get( )” is called on the “MyObject” instance. In this example, “MyObject” is the “this” object in the context of the get( ) method execution. 
     In some implementations, a method of a class can be overwritten in a subclass. In some implementations, a method for a class can be specified in an interface. For example, a user may want to trace a specific method or a specific method called by a specific receiver. For example, in order to perform method parameter tracing where a method of a class can be overwritten in a subclass, the MPT module  324  can support a plurality of variants. As another example, in order to perform method parameter tracing where a method of a class can be specified in an interface, the MPT module  324  can support a plurality of variants. 
     In some implementations, the MPT module  324  can support one or more variants for a method specification when determining the selection of a method for method parameter tracing. The MPT specification can include the variants. For example, in a first variant, a parameter trace is performed if the selected method matches the method specification included in the MPT specification and the receiver matches the full class name of the class in the method specification. In a second variant, a parameter trace is performed for a method if the criteria for the first variant are met and additionally the same method in all subclasses of the matching class is considered a match as long as the method in the subclass is not overwritten. In a third variant, a parameter trace is performed if the criteria for the first variant are met and additionally the same method in all subclasses of the matching class is matched. 
     Table 1 provides exemplar class definitions for three arrays. 
     
       
         
           
               
               
             
               
                 TABLE 1 
               
               
                   
               
               
                 Definition 
                 Class definition 
               
               
                   
               
             
            
               
                 1 
                 class Arrays {Result run (Value) {return null;}} 
               
               
                 2 
                 class Arrays2 extends Arrays {//nothing new added} 
               
               
                 3 
                 class Arrays3 extends Arrays2 {Result run 
               
               
                   
                 (Value) {return null;}} 
               
               
                   
               
            
           
         
       
     
     Table 2 shows exemplar code segments that can be included in an application running on a VM (e.g., back-end VM  218 ). The code segment can use the class definitions specified in Table 1. 
     
       
         
           
               
               
             
               
                 TABLE 2 
               
               
                   
               
               
                 Call 
                 Source code 
               
               
                   
               
             
            
               
                 1 
                 new Arrays( ).run(null); // Call 1 
               
               
                 2 
                 new Arrays2( ).run(null); // Call 2 
               
               
                 3 
                 new Arrays3( ).run(null); // Call 3 
               
               
                   
               
            
           
         
       
     
     By way of non-limiting example, a user can select the method signature, Arrays.run(Value), as the method specification for the method for parameter tracing to include in the MPT specification. When using the first variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 1 and not on Call 2 or Call 3, as Call 1 is the case where the receiver is of class “Arrays”. When using the second variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 1 and on Call 2 but not on Call 3, since the “Arrays2” method inherits the method implementation of “Arrays”. When using the third variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 1, Call 2 and Call 3, as the “Arrays3” method overwrites the “Arrays” method. 
     In another example, a user can select the method signature, Arrays2.run(Value), as the method specification for the method for parameter tracing to include in the MPT specification. When using the first variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 2 and not on Call 1 or Call 3, as Call 2 is the case where the receiver is of class “Arrays2”. When using the second variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 2 and not on Call 1 and Call 3, as the “Arrays2” method is overwritten in the “Arrays3” method. When using the third variant specified in the MPT specification, a VM (e.g., back-end VM  218 ) executing the code segment in Table 2 will perform a parameter trace on Call 2 and Call 3 and not on Call 1, as the “Arrays2” method is overwritten in the “Arrays3” method. 
     In some implementations, when using covariant return types, a method signature may omit a return class type. For example, the Java programming language allows an overwriting method to change the return type, as long as the new return type is a subtype of the return type of the overwritten method. Table 3 provides exemplar class definitions for two arrays. 
     
       
         
           
               
               
             
               
                 TABLE 3 
               
               
                   
               
               
                 Definition 
                 Class definition 
               
               
                   
               
             
            
               
                 1 
                 class A {Arrays2 exampleMethod( ) {return null;}} 
               
               
                 2 
                 class B extends A {Arrays3 example Method( ) 
               
               
                   
                 {return null;}} 
               
               
                   
               
            
           
         
       
     
     For example, a Java compiler can generate two versions of the exampleMethod method in the B class when compiling the classes in Table 3. A first version of the exampleMethod method in the B class can return the original method type (e.g., “Arrays2”). A second version of the exampleMethod method in the B class can return a new method type (e.g., “Arrays3”), which is a sub-type of the original type (e.g., “Arrays3” method inherits the method implementation of “Arrays2”). The method returning the original method type (e.g., the “Arrays2” method in class A) can forward the method call to the method returning the sub-type (e.g., the “Arrays3” method in class B). For example, a user can select a method signature for the exampleMethod method as the method specification for the method for parameter tracing to include in the MPT specification. When performing a parameter trace, if the return type is omitted in the method specification for the method to trace in the MPT specification both the methods (e.g., method of type “Arrays2” and method of type “Arrays3”) will be traced. However, the user sees one method in the source code (e.g., class B extends A {Arrays3 exampleMethod( ){return null;}}). The user can prevent the tracing of both methods by specifying the return type (e.g., either “Arrays2” or “Arrays3”). 
     Table 4 provides exemplar code segments that can be included in an application running on a VM (e.g., back-end VM  218 ). The code segments can use the class definitions specified in Table 3. 
     
       
         
           
               
               
             
               
                 TABLE 4 
               
               
                   
               
               
                 Call 
                 Source code 
               
               
                   
               
             
            
               
                   
                 Arrays2 v1 = new Arrays2( ); 
               
               
                   
                 Arrays2 v2 = new Arrays3( ); 
               
               
                   
                 Arrays3 v3 = new Arrays3( ); 
               
               
                 1 
                 v1.mth( ); // Call 1 
               
               
                 2 
                 v2.mth( ); // Call 2 
               
               
                 3 
                 v3.mth( ); // Call 3 
               
               
                   
               
            
           
         
       
     
     By way of non-limiting example, a user may look to trace all method calls to the exampleMethod method. The profiler executing the parameter trace will not trace Call 1 if the user specifies the return type of the overwritten method (e.g., “Arrays3”). The MPT will not trace Call 3 if the user specifies the return type of the original method (e.g., “Arrays2”). The MPT will trace Call 1, Call 2 and Call 3 if the user does not specify the return type of the method. However, for Call 2 the profiler executing the parameter trace will trace both the call to the method with the original return type (e.g., “Array2”) and the forwarded call to the method with the more specific return type (e.g., “Array3”). In some implementations, if the method specification in the MPT specification does not specify the return type of the method when using covariant return types, the profiler executing the parameter trace can trace only that method (from all the methods which would match in a class), which was added in the class itself or in its most specific super class. For example, the profiler executing the parameter trace can trace every call in the code segment in Table 4 once. The profiler executing the parameter trace can trace the methods, which include the actual implementation of the method and not the forwarded call to the method. 
     In some implementations, a VM (e.g., back-end VM  218 ) can determine how to specify the representation of a selected method parameter when the VM (e.g., back-end VM  218 ) reports the value of the selected method parameter. For example, the method parameter value types can be primitive value types (e.g., integers (ints) or double precision integers (double)). For example, the method parameter value types can be reference types (e.g., objects (Object) or arrays (Arrays)). When the method parameter is represented as a primitive value type, the VM (e.g., back-end VM  218 ) can report the method parameter value when entering the selected method for tracing and the profiler executing the parameter trace can directly trace the method parameter. When the method parameter is represented as a reference type, there may not be a definitive representation of the parameter and the parameter value may not be directly traced. In some implementations, the profiler executing the parameter trace specification can be supplied with a list of modifiers that operate in a chain-like fashion on the reference type object or array to return a parameter value that can be used as a definitive representation of the parameter. 
     In some implementations, the profiler executing the parameter trace can directly trace specific reference types. For example, a VM (e.g., back-end VM  218 ) can report the string content of string-like reference types (e.g., java.lang.String, java.lang.StringBuilder and java.lang.StringBuffer). For example, for a reference type of java.lang.Class, the MPT can use the class name or the class name together with information about the corresponding class loader (e.g., the name of the class loader&#39;s class). 
     For example, parameter value types and reference types that can be directly traced can include, but are not limited to: boolean; byte; short; char; int; long; double; float; java.lang.String; java.lang. StringBuilder; java.lang.StringBuffer; and java.lang.Class. 
     In some implementations, the profiler executing the parameter trace can handle reference types by adding a special case of a class to handle a specific reference type. In some implementations, a modifier can enable the use of user-specified conversions to convert a method parameter value type from one type to a method parameter value type of another type, which can be directly traceable. In some implementations, a VM (e.g., back-end VM  218 ) can use a chain of modifiers to transform a method parameter value from an initial type (the input to the chain of modifiers) that may not be directly traced to a final type (the output of the chain of modifiers) that can be directly traced (e.g., a primitive value type). In some implementations, a VM (e.g., back-end VM  218 ) can use a chain of modifiers to transform a method parameter value from an initial type (the input to the chain of modifiers) that can be the same type as a final type (the output of the chain of modifiers). In the implementation of a chain of modifiers, the output of the first modifier is used as the input to the next modifier. The parameter value at the end of the chain (the output of the chain of modifiers) is a parameter value type or reference type that the profiler can directly trace. 
     For example, the “length” modifier can modify a method parameter value from an input array type to an output integer (int) type. The precondition for the modifier is that the input type is an array. There is no optional modifier parameter. The modification results in an output parameter reported that is the length of the input array. An error can occur when the array is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. 
     For example, the “array_element” modifier can modify a method parameter value from an input array type to an output that is an element type of the array. The precondition for the modifier is that the input type is an array. The optional modifier parameter is the index of the array element to extract. For example, if the index is less than zero, the count begins from the end of the array (e.g., −1 would indicate the last element, −2 the second to last element, etc.). The modification can result in an output parameter that is the element at the given index of the input array. An error can occur when the array is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. An error can occur if the index is out of the range for the input array. When the error occurs, the output parameter is reported as INDEX_OUT_OF_BOUNDS. 
     For example, the “class” modifier can modify a method parameter value from an input object type to an output java.lang.Class type. The precondition for the modifier is that the input type is not a primitive value. There is no optional modifier parameter. The modification results in an output parameter reported that is the class of the input object. An error can occur when the object is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. 
     For example, the “instance_method” modifier can modify a method parameter value from an input object type to an output that is any type. The precondition for the modifier is that the method given as the parameter is found for the input type. The optional modifier parameter is the name and signature of the method taking no parameters. The modification can result in the method specified as the parameter is executed on the input object. The result of the method call can be used as the output. An error can occur if the object is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. An error can occur if the method throws an exception. When the error occurs, the exception is caught and the output parameter is reported as EXCEPTION_OCCURED. 
     For example, the “static_method” modifier can modify a method parameter value from an input object type to an output that is any type. The precondition for the modifier is that the class loader, which defined the class of the input object, finds the class of the static method given by the parameter. If such a class is found, the class includes a method as specified by the parameter where the method is static. The optional modifier parameter is the class name plus the method name and signature of a static method taking an object of the given input type (or a compatible type). The modification can result in the methods specified as the parameter is executed, with the input object as the first parameter. The result of the method call is used as the output. An error can occur if the method throws an exception. When the error occurs, the exception is caught and the output parameter is reported as EXCEPTION_OCCURED. 
     For example, the “field” modifier can modify a method parameter value from an input object type to an output of any type. The precondition for the modifier is that the input type contains a field with the given name and type. The optional modifier parameter is the name and field type. The modification results in the field specified as the parameter read from the input object and the content of the field is used as the output. An error can occur when the object is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. 
     For example, the “cast” modifier can modify a method parameter value from an input object type to an output object type. The precondition for the modifier is that the input type is not a primitive type. The optional modifier parameter is the name of a class. The modification results in the input type being casted to the class specified as the parameter and used as the output. For example, the assumed type of the object can be changed and not the object itself. An error occurs if the input object cannot be casted to the given type. When the error occurs, the output parameter is reported as CAST_FAILED. 
     For example, the “id” modifier can modify a method parameter value from an object type to an output long type. The precondition for the modifier is that the input type is not a primitive type. There is no optional modifier parameter. The modification results in a unique id for the input object being returned. Additionally, no two objects have the same id and the same object has the same id. An error can occur when the object is null. When the error occurs, the output parameter is reported as NULL_INVOCATION. 
     In some implementations, a chain of modifiers can be associated with each method specification included in the MPT specification. In some implementations, an empty chain of modifiers (no modifiers) can be associated with each method specification included in the MPT specification. As described in the above examples, not every modifier can be used on any input type. For example, when a method is initially entered during a method parameter trace, the VM (e.g., back-end VM  218 ) can check each applicable method specification in the MPT specification in order to determine if the VM (e.g., back-end VM  218 ) can use the modifiers for the method to determine the method parameter. If the modifiers cannot be used due to a mismatch between the modifier and the input type, the VM (e.g., back-end VM  218 ) can generate an “MPT Apply Error”, which can include additional information about the error. Modifiers are not applied to primitive value types. 
     In some implementations, a modifier specification can include the name and signature of a parameter type and method. When the method is initially entered, the name and signature of the parameter type and method can be converted to an actual class and method. 
     For example, when checking a modifier, the VM (e.g., back-end VM  218 ) can determine the trace parameter type used as an input to the modifier and the trace parameter type used as an output from the modifier. The trace parameter type used as an input to the modifier can be a general class object. Initially, the VM (e.g., back-end VM  218 ) can obtain the class object of the trace parameter. For example, using a type name and calling the loadClass( ) on the class loader that defined the parameter value can obtain the class object of the trace parameter for the reference types. If obtaining the class object of the trace parameter fails, the VM (e.g., back-end VM  218 ) can report an “MPT Apply Error”. The VM (e.g., back-end VM  218 ) will then not trace the method associated with the trace parameter using the MPT specification. If obtaining the class object of the trace parameter is successful, the class object can be the input to the first modifier, for example, in a chain of modifiers. Additionally, each modifier in the chain of modifiers can obtain the output type as a class object if the input type was also a class object. 
     For example, the previously described “array_element” modifier can output the class object of the element type of the array. In addition, a modifier (e.g., the “array_element” modifier) can check if the input type to the modifier is suitable for the modifier (e.g., the input type is an array). This check can be referred to as the preconditions described for each modifier (e.g., the precondition for the “array_element” modifier is that the input type is an array). If the input type is not suitable (e.g., the preconditions are not met), the VM (e.g., back-end VM  218 ) can report an “MPT Apply Error”. 
     If the input type is suitable and the preconditions are met, the class of the final output object (the object to be traced) is known. If the class of the final output object is not a traceable type (e.g., the resulting method parameter value type is not a primitive value type) the VM (e.g., back-end VM  218 ) can report an “MPT Apply Error”. If the class of the final output object is a traceable type, the VM (e.g., back-end VM  218 ) can report the method parameter type for the specified method for tracing along with the specific method specification in the MPT specification. For every call to the specified method, the VM (e.g., back-end VM  218 ) can apply the modifiers. For example, a modifier error can occur at each method call. In this case, the VM (e.g., back-end VM  218 ) can report the error specified in the “On Error” description for each modifier when the error condition described in the “On Error” description occurs. For example, the VM (e.g., back-end VM  218 ) may report a special tag or error code (e.g., as specified in the “On Error” description for each modifier) for the first modifier encountering an error. 
     For example, a VM (e.g., back-end VM  218 ) can report a plurality of types of values for a single MPT specification. For example, a VM can report a “Bool” type that represents a Boolean value. For example, a VM can report a “Byte” type that can represent a byte value. For example, a VM can report a “Short” value that can represent a short integer (short) value. For example, a VM can report a “Char” value that can represent a character (char) value. For example, a VM can report an “Int” value that can represent an integer (int) value. For example, a VM can report a “Long” value that can represent a long integer (long) value. For example, a VM can report a “Float” value that can represent a floating decimal integer (float) value. For example, a VM can report a “Double” value that can represent a double precision integer (double) value. For example, a VM can report a “String” value. The “String” value can represent a string like value. For example, this value type is used for a String, StringBuilder or StringBuffer trace. For example, a VM can report a “CastFailed” value that is the value type traced when a cast of a modifier fails. For example, a VM can report an “EnableFailed” value that is the value type traced when the value could not be traced because the modifiers were incorrect (e.g., a “MPT Apply Error” is reported). The method can still be traced, however, the parameter value will be “EnableFailed” (e.g., timing information or the number of method calls can still be obtained and used). For example, a VM can report an “ExceptionInCall” that is the value type traced if a modifier calling a method returns from that method with an exception. For example, a VM can report an “InvalidIndex” that is the value type traced if the VM attempts to access an array with an invalid index. For example, a VM can report a “NullInCall” that is the value type traced if the VM attempts to invoke a method in the “instance_method” modifier on a null object. For example, a VM can report a “NullValue” that is the value type traced if the value to trace is null. For example, a VM can report an “Unknown” that is the value type traced. When a MPT is enabled, a synthetic entry event can be generated of all methods on the stacks of all current threads. 
     When the profiling of a specific method specified in the MPT specification begins, the application may already be executing the method. In some implementations of the back-end VM, the back-end VW may not be able to access the parameter values of the method. For example, the application running the method may overwrite or reuse the memory location (i.e. the method stack) where the parameter values are stored, destroying the parameter values. 
     In some implementations, modifiers can call methods specified in the MPT specification. This can lead to infinite recursion in an application. Therefore, a VM (e.g., back-end VM  218 ) should not trace methods in a thread in which the MPT modifiers are currently executing. 
     In some implementations, a profiler can trace one or more methods, and can trace one or more parameters for each specific method. In some implementations, a profiler can trace the same method parameter value using different modifiers. For example, a profiler that traces the same method parameter value using different modifiers can result in a set of method parameter values each corresponding to a single MPT specification, on each method call. For example, the back-end VM  218  executing the profiler  212   b  can report the set of method parameter values to the front-end VM  220 . The front-end profiler  212   a  on the front-end VM  220  can modify or combine the set of method parameter values. For example, the front-end profiler  212   a  can combine two method parameter values into a single method parameter value. For example, the front-end profiler  212   a  can extract content from the method parameter values (e.g., when tracing Structured Query Language (SQL) methods the front-end profiler  212   a  can extract the tables involved in the query and can create a synthetic value containing only the extracted tables). 
     The front-end profiler  212   a  can combine the values of the same method parameter using different modifiers. For example, a user selects the HashMap.get(Object) method to trace. The method uses a general object as its input. A VM can call a toString( ) method in the modifier to convert the object to a string and use the result as the parameter value. In another example, a class named Special includes a field that contains more information about the general object, “Object”, than the string returned by the toString( ) method. The user can create MPT specifications, where a first MPT specification uses the “instance_method” modifier with “toString( )” as the parameter. A second MPT specification can “cast” a modifier as the first modifier, which tries to cast the object “Object” to a Special class. A field modifier can extract the field (defined in the class named Special) of the object. As a result, two values for the method parameter are generated for an entry event. When the parameter value is of the class Special, an additional parameter value will not be reported as a CastFailed. Therefore, the front-end profiler  212   a  running on the front-end VM  220  can display (e.g., on display device  108   a ) the second value for the method parameter. Whenever the second value for the method parameter is not an indication of a failed cast (e.g., CastFailed), the front-end VM  220  can display (e.g., on display device  108   a ) the second value for the method parameter as a fallback. 
     Referring now to  FIG. 10 , exemplar steps that can be executed in accordance with implementations of the present disclosure will be described. The exemplar steps of  FIG. 10  can be executed using one or more processors coupled to a computer-readable storage medium at a computer system (e.g., the computer system  114  including server  102 ) and/or a client device (e.g., the client devices  108 ,  110 ). 
     In step  1000 , one or more MPT specifications is received. For example, the MPT module  324  in  FIG. 3  can provide one or more MPT specifications to the back-end VM  218 . Each MPT specification indicates one or more methods and one or more parameters to be traced, the one or more parameters corresponding to the one or more methods. In step  1002 , an application is executed. The application including calls that call a method of the one or more methods using the virtual machine. For example, the back-end VM  218  can execute the application, and each time the back-end VM  218  calls a selected method, the back-end VM  218  can apply the applicable MPT specifications for the selected parameters to the current parameter values of the selected method. It is appreciated, however, that the MPT specifications can be received while the application is executing. Accordingly, and in some implementations, step  1000  can occur before step  1002 . In step  1004 , a subset of the MPT specifications is determined. The subset corresponds to MPT specifications that are applicable to a currently called method. For example, the VM (e.g., back-end VM  218 ) can determine the method specification included in the MPT specification for a called method. The VM (e.g., back-end VM  218 ) can call a method specified in the MPT specification during execution of the application. 
     In step  1006 , an entry event for the called method is generated. For example, each time the back-end VM  218  calls a selected method, the back-end VM  218  can apply the applicable MPT specifications for entry events for the selected method. In some implementations, the parameter values of the called method can be grouped into a first group and a second group, values of the first group can be directly written to the entry event, values of the second group can be transformed based on one or more modifiers to provide one or more modified values, and the one or more modified values can be written to the entry event. The modifiers can be provided in a chain of modifiers, each modifier in the chain of modifiers having an input and an output, an output of one modifier being an input of another modifier in the chain of modifiers, wherein an output of a last modifier in the chain of modifiers comprises a modified value. 
     In step  1008 , the entry event is reported. For example, the server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the entry event and, among other data, resultant traced method parameter values from the back-end VM  218 . 
     In step  1010 , an exit event for the called method is generated. For example, each time the back-end VM  218  exits a selected method, the back-end VM  218  can apply the applicable MPT specifications for exit events for the selected method. In step  1012 , the exit event is reported. For example, the server API  224  can enable the client  108  by way of network  106  and client API  222  to receive the exit event and, among other data, resultant traced method parameter values from the back-end VM  218 . In step  1014 , a duration of the called method can be determined and the steps end. For example, if the entry event and the exit event include respective timestamps, the duration of the called method can be determine by comparing the timestamps. This determination can be performed at the front-end, and/or the back-end. 
     In some implementations, a user may combine a MPT with event traces that are generated while profiling an executing application. Exemplar event traces can include, but are not limited to, an allocation profiling trace, a time-based sampling trace, and/or other traces that trace a parameter during execution of a method (e.g., and I/O trace). A MPT can be combined with other traces that trace events (e.g. resource consumption or waiting on a lock) occurring in a specified method. The MPT events and the events of the other trace are then stored in order for the thread in which the events occur. Additionally, a MPT can be combined with other traces that can be used to attribute a quantity (e.g. time spent in a method or waiting time on a lock) to a stack trace and a thread. For example, combining a MPT with an allocation trace can provide method parameter values for specified methods included in the allocation trace. For example, combining a MPT with a time-based sampling trace can provide method parameter values for specific methods included in the time-based profiling trace. 
     When a VM calls a selected method, the VM can record a timestamp and CPU thread time when entering the method as an entry event. Additionally, when a VM exits a selected method, the VM can record a timestamp or CPU thread time when exiting the method as an exit event. The VM can also record the thread in which the method was entered or exited. As previously described with reference to  FIGS. 6-9 , a profiler can profile events for event traces that occur in the called method. The profiled events in the called method can be correlated with the method parameters traced in a method parameter trace. For example, if an allocation trace and a MPT are enabled in parallel, a VM can report objects allocated in the method that were dependent on a parameter value. 
     In some implementations, an allocation trace and a MPT are enabled in parallel and their outputs are combined. The profiling data provided by the combined trace includes the direct and/or indirect allocations in a method specified by the method specification in the MPT specification, which depends on the value of method parameters. For example, a cache can create objects that are not already in the cache (e.g. by reading them from a database). By combining the MPT and the allocation trace, cache entry keys that have to construct their objects in the specified method can be traced by tracing the value of the key parameter of the method that retrieves an object from the cache. 
     A precondition for combining a MPT and an allocation trace can include ordering the MPT and the allocation trace entries relative to one another. The allocation trace can provide information about the thread in which the allocation occurred. An allocation that occurs before the identified method in a MPT is entered is reported by the VM running the thread prior to the reporting the MPT entry event for the identified method. An allocation event that occurs after the identified method in the MPT is entered is reported by the VM after the MPT entry event is reported. Similarly, allocations that occur before the identified method in a MPT is exited are reported by the VM running prior to the reporting of the MPT exit event for the identified method. Allocation events that occur for allocations after the identified method in the MPT is exited are reported by the VM after the MPT exit event is reported. Between MPT events (e.g., between a MPT entry event and an MPT exit event) the VM can reorder or combine allocations prior to reporting. In some cases, modifiers used in a MPT can result in additional allocations. In such cases, the additional allocations are not traced as they are an artifact of the MPT. 
     In some implementations, a time-based profiling trace (e.g., a performance hotspot analysis trace) and a MPT are enabled in parallel and their outputs are combined. The statistical nature of a time-based profiling trace can complicate the combination with a MPT. For example, time-based sampling obtains stack traces of all running threads in regular intervals. Assuming the runtime for a method is proportional to the number of times the method call is found in a method call stack, a user can determine which methods consume the most CPU resources. In order to accurately determine the runtime, a plurality of time-based samples may be required. 
     When combining a time-based sampling trace and a MPT for an identified method, a subset of the time-based samples for the time-based sampling trace are used. The subset includes the time-based samples taken while the thread was running the identified method using an identified method parameter with a specific value during the MPT. These criteria can reduce the number of samples collected for the time-based analysis. In order to increase the sample count, the trace time for the application can be increased. A user can determine which methods called by the identified method traced by a MPT consume the most CPU resources based on a specific method parameter value if a sufficient number of time-based samples are collected by the combined trace. The user can select the number of time-based samples to provide reasonable accuracy for the trace results. 
     In some implementations, system overhead can be introduced or increased in a time-based sampling trace when a thread enters an identified method for a MPT. The additional tasks performed by the specified method when entering and exiting the method (e.g. time stamps, storage of the events or call methods that transform the trace parameter) can result in additional computing time for the method, adding to the system overhead. The additional computing time for the method results in the VM remaining in the specified method for the MPT longer than it would have spent in the method if the MPT were not performed. 
     For example, when the thread enters a specified method for a MPT, the VM can set a MPT flag in the thread indicating that a MPT is tracing the method. The VM can create and then report the data for the entry event. Before continuing with the execution of the method, the VM can clear the MPT flag. Similarly, when the thread exits a specified method for a MPT, the VM can set a MPT flag in the thread indicating that a MPT is tracing the method. The VM can create and then report the data for the exit event. Before exiting the method, the VM can clear the MPT flag. When performing a time-based sampling trace, the VM can check if the MPT flag is set for a specific thread. If the MPT flag is set for the thread, the time-based sampling trace can ignore (skip) this particular sample as the sample includes the overhead introduced by the MPT. 
     The overhead of tracing a method parameter and reporting its value can result in additional computing time for the method as compared to the computing time for the method when a MPT trace is not performed. For example, if a time-based sample is taken at the point in time when the thread enters the identified method and the MPT traces the corresponding parameter, the time-based sampling trace would see the specified method on the stack and record a time for the method that includes the time for tracing and reporting the method parameter value. The recorded runtime for the particular instance of the method can be significantly longer than the actual runtime for the method when not performing a MPT. A VM running the thread that calls the identified method can mark the thread during a MPT. The time-based sampling trace can disregard the time-based sample for the marked thread. 
     In some implementations, an input/output (I/O) profiling trace and a MPT are enabled in parallel and their outputs are combined. I/O-based sampling can provide an overview of I/O operations performed and I/O resources used by methods in an application. The profiling data provided by the combined traces includes I/O operations performed and I/O resources used by a method specified by the method specification in the MPT specification that depends on the value of method parameters. For example, a cache can create objects that are not already in the cache (e.g. by reading them from a database). If an object requested from the cache is not stored in main memory, the cache can read the object from a database, using a network socket, for example. The MPT combined with an I/O profiling trace can trace the amount of bytes transferred on the network socket for creating the cache object. 
     Referring now to  FIG. 11 , exemplar steps that can be executed in accordance with implementations of the present disclosure will be described. The exemplar steps of  FIG. 11  can be executed using one or more processors coupled to a computer-readable storage medium at a computer system (e.g., the computer system  114  including server  102 ) and/or a client device (e.g., the client devices  108 ,  110 ). 
     In step  1100 , a profiler is configured to profile one or more method parameters and events of an application. For example, the VM (e.g., back-end VM  218 ) can receive user input identifying one or more MPT specifications and events to be traced. For example, the MPT module  324  in  FIG. 3  can provide the MPT specifications to the back-end VM  218 . The MPT specification can include one or more method specifications indicating one or more methods to trace and one or more method parameters for tracing. Additionally, the user can also enable an allocation trace that uses the allocation trace module  316 . In step  1102 , the application is executed. For example, the VM (e.g., back-end VM  218 ) can execute an application that includes calls to the methods indicated in the MPT specification. For example, each time the back-end VM  218  calls a selected method, the back-end VM  218  can apply the applicable MPT specifications for the selected parameters to the current parameter values of the selected method. 
     In step  1104 , in parallel, a one or more MPTs are generated and one or more event traces are generated. For example, a thread running on the VM can call a method indicated for tracing in the MPT specification and an allocation trace can be generated. In step  1106 , a method parameter trace and an event trace are combined to provide a combined trace. For example, the combined trace can include profiling data for method parameter values for specified methods included in the allocation trace. The front-end can generate the combined trace based on profiling data provided by the back-end. 
     In another example, a user can also enable a time-based sampling trace along with the MPT. The exemplar steps in  FIG. 11  can execute and combine the time-based sampling traces with the MPTs. In another example, the user can also enable an I/O trace along with the MPT. The exemplar steps in  FIG. 11  can execute and combine I/O traces with the MPTs. 
     Referring now to  FIG. 12 , a schematic illustration of exemplar hardware components  1200  that can be used to execute implementations of the present disclosure is provided. The system  1200  can be used for the operations described in association with the methods described in accordance with implementations of the present disclosure. For example, the system  1200  may be included in the application server  102 . The system  1200  includes a processor  1210 , a memory  1220 , a storage device  1230 , and an input/output device  1240 . Each of the components  1210 ,  1220 ,  1230 , and  1240  are interconnected using a system bus  1250 . The processor  1210  is capable of processing instructions for execution within the system  1200 . In one implementation, the processor  1210  is a single-threaded processor. In another implementation, the processor  1210  is a multi-threaded processor. The processor  1210  is capable of processing instructions stored in the memory  1220  or on the storage device  1230  to display graphical information for a user interface on the input/output device  1240 . 
     The memory  1220  stores information within the system  1200 . In one implementation, the memory  1220  is a computer-readable medium. In one implementation, the memory  1220  is a volatile memory unit. In another implementation, the memory  1220  is a non-volatile memory unit. The storage device  1230  is capable of providing mass storage for the system  1200 . In one implementation, the storage device  1230  is a computer-readable medium. In various different implementations, the storage device  1230  may be a floppy disk device, a hard disk device, an optical disk device, or a tape device. The input/output device  1240  provides input/output operations for the system  1200 . In one implementation, the input/output device  1240  includes a keyboard and/or pointing device. In another implementation, the input/output device  1240  includes a display unit for displaying graphical user interfaces. 
     The features described can be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The apparatus can be implemented in a computer program product tangibly embodied in an information carrier, e.g., in a machine-readable storage device, for execution by a programmable processor; and method steps can be performed by a programmable processor executing a program of instructions to perform functions of the described implementations by operating on input data and generating output. The described features can be implemented advantageously in one or more computer programs that are executable on a programmable system including at least one programmable processor coupled to receive data and instructions from, and to transmit data and instructions to, a data storage system, at least one input device, and at least one output device. A computer program is a set of instructions that can be used, directly or indirectly, in a computer to perform a certain activity or bring about a certain result. A computer program can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. 
     Suitable processors for the execution of a program of instructions include, by way of example, both general and special purpose microprocessors, and the sole processor or one of multiple processors of any kind of computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memories for storing instructions and data. Generally, a computer will also include, or be operatively coupled to communicate with, one or more mass storage devices for storing data files; such devices include magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and optical disks. Storage devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, including by way of example semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, ASICs (application-specific integrated circuits). 
     To provide for interaction with a user, the features can be implemented on a computer having a display device such as a CRT (cathode ray tube) or LCD (liquid crystal display) monitor for displaying information to the user and a keyboard and a pointing device such as a mouse or a trackball by which the user can provide input to the computer. 
     The features can be implemented in a computer system that includes a back-end component, such as a data server, or that includes a middleware component, such as an application server or an Internet server, or that includes a front-end component, such as a client computer having a graphical user interface or an Internet browser, or any combination of them. The components of the system can be connected by any form or medium of digital data communication such as a communication network. Examples of communication networks include, e.g., a LAN, a WAN, and the computers and networks forming the Internet. 
     The computer system can include clients and servers. A client and server are generally remote from each other and typically interact through a network, such as the described one. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. 
     In addition, the logic flows depicted in the figures do not require the particular order shown, or sequential order, to achieve desirable results. In addition, other steps may be provided, or steps may be eliminated, from the described flows, and other components may be added to, or removed from, the described systems. Accordingly, other implementations are within the scope of the following claims. 
     A number of implementations of the present disclosure have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the present disclosure. Accordingly, other implementations are within the scope of the following claims.