|
Dynamic Suite
Test-Drive Dynamic Suite
for FREE! The Dynamic Suite covers a wide variety of functionality. The functionality is currently broken into three pieces:
|
Join our free software testing and debugging newsletter |
Defects
Software defects come in many varieties. Compilers and programming languages catch many defects. The Java garbage collector is an example of the language preventing a defect, memory leaks. Some defects require a human to interpret the problem. These defects are typically related to the business functionality of software.
In between manual intervention and compile time defects, a large space exists where many defects reside. This class of defects is termed ‘runtime’ since the defects are only apparent when the software is executed. Fortunately, these defects can be tracked with a Software Defect Detection system. Runtime defect categories include:
- Performance and Scalability defects
- Memory corruption defects
- Memory leaks
- Interface errors
A root cause analysis of runtime defects reveals the problem with traditional approaches. Most runtime defects have a root cause based in:
- Unexpected input
- Untested and unexecuted code
- Poor error handling
Each category of runtime defect suffers from the same root causes.
Solving Runtime Defects
Every major software development shop must struggle with the question of debugging runtime defects in production software. Each defect that lands in production can cost a tremendous amount in terms of programmer resource, lost productivity and customer dissatisfaction.
The traditional approach to runtime defect detection has been to ‘instrument’ applications and libraries using in-house or 3rd party tools. Every C/C++ programmer is familiar with ‘printf’ debugging as a means of runtime defect debugging.
Dynamic Suite is a Software Defect Detection system for runtime defects. A four phased approach is taken to mitigating runtime defects.
|
Dynamic Leak Check Dynamic Profile Dynamic Code Coverage |
Memory Corruption, Heap Profiling, Memory Access Errors Performance Bottleneck detection and monitoring Code Coverage analysis featuring Decision/Branch analysis |
Dynamic Suite gives development, testing and production support teams a powerful tool to combat runtime defects. Using Dynamic Suite, defects can be caught early in the development cycle. For production sites, Dynamic Suite can be deployed to catch the errors that slip through.
Instrumentation
Instrumentation is the general term for adding debugging code into an executable. Instrumentation can be added into the source code or into the object modules. Several commercial products including Parasoft’s Insure++ and Rational’s Purify use this strategy for executable instrumentation.
While the mechanics of instrumentation are usually simple, the practical realities are anything but simple. Programs in a production environment are often created from thousands of individual source files and dozens of libraries both shared and archived. Source code is likely spread across multiple groups within the company.
Instrumentation of a large source code base is intimidating due to the time and effort required. As a result Code Coverage tools, Profiles and runtime Debuggers are often not used, even when available.
A third strategy is also possible, introduce instrumentation only at runtime so called ‘late binding’. In this strategy executables are not modified on disk but only in the memory of the computer.
Dynamic Suite offers products that use runtime instrumentation to combat runtime defects. In the minimum case, no source code or object modules are required. Dynamic Suite can detect and pinpoint many defects with only the executable. When source code and object modules are available, Dynamic Suite can detect and pinpoint even more defects.
Runtime Debuggers
A runtime debugger is a tool used to find errors not at compile or link time but instead at runtime. Runtime Debuggers can be extremely useful in finding difficult corruption errors, stack-based errors, runtime linking issues and other complex errors. In general, compilers and linkers cannot find these errors.
Current runtime Debuggers have two key downsides
- Compile and/or link time instrumentation
- Unsuitable for production environments
Runtime debugging creates a tremendous overhead that causes a process to run very slowly. Depending on the program internals, a runtime debugger will cause a three to one thousand times performance decrease. Instrumented programs are not placed in production environments due to the performance impact caused by the instrumentation. When a problem occurs in production, a special executable must be instrumented and brought to the production box. What is really needed is a runtime debugger that can be directly used on production executables.
Performance Profiles
Performance Profiles are used to identify performance and scalability bottlenecks within an application.
Performance problems are difficult to identify in development and test environment. As a result, many production sites experience inexplicable slowdowns in the software systems. Tracking the cause of such systems can be difficult as many culprits are possible e.g. network, hard drives, database time, poorly scalability in software. The unfortunate result is that customers often become de facto performance testers.
Most performance Profiles require an excessive amount of instrumentation. The resulting executables are unsuitable for a production environment due to the tremendous performance penalty incurred. Profiles are generally used after a customer or test team notices a performance problem. Dynamic Profile uses only runtime instrumentation and incurs only a modest performance penalty.
Another key problem with current Profile technology is the reactive as opposed to proactive nature. Profiles are generally used only after a customer or test team notices a performance and/or scalability problem.
In contrast, Dynamic Profile can be deployed in a proactive fashion. It can monitor the performance of a particular process and report any anomalies. In this fashion, the development shop becomes aware of the problem before the customer notices a problem.
Code Coverage Analysis
Code Coverage Analysis determines which lines of source code have been executed within a particular source module. By helping to guiding testing, Code Coverage analysis has been proven to reduce production software defects substantially.
As with the other areas, most Code Coverage analysis tools require the software base to be recompiled and thoroughly instrumented. The resulting executable is not useful for any other tasks.
Dynamic Code Coverage does not require any compile/link time instrumentation. Through an innovative strategy, runtime instrumentation is used to gather the same information.
Each function/method, line and branch are evaluated for execution. As the process runs, a detailed Code Coverage file is accumulated. Code Coverage files from multiple runs can be assembled together. The result is a detailed Code Coverage Analysis of a particular process.
High-speed Memory Leak Detection
Memory leaks are an irritating defect that can cause endless production headaches. A ‘leak’ is defined as a process losing all references to a block of dynamic memory. Once a memory blocked is leaked, a process cannot reuse the memory. As a result, a process will use more and more memory overtime. Eventually, the process will exhaust the operating system resources and crash. By hogging the physical memory of the Unix box a process can cause all processes to run slower and slower. The slow down is often referred to as ‘thrashing.’
Many compile and link time instrumentation tools exist for memory leak detection. The existing tools have two key problems.
- Only the allocation is identified not the spot of the actual leak
- In some cases a leak will exist in a required 3rd party library. In such case, the tools are no help in terms of fixing the problem.
Dynamic Leak Check cures both problems while delivering all the traditional functionality. Leaks are identified by allocation stack and by point of last reference. When the last pointer to a block is lost, Dynamic Leak Check delivers module and line information.
Since no instrumentation is required, Dynamic Leak Check is useful in production environments. When leaks are suspected, Dynamic Leak Check can be run to identify and pinpoint the problem.
Test-Drive Dynamic Suite for Free!
For more information and a
free evaluation, call us today at
1-877-293-4144 or
click here.
