Getting memory usage of program from another program in C++ (LINUX)

You can use getrusage( RUSAGE_CHILDREN, ... ) to obtain the maximum resident memory. Note that this call will return the maximum memory used by the biggest child at that point in time.

In the example below I used boost::process because it gives better control but it's up to you to use std::system or not, works the same way.

#include <string>
#include <cstdint>
#include <string.h>
#include <iostream>
#include <boost/process/child.hpp>
#include <sys/resource.h>

namespace bp = boost::process;

int parent( const std::string& exename )
{
    // Loop from 0 to 10 megabytes
    for ( int j=0; j<10; ++j )
    {
        // Command name is the name of this executable plus one argument with size
        std::string gencmd = exename + " " + std::to_string(j);

        // Start process
        bp::child child( gencmd );

        // Wait for it to allocate memory
        sleep(1);

        // Query the memory usage at this point in time
        struct rusage ru;
        getrusage( RUSAGE_CHILDREN, &ru );
        std::cerr << "Loop:" << j << " mem:"<< ru.ru_maxrss/1024. << " MB" << std::endl;

        // Wait for process to quit
        child.wait();
        if ( child.exit_code()!=0 )
        {
            std::cerr << "Error executing child:" << child.exit_code() << std::endl;
            return 1;
        }
    }
    return 0;
}

int child( int size ) {
    // Allocated "size" megabites explicitly
    size_t memsize = size*1024*1024;
    uint8_t* ptr = (uint8_t*)malloc( memsize );
    memset( ptr, size, memsize );

    // Wait for the parent to sample our memory usage
    sleep( 2 );

    // Free memory
    free( ptr );

    return 0;
}

int main( int argc, char* argv[] )
{
    // Without arguments, it is the parent. 
    // Pass the name of the binary 
    if ( argc==1 ) return parent( argv[0] );
    return child( std::atoi( argv[1] ) );
}

It prints

$ ./env_test 
Loop:0 mem:0 MB
Loop:1 mem:3.5625 MB
Loop:2 mem:4.01953 MB
Loop:3 mem:5.05469 MB
Loop:4 mem:6.04688 MB
Loop:5 mem:7.05078 MB
Loop:6 mem:7.78516 MB
Loop:7 mem:8.97266 MB
Loop:8 mem:9.82031 MB
Loop:9 mem:10.8867 MB

If you cannot use boost libraries, you'd got to work a little more but it is still feasible.

If you just want to know the maximum size ever of your children processes then the following works with std::system:

#include <cstdio>
#include <string>
#include <iostream>
#include <sstream>

#include <string.h>
#include <unistd.h>
#include <sys/resource.h>

int main(int argc, char* argv[]) {
    if (argc > 1) {
        size_t size = ::atol(argv[1]);
        size_t memsize = size * 1024 * 1024;
        void* ptr = ::malloc(memsize);
        memset(ptr, 0, memsize);
        ::sleep(2);
        ::free(ptr);
        return 0;
    }

    for (int j = 0; j < 10; ++j) {
        std::ostringstream cmd;
        cmd << argv[0] << " " << j;
        int res = std::system(cmd.str().c_str());
        if (res < 0) {
            fprintf(stderr, "ERROR system: %s\n", strerror(errno));
            break;
        }
        struct rusage ru;
        res = getrusage(RUSAGE_CHILDREN, &ru);
        size_t maxmem = ru.ru_maxrss;
        fprintf(stderr, "Loop:%d MaxMem:%ld\n", j, maxmem);
    }
    return 0;
}

It prints

Loop:0 MaxMem:3552
Loop:1 MaxMem:4192
Loop:2 MaxMem:5148
Loop:3 MaxMem:6228
Loop:4 MaxMem:7364
Loop:5 MaxMem:8456
Loop:6 MaxMem:9120
Loop:7 MaxMem:10188
Loop:8 MaxMem:11324
Loop:9 MaxMem:12256

However if you want to keep track of the memory usage during the child process execution you cannot use std::system(). First, you need to call fork() to spawn a new process and then execv() to execute a bash command.

#include <string>
#include <cstdint>
#include <string.h>
#include <unistd.h>
#include <iostream>
#include <sys/resource.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <vector>

int parent(const std::string& exename) {
    // Loop from 0 to 10 megabytes
    for (int j = 0; j < 10; ++j) {
        // Command name is the name of this executable plus one argument with size
        std::string gencmd = exename + " " + std::to_string(j);

        // Start process
        pid_t pid = fork();
        if (pid == 0) {  // child
            const char* args[] = {"/bin/bash", "-c", gencmd.c_str(), (char*)0};
            int res = execv("/bin/bash", (char**)args);
            // Should never return
            std::cerr << "execv error: " << strerror(errno) << std::endl;
            return 1;
        }

        // parent
        long maxmem = 0;
        while (true) {
            int status;
            pid_t rid = ::waitpid(pid, &status, WNOHANG);
            if (rid < 0) {
                if (errno != ECHILD) {
                    std::cerr << "waitpid:" << strerror(errno) << std::endl;
                    return 2;
                }
                break;
            }
            if (rid == pid) {
                if (WIFEXITED(pid)) {
                    break;
                }
            }

            // Wait for it to allocate memory
            usleep(10000);

            // Query the memory usage at this point in time
            struct rusage ru;
            int res = getrusage(RUSAGE_CHILDREN, &ru);
            if (res != 0) {
                if (errno != ECHILD) {
                    std::cerr << "getrusage:" << errno << strerror(errno) << std::endl;
                }
                break;
            }
            if (maxmem < ru.ru_maxrss) {
                maxmem = ru.ru_maxrss;
            }
        }
        std::cerr << "Loop:" << j << " mem:" << maxmem / 1024. << " MB" << std::endl;
    }
    return 0;
}

int child(int size) {
    // Allocated "size" megabites explicitly
    size_t memsize = size * 1024 * 1024;
    uint8_t* ptr = (uint8_t*)malloc(memsize);
    memset(ptr, size, memsize);

    // Wait for the parent to sample our memory usage
    sleep(2);

    // Free memory
    free(ptr);

    return 0;
}

int main(int argc, char* argv[]) {
    // Without arguments, it is the parent.
    // Pass the name of the binary
    if (argc == 1) return parent(argv[0]);
    return child(std::atoi(argv[1]));
}

The result on my machine is:

$ ./fork_test 
Loop:0 mem:3.22656 MB
Loop:1 mem:3.69922 MB
Loop:2 mem:4.80859 MB
Loop:3 mem:5.92578 MB
Loop:4 mem:6.87109 MB
Loop:5 mem:8.05469 MB
Loop:6 mem:8.77344 MB
Loop:7 mem:9.71875 MB
Loop:8 mem:10.7422 MB
Loop:9 mem:11.6797 MB

There is a video about this post.