Java Enterprise Runtime 

The Java enterprise runtime provides the core functions of the system. It is made up of several low-level subsystems containing manager components which provide the infrastructure and runtime to support the upper layer of the AS Java system components.

The Java enterprise runtime provides a number of key concepts which significantly enhance the robustness, stability and supportability of the AS Java, such as central cache management and session management.

Cluster Communication

AS Java cluster elements communicate via cluster messages. The system is able to send messages to one cluster element, to a group of elements, or to all elements in the cluster. Cluster elements use messages to broadcast notification events. The Cluster Manager is responsible for managing this communication.

There are several types of cluster communication depending on the abilities they provide for transferring messages. The type of cluster communication that is used when processing one message is determined by the Cluster Manager and is transparent for the cluster elements.

The successful message delivery is guaranteed, except in cases when the corresponding element stops or is timed out. In this case, the corresponding exception occurs and can be handled by the sending party. The ability of a server element to process a notification depends on the load level of that particular VM – if the load is too high, the server element will not be able to process the notification immediately.

Cache Management

The AS Java uses a central cache management to better control the memory consumption of the components’ caches. It provides a complete cache framework - the Cache Management Library (CML) - which drastically reduces the overall memory footprint of the system. This lower memory footprint results in the capability of running more VMs.

Cache management has the following features:

●      One cache implementation is used by all layers to reduce redundancies

●      Central cache configuration for all system caches

●      Advanced monitoring and administration of the whole cache landscape

●      Optimizations and tuning of the cache can be done on a higher level and therefore more efficiently.

●      Cluster-wide invalidation of cache entries is possible

Session Management

AS Java has a central session management which provides the following features:

●       Enhanced control of the sessions in the server

●       Enables a session failover safety mechanism

In general, sessions are used to keep the state of a user accessing an application between several requests. The AS Java architecture provides a reduced number of sessions per VM, which is achieved through separating the inactive user sessions from the active user sessions and reducing the number of sessions stored in a VM.

An active user session is a session which is currently bound with a request that is processed by the server, while an inactive user session is currently not bound with a request.

Active user sessions are stored inside the memory space of the VM, while inactive user sessions are stored in a shared memory region which is not damaged if the VM crashes due to certain problems such as Out Of Memory Errors, JVM bugs, and so on. In case of failure, the inactive user sessions stored in the shared memory region remain unaffected, and they can be mapped to a different VM process when a request for that session needs to be processed.

Thread Management

The AS Java thread management system provides common handling, maintenance, configuration, error processing, and monitoring for the thread resources used for execution of parallel system and application requests. The thread management system comprises two thread managers which handle the system and application operations separately. The Thread Manager supplies threads for the AS Java system operations such as framework tasks, system events handling, and services management, while the Application Thread Manager supplies threads for application requests processing.

Thread management controls the thread usage in the system and ensures that the overload on one AS Java component cannot deplete the thread resources and leave the other components blocked due to lack of threads. This is achieved by effective load control for application requests, optimal resource management, low synchronization level, and high degree of isolation.

Reference

The managers that constitute the subsystems of Java Enterprise Runtime are:

●      Application Thread Manager – handles threads in which client applications’ source code is executed.

●      Cache Manager – provides a centralized cache management infrastructure that consolidates caches used by various components within the system.

●      Class Loader Manager – responsible for registering and removing loaders and references between them.

●      Cluster Manager – manages communication between elements in the AS Java cluster. It updates the information about the status of each cluster element and the services running on it.

●      Configuration Manager - manages the process of storing and reading persistent configuration data to and from a relational database.

●      Database Manager – provides a pooling functionality for database connections.

●      Licensing Manager – handles SAP licenses.

●      Locking Manager – handles locking as interface to the enqueue service.

●      Log Manager – manages the process of logging system events.

●      Pool Manager – manages the process of pooling Java objects.

●      Service Manager – manages the lifecycle of AS Java system components and acts as a container in which all services in the cluster work.

●      Session Manager – manages the lifecycle of user sessions and provides failover capabilities.

●      Thread Manager – handles threads in which the AS Java system operations are executed.