 |
 |
|
|
|
|
|
|
888-305-0041
|
|
|
|
|
|
 |
Runtime Analysis and Memory Error Detection for C and C++
|
  |
Current version: 7.4.3 (January 8, 2013)
Parasoft® Insure++®: C/C++ Runtime Analysis, Error Detection
Parasoft® Insure++® is a runtime memory analysis and error detection tool for C and C++ that automatically identifies a variety of difficult-to-track programming and memory-access errors, along with potential defects and inefficiencies in memory usage. Errors such as memory corruption, memory leaks, access outside of array bounds, invalid pointers, and the like often go undetected during normal testing, only to result in application crashes in the field. Insure++ will help you find and eliminate such defects in your applications to ensure the integrity of their memory usage.
During testing, Insure++ checks all types of memory references, including those to static (global), stack, and shared memory – both in user's code and in third party libraries. Errors that Insure++ detects include:
- Corrupted heap and stack memory
- Use of uninitialized variables and objects
- Array and string bounds errors on heap and stack
- Use of dangling, NULL, and uninitialized pointers
- All types of memory allocation and free errors or mismatches
- All types of memory leaks
- Type mismatches in global declarations, pointers, and function calls
- Some varieties of dead code (compile-time)
Parasoft's customers, including 58% of the Fortune 500, rely on Insure++ for:
- Pinpointing and removing the cause of erratic runtime behavior such as mysterious crashing and hanging
- Exposing serious defects that have evaded all other testing efforts for years
- Finding errors during 64-bit porting
- Optimizing application memory usage
|
|
For a Printable Version, Click Here (703 KB PDF).
|
| |
Insure++: Runtime Error Detection and Memory Error Detection |
| |
Find Elusive C/C++ Errors Automatically with Parasoft Insure++
Insure++ is a runtime memory analysis and error detection tool for C and C++ that automatically identifies a variety of difficult-to-track programming and memory-access errors, along with potential defects and inefficiencies in memory usage. Errors such as memory corruption, memory leaks, access outside of array bounds, invalid pointers, and the like often go undetected during normal testing, only to result in application crashes in the field. Insure++ will help you find and eliminate such defects in your applications to ensure the integrity of their memory usage.
Errors Detected
During testing, Insure++ checks all types of memory references, including those to static (global), stack, and shared memory — both in user’s code and in third party libraries. Errors that Insure++ detects include:
- Corrupted heap and stack memory
- Use of uninitialized variables and objects
- Array and string bounds errors on heap and stack
- Use of dangling, NULL, and uninitialized pointers
- All types of memory allocation and free errors or mismatches
- All types of memory leaks
- Type mismatches in global declarations, pointers, and function calls
- Some varieties of dead code (compile-time)
Multiple Use Modes
Insure++ has highly detailed memory analysis capabilities that are based on patented* source instrumentation algorithms. Source code instrumentation enables Insure++ to detect more error types than other memory error detection technologies, and also provides complete information indicating the root causes of the errors found, using a full database of program elements and memory structures.
There are two ways to use Insure++ for memory analysis and error detection. The first and most detailed analysis is achieved with full source code instrumentation. This requires that application sources be compiled and linked with Insure++, which generates its own instrumented files that are passed to the actual compiler.
The second option is linking with Insure++, which provides a trade-off between the extent of error reporting and the actual time to build and run an instrumented application. In this mode, Insure++ can detect and report most of the error types, including leaks, bad memory references, standard API usage errors, and so on.
Parasoft Inuse® and Parasoft TCA®
Along with the runtime memory error detection engine, Insure++
includes two components that increase the tool's scope of analysis:
- TCA (provides total coverage analysis)
- Inuse (provides application memory usage analysis)
TCA analyzes and reports block code coverage and lets you get "beneath the hood" of your program to see which parts are actually tested and how often each block is executed. In conjunction with a runtime error detection tool like Insure++ and a comprehensive test suite, this can dramatically improve the efficiency of your testing and promote faster delivery of more reliable programs.
Inuse visualizes how an application uses memory. This component
provides a graphical view of all memory allocations, over time, with
specific visibility into overall heap usage, block allocations,
possible outstanding leaks, and so on. By providing insight into an
application's memory usage patterns, Inuse allows you to
effectively analyze and optimize runtime memory usage and
performance.
*Parasoft holds patents #5,581,696 and #6,085,029 for its source instrumentation algorithms.
Features
- Detection of memory corruption on heap and stack
- Detection of uninitialized variables, pointers, and objects
- Detection of memory leaks and other memory allocation/free errors
- STL checking** for proper usage of STL containers and related memory errors
- Compile-time checks for type- and size-related errors
- Runtime tracing of function calls
- GUI and command line interface
- Memory error checking in 3rd party static and dynamic libraries
- Direct interfaces with Visual Studio debugger
**Available for any Unix users with GCC 3.0 and above.
Benefits
- Finds memory errors before they become runtime problems
- Finds common errors during 64 bit porting
- Helps optimize memory usage of applications
- Reduces development and support costs
- Easily integrates with regression test suites in “smoke alarm” mode
- Provides detailed stack traces of errors to help understand their causes
TCA Test Coverage
- Calculates line and block coverage
- Reports line, block, class, function, and file coverage
- Text reports and interactive code browser with coverage highlighting
Inuse Memory Monitor
- Visualizes memory leaks
- Displays memory use in real time
- Helps correlate memory usage with program events
Supported Platforms
Microsoft Windows (32-bit, 64-bit)
Insure++ works as a plug-in for Visual C++
- 7: VS2005 SP1 - VS2010
- Vista: VS2005 SP1 - VS2010
- 2008: VS2005 SP1 - VS2010
- XP: VS6 - VS2010
- 2003: VS6 - VS2010
- 2000: VS6 - VS2005
Linux for x86 processors 32 bits (all distributions)
- GNU gcc/g++ 2.95.x, 3.2 - 4.5
- Intel ICC 8.1, 9.0, 9.1, 10.0, 10.1, 11.0
Linux for AMD64 and Intel EM64T 64 bits (all distributions)
- GNU gcc/g++ GNU gcc/g++ 3.2.x - 4.5
- Intel ICC 8.1, 9.0, 9.1, 10.0, 10.1, 11.0
Solaris 8, 9, 10 UltraSparc Processor
- Forte Developer 6 Update 2 (6.2) / Sun CC 5.3
- Sun ONE Studio 7 / Sun CC 5.4
- Sun ONE Studio 8 / Sun CC 5.5
- Sun Studio 9 / Sun CC 5.6
- Sun Studio 10 / Sun CC 5.7
- Sun Studio 11 / Sun CC 5.8
- Sun Studio 12 / Sun CC 5.9
- GNU gcc/g++ 2.95 - 4.2
IBM AIX 5.1, 5.2, 5.3, PowerPC Processor 32 and 64 bits
- IBM VisualAge v5
- IBM Visual Age (xIC compilers) v6 , v7, v8
- GNU gcc/g++ 2.95 - 4.2
IBM AIX 6.1, PowerPC processor
- IBM Visual Age (xIC compilers) v10.1
- IBM Visual Age (xIC compilers) v11.1
- GNU gcc/g++ 2.95 - 4.2
|
|
"Problems that used to take us several days or even weeks to track down, we
are able to routinely find and fix in a few hours with Insure++. So,
Insure++ is now a standard tool that is used on all software that we develop
before it is released. Our engineering team is very enthusiastic about it
and management is convinced that it was well worth the money. We have told
lots of our peers about Insure and will keep doing so."
David Miller
Hewlett-Packard
|
|
"Within only hours I was able to track down a nasty memory bug in my code
that had plagued me for weeks. Insure++ is of tremendous help in debugging
programs and it is very easy to use. "
Dr. Marcus E. Hennecke
Applied Research Laboratories
|
|
"Insure++’s ability to model applications at the source code level make its error detection capabilities unmatched in the industry. It has allowed us to find application defects that Purify and other tools were not able to find."
Chris Teague, Systems Administrator
Kinesix Corporation
|
|
"Insure++ is an indispensable tool for my development. It automatically
finds all the otherwise hard-to-find bugs and memory leaks during compilation
and runtime. Inuse is a graphical tool that comes with Insure++. During
testing, I run my program with Inuse for a few days, non-stop. This way, I can
be sure my program is free of memory leaks. I won't deliver my programs to
customers unless I first check them with Insure++. I can't imagine doing
development without Insure++. "
Chee Cheng
Chicago Tribune
|
|
"We're very happy with Insure++. This is a really good product that has
saved my butt several times during the development of several large systems
here... I work in a small (overworked) team with tight deadlines. We can't
afford to waste days tracking down bugs. We depend on tools like Insure++ to
quickly locate problems and let us get back to development. We use
CodeCenter during initial development and Insure++ for quality assurance
testing. All my dealings with Parasoft have been pleasant. I would not
hesitate to contact to recommend your products to anyone who cares about
the quality of the software they produce."
John Wendel, Computer Specialist
Branch of US Military
|
|
|
"We recently used Insure++ (Linux version) to detect memory leaks in
our multi-threaded code and it was very helpful. It helped us to find a
problem that had been nagging us for months."
Aniruddha R. Thakar
Johns Hopkins University
|
|
"I wanted my money to go towards a system that would find as many
"hard to find "bugs as possible. I decided Insure would do me
better, based on my evaluation. I know from past experience some of the
hardest bugs to find are incorrect values and formatting strings passed to
printf/sprintf, and random behavior caused by non-core dumping pointer
overruns. So thanks for all the support, and I look forward to sleeping a
little better knowing that I now have a tool that will prevent me from having
to put a detective's hat on and crawl through code printouts with a
magnifying glass just to figure out why variables are getting corrupted. "
Greg Ercolano
Digital Domain
|
|
|
“Parasoft Insure++ gives me the ability to analyze my content in the environment where it's being run as opposed to just looking at the code on paper. It forces you to verify that the standards and practices that are being used are absolutely pristine. One of the challenges as a project leader—or managing partner, like myself—is confirming that your team is writing code that meets high standards. It's extremely difficult to go through and double check every line of code. In fact, it's just not possible. Insure++ can help me verify that my team is writing code that meets my standards. Insure++ can allow me to guarantee results. I am really excited about that.”
Timothy W. Okrey, Managing Partner
BITTT Enterprises, Inc
|
Insure++ is available in a 32-bit Edition and 64-bit Edition. It is also available as part of various options.
32-bit Edition
The 32-bit edition includes:
- Insure++: Runtime memory analysis and error detection.
- TCA: Coverage analysis.
- Inuse: Application memory usage analysis.
Licenses are also available for:
- Runtime for Unix: Insure++ licensing includes one Runtime license for execution on the licensed platform. To execute instrumented code on another machine in runtime mode, an additional runtime license must be purchased for the same platform as the primary Insure++ license.
- Threads for Unix: For runtime memory analysis and error detection in threads.
64-bit Edition
The 64-bit edition includes:
- Insure++: Runtime memory analysis and error detection.
- TCA: Coverage analysis.
- Inuse: Application memory usage analysis.
- Threads for Unix: For runtime memory analysis and error detection in threads.
Licenses are also available for:
- Runtime for Unix: Insure++ licensing includes one Runtime license for execution on the licensed platform. To execute instrumented code on another machine in runtime mode, an additional runtime license must be purchased for the same platform as the primary Insure++ license.
|
Microsoft Windows (32-bit, 64-bit)
Linux 32 and 64 bit
Solaris UltraSparc Processor
- Forte Developer
- Sun Studio
- GNU gcc/g++
IBM AIX, PowerPC 32 and 64 bit processor
- IBM Visual Age
- IBM Visual Age (xIC compilers)
- GNU gcc/g++
|
|
|
|
|
|
|
