Heap compaction on W2K/XP, JDK 1.4.2

Question

Hello all,
we have a large client-side application written in Java. Some operations of this application require a large amount of memory, but only for a short-time. Our experience has been that the VM will increase the heap-size as this memory is needed, but it will never compact the heap again (i.e. release the memory back to the OS) after the operation is completed.
This is not an application memory leak, as the amount of free heap space after the operation is very large, i.e. as it was before, plus the memory that was used by the operation.
Is there any way to get the VM to return this memory to the OS?
Thanks in advance,
David Sykes

Answer 1

The virtual memory is really not returned to the OS, but the physical memory is.
If you're using Windows, try running this C++ program as:
setwss java
and check the Task Manager graphs. You will see a sudden memory decrease, and the memory use slowly returning to a lower level.
(I suppose that your program is the only Java program running in your machine. If you have several programs, pass the PID of the program instead, like setwss 1878)
// to compile this program,
// use Microsoft Visual Studio (6.0, .NET, .NET 2003) and the following command-line:
// cl -GX setwss.cpp
#include <windows.h>
#include <tlhelp32.h>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
string toLower(const string& s) {
    string ret(s);
    _strlwr((char*)ret.data());
    return ret;
DWORD findPid (const string& name) {
    HANDLE         hProcessSnap = NULL;
    BOOL           bRet      = FALSE;
    PROCESSENTRY32 pe32      = {0};
    DWORD pid = -1;
    //  Take a snapshot of all processes in the system.
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnap == INVALID_HANDLE_VALUE)
        return (FALSE);
    //  Fill in the size of the structure before using it.
    pe32.dwSize = sizeof(PROCESSENTRY32);
    //  Walk the snapshot of the processes, and for each process,
    //  display information.
    for (bRet = Process32First(hProcessSnap, &pe32); bRet; bRet = Process32Next(hProcessSnap, &pe32)) {
        if (toLower(pe32.szExeFile).find(toLower(name)) == 0) {
            pid = pe32.th32ProcessID;
            break;
    // Do not forget to clean up the snapshot object.
    CloseHandle (hProcessSnap);
    return (pid);
main (int argc, char *argv[]) {
    long pid;
    int ret = 1;
    DWORD lastError;
    do {
        if (argc != 2) {
            cerr << "Temporarily trims the working set of the specified process to zero. This essentially swaps the process out of physical RAM memory. " << endl;
            cerr << "Syntax: " << argv[0] << " pid_or_processname " << endl;
            break;
        if (atol(argv[1]) > 0)
            pid = atol(argv[1]);
        else
            pid = findPid(argv[1]);
        if (pid == (DWORD) -1) {
            cerr << "Process not found" << endl;
            break;
        cerr << "Trying to trim the working set size of the process with pid = " << pid << endl;
        HANDLE hProcess = OpenProcess(PROCESS_SET_QUOTA, FALSE, pid);
        lastError = GetLastError();
        if (hProcess == NULL) {
            cerr << "OpenProcess failed with code 0x" << hex << setw(8) << setfill('0') << lastError << endl;
            break;
        BOOL ret = SetProcessWorkingSetSize (hProcess, (SIZE_T)-1, (SIZE_T)-1);
        lastError = GetLastError();
        CloseHandle (hProcess);
        if (!ret) {
            cerr << "SetProcessWorkingSetSize failed with code 0x" << hex << setw(8) << setfill('0') << lastError << endl;
            break;
        cout << "Working set size of process " << pid << " trimmed" << endl;
        ret = 0;
    } while (false);
    return ret;
[]code]