View source for Dynamic memory allocation example

====Advanced memory locking example====

This is a complexer example for handling memory locking.
    
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/mman.h> // Needed for mlockall()
    #include <unistd.h> // needed for sysconf(int name);
    #include <malloc.h>
    #include <sys/time.h> // needed for getrusage
    #include <sys/resource.h> // needed for getrusage
    <BR>
    #define SOMESIZE (100*1024*1024) // 100MB
    <BR>
    int main(int argc, char* argv[])
    {
        // Allocate some memory
        int i, page_size;
        char* buffer;
        struct rusage usage;
        <BR>
        // Now lock all current and future pages from preventing of being paged
        if (mlockall(MCL_CURRENT | MCL_FUTURE ))
        {
            perror("mlockall failed:");
        }
        <BR>
        // Turn off malloc trimming.
        mallopt (M_TRIM_THRESHOLD, -1);
        <BR>
        // Turn off mmap usage.
        mallopt (M_MMAP_MAX, 0);
        <BR>
        page_size = sysconf(_SC_PAGESIZE);
        buffer = malloc(SOMESIZE);
        <BR>
        // Touch each page in this piece of memory to get it mapped into RAM
        for (i=0; i < SOMESIZE; i+=page_size)
        {
            // Each write to this buffer will generate a pagefault.
            // Once the pagefault is handled a page will be locked in memory and never
            // given back to the system.
            buffer[i] = 0;
            // print the number of major and minor pagefaults this application has triggered
            getrusage(RUSAGE_SELF, &usage);
            printf("Major-pagefaults:%d, Minor Pagefaults:%d\n", usage.ru_majflt, usage.ru_minflt);
        }
        free(buffer);
        // buffer is now released. As glibc is configured such that it never gives back memory to
        // the kernel, the memory allocated above is locked for this process. All malloc() and new()
        // calls come from the memory pool reserved and locked above. Issuing free() and delete()
        // does NOT make this locking undone. So, with this locking mechanism we can build C++ applications
        // that will never run into a major/minor pagefault, even with swapping enabled.
        <BR>
        //<do your RT-thing>
        <BR>
        return 0;
    }

==Author/Maintainer==
<p>
[[User:Remy | Remy Bohmer]]<br>
</p>

==Revision==
{| border="1" width="100%" summary="Revision history"
! align="left" valign="top" colspan="2" | <b>Revision History</b>
|- 
| align="left" | Revision 1
| align="left" | 2008-01-15
|}