Sun Microsystems, Inc.

Oracle America, Inc.

Ruslan V Belkin

Viswanath Ramachandran

Matthew Helgren

A mechanism for enabling session information to be shared across multiple processes in a multi-process environment is disclosed. There is provided a shared persistent memory-mapped file in a file system, which is mapped to the memory space of each of the processes. This file is used by all of the processes to store session information. Because the memory space of each process is mapped to the shared file, each process is able to access and manipulate all of the sessions in the system. Thus, sessions are no longer maintained on a process-specific basis. Rather, they are maintained on a centralized, shared basis. As a result, different requests pertaining to the same session may be serviced by different server processes without any adverse effects. Each process will be able to access and manipulate all of the state information pertaining to that session. By enabling session information to be shared, this mechanism eliminates the session management errors experienced by the prior art.

Mechanism for enabling session information to be shared across multiple processes

An SLO (service level objective) is represented by a model that includes nodes that represent elements in a system that are used to fulfill the SLO and information that represents dependencies between the elements. Telemetry information is received describing a condition of an element in the system. The telemetry information can be applied to a particular procedure associated with a particular node in the model to determine if there is a problem associated with the element represented by the particular node. At least a portion of the telemetry information is applied to procedures to determine problem cause information describing which elements have problems relating to the SLO. A relative contribution of elements to a problem associated with the SLO is determined by analyzing the problem cause information and the dependencies between the elements.

Method and apparatus for identifying problem causes in a multi-node system

A mechanism for enabling customized session managers to interact with a network server is disclosed. A programming interface enables customized session managers to 'plug in' to and to interact with the server, making it possible to change session management functionality without having to make any changes to the core server. It also makes it possible to incorporate multiple session managers into the server. These aspects of the programming interface significantly increase the flexibility and scalability of the web server. The mechanism further includes a service engine for coordinating the interaction with the session managers. For each client request, the service engine determines which application needs to be invoked. Then, based upon that application, the service engine determines which, if any, associated session manager needs to be invoked to manage session (i.e. state) information for that application. The service engine invokes the session manager via the programming interface.

Mechanism for enabling customized session managers to interact with a network server

A mechanism is provided for enabling a request to be evaluated prior to the request being disposed. Particularly, an evaluation function is associated with a thread pool. Whenever a thread is to be assigned from that thread pool, the evaluation function may be invoked. The evaluation function may be invoked in response to one or more conditions being satisfied, or it may be invoked each time a thread is needed from that thread pool. When invoked, the evaluation function performs an evaluation on the request. Based upon the evaluation, the evaluation function may take one or more actions. For example, if the evaluation function determines that the request is a high priority request, then it may ensure that the request will be processed regardless of system workload. The evaluation function is user specifiable; thus, it may be programmed to perform any desired operations, and to take any desired considerations and factors into account. Overall, the evaluation function gives a user great freedom in determining how to dispose of a request.

Mechanism for evaluating requests prior to disposition in a multi-threaded environment

A JAVA application is typically executed as follows. First, a thread from a thread pool is attached to the JAVA virtual machine (JVM). Then, that thread is used to execute the JAVA application. Once the execution of the JAVA application is completed, the thread is detached from the JVM and returned to the thread pool. This is repeated for every execution of a JAVA application. Because this constant attaching and detaching of threads imposes additional overhead on the system, this process is inefficient. To improve the efficiency of the execution process, a &ldquo;sticky attach&rdquo; mechanism is provided. With sticky attach, a thread is not attached and detached from the JVM each time a JAVA application is executed. Rather, a thread is attached to the JVM only once: the first time it is used to execute a JAVA application. When execution of the JAVA application is completed, the thread is returned to the thread pool without detaching from the JVM. That way, the next time that thread is obtained from the thread pool, there will be no need to reattach it to the JVM. It will already be attached. Thus, it can be used as is to execute a JAVA application. By eliminating the need to constantly attach and detach threads, the sticky attach mechanism significantly decreases overhead. This in turn increases overall system efficiency.

Mechanism for obtaining a thread from, and returning a thread to, a thread pool without attaching and detaching

A mechanism for enabling customized session managers to interact with a network server is disclosed. The mechanism includes a programming interface which enables customized session managers to &ldquo;plug in&rdquo; to and to interact with the server. This programming interface makes it possible to change session management functionality without having to make any changes to the core server. It also makes it possible to incorporate multiple session managers into the server. These aspects of the programming interface significantly increase the flexibility and scalability of the web server. In addition to the programming interface, the mechanism further includes a service engine for coordinating the interaction with the session managers. For each client request, the service engine determines which application needs to be invoked. Then, based upon that application, the service engine determines which, if any, associated session manager needs to be invoked to manager session (i.e. state) information for that application. The service engine invokes the session manager via the programming interface. With the programming interface and the service engine, the present invention provides a flexible and scalable mechanism for implementing session management functionality in a network server.

Executing a thread unaware or non-thread-safe application in a multi-threaded environment is potentially hazardous. If multiple instances of the thread unaware application are executed concurrently in the same process space, as may be the case in a multi-threaded environment, one instance may try to modify or overwrite the information used by the other instance, which can lead to serious errors. To enable a thread unaware application to be executed safely in a multi-threaded environment, multiple thread pools are implemented. That is, for each thread-unaware or non-thread-safe application, a separate thread pool is defined and associated with the application. Unlike other thread pools, though, this thread pool has its maximum number of threads parameter set to &ldquo;1&rdquo;. By limiting the number of threads in the pool to 1, it is guaranteed that there will be no more than one instance of the thread unaware application executing at any one time. This in turn precludes any possibility of one instance of the application overwriting or modifying the information used by another. By implementing thread pools in this manner, execution of the thread-unaware application in a multi-threaded environment is made safe.

Mechanism for enabling a thread unaware or non thread safe application to be executed safely in a multi-threaded environment

A mechanism is disclosed for implementing multiple thread pools in a computer system to optimize system performance. In accordance with the invention, a plurality of thread pools is initially allocated within a process space, with each thread pool comprising one or more threads. Each thread pool has a set of characteristics associated therewith, and the characteristics of each thread pool are customized for one or more particular types of service. After the thread pools have been allocated, the system receives one or more requests. When a request is received, it is processed to determine with which thread pool the request is to be associated. This processing is carried out by determining the type of service being requested by the request, and then determining which thread pool is associated with that type of service. Alternatively, this processing is carried out by extracting a set of indication information (e.g. a universal resource identifier) from the request, and then determining which thread pool is associated with that set of indication information. Once the proper thread pool is determined, a thread from that thread pool is used to carry out servicing of the request. Because the request is serviced using a thread from the thread pool customized for the type of service requested, the servicing of the request is optimized. This in turn optimizes system performance.

Growing community of inventors

Santa Clara, CA, United States of America

Ruslan V Belkin