Back to index

numactl  2.0.8~rc4
Functions | Variables
migspeed.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include "numa.h"
#include "numaif.h"
#include <time.h>
#include <errno.h>
#include <malloc.h>
#include <unistd.h>
#include "util.h"

Go to the source code of this file.

Functions

void usage (void)
void displaymap (void)
int main (int argc, char *argv[])

Variables

char * memory
unsigned long pages = 1000
unsigned long pagesize
const char * optstr = "hvp:"
char * cmd
int verbose

Function Documentation

void displaymap ( void  )

Definition at line 41 of file migspeed.c.

{
       FILE *f = fopen("/proc/self/numa_maps","r");

       if (!f) {
              printf("/proc/self/numa_maps not accessible.\n");
              exit(1);
       }

       while (!feof(f))
       {
              char buffer[2000];

              if (!fgets(buffer, sizeof(buffer), f))
                     break;
              if (!strstr(buffer, "bind"))
                     continue ;
              printf("%s", buffer);

       }
       fclose(f);
}

Here is the caller graph for this function:

int main ( int  argc,
char *  argv[] 
)

Definition at line 64 of file migspeed.c.

{
       char *p;
       int option;
       int error = 0;
       struct timespec result;
       unsigned long bytes;
       double duration, mbytes;
       struct bitmask *from;
       struct bitmask *to;

       pagesize = getpagesize();

       /* Command line processing */
       opterr = 1;
       cmd = argv[0];

       while ((option = getopt(argc, argv, optstr)) != EOF)
       switch (option) {
       case 'h' :
       case '?' :
              error = 1;
              break;
       case 'v' :
              verbose++;
              break;
       case 'p' :
              pages = strtoul(optarg, &p, 0);
              if (p == optarg || *p)
                     usage();
              break;
       }

       if (!argv[optind])
              usage();

       if (verbose > 1)
              printf("numa_max_node = %d\n", numa_max_node());

       numa_exit_on_error = 1;

       from = numa_parse_nodestring(argv[optind]);
       if (!from) {
                printf ("<%s> is invalid\n", argv[optind]);
              exit(1);
       }
       if (errno) {
              perror("from mask");
              exit(1);
       }

       if (verbose)
              printmask("From", from);

       if (!argv[optind+1])
              usage();

       to = numa_parse_nodestring(argv[optind+1]);
       if (!to) {
                printf ("<%s> is invalid\n", argv[optind+1]);
              exit(1);
       }
       if (errno) {
              perror("to mask");
              exit(1);
       }

       if (verbose)
              printmask("To", to);

       bytes = pages * pagesize;

       if (verbose)
              printf("Allocating %lu pages of %lu bytes of memory\n",
                            pages, pagesize);

       memory = memalign(pagesize, bytes);

       if (!memory) {
              printf("Out of Memory\n");
              exit(2);
       }

       if (mbind(memory, bytes, MPOL_BIND, from->maskp, from->size, 0) < 0)
              numa_error("mbind");

       if (verbose)
              printf("Dirtying memory....\n");

       for (p = memory; p <= memory + bytes; p += pagesize)
              *p = 1;

       if (verbose)
              printf("Starting test\n");

       displaymap();
       clock_gettime(CLOCK_REALTIME, &start);

       if (mbind(memory, bytes, MPOL_BIND, to->maskp, to->size, MPOL_MF_MOVE) <0)
              numa_error("memory move");

       clock_gettime(CLOCK_REALTIME, &end);
       displaymap();

       result.tv_sec = end.tv_sec - start.tv_sec;
       result.tv_nsec = end.tv_nsec - start.tv_nsec;

       if (result.tv_nsec < 0) {
              result.tv_sec--;
              result.tv_nsec += 1000000000;
       }

       if (result.tv_nsec >= 1000000000) {
              result.tv_sec++;
              result.tv_nsec -= 1000000000;
       }

       duration = result.tv_sec + result.tv_nsec / 1000000000.0;
       mbytes = bytes / (1024*1024.0);

       printf("%1.1f Mbyte migrated in %1.2f secs. %3.1f Mbytes/second\n",
                     mbytes,
                     duration,
                     mbytes / duration);
       return 0;
}

Here is the call graph for this function:

void usage ( void  )

Definition at line 30 of file migspeed.c.

{
       printf("usage %s [-p pages] [-h] [-v] from-nodes to-nodes\n", cmd);
       printf("      from and to nodes may specified in form N or N-N\n");
       printf("      -p pages  number of pages to try (defaults to %ld)\n",
                     pages);
       printf("      -v        verbose\n");
       printf("      -h        usage\n");
       exit(1);
}

Variable Documentation

char* cmd

Definition at line 25 of file migspeed.c.

char* memory

Definition at line 17 of file migspeed.c.

const char* optstr = "hvp:"

Definition at line 23 of file migspeed.c.

unsigned long pages = 1000

Definition at line 19 of file migspeed.c.

unsigned long pagesize

Definition at line 21 of file migspeed.c.

int verbose

Definition at line 27 of file migspeed.c.