User level      


Additional Requirements

It's not required to install ColdFusion to read this article, however, if you wish to download ColdFusion 8 Update 1 to try the features, you may do so.
ColdFusion 8 Update 1
Note: Read more about ColdFusion 8 Update 1, and download and install the latest Update if you already have installed ColdFusion 8. If you are installing ColdFusion 8 for the first time, the ColdFusion trial or purchased versions downloaded from the Try and Buy links above contain Update 1.
Computer applications have evolved rapidly over the past few decades. From 1971 when the first commercially available single-chip microprocessor, Intel 4004, was released till today—there has been a rapid change in computing. In the early days of 4-bit, 8-bit and 12-bit microprocessors, specialized applications were written, which solved specific computing needs. With the advent of 16-bit microprocessors based on Intel 8086 or Motorola 68000, the applications became more general and grew in complexity. Today most of the microprocessors that are used are 32-bit. These 32-bit microprocessors and the associated system software and applications represent a significant leap from the 16-bit systems and enable the user to run complex applications like databases.
As the applications got more general and complex, the hardware limitations—in terms of performance, scalability, and limit of memory address space—became exposed. The size and volume of data that are handled by these applications are always on the rise. It is due to this fact that each time a higher bit processor has been released, it caused lower-bit processors to become obsolete. The address space limitations of the now widely used 32-bit systems forecast a major constraint. There is now a growing need to migrate to 64-bit systems. Over the last several years, 64-bit systems have started evolving that include Intel x86-64 CPU, AMD Opteron, Intel Itanium, IBM POWER 64 bit architecture, etc. Most of the software vendors too are providing 64-bit applications or 64-bit ‘compliant' applications (32-bit applications that can run on 64-bit platform) to run on these 64-bit systems.
So, what does all this mean for you, a ColdFusion developer? ColdFusion 8 is one of the best and feature-rich releases ever in the history of ColdFusion. The release of ColdFusion version 8.0.1 enhances the ColdFusion 8 release and introduces the support for 64-bit computing platforms. Of course there are many more features and enhancements in the update, but this article helps you understand how to take advantage of 64-bit support of ColdFusion, its benefits and limitations. Comparison of performance of certain features of ColdFusion on 32-bit and 64-bit platforms is also presented.
64-bit computing and its benefits
64-bit computing means that the CPU system has a 64-bit microprocessor and a 64-bit data-bus. However, there are instances where a 64-bit CPU system has a 64-bit microprocessor but has a lower-bit data-bus or vice-versa. In this article, a 64-bit CPU system is considered to have a 64-bit microprocessor which can directly address physical memory with a 64-bit address and that it has a 64-bit data-bus.
The key benefits of 64-bit computing are that it can perform high-precision computations faster than 32-bit systems, and that it can directly address huge amount of physical memory.
64-bit microprocessors process 64-bit data in one clock cycle. All the registers associated with the microprocessors are 64-bit. This enables High- precision computations and 64-bit arithmetic to be performed in fewer clock-cycles as compared to 32-bit microprocessors. In certain cases like 64-bit multiplication, it is twice as fast.
32-bit microprocessors can directly address a maximum of 232 ~= 4 GB of memory, while 64-bit microprocessors have pushed this limit further and can directly address up to a maximum of 264 bytes = ~16 Exabytes = ~17.2 billion GB of physical memory. Practically speaking, this means that applications running on a 64-bit microprocessors have unlimited memory available to them. However, most of the 64-bit systems and operating systems available today pose a limit on the amount of RAM that they can recognize; for instance, Apple Mac Pro can recognize up to 32GB of memory, while Windows 2008 64-bit Enterprise can utilize 2TB of memory—both are still an incredible amount of memory.
In theory, applications that require more memory and have more computations would perform better in 64-bit systems than on 32-bit computing systems. However, there is a limitation associated with the 64-bit systems. The address references are 64-bit wide twice the size compared to 32-bit systems. According to a white paper, IBM WebSphere Application Server 64-bit Performance Demystified:
This results in an increased memory footprint and can reduce hardware cache efficiency. Therefore, applications may actually see a performance loss. General performance expectations for applications that do not specifically leverage 64-bit features are +/- 10% of 32-bit applications.

Java and 64-bit

Now that I have discussed enough of what 64-bit systems provide, let's get specific and check how ColdFusion benefits from being a 64-bit application. First of all, remember that ColdFusion is a Java application; thus, it is important to understand the implications of 64-bit computing on Java.
Sun first introduced a 64-bit version of Java for their Solaris operating system on SPARC processors with Java Development Kit (JDK) 1.4. The JDK 1.5 and JDK 1.6 releases introduced support for the x86-64 processors made by Intel, these processors are widely used by Windows, Linux, and Mac OS×operating systems today. The main implication of 64-bit in Java relates to the heap space used by Java applications and the algorithm used for garbage collection of the objects created on the heap, which I will discuss in the next few paragraphs.
When a Java application executes and creates objects, the objects are stored in a place called heap. The amount of heap space an application can use depends on the operating system, the amount of RAM available in the system, and the amount of memory that the hardware can address. A 32-bit system, as discussed earlier, can support a maximum of 4GB memory. But not all 4GB RAM space is available for use by a single Java application. For instance, an OS uses some of the RAM space. Assuming that the hardware has 4 GB RAM, the maximum heap space a typical application can use would be 1.2 GB to 2 GB. However, this limit is not true for Java applications on a 64-bit CPU system. The value that you can set for the maximum java heap space on a 64-bit CPU system is only limited by the limitations of hardware and the OS (as discussed in the previous section).
You can increase or decrease heap space for Java applications by changing the Xmx value in your Java command line arguments ( also called Java args). In ColdFusion, you can configure Java args in jvm.config, a ColdFusion proprietary file that resides under the<ColdFusion_Root>\runtime\bin folder on standard server installations. On multi-server and JRun deployments, you can find the file under the <jrun_root>\bin directory. On our 32-bit lab machines, we were able to set the Xmx value to a maximum of 1280 MB. When we increased the Java heap space Xmx value to more than 1280 MB and started ColdFusion, the server threw the following error message: "Error occurred during initialization of VM. Could not reserve enough space for object heap." Running ColdFusion as 64-bit effectively removes this limitation.
With the availability of large heap space, large-scale ColdFusion applications (or ColdFusion applications that are memory intensive) can load all the data it needs into memory (caching) as part of boot-strapping effectively reducing the disk/database access that are usually costly. However, large heap space isn’t always a benefit. The memory given to the objects that are created on the heap need to be retrieved once the executing program does not reference the object anymore. Java does this on a separate thread and is called garbage collection. Garbage collection happens at certain intervals of time during the execution of the Java application. As the heap space increases, garbage collection may create large pauses in Java applications if it is not tuned properly. According to the Sun Frequently Asked Questions (FAQ) about Java:
The Hotspot VM comes with a number of garbage collection implementations some of which are targeted at Java applications with large heaps. SUN recommends enabling one of the Parallel or Concurrent garbage collectors when running with very large heaps. These collectors attempt to minimize the overhead of collection time by either collecting garbage concurrent with the execution of the Java application or by utilizing multiple CPUs during collections to get the job done faster.
ColdFusion uses the Throughput/Parallel garbage collector as the default collector for server and multi-server installations and it is enabled by having -XX:+UseParallelGC in the Java arg in jvm.config. For more information on these garbage collection modes and how to select them, refer to the Hotspot garbage collection tuning guide: Tuning Garbage Collection with the 5.0 Java Virtual Machine.

ColdFusion 64-bit support

Adobe introduced 64-bit support for ColdFusion for the first time in ColdFusion 8, which can run on Solaris SPARC. Since that time, Sun has released a 64-bit JDK for Intel x86-64 processors. With the release of this new JDK, along with the efforts from the ColdFusion team to ensure the 64-bit compatibility, the ColdFusion 8.0.1 update has added full 64-bit support for Windows, Linux, and Mac OS X. For complete up-to-date details on ColdFusion 64-bit platform support, refer the ColdFusion platform support matrix.
Most of the functionality and features of ColdFusion run just fine on 64-bit platforms, however, certain features like ColdFusion COM interoperability, ColdFusion Delphi interoperability, and Microsoft Access database connectivity do not work on a ColdFusion 64-bit platform. A few other features, such as ColdFusion .NET integration services and database drivers currently run in 32-bit mode.
Additionally, the cfregistry tag now has a new attribute called registryversion, which is used to handle the existence of two registries on Windows 64-bit operating system.
ColdFusion 64-bit and performance
In this section, I share with you a few of the performance tests that our team performed on a ColdFusion 64-bit configuration and compared it with ColdFusion 32-bit configuration.
Large memory scenario
As I discussed earlier, applications that can use the large memory addressing capability of 64-bit can gain significant performance advantages. To demonstrate this, our team created a ColdFusion script that reads a few large files (around 3 MB each) stored on the disk. The script was run on two configurations of ColdFusion against varying values of the maximum Java heap space (the Xmx value). One of the configurations was ColdFusion 8.0.1 Enterprise Edition 32-bit deployed on a Windows 2003 32-bit operating system. The other configuration was ColdFusion 8.0.1 Enterprise Edition 64-bit deployed on Windows 2003 64-bit operating system. We used JMeter as the client, which sent requests to the ColdFusion servers with 30 no-think time virtual users for five minutes. Note that JMeter was running on a different system. Figure 1 shows the results.
Performance in 32-bit versus 64-bit ColdFusion on Windows
Figure 1. Performance in 32-bit versus 64-bit ColdFusion on Windows
As you can see, the number of requests processed per second (throughput) increases dramatically as the Java heap space is increased. When the physical memory limit is reached, virtual memory usage comes into picture, resulting in the operating system using a lot of disk-swapping operations, causing time delays. On a 64-bit system, with a higher java heap space value set, this limit is reached late due to which disk-swapping is low, resulting in better performance.
In addition to this, on 32-bit operating systems, the maximum number of File-Descriptors that can be created by a process has a limit that is much lower as compared to 64-bit operating systems. This explains the reason for 64-bit systems to perform better at the same Xmx value.
Note that this is a "best-case" scenario. Other applications that are memory-intensive would see a lower performance gain. In this test, on a 32-bit system, the maximum heap space that could be given was 1280 MB, whereas, for a 64-bit system, the maximum heap space we tried was 8192 MB. We could have easily increased the RAM but I think this is enough evidence to demonstrate that memory intensive applications would scale better on 64-bit systems.
Performance of ColdFusion tags on Windows
The next performance test that our team ran was on a few of the ColdFusion tags and functions, such as CFImage and CFDocument tags; the REFindNoCase, CFSwitch/CFCase, pEvaluate, various Date functions, IsDefined, Encrypt, and Evaluate functions; and structures and components. The test was run on the same configurations as used in the previous test; the maximum Java heap space was set at 1280 MB for both of the configurations.
Testing ColdFusion tags, functions, structures, and components in the two configurations on the PC platform.
Figure 2. Testing ColdFusion tags, functions, structures, and components in the two configurations on the PC platform.
As you can see, there are performance gains of around 0-15% in most of the tags. This can be attributed to the fact that most of these tags are computationally intensive and perform better on 64-bit systems.
Performance of ColdFusion tags on Macintosh
The same performance tests were run on the Macintosh platform. Here, one of the configurations was ColdFusion Enterprise Edition 8.0.1 64-bit deployed on Mac Intel 10.4 32-bit OS. The other configuration was ColdFusion Enterprise Edition 8.0.1 64-bit deployed on Mac Intel 10.5 64-bit OS. On both of the configurations, readings were taken with maximum Java heap space at 1280 MB. Default JDKs shipped with these operating systems were used. For Mac Intel 10.5 64-bit OS, JDK 1.5.0_13 is the default JDK. Due to the presence of different JDKs, this would not be an apples-to-apples comparison (the pun absolutely intended), but this is what the end-user would see for results.
Testing ColdFusion tags, functions, structures, and components in the two configurations on the Mac platform.
Figure 3. Testing ColdFusion tags, functions, structures, and components in the two configurations on the Mac platform.
There were huge performance gains, around 10-150%. However there was a drop in performance of the cfdocument tag.
Note that for the above tags’ performance tests, the graphs are normalized such that the bar graph is readable. For example, in case of Windows, the actual throughput for the cfimage tag performance was 5 and 5.75 for 32-bit and 64-bit systems respectively. This data was multiplied by 50 so that the bars are visible for the cfimage tag.
With the addition of full 64-bit support, ColdFusion 8.0.1 has shown the commitment the ColdFusion team at Adobe has for enterprise application development. 64-bit systems are the future of computing and with the ColdFusion 8.0.1 update, you can take advantage of these enterprise features today. Someday soon, 32-bit systems could be a thing of the past.
I would like to acknowledge the help of the following people and resources that contributed to this article: