EAServer Performance Tuning Techniques

Using local interfaces can improve performance, but in coding you must be aware that parameters are passed by reference rather than by copy, so object instances passed through a local invocation can be shared by the client and component, and that the called component must be hosted in the same server process as the calling component since Local interfaces are not location transparent.

• BeforeInvoke: before calling each business method
• BeforeRemove: before calling ejbRemove
• AfterBegin: (default) at the beginning of a transaction. This option may provide the best performance.

For best performance, set the Read Only property for all methods that do not modify data. As a result, he components ejbStore or ctsStore method is not invoked after the business method returns.

In addition, if you are updating multiple fields, call the entity bean from session bean with the transaction open, then do multiple sets in entity bean, so only one ejbStore will occur instead of being called for each set.

EAServer supports object and query caching for EJB entity beans and entity components that use automatic persistence. Caching can improve performance by minimizing the number of database select queries required for load, finder, and select operations. Performance gains may range from 1.5 to 2 times faster for applications where most transactions are updates, and from 3 to 30 times faster for applications where most transactions are read-only.

Object Caching is off by default and can be turned on for all Components and their finder methods that use Automatic Persistence.

To further optimize performance, you can;

For entity components that use automatic persistence, using timestamps for concurrency control yields the best performance in most cases.

In optimistic concurrency control, use of the timestamp reduces unnecessary database read operations for tables with many columns or large column values (such as Sybase text or image columns).

EJB 2.0 entity beans can use EJB Query Language (EJB-QL) in the EJB-JAR deployment descriptor. EAServer translates EJB-QL to SQL at runtime. You can configure additional EAServer query mapping properties to enable caching of the query results for improved performance.

To improve the performance of Servlet and jsp(SUN企业级应用的首选) requests, you can use the page caching feature. When page caching is enabled for a Servlet or jsp(SUN企业级应用的首选) Web component, EAServer checks the cache before invoking the Web component. If an appropriate response is found in the cache, EAServer returns the contents of the cache, instead of calling the Servlet

Page caching is not enabled for any jsp(SUN企业级应用的首选)s or Servlets by default. It must be enabled on page by page basis as caching requirements might be different for each jsp(SUN企业级应用的首选)/Servlet See:

jsp(SUN企业级应用的首选)s and Servlets provide superior performance and scalability because they can be compiled, loaded into memory, and reused by multiple clients while running in a single thread, and they can take advantage of connection caching or pooling.

Additionally, they overcome many of the deficiencies of CGI, ISAPI, and NSAPI. Although the CGI-BIN interface is not platform-specific, code has to be recompiled for different platforms, and performance is poor for large-scale applications because each new CGI request requires a new server process. Similar platform-specific interfaces such as ISAPI and NSAPI improve performance, but at the cost of even less portability.

The com.sybase.jaguar.webapplicaton.jsp(SUN企业级应用的首选)c-interval property value indicates if and when the jsp(SUN企业级应用的首选) runtime checks whether a jsp(SUN企业级应用的首选) is current.

• If set to a negative number, the jsp(SUN企业级应用的首选) runtime never checks.
• If set to 0, the jsp(SUN企业级应用的首选) runtime always checks.
• To specify the number of seconds before the next check, set the value to a number greater than 0. If a request comes in before the time expires, the jsp(SUN企业级应用的首选) is not checked.

You can set initialization and destroy timeouts for Web Applications, and override most of the settings at the individual Servlet level. See these properties for more information:

"Repository Properties Reference" in EAServer System Administration Guide

"Server properties for Servlets" in EAServer Programmer's Guide

The com.sybase.jaguar.component.objects specifies the maximum number of component instances that can exist at once. For a C++ component that runs as an external process, it specifies the maximum number of simultaneously running external processes.

If a request arrives when the maximum number of instances exist and are all busy, the request blocks, with blocking time constrained by the Maximum Wait setting.

For large retrievals or imports into a DataWindow object, set the datawindow.storagepagesize property to large. Setting this property allows the DataWindow to most efficiently use the available virtual memory. While the setting LARGE is recommended, a setting of MEDIUM is also available.

To remove unused objects from memory, you can call the GarbageCollect() function to force garbage collection to occur immediately.

Setting the Bind Thread property to false can improve performance. However, you can only set this property to false for a PB component that either:

• does not declare a DataStore as an instance or global variable, or
• is deployed to a UNIX server

If the Bind Thread property is set to true, be sure to utilize Named Instance Pools, which is described in the Components in general section.

In the development environment, this property must be set to TRUE if you are using live editing to build your component.

If you do not use a feature such as display formatting, validation rules, or client-side scripting, you can enhance performance by preventing the server component from generating code for the unused feature.

You can also cache client-side methods in JavaScript files to reduce the size of the generated code and increase performance on both the server and the client. Without JavaScript caching, each time a Web DataWindow is rendered in a client browser, JavaScript code for DataWindow methods is generated on the server and downloaded to the client. However, there is no performance gain if the client web browser settings prevent caching.

Using a customized component instead of the preinstalled HTML generator component allows you to set properties for your component in Jaguar Manager. Setting properties reduces the number of method calls required to configure the component and can result in improved performance, maintainability, and scalability.

Specifically, you can set the source file and DataWindow object on the server so that the DataWindow object is loaded when the component instance is created, resulting in fewer method calls from server-side scripts in the Web page. You can also improve performance by having your custom component maintain its state.

"Web DataWindow Container component" in PowerBuilder Building Internet and Enterprise Applications

Using a custom server component" in PowerBuilder DataWindow Programmer's Guide

To optimize the performance of a JMS application, set REQUIRES_ACKNOWLEDGE to false so the message service will not acknowledge messages.

By default, the Reader, Writer and Worker Threads are set to 0.

For high-volume client notification with transient messages, you can improve performance by tuning the number of reader and writer threads if it improves throughput.

For component notification, you can prevent or allow parallel message processing by changing the worker threads setting.

In designing your client, plan to optimize network performance by keeping traffic between the client and components on the server to a minimum. To optimize network performance, plan to:

• Cache property changes in client data structures
• Validate field values on the client
• Update only the rows and columns that have changed
• Group data changes into larger sets with fewer method calls
• Compress large blobs before passing them between server and client. Some free data compression tools are available, including zlib.

"Implementing components and clients" in EAServer Programmer's Guide

http://www.gzip.org/zlib/

PowerObjects article: Jaguar Performance Using ZLIB

Client Timeout

The IdleConnectionTimeout property specifies the amount of time a connection is allowed to sit idle. By default, connections do not timeout. Specifying a finite timeout for your client applications can improve server performance. If many instances of the client run simultaneously, a finite client connection timeout limits the number of server connections that are devoted to idle clients. A finite timeout also allows rebalancing of server load in an application that uses a cluster of servers.

For CORBA-Java clients -- If you specify an idle connection timeout, make sure the garbage collection interval (com.sybase.CORBA.GCInterval) is set to an equal or lesser value

For C++ clients, use the ORBRetryCount and ORBRetryDelay options

"Creating EJB Clients", "Creating Java-CORBA Clients", "Creating C++ Clients" in EAServer Programmer's Guide

Specify the number of times that a network connection may be reused to call methods from one server. The default is 0, which indicates no limit. The default is ideal for short-lived clients. The default may not be appropriate for a long-running client program that calls many methods from servers in a cluster. If sockets are reused indefinitely, the client may build an affinity for servers that it has already connected to rather than randomly distributing its server-side processing load among all the servers in the cluster. In these cases, the property should be tuned to best balance client performance against cluster load distribution. In Sybase testing, settings between 10 and 30 proved to be a good starting point. If the reuse limit is too low, client performance degrades.

Ensure that IIOP protocol tracing is not turned on via the ORBLogIIOP parameter to ORB_init, or via the JAG_LOGIIOP environment variable.

By default, the client ORB attempts to open IIOP connections, then attempts an HTTP-tunnelled connection if plain IIOP fails. Since Web proxy connections require HTTP tunneling, set the following property to true to eliminate the performance overhead of trying plain IIOP connections before trying HTTP-tunnelled IIOP.

CORBA property: com.sybase.CORBA.http
EJB property: com.tunnel.ejb.http

SSL reuses the previously negotiated security session parameters in a number of short-lived connections, which results in a relatively large performance gain over setting up completely new security sessions for each connection. When a security session is reused, clients avoid a CPU-intensive encryption of the premaster-secret using the server's public key. Similarly, servers avoid a CPU-intensive decryption of the premaster-secret using its private key. By configuring these parameters, you can control SSL caching on the server side.

The com.sybase.jaguar.server.http.force.close property specifies whether HTTP-tunnelled IIOP connections should be closed after sending each IIOP response. When debugging proxy configurations, you can set this property to true if it helps your debugging efforts. This setting degrades server performance, so it should only for debugging purposes.

This is an optional property that specifies the length of time, in seconds, to keep a connection alive before it is closed by EAServer. The default value is 120 seconds (2 minutes) and can be modified, if necessary, to improve performance.

This optional property determines the number of requests processed before EAServer closes the connection. The default value is 100 and can be modified, if necessary, to improve performance.

Physical database connects are very expensive. You can reduce the cost using EAServer connection caches. A connection cache maintains a pool of connections to a database\ server, increasing performance by allowing connection sharing and reuse. Since more clients can be serviced using fewer third-tier connections, CPU time and memory are not consumed by opening more connections than necessary.

Disable connection sanity check. When the option is enabled, EAServer verifies that the connection is open and accepts commands before making it available for reuse. Disabling the option increases performance, but may complicate debugging. For example, components may release a connection that is not ready for use by another component, such as when there is unretrieved results on the connection.

JDBC driver properties can also provide good performance boots depending on what you enable/disable.

To help you choose a driver type, read the JavaWorld article " JDBC drivers in the wild" to learn the differences between JDBC driver types, and how to benchmark them.

Performance and Tuning chapter in Programmer's Reference jConnect for JDBC

• SYC Interface
  Ensure that ASE connection caches are defined to use the SYJ interface, since the SYC interface does not utilize the cache at all.
• UNIX File Descriptors
  On UNIX platforms, ensure the operating system allows enough file descriptors to handle the number of connections you wish to allow.

When generating WSDL or SOAP templates, do not include the -d or -t flags for debug or trace output

See TechWave 2001 presentation http://techwave.sybase.com/2001_presentations/ID333.zip

Use operating system tools and utilities to monitor and gather information about process and resource utilization.

Microsoft Windows platforms:

You should always stress test an application before putting it into production. A variety of stress testing tools are available, to help you simulate a load to test if the application will scale and perform at acceptable levels. Some of the tools are available free of cost. For example, OpenSTA is free from http://www.opensta.org/

A whitepaper is available that points out the fundamentals involved in an application server benchmark, and outlines the results for EAServer tests for the nile.com benchmark.

EAServer 4.0 introduces Java-to-IDL and IDL-to-Java code generation optimizations. These optimizations can increase your productivity when you deploy Java based applications with complicated component class hierarchies and when you generate Java stubs for these applications. The J2EE EAR importer, EJB JAR importer, and the Java code generator have been enhanced to allow you to specify a code generation strategy as follows:

• Full - Always generates Java or IDL types for every interface and type.
• Incremental - Compares IDL and Java timestamps to determine whether new versions must be generated. Java timestamps are maintained in a database in the EAServer repository.
• Optimistic - Similar to Incremental, except that the check for changed types in each IDL module or Java package ends if the first comparison indicates no change.