HeapAgent






New features in HeapAgent for Windows NT 3.x/4.0 and Windows 95

Following is a list of the new features in each release of HeapAgent for 32-bit Windows.

New in HeapAgent 3.1

  • Support for Visual C++ 5.0: HeapAgent 3.1 adds support for the Microsoft Visual C++ 5.0 compiler.
  • Patching control API: HeapAgent 3.1 introduces an API to control patching of heap functions. The new API allows the same control over patching as the existing registry values.
  • Tracing facility introduced for HeapAgent's patching: HeapAgent 3.1 adds a diagnostic tracing facility that allows you to see exactly which functions in which DLLs HeapAgent is patching.
  • New API for managing user-supplied region of memory: HeapAgent 3.1 introduces a new API for allocating within a region of memory supplied by the caller.

New in HeapAgent 3.0

  • Support for NT 4.0 and Visual C++ 4.2: HeapAgent 3.0 adds support for Windows NT 4.0 and the Microsoft Visual C++ 4.2 compiler.
  • Stack checking: In addition to detecting heap errors, HeapAgent 3.0 now detects stack errors. By default, HeapAgent fills the stack frame with the uninitialized fill value on entry to functions and places a guard at the end of each stack frame. Additionally, you can have HeapAgent check the guard area and fill stack frames with the free-fill value on function return. Or, you can disable stack checking altogether.
  • Call stack included in browsers and error reports: HeapAgent 3.0 includes the list of callers, including function names, file names, and line numbers in all error reports and browsers. The call stack is displayed for both the location where the error was detected and the location that created the object related to the error.
  • Module path included in error reports: HeapAgent 3.0 error reports include the full path of the EXE or DLL in which errors are detected and where objects related to the error were created.
  • LoadLibrary DLLs patched by HeapAgent DLL: If your application dynamically loads DLLs, HeapAgent 3.0 automatically patches heap routines in and can, therefore, detect errors in these DLLs. You no longer need to link your LoadLibrary DLLs with the HeapAgent Library.
  • HeapAlloc, GlobalAlloc, and LocalAlloc APIs supported: HeapAgent 3.0 adds support for the Win32 memory allocation APIs. All calls to Win32 memory APIs in your EXE and DLLs, as well as in non-kernel operating system DLLs and third-party DLLs, are monitored by HeapAgent for memory errors. If you'd like, you can also disable patching of Win32 APIs.
  • Global and per-app DLL patching configuration: In HeapAgent 3.0, you can control HeapAgent's patching and launching of the HeapAgent user interface globally as well as per-application.
  • Auto-loading of HeapAgent added for Windows 95: You can now have HeapAgent run automatically whenever you run your app under Windows 95. In earlier versions of HeapAgent, this feature was only available under NT. Only GUI apps are supported for this feature, not console apps.
  • Performance optimizations: HeapAgent 3.0 now searches debugging information only during error reporting. Consequently, load times for large applications are much quicker in HeapAgent 3.0.
  • HeapAgent no longer requires administrator privileges: HeapAgent Setup and HeapAgent App Setup now change only registry settings that normal users have permission to modify. Administrator privileges are therefore no longer required to install or run HeapAgent.

New in HeapAgent 2.1

  • Support for the latest compilers: Support has been added for Microsoft Visual C++ 4.1 and Borland C++ 5.0.
  • Tracking of process ID: HeapAgent error reports now include the process that detected the error and the process that created the responsible allocation.
  • Support for shared memory: HeapAgent supports debugging of shared memory managed with SmartHeap shared-memory APIs.
  • Support for NT services: HeapAgent can now be used to debug services that run before logon.

New in HeapAgent 2.0

  • HeapAgent loads automatically without relink or recompile: If you're running under Windows NT and using Microsoft Visual C++, you can have HeapAgent automatically load whenever you run your application, even when you run from the Visual C++ debugger.
  • Support for Visual C++ 4.0/MFC 4.0: Support has been added for version 4.0 of Visual C++ and MFC, including support for all of the new debugging APIs introduced in Visual C++ 4.0.
  • HeapAgent Application Setup utility: This utility lets you control which DLLs HeapAgent checks and when the HeapAgent user interface launches.
  • Error suppression: HeapAgent's new error suppression facility gives you great flexibility in controlling which errors you see and which ones you don't.
  • Per-application settings: HeapAgent now stores debugging and error reporting settings separately for each application. If you have multiple processes in your app, you can now have a separate log file and agents for each process, for example.
  • Tracking of thread ID: HeapAgent error reports and browsers now include the thread that detected the error and the thread that created the responsible allocation.
  • More errors detected: HeapAgent 2.0 detects these new errors:
    • Write to free memory
    • Read from free memory
    • Read beyond the bounds of an allocation
    • Read from uninitialized memory

New in HeapAgent 1.1

  • No relink and no recompile: If you use the Microsoft Visual C++ compiler, you no longer need to recompile and relink your application for HeapAgent - simply load your application from the HeapAgent user interface.
  • Support for Windows 95: The Win32 version of HeapAgent now supports Windows 95.
  • Background heap checking: HeapAgent now performs heap checking in the background when the system is idle. This allows checking to occur more frequently, yet has minimal impact on your application's performance.
  • Additional statistics: The HeapAgent Statistics Browser now includes additional system statistics, including available physical memory, paging file space, and process address space.
  • Performance enhancements: Browsing and searching heap data is significantly faster in HeapAgent 1.1.