The IBM Parallel Environment (PE) Developer Edition
IBM Redbooks Solution Guide
Published 13 September 2013
Rate and comment
Authors: Dino Quintero, Feng Dong, Jose Higino, Peter Mayes, Kleber Sacilotto de Souza, Wainer dos Santos Moschetta, Xiao Tian Xu
This IBM® Redbooks® Solution Guide describes how to take advantage of the strengths of IBM PE Developers Edition for HPC applications and solve customer challenges and maximize system throughput, performance, and management. This Solution Guide examines the tools, utilities, documentation, and other resources that are available to help IBM technical teams provide solutions and support for IBM HPC solutions in an IBM hardware environment.
Related Blog Posts
IBM® PE Developer Edition provides an Eclipse-based development environment that allows developers to edit, compile, run, and debug applications all from within the framework. It also includes a set of performance tools that helps the developer analyze the performance of an application. IBM PE Developer Edition provides an integrated development environment (IDE) that combines open source tools, and IBM developed tools to fulfill the following requirements:
- Editing, compiling, running, and debugging an application
- Performing static analysis of an application to find programming problems
- Analyzing the performance of serial and parallel applications
- Interactively running and debugging parallel applications
- Submitting batch serial or parallel jobs to IBM LoadLeveler®
IBM PE Developer Edition consists of two major integrated components:
- A client workbench that runs on a desktop or notebook computer
- A server that runs on select IBM Power Systems™, IBM PureFlex™ Systems, IBM System x®, and iDataPlex® servers
The client workbench is built upon the Eclipse platform and provides a set of tools to improve the productivity of high performance and technical computing developers. The client component contains the Eclipse IDE, Parallel Tools Platform (PTP), and client code for the IBM High Performance Computing (HPC) Toolkit. The server component contains instrumentation libraries and tools for the IBM HPC Toolkit and X11-based GUI tools that can be used, if necessary, in place of the client-side IBM HPC Toolkit plug-in.
Figure 1 shows the overall architecture of the IBM PE Developer Edition.
Figure 1. Architecture of IBM PE Developers Edition
Did you know?
IBM PE Developer Edition Multiplatform provides an Eclipse-based development environment combining open source tools and IBM proprietary tools. IBM PE Developer Edition consists of two major components that are integrated:
- A workbench component that runs on a desktop or notebook
- A server component that runs on select IBM Power Systems, IBM PureFlex Systems, and iDataPlex servers
The workbench component contains an industry standard, innovative workbench client IDE for enhancing the productivity of high performance and technical computing programmers. The server component contains the IBM High Performance Computing (HPC) Toolkit, which is used to analyze and tune the performance of application programs. It also contains Scalable Communication Infrastructure (SCI), which is a communication library and run time for a tools developer to use as infrastructure in developing scalable tools.
On Linux, the names of the RPM Package Managers change to reflect a single RPM for each platform. Considering that, when upgrading software, the current RPMs must be removed and then the new RPMs are installed. There is no impact on the migration. On IBM AIX®, the name of the packages does not change; so, there is no impact on this platform. IBM PE Developer Edition supports only a homogeneous environment, where all the nodes in the cluster are using the same level of IBM PE Developer Edition.
IBM PE Developer Edition combines a number of tools to provide a complete development environment for high performance and technical computing. These tools support features that enable developers to perform the complete range of programming tasks, such as editing, compiling, running, and debugging serial and parallel applications. Supporting these features directly within the workbench results in improved developer productivity.
Developers can use the following standard Eclipse features:
- Code assist
- Interactive code completion
- Syntax-directed highlighting of source code
- Built-in help information, including hover help, to assist developers as they are writing code
Developers can use the following PTP features:
- Edit and compile applications on remote systems.
- Use source code cross referencing tools.
- Perform static analysis of source code.
- Run applications on remote systems using various job schedulers and runtime systems.
Developers can also use the following integrated performance analysis tools features:
- Analyze application code and locate performance problems.
- Analyze resource usage.
- Perform MPI profiling and tracing.
- Perform input/output (I/O) profiling.
The Eclipse Parallel Tools Platform (PTP) integrated development environment (IDE) editor increases developer productivity by providing coding assist tools, such as interactive code completion and syntax-directed highlighting of source code. PTP provides an integrated environment for the developer to complete the edit, and compile, debug, run cycle, and source analysis tools to help identify coding problems in the application. This is referred to as the workbench. The IBM High Performance Computing (HPC) Toolkit allows the developer to analyze application performance, including processor resource usage, MPI tracing and profiling, OpenMP profiling, and I/O tracing and profiling.
IBM PE Developer Edition provides an Eclipse-based development environment that combines open source tools and IBM proprietary tools to satisfy the following requirements:
- Edit, compile, run, and debug an application.
- Perform static analysis of the application to find common programming problems.
- Analyze application performance for serial and parallel applications.
- Easily run and debug parallel applications using IBM PE interactively.
IBM PE Developer Edition consists of two major components that are integrated:
- A workbench component that runs on a desktop or notebook
- A server component that runs on select IBM Power Systems, IBM PureFlex Systems, and iDataPlex servers
The workbench component contains an industry standard, innovative workbench client IDE for enhancing the productivity of high performance and technical computing programmers. The server component contains the IBM High Performance Computing (HPC) Toolkit, which is used to analyze and tune the performance of application programs. It also contains Scalable Communication Infrastructure (SCI), which is a communication library and run time for a tools developer to use as infrastructure in developing scalable tools
IBM PE Developer Edition supports three project types:
- Local: A local project is where source code is held only on the local machine. With a local project, building an application and starting an application usually occurs only on the local machine.
- Synchronized: A synchronized project is where source code is held on both the local and remote machines and synchronized between the two. Building an application and starting an application occur either locally or remotely. Because the source code is available locally, editing can use all the Eclipse workbench features, and response is fast. Work can continue locally even if the network connection to the remote machine is lost.
- Remote: A remote project is where source code is held only on the remote machine. Building an application and starting an application occur only on the remote machine. Source code is brought only to the local machine in an editor buffer when a file is edited. A reliable and consistent network connection is required to work easily with remote projects, but all the files do not have to be mirrored on the local machine.
This Solution Guide mainly focuses on synchronized projects to demonstrate the flexibility of the IBM PE Developer Edition tools. Furthermore, for C/C++ and Fortran projects, you can use two build types:
- Makefile: A makefile project contains one or more makefiles for building an application. The user provides the makefile. Any type of command can be used for the build. Scripts can call a collection of tools, including makefiles. A makefile project just means that you control the build commands.
- Managed: A managed project does not require a makefile, and Eclipse manages the application build process. Eclipse writes a makefile under the covers.
IBM PE Developer Edition Multiplatform V1.3 provides the following features:
- In an AIX environment, the use of libmpitrace from IBM PE Developer Edition with an MPICH2 MPI program
- Support for iDataPlex hardware counters for systems with Intel IvyBridge processors and for IBM POWER7+™ systems
- A streamlined sequence to instrument and start the application
- Enhancements to the PTP developer workflow and the integration of module support
- Enhancements to the IBM Platform LSF® target system configuration in PTP (application launch), and support in PTP for running IBM Platform MPI applications
The performance analysis tools that are integrated with the IDE help developers locate performance problems in their application code, including tools to analyze processor resource usage, MPI profiling and tracing, OpenMP profiling, and I/O profiling. These performance management tools might improve systems availability. Performance management tools allow you to optimize the use of computing resources, thereby protecting those investments. The performance tools that are provided by IBM PE Developer Edition can help you understand the utilization of system resources concurrently so you can balance your workloads or tune programs. By maximizing system resource utilization, you can optimize your system and network performance.
The Eclipse framework provides the foundation for the IBM PE Developer Edition. Eclipse is a technology platform that was originally an IDE. Today, Eclipse is used as the foundation for many different types of tools. Eclipse is also an Open Source Project. The Eclipse Public License is Open Source Initiative (OSI) certified. The Eclipse community is also an important part of the platform, and there are hundreds of companies and thousands of programmers working to improve and extend Eclipse all the time.
Figure 2 shows a high-level architectural view of Eclipse. You can develop stand-alone Rich Client Platform (RCP) applications. You can also use many different development tools, such as the C/C++ Development Tooling that extend the Eclipse platform, and you can also develop additional plug-ins using the Plug-in Development Environment (PDE).
Figure 2. High-level Eclipse architecture
Figure 3 shows core components of the Eclipse platform, such as the workbench, help system, and team components.
Figure 3. Eclipse components and some example plug-ins
Here are some key concepts and definitions of Eclipse:
- Workspace: The workspace is a physical location on a computer. It contains projects, folders, and user files. For IBM PE Developer Edition users, it contains their application source files, makefiles, and so on. A project is a collection of folders and files for a particular task. A folder is a subdirectory and can contain folders and other files. A file is just a file. A workspace is just a directory. The first time that you run Eclipse, you are prompted to choose a workspace. You can also create many different workspaces. To switch to another workspace, click File -> Switch Workspace in the Eclipse main menu.
- Workbench: The workbench is the Eclipse environment. When you open Eclipse, you see a workbench that displays the resources in a particular workspace. A resource is a file, such as an application source file. A workbench contains perspectives, views, and editors.
- Perspective: A perspective is a set of views that is organized for a particular task. If you are writing C/C++ or Fortran code, certain views are useful. If you are debugging C/C++ or Fortran code, other views are useful. A perspective lets you arrange the views that you need. IBM PE Developer Edition comes with several perspectives installed. If you install plug-ins for various tasks, other perspectives might appear. You can customize a perspective in many ways. For example, you can change the views that are part of a perspective, or you can change how those views are arranged on the window. To define which menu items and toolbar buttons are available for a given perspective, click Window -> Customize Perspective.
- View: A view is a window on some resources in your workspace. For example, one view might list all the files in your workspace. You can open and close and arrange views in any way you want. Two views might display the same thing in different ways. To open a view at any time, click Window -> Show View. To see a complete list of views, click Window -> Show View -> Other. Views can also be stacked.
- Editors: Use an editor to modify a resource. There are different kinds of editors for different kinds of resources. Like all views, editors can be stacked.
- Preferences: Eclipse has a number of preferences that you can set. Preferences are settings, such as default values for options in Eclipse or preferences that can control the behavior of Eclipse components, such as the behavior of views. If you install a new plug-in, that plug-in can also have preferences. As a result, your Eclipse installation can have many settings. To get to the Preferences window, click Window -> Preferences.
IBM Parallel Environment (PE) Runtime Edition is a capability-rich development and execution environment for parallel applications. IBM PE Runtime Edition offers parallel application programming interfaces (APIs) and execution environment for parallel applications.
Parallel Environment Runtime Edition includes the following components:
- The Parallel Operating Environment (POE) for submitting and managing jobs
- The IBM MPI, PAMI, and LAPI libraries for communication between parallel tasks
- A parallel debugger (pdb) for debugging parallel program
The IBM Parallel Operating Environment (POE) enables users to develop and run parallel applications across multiple operating system images (nodes). POE includes parallel application compile scripts for programs that are written in C, C++, and Fortran, and a command-line interface to submit commands and applications in parallel. POE also provides an extensive set of options and additional functions to fine-tune the application environment to suit the execution of the application and system environment.
POE is used to set up the environment for the user’s parallel program and to control and monitor job execution. You can use the resource manager of your choice for submitting and managing batch or interactive parallel jobs. IBM PE Runtime Edition includes a set of resource management interfaces and data areas for configuring your resource manager to interact with POE. Integration with IBM Tivoli® Workload Scheduler LoadLeveler: IBM PE Runtime Edition allows users to run POE jobs in interactive or batch mode with LoadLeveler managing the node, network, processor, memory, and other key resources for optimum throughput and resource utilization.
The IBM MPI is a complete MPI 2.2 implementation that is designed to comply with the requirements of the MPI standard. IBM MPI supports the MPI 2.1 process creation and management scheme. The IBM design is enabled by using static resources that are allocated at job start time. The IBM MPI provides many non-blocking collective communications subroutines that are available for parallel programming. These subroutines are extensions of the MPI standard. Collective communications routines for 64-bit programs were enhanced to use shared memory for better performance. The IBM MPI collective communication is designed to use an optimized communication algorithm according to job and data size. The IBM MPI provides a high scalability and low memory usage implementation. The IBM MPI library minimizes its own memory usage so that an application program can use as much system resources as possible. It is designed to support parallel job size of up to one million tasks. IBM MPI runs over PAMI. This is achieved through using the PAMI APIs. For Linux, PE Runtime Edition also includes an MPICH2 MPI implementation that can be used as an alternative to the IBM MPI implementation.
IBM PAMI is a converged messaging API that covers both point-to-point and collective communications. PAMI uses the low-level user space interface to the Host Fabric Interface (HFI) and TCP/IP using UDP sockets.
PAMI has a rich set of collective operations that are designed to support MPI and pGAS semantics, multiple algorithm selection, and non-blocking operation. It supports non-blocking and ad hoc geometry (group/communicator) creation and non-blocking collective allreduce, reduce, broadcast, gather(v), scatter(v), alltoall(v), reduce scatter, and (ex)scan operations. The geometry can support multiple algorithms, including hardware-accelerated (through HFI Collective Acceleration Unit, or Barrier Service Register) versions of broadcast, barrier, allreduce, and reduce.
The low-level application programming interface (LAPI) is a message-passing API that provides a one-sided communication model. In this model, one task initiates a communication operation to a second task. The completion of the communication does not require the second task to take complementary action. The LAPI library provides basic operations to “put” data to and “get” data from one or more virtual addresses of a remote task. LAPI also provides an active message infrastructure. With active messaging, programmers can install a set of handlers that are called and run in the address space of a target task on behalf of the task that originates the active message. Among other uses, these handlers can be used to determine dynamically the target address (or addresses) where data from the originating task must be stored. You can use this generic interface to customize LAPI functions for your environment. LAPI is meant to be used by programming libraries and by power programmers for whom performance is more important than code portability. MPI and LAPI provide communications between parallel tasks, enabling application programs to be parallelized. MPI provides message passing capabilities that enable parallel tasks to communicate data and coordinate execution. The message passing routines call communication subsystem library routines to handle communication among the processor nodes. LAPI differs from MPI in that it is based on an active message style mechanism that provides a one-sided communications model in which one process initiates an operation and the completion of that operation does not require any other process to take a complementary action. LAPI is also the common transport layer for MPI and is packaged as part of the AIX RSCT component.
The parallel debugger (pdb) streamlines debugging of parallel applications, presenting the user with a single command-line interface (CLI) that supports most dbx/gdb execution control commands and provides the ability to examine running tasks. To simplify management of large numbers of tasks, dbx/gdb allows tasks to be grouped so that the user can examine any subset of the debugged tasks. The pdb allows users to start a POE job or attach to a running POE job and place it under debug control. It starts a remote dbx/gdb session for each task of the POE job that is put under debugger control.
IBM Parallel Environment Developer Edition is an Eclipse-based integrated set of application development tools that help you develop, debug, and tune your parallel applications. It includes a set of standard Eclipse components and additional support for IBM environments. The IBM PE Developer Edition also includes the IBM HPC Toolkit (HPCT), which is a collection of tools that you can use to analyze the performance of parallel and serial applications, which are written in C or Fortran, that are running the AIX or Linux operating systems on IBM Power Systems servers. Applications running on Red Hat Enterprise Linux 6 on IBM System x servers with the Intel microarchitecture codename Nehalem, Westmere, and Sandy Bridge family of processors are also supported. The Xprof GUI also supports C++ applications.
The Parallel Tools Platform (PTP) is an Eclipse-based application development environment that contains an integrated set of tools to help you edit, compile, run, debug, and analyze your parallel application that is written in C, C++, and Fortran. Advanced tools that are included with PTP include static analysis tools to locate errors before the code is compiled, refactoring tools to modify code while preserving behavior, and an integrated parallel debugger. PTP supports a broad range of architectures and job schedulers and provides the ability to easily add support for additional systems. The C/C++ Development Tooling provides a fully functional C and C++ IDE based on the Eclipse platform. Photran is an IDE and refactoring tool for Fortran based on Eclipse and the C/C++ Development Tooling.
These tools perform the following functions:
- Provide access to hardware performance counters for performing low-level analysis of an application, including analyzing cache usage and floating-point performance.
- Profile and trace an MPI application for analyzing MPI communication patterns and performance problems.
- Profile an OpenMP application for analyzing OpenMP performance problems and to help you determine whether an OpenMP application properly structures its processing for best performance.
- Profile application I/O for analyzing an application’s I/O patterns and whether you can improve the application’s I/O performance.
- Profile an application’s execution for identifying hotspots in the application and for locating relationships between functions in your application to help you better understand the application’s performance.
IBM PE Developer Edition provides features that augment the C/C++ Eclipse editor for ease of using PAMI and LAPI APIs, locating them in the source code, getting information about API usage and arguments, and so on. IBM PE Developer Edition provides a source-linked view of items that are identified by the IBM XLC/XLF Compiler Transformation reports.
The software requirements for the IBM PE Developer Edition server component are one of the following items:
- The toolkit component, when running on Linux operating system on IBM POWER® servers, requires Red Hat Enterprise Linux 6.3 or 6.4.
- Note: To run parallel operating environment jobs, IBM PE Runtime Edition for Linux on Power Systems V1.3 is required.
- The toolkit component, when running on IBM AIX operating system servers, requires IBM AIX V7.1 with Service Pack 3 or later.
- Note: To run parallel operating environment jobs, IBM PE Runtime Edition for AIX V1.2 is required.
- The toolkit component, when running on Linux operating system on x86 servers, requires Red Hat Enterprise Linux (RHEL) 6.3 or 6.4 or SUSE Linux Enterprise Server (SLES) 11 SP2 or SP3.
To run parallel operating environment jobs, IBM PE Runtime Edition Multiplatform V1.2 is required.
Note: Running batch parallel operating environment jobs requires the usage of a job scheduler that provides support for the common resource manager interface that is used by a parallel operating environment. Examples of supported job schedulers are IBM Platform LSF, SLURM, PBSPro, and IBM LoadLeveler.
The workbench component uses one of the following operating systems:
- Microsoft Windows XP (32-bit)
- Microsoft Windows 7 (32-bit or 64-bit)
- Red Hat Enterprise Edition (RHEL) 5 (32-bit or 64-bit)
- RHEL 6 (32-bit or 64-bit)
- SUSE Linux Enterprise Server (SLES) 11 (32-bit or 64-bit)
- Apple Mac OS X 10.6 (64-bit)
Note: The Windows and Linux operating systems require Java Runtime 7.0.0, provided with IBM PE Developer Edition. Mac OS uses the Java run time that is distributed with the Mac OS X operating system. For all environments, check the IBM service site, Fix Central, for required updates to IBM PE Developer Edition. For Parallel Operating Environment (POE) jobs, IBM PE Runtime Edition for Linux on x86 Architecture V1.2 is required. Additionally, for batch jobs, LoadLeveler for Linux on x86 Architecture V5.1 is required.
The software requirements for the IBM PE Developer Edition client component are one of the following operating systems:
- Microsoft Windows XP, 32-bit
- Microsoft Windows 7, 32-bit or 64-bit
- RHEL 5, 32-bit or 64-bit
- RHEL 6, 32-bit or 64-bit
- SLES 10, 32-bit or 64-bit
- SLES 11, 32-bit or 64-bit
- Apple Mac OS X 10.6, 64-bit
- Apple Mac OS X 10.7, 64-bit
For server-side systems (toolkit), the supported hardware includes the following hardware:
- IBM Power Systems or IBM PureFlex System compute nodes, which are based on POWER7® or POWER7+ technology with supported adapters and switch
- Stand-alone POWER7 or POWER7+ clusters, or POWER7 or POWER7+ clusters that are connected with a LAN supporting IP
- IBM System x iDataPlex
- IBM Intelligent Cluster™
- Select IBM System x servers
Note: For supported levels, compatibility, and limitations regarding adapter and switch support, see the readme file that is located under documentation and IBM High Performance Computing Clusters Service Packs sections at https://www.ibm.com/developerworks/wikis/display/hpccentral/HPC+Central.
Ordering information is shown in Table 1.
Table 1. Ordering part number and feature code
|Program name||Program number||VRM|
|IBM PE Developer Edition Multiplatform||5725-M46||1.3.0|
For IBM Passport Advantage®, use Product group: Technical Computing, Product Identifier Description (PID), IBM PE Developer Edition Multiplatform (5725-M46), Product category: Other software. Passport Advantage ordering information is shown in Table 2.
Table 2. Ordering part numbers and feature codes
|Program name||Description||Part number|
|IBM PE Developer Edition Multiplatform V1.3||Toolkit||BH041EN|
|IBM PE Developer Edition Multiplatform V1.3||Workbench||BH042EN|
|IBM PE Developer Edition Multiplatform - Toolkit||per Install LIC+SW MAINT 12 MO||D11CULL|
|IBM PE Developer Edition Multiplatform - Toolkit||per Install ANNUAL SW MAINT RNWL||E0IBVLL|
|IBM PE Developer Edition Multiplatform - Toolkit||per Install SW MAINT REINSTATE 12 MO||D11CVLL|
|IBM PE Developer Edition Multiplatform - Workbench||per Client Device LIC+SW MAINT 12 MO||D11CWLL|
|IBM PE Developer Edition Multiplatform - Workbench||per Client Device ANNUAL SW MAINT RNWL||E0IBWLL|
|IBM PE Developer Edition Multiplatform - Workbench||per Client Device SW MAINT REINSTATE 12 MO||D11CXLL|
For more information, see the following documents:
- IBM Parallel Environment (PE) Developer Edition, SG24-8075
- Parallel Environment (PE) product page
- Product information is available through the Offering Information website
- Product offering information is also available through the Passport Advantage website
- IBM Offering Information page (to search on announcement letters, sales manuals, or both):
On this page, enter IBM PE Developer Edition, select the information type, and then click Search. On the next page, narrow your search results by geography and language.
The following publications are available from the web:
- IBM High Performance Computing Toolkit Installation and Usage Guide, SC23-6940
- IBM Parallel Environment Developer Edition Eclipse Client for AIX and Linux Installation Guide, SC23-7030
To access the above documentation, see the IBM Cluster Information Center website. This website contains the most recent documentation in PDF and HTML formats and is at http://publib.boulder.ibm.com/infocenter/clresctr/vxrx/index.jsp.
Note: IBM PE Developer Edition does not provide IBM-specific PTP documentation; PTP documentation is included within the PTP plug-ins that are part of the IBM PE Developer Edition installation.
Others who read this publication also read
This material has not been submitted to any formal IBM test and is published AS IS. It has not been the subject of rigorous review. IBM assumes no responsibility for its accuracy or completeness. The use of this information or the implementation of any of these techniques is a client responsibility and depends upon the client's ability to evaluate and integrate them into the client's operational environment.
Follow IBM Redbooks
Follow IBM Redbooks