Tracking Native Memory used by Gurobi in Java

Answered

Daniel Özcan

October 16, 2024 08:41

• 
• 

I am using Gurobi in Java with Gurobi's Java API. I would like to track the full memory footprint of a Gurobi-based solution to a problem with other solutions, such as SAT solvers. Currently I am using Java JMH garbage collection profiler, but I have become aware that this does not include Gurobi's native memory used during solving. Can anyone recommend a method to measure Gurobi's native memory on top the Java's heap allocations?

Related to

• Memory
• Java

0

• Official comment

  

  Simranjit Kaur

  • Gurobi Staff

  November 13, 2026 01:12 Edited

  This post is more than two years old. Some information may not be up to date. For current information, please check the Gurobi Documentation or Knowledge Base. If you need more help, please create a new post in the community forum, or try Gurobot, our chatbot interface offering instant, expert-level support.
• 

  Riley Clement

  • Gurobi Staff

  October 20, 2024 23:48

  Hi Daniel,

  I use psrecord when profiling memory with Gurobi through our Python API.

  According to ChatGPT you could also use it for Gurobi & Java API.  You would need to install it in a Python environment though and pass it the java command as an arguments.

  Yes, **`psrecord`** is a good choice for tracking memory usage, including native memory, while running a Java program that uses Gurobi. `psrecord` monitors and records the memory and CPU usage of a specific process over time. It works well for capturing the entire memory footprint, which includes both the Java heap and native memory allocated by the Gurobi solver.

  ### How to Use `psrecord`

  1. **Install psrecord**:
     You can install `psrecord` using `pip` if it's not already installed:
     ```bash
     pip install psrecord
     ```

  2. **Run psrecord**:
     Start your Java process and find its process ID (`PID`). Once you have the `PID`, use `psrecord` to track the memory and CPU usage. For example:
     ```bash
     psrecord <PID> --interval 1 --plot memory_cpu_usage.png --log memory_cpu_usage.txt
     ```

     This command will:
     - Record the memory and CPU usage of the process with the specified `PID`.
     - Take samples every second (`--interval 1`).
     - Save the results to a log file (`memory_cpu_usage.txt`) and generate a plot (`memory_cpu_usage.png`).

  3. **Monitor Both Heap and Native Memory**:
     `psrecord` captures the **resident set size (RSS)**, which is the portion of memory occupied by a process in RAM. This includes:
     - Java heap memory managed by the JVM.
     - Native memory allocations performed by the Gurobi C library.

     By analyzing the log file and generated plot, you can see how the memory usage evolves over time during the optimization process.

  ### Advantages of Using `psrecord`
  - **Easy setup**: No need for invasive instrumentation in your Java or Gurobi code.
  - **Comprehensive memory monitoring**: Tracks the entire process memory, including native allocations.
  - **CPU profiling**: Provides additional insight into CPU usage alongside memory data.

  This approach is especially useful when you want a high-level overview of memory usage without delving into deeper C/C++ integrations or setting up detailed memory profilers.

  It is a ChatGPT answer though so take it with a grain of salt.

  - Riley

  0

Post is closed for comments.