LFS201 - Chapter 13 Discussion // Questions // Banter

Here's a little C program that we use in some other courses to devour and then release the memory. Just run it with one argument (the memory to eat in MB) or with no argument figures out how much memory you have and uses that.

c8:/tmp>cat lab_wastemem.c

/* simple program to defragment memory, J. Cooperstein 2/04-1/2020
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/sysinfo.h>
#include <signal.h>

#define MB (1024*1024)
#define BS 16           /* will allocate BS*MB at each step */
#define CHUNK (MB*BS)
#define QUIT_TIME 20
void quit_on_timeout(int sig)
{
    printf("\n\nTime expired, quitting\n");
    exit(EXIT_SUCCESS);
}   

int main(int argc, char **argv)
{
    struct sysinfo si;
    int j, m;
    char *c;

    /* get total memory on the system */
    sysinfo(&si);
    m = si.totalram / MB;
    printf("Total System Memory in MB = %d MB\n", m);
    m = (9 * m) / 10;   /* drop 10 percent */
    printf("Using somewhat less: %d MB\n", m);

    if (argc == 2) {
        m = atoi(argv[1]);
        printf("Choosing instead mem = %d MB\n", m);
    }

    signal(SIGALRM, quit_on_timeout);
    printf("Will quite in QUIT_TIME seconds if no normal termination\n");
    alarm(QUIT_TIME);

    for (j = 0; j <= m; j += BS) {
        /* yes we know this is a memory leak, no free,
         * that's the idea!
         */
        c = malloc(CHUNK);
        /* just fill the block with j over and over */
        memset(c, j, CHUNK);
        printf("%8d", j);
        fflush(stdout);
    }
    printf("\n\n    Quitting and releasing memory\n");
    exit(EXIT_SUCCESS);
}

You can compile with "gcc -o lab_wastemem.c lab_wastemem.c" and run with "./lab_wastememc." (or any other name you want.

This started out as a one line program in C (really) but evolved to this.

Hi @heiko_s , that's good! Did you try that on CentOS or Ubuntu LST?

Regards,
Luis.

I was also not able to fill it up on CentOS. I will have to revisit this one..

Hi @heiko_s ,

I found a C code that works faster than stress-ng. Perhaps I forgot to disable swap, because I did it on Ubuntu 18 and stress-ng took some time before killing the process, triggering the OOM Killer, and restarting the process (but it worked anyway).

So, I tried the following C code and it worked very fast (it's necessary to disable swap as well):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define PAGE_SZ (1<<12)

int main() {
    int i;
    int gb = 2; // memory to consume in GB

    for (i = 0; i < ((unsigned long)gb<<30)/PAGE_SZ ; ++i) {
        void *m = malloc(PAGE_SZ);
        if (!m)
            break;
        memset(m, 0, 1);
    }
    printf("allocated %lu MB\n", ((unsigned long)i*PAGE_SZ)>>20);
    getchar();
    return 0;
}

Then compile it as "gcc memory_exhaust.c -o memory_exhaust", and then run it

Many regards,
Luis.

Hi @TemiAworanti ,

The offending process -the one that's consuming more memory, or causing memory exhaustion- will be terminated first.

Many regards,
Luis.