| August 23, 2009 12:00 AM PDT | |
by George Walsh
Discover the advantages in speed and total cost of ownership that can be achieved in moving to the Linux* operating system running on an Itanium® processor-based platform.
Until Linux* first appeared in 1991, the platform of choice for information technology and corporate networking was undisputedly UNIX*, developed at Bell Labs in the 1960s. However, as the networking needs of organizations has shifted over time to achieve more horsepower with less money, many are now considering the move to the Linux operating system based on the idea that it is a leaner, cheaper, and higher-quality alternative. This paper doesn’t intend to provide a head-to-head comparison of the systems based on Intel® technology with that of specific UNIX*-based systems. It strives only to illustrate the tools and hardware that developers can leverage if they decide to break ranks from the UNIX* world and target their applications toward Linux.
The Intel® processors are uniquely suited to the environment model of Linux systems. The Itanium® brand family of processors is a particularly good match for processes in which the operating system (OS) is frequently used, including technical applications that require intensive floating-point math operations and database applications. As the 64-bit Itanium brand family has become more affordable, so too has its processing power in areas that used to be considered the realm of proprietary 64-bit processors that run UNIX*. In addition, the Intel® Software development tools are designed to help application builders future-proof their applications, in many cases requiring them to merely recompile an application to take advantage of the latest and greatest Intel® processor.
One of the chief reasons for hosting applications on Linux is that it is open-source software; in addition, it is free in its non-commercial incarnations. For developers, this opens the “black box” of the OS to allow them to see how it works and how it can be adapted to their needs. Linux provides all of the benefits of UNIX* in that it is scalable, secure, and flexible. The true benefit of its scalability lies in the fact that it can be run on the relatively inexpensive Intel® Architecture (IA), as opposed to propriety forms of UNIX* that need specific RISC-based silicon. Its inherent scalability means that as processing needs increase, the number of physical processors (or processor cores) on which applications run can be increased in the same manner as one would add processing power to a RISC-based system—at a substantially lower price.
As an example of the potential cost savings inherent in moving to the Linux OS on the Intel® x86 platform, Intel itself realized a substantial savings back in 1998, when it switched its design engineering operations from UNIX* running on RISC platforms to Linux running on Intel® architecture. In Intel’s case, moving to the IA platform running Linux gave the company a 90% performance advantage over the fastest RISC system it tested. The performance gains allowed Intel to reduce the number of servers it purchased for design engineering by 47%. The performance and cost advantages gave Intel a total cost of ownership (TCO) that was around 6% that of a comparable RISC installation for a savings of hundreds of millions of dollars over a three-year period.
While it should be noted that the total savings an enterprise can realize by using the combination of Linux and IA will vary based on factors such as installation size, the learning curve for technical staff, and the type of application the installation is used for, it should also be noted that the amount of performance per dollar has also increased dramatically since 1998.
As mentioned above, Intel saw a substantial reduction in its TCO by moving from UNIX* and RISC-based platforms to Linux on IA. While it could be said that Intel has more to gain by demonstrating the platform’s benefits, a large number of other organizations have experienced the power and reduced cost of Linux running on Intel processors. Users in astronomy, chemistry, physics, engineering, and many educational institutions all take advantage of the OS. If your needs are simple, Linux will run on just about the oldest Intel® x86-based machine. In fact, Linux was developed and optimized for Intel® architecture from the beginning. If your needs require tremendous horsepower, simply add more machines with more processors or move to a 64-bit environment such as the Intel® Itanium-based platform. The University of California’s Lawrence Livermore National Laboratory, for example, currently has one of the world's most powerful supercomputers*. The supercomputer, a Linux-based cluster, makes use of 4,096 Intel® Itanium® processors.
The combination of Linux and IA has also made inroads primarily based on its low cost relative to RISC-based platforms, its scalability due to cluster technology, and a number of other factors. Because Linux is closely related to UNIX*, moving to Linux does not typically have the learning curve associated with an OS change, making it easier for IT staff, developers, and support personnel to use their knowledge of UNIX* to leverage Linux. Because Linux is based on open source code, many find it simple to administer, gain support from experts within the Linux community, and make changes or adjustments to the OS to suit their needs. In addition, relative to TCO, the initial price of an OS is not the only consideration. Operational expenses, licensing fees, and support costs must also be considered, and with Linux, once the system is up and running, there is little or no cost associated with upgrading and licensing (depending on whether a free version or a commercial version of Linux is used).
In areas such as financial applications, Linux is becoming a trusted platform for high-end processing. Many companies realize substantial performance gains in moving applications to Linux on Intel® processors. E*TRADE*, for example, replaced approximately 300 of its servers with Intel/Linux systems and reportedly reduced technology costs by an estimated $65 million in four months. Financial industry giant Merrill Lynch also saw the advantages of improved performance, scalability, availability and lower cost with an Intel® architecture and Linux solution in migrating its application from RISC-based systems to an Intel® architecture-based system r unning Oracle9i* Real Application Cluster (RAC) and Linux. In four months, the new platform showed an immediate two-fold performance improvement over the RISC-based platform and an anticipated 50 percent reduction in TCO. Other large-scale organizations, including FedEx, Amazon.com, and Google also base their systems on the Linux/IA combination.
Cost would mean nothing if the processing power of Intel-based systems didn’t offer an advantage to users. In many areas where Linux is moving to the forefront due to its optimization for the Intel® architecture, floating-point performance is also a key issue. Here is where Intel’s processors really perform. In floating-point performance, the 1.6 GHz 64-bit Intel Itanium processor with 3MB L3 cache has been clocked as being 13% faster than the fastest RISC processor (processors with up to 9MB L3 cache are also part of the Itanium processor family). In addition, this processor has also been benchmarked at 45% faster in Web serving and 56% faster in transactional database processing with greater speed increases to come in the upcoming dual-core (code named Montecito) versions. These impressive results are echoed by the fact that the three leading vendors of RISC servers all now sell 64-bit Itanium processors. To add more weight to Intel’s value proposition, its 64-bit processors are also substantially cheaper, as well as being backward compatible with 32-bit applications to ensure a smooth upgrade path to the faster architecture.
To complement its state-of-the-art hardware, Intel offers a suite of software development tools that include full support for the Itanium platform family and Linux. Intel’s compilers and threading tools provide unprecedented features for identifying threading correctness and threading performance issues. In general, the more threads that a system can execute simultaneously, the higher the system performance. For heavily threaded applications such as those targeted at financial services and the scientific community, taking advantage of these software tools allows developers to use Intel’s hardware to its fullest potential. In addition, because the Linux platform demands less overhead than UNIX*, an application developed for the platform can use more of the system’s processing power.
Intel’s suite of development tools can provide invaluable aid to those seeking to develop applications for Linux or to port a current application to the platform. The Intel® C++ and Intel® Fortran Compilers provide advanced optimizations for high performance applications, including a High Level Optimization option that provides for advanced loop transformations and cache optimizations that are particularly useful for taking advantage of the floating-point performance of the Itanium platform. In addition, standardizing on Intel compilers allows developers to adapt their applications to future Intel processor innovations more easily. Recompiling applications using a new Intel® compiler that were compiled with a previous version gives developers access to the features of new processors as they become available. Intel’s threading tools, performance libraries, and code analysis tools are also invaluable in getting the most out of any application. The following is a brief overview of Intel® development tools that can be of use in developing applications for the Linux platform:
Intel® C/C++ Compiler for Linux: The Intel® C/C++ Compiler 8.1 for Linux includes tools that can aid Linux software developers in creating applications that run at top speeds on Intel processors using Intel® Extended Memory 64 Technology (Intel® EM64T). The compiler integrates with the Eclipse open source integrated development environment and ships with a copy Eclipse to expedite integration efforts. Intel® C/C++ Compiler 8.1 for Linux also continues to provide compilers for the latest Intel® Xeon® processors and allows developers to profile applications given specific workloads using the compiler code-coverage tool. The compiler’s test-prioritization tool reduces testing and debugging time. It also supports automatic and manually precompiled header processing, dramatically improving compilation time. In addition, the compiler enables threading by supporting both OpenMP* and auto-parallelization. OpenMP is effective at threading loop-level parallel problems and function-level parallelism. The compiler also supports auto-parallelization for the automatic threading of loops. This option detects loops capable of being executed safely in parallel and automatically generates threaded code for these loops. The Intel® C/C++ Compiler 8.1 for Linux is compatible with GCC (the GNU Compiler Collection) and widely used Linux application development tools.
Intel® Fortran Compiler for Linux: The Intel® Fortran Compiler for Linux is an ISO Fortran 95 compiler that combines the Compaq Visual Fortran* (CVF*) language features with the code-generation and optimization features of Intel compiler technology. It features over 250 commands that are common to Intel® Fortran and CVF to support the way developers work, preserve investment code bases, and support commonly-used Linux development tools. The Intel® Fortran Compiler for Linux delivers outstanding application performance through optimization technology, threaded application support, and compatibility with leading tools and standards. It also offers compatibility with widely-used Linux utilities, such as make, Emacs and gdb. The compiler allows developers to build performance-sensitive applications that use floating-point operations with highly-optimized, floating-point emulation and dramatically improves application performance in programs that contain many frequently-used small- or medium-sized functions using Interprocedural Optimization (IPO). In addition, it delivers multithreaded application capability with support for OpenMP and auto-parallelism, and supports the Intel® Debugger and Intel EM64T.
Intel® VTune™ Performance Analyzer for Linux: The Intel® VTune Performance Analyzer for Linux helps developers identify lines of code that use excessive resources, helping them to remove performance bottlenecks and achieve higher application speeds on Intel-based systems running Linux. It enables developers to tune the performance of applications using time and event based sampling, hotspot analysis, call graph profiling, sampling information for each source code line, and event ratio di splays. The VTune analyzer provides four vectors of performance tuning applications for Intel’s multi-core Itanium processors: load balancing, thread model tuning, idle time recognition, and micro architectural tuning. Developers can use the Eclipse graphical user interface or a powerful command-line interface on IA-32 and Itanium-based systems for code optimization on Linux host systems or remotely connect to Linux systems running any supported processor.
Intel® Thread Checker: The Intel Thread Checker is a plug-in that resides in the VTune performance analyzer environment to enable the analysis, debugging, and verification of a threaded application. Thread Checker is able to locate many hard-to-catch parallel programming and serial program errors including deadlock detection and prediction, data race detection, thread stalls, API violations, illegal memory access, memory leaks, and failing library routines.
Intel® Thread Profiler: Also available under the VTune performance analyzer environment is the Intel Thread Profiler, which presents multiple views of OpenMP application performance data to help identify performance bottlenecks. Thread Profiler presents the runtime statistics file in various views that can provide a breakdown of the app by threads or by regions within the application. The profile pinpoints the time spent in serial regions, parallel regions, and critical sections, as well as identifying various synchronization overheads.
Performance Libraries: Developers can also make use of the libraries that are a part of the threading tools suite in the Intel® Math Kernel Library (Intel® MKL) and Intel® Integrated Performance Primitives (IPP) libraries to optimize the compute-intensive tasks that are typical in Linux environments. These libraries enable developers to take advantage of highly optimized algorithms that are tuned to get the most out of Intel processors and help support cost-effective migration to next-generation processors, including the Itanium processor family.
The combination of Intel® tools and processors provide developers with unprecedented performance. Multithreading applications to take advantage of the capabilities of Intel® processors allow those who are building applications for the Linux platform to not only make use of the current generation of processors, but also to “future proof” their software to leverage new processor advancements as they emerge. This holds true whether the hardware platform includes Hyper-Threading single processors such as Intel® Pentium® 4 processor 3.06GHz (where two logical processors are contained within one physical processor core), multiple 32-bit processors, multiple 64-bit Itanium processors, or multi-core processors such as Intel’s upcoming dual-core Itanium (code-named Montecito).
As an example of the evolution in processor speed, take a look at the 64-bit Itanium processor family, the workhorse of floating-point performance (key to quickly executing math-intensive tasks). Itanium processors (released in 2003) currently allow several instructions to be executed at once and can process up to six instructions in a single clock cycle. In real-world terms, these pr ocessors are in the area of 25% faster than the first generation of Itanium processors (released in 2001). Running multithreaded applications, the upcoming dual-core version of the Itanium will raise the bar much higher in terms of application speed. The Itanium processor is also the only 64-bit processor in history capable of running four different commercial operating systems.
Dual-core processors are already a reality (as evidenced by the Intel® Pentium® processor Extreme Edition with two full processing cores) and Intel will continue to evolve its silicon offers to provide more features, more cores, and more performance. Applications that take advantage of multithreading technology today will be far easier to adapt to fully realize the potential of future processors.
While substantial benefits in speed and TCO can be achieved in moving from a UNIX*/RISC platform to IA/Linux, a few considerations must be kept in mind before migrating applications to a the new platform. In some cases, the issues inherent in porting C++ applications from UNIX *to Linux can be handled effectively and the transition process streamlined using developer tools from Intel or its partners. In other cases, developers many need to modify their code on a case-by-case basis. The following are key issues that can emerge during the migration process.
Developers who have created applications using a compiler other than GNU C/C++ on UNIX will very likely have to switch compilers when moving to Linux. In the process, compiler flags may have to change to accommodate the Linux platform. The Intel C++ Compiler for Linux, with GNU C/C++ binary compatibility, simplifies this transition. Compliance with ANSI/ISO C++ standards and the availability of advanced compiler optimizations commonly used on UNIX systems also make the Intel C++ Compiler for Linux a good choice for this type of migration.
Every compiler enforces compliance with the ANSI/ISO standard for C++ differently. Developers accustomed to older UNIX compilers often find that newer compilers under Linux more rigorously adhere to ANSI/ISO specifications. Although compilers, including the Intel C++ Compiler for Linux, let developers set options for less strict compliance, developers can produce cleaner code by enabling strict ANSI warning diagnostics. The warnings generated can help remove problems with older, less-compliant code.
Different vendor interpretations of the ANSI/ISO C++ specification have resulted in platform issues with the Standard C++ Library. Changing platforms typically requires changing Standard Library implementations, which, in turn, requires application changes because older Standard Library implementations were written to conform to earlier drafts of the ANSI/ISO standard. The Standard Library is not truly “standard” because different vendors have interpreted the language of the standard differently, so developers should be prepared for code changes.
Most “endian” issues involve applications that were originally developed in the C language. As more developers have moved to the C++ language, modification of the individual bits within data types is much less frequent within the application code. The endian problem occurs when an application designed to run on a typical RISC-based system using big-endian byte order is moved to an Intel processor-based platform, which uses little-endian byte order. If the application includes any routines that directly modify the bits, these sections of code must be updated appropriately.
Almost all versions of UNIX* and Linux* use POSIX* threads. Typically, developers only have to modify applications being ported to Linux if they were written using a threading library other than POSIX*. Very early applications that were written using other threading libraries can require substantial reprogramming for operation under Linux. OpenMP is the industry standard for portable, multithreaded application development, and the Intel C++ Compiler for Linux provides support for OpenMP and automatic parallelization, simplifying the development of portable, multithreaded applications. Automatic parallelization helps developers take advantage of parallelism and improve application performance on multiprocessor systems by enabling the automatic threading of loops. Intel® Threading Tools can also help optimize the efficiency and performance of applications designed for the Linux platform.
In many situations, transitions from UNIX* to Linux* will also be accompanied by a move to a different database version. This creates a situation where companies are not only changing operating systems, but also upgrading to a new version of their existing database. Interfacing with the current database may involve changes to the way the API is used.
Developers need to be aware of internationalization issues when changing platforms. The existence of several different internationalization types creates a challenge when moving from UNIX* to Linux. UNIX* typically uses the wide character type to represent internationalized strings. Windows leans towards Unicode. Linux, being much like UNIX*, provides wide character-type support. In addition, developers can access the open source Internationalized Character Union (ICU) library under different versions of UNIX and Linux, enabling access to Unicode in each environment. Each of these types is treated differently and introduces complexity when migrating between platforms. For example, this variation could cause problems for developers moving from an older UNIX platform to Linux, or for those who previously used wide characters and now want to start using the ICU approach.
In the past, developers porting applications to Linux were limited to 32-bit versions of the operating system. With the release of a 64-bit version of Linux and widespread acceptance of enterprise servers powered by the Intel Itanium family of processors, more Linux applications are being targeted for 64-bit implementations. Transitioning an application designed for 32-bit processing to a 64-bit platform always presents challenges. The degree of difficulty in making the transition depends on what level of abstraction the developers used with data types when initially coding the application. As a rule of thumb, the more abstracted the data types, the less difficult the transition from 32-bit to 64-bit (or vice versa). Frequently, companies that have been running UNIX* have applications designed for 64-bit use. If developers are considering migrating to Linux, the applications may be targeted for either a 32-bit platform or a 64-bit platform such as the Itanium processor family. The Intel C++ Compiler includes optional diagno stics that warn of 64-bit migration issues.
Direct operating-system calls can cause problems in the behavior of an application if not corrected during a platform migration. Calls that are designed for operation under UNIX may not apply when running Linux. These types of application issues can’t be readily solved by development tools, but must be individually identified and corrected by developers.
Applications that make extensive use of dynamic memory may experience a performance slowdown when moving from UNIX* to Linux*. Performance improvements can be gained through optimization tools, such as Intel Threading Tools. Intel Thread Checker and Intel Thread Profiler can systematically evaluate the behavior of multithreaded tasks and indicate areas where performance achievements can be gained. These tools can also pinpoint other inefficiencies in the way multithreaded tasks are performed, providing opportunities for the developer to tune the application for optimal performance under Linux*.
While it is unlikely that any development effort will encounter all of these challenges, it is important to realize that they exist and include them in any analysis related to TCO. However, due to the low cost of the Linux/Intel platform and the reduced cost of maintaining and upgrading the operating system, the price of adapting to an Intel-based Linux platform is typically far outweighed by the overall savings in implementation and ownership.
The benefits of moving systems and applications from RISC and UNIX* to Intel and Linux* based systems have been proven time and again by companies of many sizes. These benefits are so prevalent, in fact, the many readers may not be looking at migration but at using the solution from the start as a backbone for their enterprise. Intel processors are both faster and cheaper than RISC processors, and Linux—from both an initial cost and maintenance cost perspective—is also a proven means of reducing expenditures. Combined, they serve to increase performance and future-proof enterprise systems. Using Intel software tools makes the prospect yet more attractive by guaranteeing backwards compatibility with previous processor versions and providing a clear upgrade path as new processors emerge. In the end, it is clear that the Linux/Intel solution will soon be the basis of the vast majority of enterprise applications.
- Migrating to Linux* on Intel® Architecture (PDF 333KB)
- Intel's Itanium Processor Family: The Roadmap
- Intel® Itanium® Processor Technical Documents
- Linux* and Financial Markets
- Achieving Successful UNIX*-to-Linux* Migration: The Value of Developer Tools from Rogue Wave Software and Intel
- Intel® C++ Compiler for Linux*
- Intel® Fortran Compiler for Linux
- Intel® VTune Performance Analyzer for Linux
- Intel® Thread Checker for Linux
- Intel Thread Profiler for Windows
At this time, there is no Linux* version of Intel(R) Thread Profiler offered as a separate product. Customers requiring Linux* support should purchase the Windows* version and download, from Intel® Premier Support (accessible after registering your software product for support), the Linux* data collector that we are offering at no additional charge with the v3.0 product. A Windows* machine will be required to analyze the collected results.
George Walsh is a veteran technical editor and writer with experience in fields ranging from embedded systems programming to CAD. As a freelance researcher and writer he has provided his expertise to clients in a wide variety of markets.
For more complete information about compiler optimizations, see our Optimization Notice.
