SGI's ProDev WorkShop is a comprehensive programming environment offering an integrated set of powerful and highly visual tools for creating, debugging, and tuning software.
For All Stages of Software Development
ProDev WorkShop covers all phases of software development - from initial coding through debugging and perfomance tuning - with powerful graphics to speed development. Whether you're programming in C, C++, Fortran, or Ada, for single-processor workstations or multi-processor servers, ProDev WorkShop has a complete set of tools.
- Visual tools speed programming - help you create better software faster
- Includes a static analyzer, source-level debugger and powerful performance analyzer
- Tight integration of tools saves time and improves productivity
- Works with C, C++, Fortran and Ada
- Supports MP debugging and code development for parallel processor systems
The WorkShop Debugger is a state-of-the-art source-level debugger featuring multiple graphical views that are dynamically updated during a program execution. It was written from the ground up by SGI developers to provide functionality unavailable in standard UNIX debuggers. It is tightly integrated with the other tools, particularly the Performance Analyzer, providing increased efficiency for overall program analysis.
In large-scale development efforts, the Debugger provides unparalleled support for large programs. Other debuggers that provide such high levels of functionality often cannot handle programs over 50,000 lines of code. Not only can the Debugger handle millions of lines of source and executables over 100MB, it facilitates the debugging effort by providing different views into the code, which allows for better understanding of large amounts of data.
Fix & Continue
Fix & Continue gives you the ability to make changes to a program you are debugging without having to recompile and link the entire program. You can edit a function, parse the changes and continue execution. Fix & Continue significantly speeds up the development cycle. Fix & Continue lets you:
- Redefine existing function definitions
- Disable, re-enable, save and delete redefinitions
- Set breakpoints in and single-step within redefined code
- View the status of changes
- Examine differences between original and redefined functions
Enhanced Productivity through Visualization
Tools such as the 3-D Array Visualizer and the Structure Browser allow users to identify problems in their code by examining the visual representation of the expressions or data. The Debugger provides 15 different "views" into a program that are dynamically updated as the user steps through the program.
Fast Data Watchpoints
Most debuggers that support watchpoints do so by single-stepping the target process, thereby slowing the program down by several orders of magnitude. The WorkShop debugger, with support from the IRIX(tm) operating system, implements fast data watchpoints that permit better performance of the target process than traditional implementations.
Source Level Expression Evaluation
The WorkShop debugger allows programmers to evaluate FORTRAN, C and C++ expressions in their native syntax. The Debugger has extensive support for C++ expressions such as static and non-static data members, virtual functions, multiple inheritance and virtual base classes.
Multiple Process and Distributed Debugging
MP View provides debugging support for programs that have multiple processes or have been parallelized. It permits automatic or manual specification of process groups and provides individual and group process control. Traps can be set to stop a single thread or all threads. The Debugger is based on a client/server model, allowing distributed debugging.
Three views provide powerful machine-level debugging capabilities: Register View, Memory View and Disassembly View. Each view allows the modification of the values it displays. The Disassembly View allows disassembly of the displayed code by address, function or file.
Efficient access to most dbx commands is provided for those who prefer a command line interface.
SGI SpeedShop - powerful performance analyzer
The ProDev WorkShop performance analyzer tool SpeedShop helps the user eliminate bottlenecks and bugs, maximize overall application performance, and improve quality. Bottlenecks occur in CPU utilization, memory latency, system calls, and kernel interruptions. SpeedShop provides a wide variety of performance experiments to help you identify bottlenecks, pinpoint system resource usage, and detect memory leaks.
Graphical views clearly depict which resources are being under- or overutilized. Time calipers let you zoom in on specific sections of code for detailed tuning. SpeedShop has several views, all of which can be used to look at the performance of each thread of an executing program:
- Resource usage view-helps identify CPU and I/0 bottlenecks
- Function list-shows the performance cost of each function
- Call graph view-displays function relationships during execution (e.g., who called whom and how often)
- I/O view-displays I/O activity on a file-descriptor basis
- Butterfly view-for viewing MPI experiment data, new with version 1.4.4
Performance Data Sampling Paradigm
SpeedShop utilizes a sampling paradigm that allows the collection of performance data at specified points during program execution and analysis of that data during the different phases of the program execution. The sampling paradigm is critical for very large programs, as it allows for analysis of specific portions of the program, and tuning of each portion, individually.
SpeedShop provides valuable output for analyzing application performance. It provides a toolbox of experiments that can be applied to analyze your application's performance. The output of each experiment is analyzed with either SpeedShop's prof and sscompare tools, or by the more graphically oriented cvperf tool that is part of ProDev WorkShop. The following experiments are currently available in SpeedShop:
PC Sampling-Periodically samples the PC (program counter) value in your running application; allows you to determine what functions in your application are consuming the largest amount of CPU time
Call Stack Sampling-Similar to PC sampling, but stores the entire call stack of your application at each sample; allows you to determine what call chains in your application are consuming the largest amount of CPU (or wall-clock) time
Basic Block Counting-Instruments your binary code to determine precisely how many times each machine instruction, source line, and function in your application were executed
Floating-Point Exception Tracing-Records details about each floating-point exception that occurred in your application, including where the exception occurred
Heap Tracing-Records information about each malloc() and free() call your application makes; allows you to identify the source of various types of memory allocation bugs
I/O Tracing-Records the amount of time taken, and the number of bytes transferred, by the major I/O functions such as read() and write()
MPI Tracing-Records the amount of time taken in MPI routines within an MP application. The time taken can be mapped back to specific MPI calls in your application as well as to specific call chains
Hardware Counters-On systems with R10000®, R12000, R14000, and R16000 processors, there are several experiments that make use of the CPU's hardware counters; this can be used to determine (among other things):
- Where instruction cache misses are occurring
- Where data cache misses are occurring
- Whether you have a good balance of integer and floating-point instructions
- Whether your code causes processor branch prediction problems
- Whether your MP application exhibits false sharing
NUMA Profiling-On SGI® Origin® systems with the SGI® NUMA architecture, this experiment profiles the SGI NUMA memory access patterns of your MP application
This tool allows users to compare performance data from multiple experiments
For R10000, R12000, R14000, and R16000 machines with hardware performance counters, the following additional types are supported using statistical PC sampling based on overflows of specific counters:
- Graduated-instruction counter
- Cycle counter
- Primary instruction-cache miss counter
- Secondary instruction-cache miss counter
- Primary data-cache miss counter
- Secondary data-cache miss counter
- TLB miss counter
- Graduated floating-point instruction counter
- Failed store conditionals
Combined, these tools provide a superb environment for facilitating the development of applications to run on MP systems. Whether you are an experienced MP application developer, or are trying to write your first MP program, the SGI® MP development tools provide you with the functionality you need to take advantage of all of the power of your systems.
Integrated Build Manager
The Build Manager lets you recompile from within the ProDev WorkShop environment, and graphically displays makefile dependencies and compiler messages.
Graphical Code Analyzer
The Static Analyzer is a visual source code navigation and analysis tool.
It operates in two modes:
- Scan mode - based on a fast pattern matching mechanism, it is ideal for analyzing code that does not compile
- Compile mode - invokes a native compiler and generates a database from symbol table information, providing the ability to perform more complex queries
With the Static Analyzer, users can visualize the structure of their programs and easily navigate through their code, which is vital for restructuring and re-engineering existing software. The graphical presentation makes the structure of the code very easy to understand, even for someone who is not the original developer. It is also helpful in porting situations when code that is being ported to other platforms will not run or compile.
The Static Analyzer provides a variety of different views:
- Call Tree View - displays the results in the form of a call graph. (Arcs represent caller-callee relationships between functions)
- C++ Class Tree View - displays the class hierarchy of the code and supports queries on both classes and methods
- File Dependency View - displays the include dependencies between files
Provides Multiple Views
- Class Information Window - Presents user configurable, comprehensive class member information and inter-class relationships
- Class Graph - Displays inter-class relationships graphically (inheritance, component, usage, friends)
- Static Analysis Window - Displays detailed results of queries
Supports Extensive Class Queries
The browser provides a set of static analysis queries tailored for C++ programs. These queries help users analyze interdependencies of a class with its related classes such as base classes, derived classes, component/container classes, classes that are used and friend classes. A few examples of queries on class members and related classes:
- Which members are declared or defined by a given base class
- Which methods are overridden by a given derived class
- Which classes use a given method
- Which members are used by a given class
- Which classes contain a given class
The Class Browser handles extremely large programs and provides easy navigation even when analyzing complex problems. Users can control the amount of information to be viewed when analyzing class relationship graphs or viewing class definitions. For example, the user can choose to display all class relationships or just immediate class relationships with respect to a class. Similarly, when viewing a class definition, users can choose to view just its public members.
The various views are integrated, providing the ability to select a class or method in one view and display additional information about it in another view. The Class Information Window can be invoked by clicking on a class in the Class Graph and the Call Graph can be pruned or populated from the Class Information Window. Also, Source View, the annotated textual viewer used by all WorkShop tools, can be invoked by clicking on a class in any of the views.