test/test74.c

   1 /* Test 74 - mmap functionality test.
   2  */
   3
   4 #include <sys/types.h>
   5 #include <sys/mman.h>
   6 #include <sys/ioc_memory.h>
   7 #include <stdio.h>
   8 #include <assert.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13
  14 #include "common.h"
  15 #include "testcache.h"
  16
  17 int
  18 dowriteblock(int b, int blocksize, u32_t seed, char *data)
  19 {
  20         u64_t offset;
  21         int fd;
  22
  23         get_fd_offset(b, blocksize, &offset, &fd);
  24
  25         if(pwrite(fd, data, blocksize, offset) < blocksize) {
  26                 perror("pwrite");
  27                 return -1;
  28         }
  29
  30         return blocksize;
  31 }
  32
  33 int
  34 readblock(int b, int blocksize, u32_t seed, char *data)
  35 {
  36         u64_t offset;
  37         int fd;
  38         char *mmapdata;
  39         int pread_first = random() % 2;
  40
  41         get_fd_offset(b, blocksize, &offset, &fd);
  42
  43         if(pread_first) {
  44                 if(pread(fd, data, blocksize, offset) < blocksize) {
  45                         perror("pread");
  46                         return -1;
  47                 }
  48         }
  49
  50         if((mmapdata = mmap(NULL, blocksize, PROT_READ, MAP_PRIVATE | MAP_FILE,
  51                 fd, offset)) == MAP_FAILED) {
  52                 perror("mmap");
  53                 return -1;
  54         }
  55
  56         if(!pread_first) {
  57                 if(pread(fd, data, blocksize, offset) < blocksize) {
  58                         perror("pread");
  59                         return -1;
  60                 }
  61         }
  62
  63         if(memcmp(mmapdata, data, blocksize)) {
  64                 fprintf(stderr, "readblock: mmap, pread mismatch\n");
  65                 return -1;
  66         }
  67
  68         if(munmap(mmapdata, blocksize) < 0) {
  69                 perror("munmap");
  70                 return -1;
  71         }
  72
  73         return blocksize;
  74 }
  75
  76 void testend(void) { }
  77
  78 void basic_regression(void)
  79 {
  80         void *block;
  81 #define BLOCKSIZE (PAGE_SIZE*10)
  82         block = mmap(0, BLOCKSIZE, PROT_READ | PROT_WRITE,
  83                 MAP_PRIVATE | MAP_ANON, -1, 0);
  84
  85         if(block == MAP_FAILED) { e(1); exit(1); }
  86
  87         memset(block, 0, BLOCKSIZE);
  88
  89         /* shrink from bottom */
  90         munmap(block, PAGE_SIZE);
  91 }
  92
  93 int
  94 main(int argc, char *argv[])
  95 {
  96         int iter = 2;
  97
  98         start(74);
  99
 100         basic_regression();
 101
 102         makefiles(MAXFILES);
 103
 104         cachequiet(!bigflag);
 105         if(bigflag) iter = 3;
 106
 107         /* Try various combinations working set sizes
 108          * and block sizes in order to specifically
 109          * target the primary cache, then primary+secondary
 110          * cache, then primary+secondary cache+secondary
 111          * cache eviction.
 112          */
 113
 114         if(dotest(PAGE_SIZE,    100, iter)) e(5);
 115         if(dotest(PAGE_SIZE*2,  100, iter)) e(2);
 116         if(dotest(PAGE_SIZE*3,  100, iter)) e(3);
 117         if(dotest(PAGE_SIZE,  20000, iter)) e(5);
 118
 119         if(bigflag) {
 120                 u32_t totalmem, freemem, cachedmem;
 121                 if(dotest(PAGE_SIZE,  150000, iter)) e(5);
 122                 getmem(&totalmem, &freemem, &cachedmem);
 123                 if(dotest(PAGE_SIZE,  totalmem*1.5, iter)) e(6);
 124         }
 125
 126         quit();
 127
 128         return 0;
 129 }
 130