This is a test-application that shows the effects of mlockall() on stack memory.
/* * gcc -o check_stack_page_faults check_stack_page_faults.c -Wall -O3 -lpthread * This application checks whether mlockall() forces all pages of a * stack into RAM. */ #include <limits.h> #include <pthread.h> #include <sched.h> #include <semaphore.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/mman.h> #include <sys/resource.h> #include <unistd.h> /* struct thread_data communicates data to our threads */ struct thread_data { char *name; sem_t semId; size_t stack_filler_size; }; /* Lock the application in memory to avoid page faults */ static void lock_application(void) { if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) { perror("mlockall() failed"); exit(-1); } } /* Dump minor and major page faults that occurred since the previous call */ static int dump_page_faults(void) { int new_minor_page_faults, new_major_page_faults; int page_faults_detected = 0; static struct rusage rusage_prev; struct rusage rusage; static int init; getrusage(RUSAGE_SELF, &rusage); new_minor_page_faults = rusage.ru_minflt - rusage_prev.ru_minflt; new_major_page_faults = rusage.ru_majflt - rusage_prev.ru_majflt; rusage_prev.ru_minflt = rusage.ru_minflt; rusage_prev.ru_majflt = rusage.ru_majflt; if (init) { if ((new_minor_page_faults > 0) || (new_major_page_faults > 0)) { printf("New minor/major page faults: %d/%d\n", new_minor_page_faults, new_major_page_faults); page_faults_detected = 1; } } init = 1; return page_faults_detected; } /* Start a thread */ static pthread_t startThread(int prio, int stack_size, void *(*thread_run)(void *), void *args) { int min_stack_size = 16384; struct sched_param sched; const char *failure; pthread_attr_t attr; int priority_min; int priority_max; pthread_t tid; int policy; for (;;) { policy = sched_getscheduler(0); if (policy == -1) { failure = "sched_getscheduler"; break; } priority_min = sched_get_priority_min(policy); if (priority_min == -1) { failure = "sched_get_priority_min"; break; } if (prio < priority_min) prio = priority_min; priority_max = sched_get_priority_max(policy); if (priority_max == -1) { failure = "sched_get_priority_max"; break; } if (prio > priority_max) prio = priority_max; if (sched_getparam(0, &sched) != 0) { failure = "sched_getparam"; break; } if (pthread_attr_init(&attr) != 0) { failure = "pthread_attr_init"; break; } if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) != 0) { failure = "pthread_attr_setdetachstate"; break; } if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) != 0) { failure = "pthread_attr_setscope"; break; } if (stack_size < min_stack_size) stack_size = min_stack_size; if (pthread_attr_setstacksize(&attr, stack_size) != 0) { failure = "pthread_attr_setstacksize"; break; } if (pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) != 0) { failure = "pthread_attr_setinheritsched"; break; } if (pthread_attr_setschedpolicy(&attr, policy) != 0) { failure = "pthread_attr_setschedpolicy"; break; } sched.sched_priority = prio; if (pthread_attr_setschedparam(&attr, &sched) != 0) { failure = "pthread_attr_setschedparam"; break; } if (pthread_create(&tid, &attr, thread_run, args) != 0) { failure = "pthread_create"; break; } if (pthread_attr_destroy(&attr) != 0) { failure = "pthread_attr_destroy"; break; } return tid; } printf("FAILURE while %s in startThread\n", failure); return -1; } /* Define a stack size for our threads */ static const int stack_size = 1024 * 1024 * 8; /* Our thread routine */ static void *check_stack_thread(void *pArg) { struct thread_data *pthread_data = (struct thread_data *)pArg; int i; /* Tell the world we are alive */ printf("%s started\n", pthread_data->name); /* Wait until we are told to fill the stack */ sem_wait(&(pthread_data->semId)); { /* Limit the scope */ char stack_filler[pthread_data->stack_filler_size]; printf("%s performing checks\n", pthread_data->name); for (i = 0; i < (int)pthread_data->stack_filler_size; i += sysconf(_SC_PAGESIZE)) { stack_filler[i] = 42; } /* dummy read of stack_filler[52] to prevent unused warning */ printf("%s done %d\n", pthread_data->name, stack_filler[52]); } /* Wait until we are told to terminate */ sem_wait(&(pthread_data->semId)); printf("%s terminating\n", pthread_data->name); return 0; } int main(int argc, char *argv[]) { const int page_size = sysconf(_SC_PAGESIZE); int page_faults_detected_in_thread1; int page_faults_detected_in_thread2; int lock_memory = 1; struct thread_data thread_data[2]; pthread_t thread_ids[2]; int i; /* Start a thread prior to locking memory. */ thread_data[0].name = "Thread 1: "; (void)sem_init(&(thread_data[0].semId), 0, 0); thread_data[0].stack_filler_size = stack_size - PTHREAD_STACK_MIN; thread_ids[0] = startThread(0, stack_size, check_stack_thread, (void *)&thread_data[0]); if (thread_ids[0] == -1) { printf("Exiting - Unexpected failure while creating thread1\n"); exit(-1); } /* Give it 1 second to start */ sleep(1); for (i = 1; i < argc; i++) { if (strncmp(argv[i], "-nolockmem", 10) == 0) lock_memory = 0; } if (lock_memory) { lock_application(); printf("Current and future memory locked in RAM\n"); } (void)dump_page_faults(); /* Set the baseline */ /* * From this point onwards we no longer expect to have any * page faults for currently allocated memory. */ /* Make the first thread fill the stack. */ sem_post(&(thread_data[0].semId)); /* Give it 1 second to complete. */ sleep(1); page_faults_detected_in_thread1 = dump_page_faults(); if (lock_memory) { if (!page_faults_detected_in_thread1) printf("After locking memory, no new page faults " \ "have been generated during stack access of " \ "thread 1. This is expected.\n"); else printf("After locking memory, new page faults have " \ "been generated during during stack access " \ "of thread 1. This is unexpected!\n"); } /* * Thread 1 has not yet terminated, meaning that thread 2 will not * reuse the same (locked) stack region. */ /* Start the second thread and make it fill the stack. */ thread_data[1].name = "Thread 2: "; (void)sem_init(&(thread_data[1].semId), 0, 0); thread_data[1].stack_filler_size = stack_size - PTHREAD_STACK_MIN; thread_ids[1] = startThread(0, stack_size, check_stack_thread, (void *)&thread_data[1]); if (thread_ids[1] == -1) { printf("Exiting - Unexpected failure while creating thread2\n"); exit(-1); } /* Give it 1 second to start */ sleep(1); if (lock_memory) { if (dump_page_faults()) /* Reset the baseline */ printf("New page faults have occurred as a result " \ "of starting thread 2. This is expected.\n"); else printf("Did not observe new page faults as a result " \ "of starting thread 2. This is unexpected!\n"); } else { (void)dump_page_faults(); /* Reset the baseline */ } sem_post(&(thread_data[1].semId)); /* Give it 1 second to complete. */ sleep(1); page_faults_detected_in_thread2 = dump_page_faults(); /* Check whether page faults have been detected. */ int exit_code = 0; if ((page_faults_detected_in_thread1) || (page_faults_detected_in_thread2)) { exit_code = 1; } /* Make the threads terminate */ sem_post(&(thread_data[0].semId)); sem_post(&(thread_data[1].semId)); (void)pthread_join(thread_ids[0], 0); (void)pthread_join(thread_ids[1], 0); printf("Done, result: %s\n", (exit_code != 0) ? "failed" : "success"); return exit_code; }