OpenEdge Memory Profiler
Identify and resolve memory-related issues within Progress OpenEdge applications.
Enhancing Application Performance and Stability
The Progress® OpenEdge® Memory Profiler (OEMP) helps Advanced Business Language (ABL) developers analyze memory usage, detect memory leaks and optimize application performance.
By providing visibility into memory allocation and object lifecycles, OEMP helps organizations improve application stability, reduce troubleshooting time and deliver more reliable business applications.
What Is a Memory Profiler?
A memory profiler is a diagnostic tool that helps developers understand how an application allocates, uses and releases memory during execution.
Memory profiling enables teams to identify excessive memory consumption, leaks and inefficient allocation patterns that can negatively affect performance and stability.
OEMP is designed specifically for OpenEdge applications and Progress® Application Server (PAS) for OpenEdge® environments, providing detailed insight into memory behavior within the OpenEdge runtime.
Common Memory Issues You Can Detect
Identifies Excessive Memory Consumption
Helps identify areas where memory usage is higher than expected. By pinpointing memory-intensive processes and objects, developers can optimize resource utilization and improve application performance.
Detects Memory Leaks
Enables developers to identify memory growth patterns and compare memory snapshots to investigate objects that remain in memory longer than expected. Memory leaks can lead to application crashes, system instability, performance degradation and increased infrastructure costs. This allows teams to isolate potential leaks during development and testing before they affect production environments.
Pinpoints Inefficient Memory Usage
Supports the uncovering of these patterns and facilitates more efficient application design. Because not all memory-related issues are caused by leaks—repeated object creation, inefficient data structures and unnecessary allocations can all impact performance.
Improves Developer Productivity
Provides visualizations and detailed metrics that simplify troubleshooting and accelerate the resolution of memory-related issues. Thus, developers can spend less time diagnosing problems and more time improving application functionality.
Memory Profiling Workflow
OEMP collects memory usage information while an application is running and stores the results for analysis. A typical workflow for the OEMP:
Enable profiling using the -profileMemory startup parameter
Run an OpenEdge application or PAS for OpenEdge workload
Generate memory profiling recordings as .oemp files
Import recordings into OEMP
Analyze memory snapshots and object details
Identify optimization opportunities and investigate memory leaks
Figure 1: OEMP Architecture. Memory profiling recordings generated by OpenEdge AVM processes and PAS for OpenEdge instances are stored as .oemp files and imported into OEMP for analysis and troubleshooting.
Types of Memory Profiling
OEMP supports multiple approaches to analyzing application memory. Each technique helps developers investigate different types of performance and stability issues, including:
Heap Profiling
Captures the state of application memory at specific points in time by comparing memory snapshots, allowing developers to identify which objects remain in memory, how memory usage changes during execution and where unexpected growth may be occurring.
Allocation Tracking
Records when objects are created and how memory is allocated throughout application execution, which helps identify code paths that generate excessive object creation, unnecessary allocations or inefficient memory usage that can impact performance.
Memory Leak Detection
Focuses on identifying objects that continue to consume memory after they are no longer needed by comparing multiple memory snapshots, allowing developers can investigate retained objects, determine why they remain referenced and resolve issues before they affect application stability.
Which Memory Profiler Should I Use?
Different development platforms require different memory profiling tools, such as:
| Platform | Typical Memory Profiling Tool |
|---|---|
| OpenEdge ABL | OEMP |
| Python | Memray, memory_profiler |
| .NET | dotMemory, Visual Studio Profiler |
| C++ | Valgrind, Visual Studio Diagnostic Tools |
For OpenEdge applications, OEMP provides profiling capabilities tailored specifically to the OpenEdge runtime environment.
Key Features
Import Recordings
Import memory profiling recordings into an OpenEdge database for centralized access and analysis.
Open/View Recordings
Open and view existing memory profiling recordings for ABL applications or PAS for OpenEdge instances stored in the database.
View Snapshot Summary
Access a summary of the objects within a specific memory snapshot to quickly understand memory allocation and identify areas that may require further investigation.
Detail Object Information
Drill into individual objects within a snapshot to gain deeper insight into memory usage and investigate objects contributing to memory growth.
Manage Recordings
Organize profiling recordings and delete one or more from the database when they are no longer needed and retain only pertinent data.
Visualize Data
Use visualizations to identify memory usage trends, allocation and consumption patterns and optimization opportunities.
Understanding Memory Profiling Recordings and Snapshots
OEMP collects memory information while an application is running and stores profiling results in recordings that can be analyzed later. Within a recording, snapshots provide views of application memory at particular points in time.
What Is an .oemp Recording?
It is a memory profiling file generated by an OpenEdge AVM process or PAS for OpenEdge instance when memory profiling is enabled. The recording can be imported into OEMP and stored in an OpenEdge database for analysis.
What Is a Memory Snapshot?
It captures information about objects in memory at a particular point during application execution. A recording can contain multiple snapshots, allowing developers to examine how memory changes throughout a profiling session.
Recording vs. Snapshot
A recording represents the profiling session and contains the memory profiling information collected during that session. A snapshot represents memory at a particular point within the recording. Comparing snapshots helps developers understand what changed between different stages of application execution.
Snapshot Creation Methods
Snapshots can be generated automatically during profiling or created at specific points in application execution. Developers can use targeted snapshots before and after a particular operation to investigate how that operation affects memory usage.
Memory Usage Trends
Analyzing multiple snapshots allows developers to observe memory usage over time. Consistent growth across repeated application operations can help identify objects or processes that require further investigation.
Snapshot Comparison
Developers can compare snapshots taken at different points during application execution to identify changes in object counts and memory consumption. For example, a developer can capture a snapshot before running a process and another after the process completes. Objects that continue to accumulate when they are expected to be released may indicate inefficient memory management or a potential memory leak.
Common Use Cases
Organizations use OEMP to:
- Investigate memory growth in long-running applications
- Troubleshoot application performance issues
- Detect memory leaks during development and testing
- Optimize memory-intensive business processes
- Validate application behavior before production deployment
- Improve application scalability and reliability
How to Detect Memory Leaks
Memory leaks are often identified by comparing memory usage over time rather than examining a single snapshot. A typical investigation follows these steps.
Enable memory profiling using the -profileMemory startup parameter
Run the application while performing the workflow you want to analyze
Capture multiple memory snapshots during execution
Compare snapshots to identify objects that continue to grow in memory
Examine retained objects and their allocation details to determine why they remain referenced
Modify the application to release unnecessary objects and repeat the analysis to verify the issue has been resolved
This iterative process helps developers isolate memory leaks before they affect application performance, scalability or stability in production environments.
Memory Leak Investigation Example
As an example, an application can repeatedly run a business process that creates temporary objects, but memory consumption continues to increase after each execution. A developer can capture a baseline snapshot before running the process and another snapshot after it completes. Comparing the two snapshots can reveal that certain objects created during the process remain in memory instead of being released.
The developer can then examine those objects to determine why they are being retained and identify the relevant code that needs to be corrected. After modifying the application to release the objects appropriately, the developer can run the same process again and compare new snapshots to verify that the objects are released and memory usage no longer continues to grow.
FAQs
Ready to Optimize Your OpenEdge Applications?
Explore OpenEdge Memory Profiler resources, review the documentation or connect with a Progress expert to learn how memory profiling can help improve the performance and reliability of your OpenEdge applications.
Resources
Progress OpenEdge
Your application evolution journey starts here.