Download PDF (1.3 MB) - IBM Redbooks

2.6 Considerations for 64-bit mode
You can run Business Process Manager applications by using either 32-bit or 64-bit JVMs.
However, we suggest 64-bit mode for both Process Server and Process Center because in
32-bit mode, the maximum heap size is limited by the 4 GB address space size. In most 32-bit
operating systems, the practical heap size maximum varies in the range of 1.5 GB and 2.5
GB. In contrast, although maximum heap size is essentially limitless in 64-bit mode, standard
Java best practices still apply (for example ensure sufficient physical memory exists to back
the heap).
The sum of the maximum heap sizes and native memory use of all the Java processes
running on a system should not exceed the physical memory available on the system. This
total also includes additional memory required for the operating system and other
applications. Java processes include threads, stacks, and just-in-time (JIT) compiled code.
Business Process Manager V8.0 servers run most efficiently on a 64-bit JVM instance
because of the much larger amount of memory that is accessible in this mode. The
performance and memory footprint of a 64-bit runtime server is about the same as the 32-bit
version.
Consider the following factors when determining in which of these modes to run:
► The 64-bit mode is an excellent choice for applications whose live set approaches or
exceeds the 32-bit limits. Such applications either experience OutOfMemory exceptions or
suffer excessive time in garbage collection (GC). We consider anything greater than 10%
of the time in GC as excessive. These applications exhibit much better performance when
allowed to run with the larger heaps they need. However, sufficient physical memory on
the system must exist to back the Java heap size.
► The 64-bit mode is also an excellent choice for applications that, although well-behaved in
32-bit mode, can be algorithmically modified to perform better with larger heaps. An
example might be an application that frequently persists data to a data store to avoid
maintaining a very large in-memory cache, even if such a cache greatly improves
throughput. Re-coding such an application to trade off the additional space available in
64-bit heaps for less execution time yields better performance.
► Moving to 64-bit can cause some degradation in throughput if a 32-bit application fits well
with a 1.5 GB to 2.5 GB heap and the application is not expected to grow significantly. For
these situations where the memory limitation is not a significant factor, using 32-bit JVMs
might be a better choice than 64-bit.
Chapter 2. Architecture best practices 21