ioshark/ioshark_bench_mmap.c

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <sys/time.h>
  19 #include <sys/types.h>
  20 #include <unistd.h>
  21 #include <sys/syscall.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <pthread.h>
  25 #include <sys/stat.h>
  26 #include <sys/errno.h>
  27 #include <fcntl.h>
  28 #include <string.h>
  29 #include <assert.h>
  30 #include "ioshark.h"
  31 #include "ioshark_bench.h"
  32
  33 /*
  34  * The purpose of this code is to convert mmap() calls into
  35  * a mix of (semi)-random reads and writes.
  36  * PROT_READ => 4KB/8KB/16KB random reads.
  37  * PROT_WRITE => adds 4KB random writes.
  38  */
  39
  40 extern char *progname;
  41
  42 #define IOSHARK_MAX_MMAP_IOLEN  (16*1024)
  43
  44 #define MMAP_ENTS               16
  45
  46 struct mmap_io_ent_tab_s {
  47         off_t offset;
  48         size_t len;
  49 };
  50
  51 struct mmap_io_ent_s {
  52         int                             num_entries;
  53         struct mmap_io_ent_tab_s        table[MMAP_ENTS + 1];
  54         size_t                          resid;
  55 };
  56
  57 static void
  58 setup_mmap_io_state(struct mmap_io_ent_s *mio,
  59                     size_t total_len, off_t offset)
  60 {
  61         int slice;
  62
  63         memset(mio, 0, sizeof(struct mmap_io_ent_s));
  64         mio->resid = total_len;
  65         slice = MAX(IOSHARK_MAX_MMAP_IOLEN,
  66                     total_len / MMAP_ENTS);
  67         while (total_len > 0) {
  68                 assert(mio->num_entries < MMAP_ENTS + 1);
  69                 mio->table[mio->num_entries].offset = offset;
  70                 mio->table[mio->num_entries].len =
  71                         MIN((u_int64_t)total_len, (u_int64_t)slice);
  72                 total_len -= mio->table[mio->num_entries].len;
  73                 offset += mio->table[mio->num_entries].len;
  74                 mio->num_entries++;
  75         }
  76 }
  77
  78 static size_t
  79 mmap_getnext_off_len(struct mmap_io_ent_s *mio,
  80                      off_t *offset)
  81 {
  82         int i;
  83         int find_rand_index[MMAP_ENTS + 1];
  84         int rand_index_len = 0;
  85         size_t iolength;
  86
  87         if (mio->resid == 0)
  88                 return 0;
  89         /* Pick a slot with residual length > 0 at random first */
  90         for (i = 0 ; i < MMAP_ENTS + 1 ; i++) {
  91                 if (mio->table[i].len > 0)
  92                         find_rand_index[rand_index_len++] = i;
  93         }
  94         i = find_rand_index[rand() % rand_index_len];
  95         /* Randomize iolength 4K-16K */
  96         iolength = ((rand() % 4) + 1) * 4096;
  97         iolength = MIN(mio->table[i].len, iolength);
  98         *offset = mio->table[i].offset;
  99         mio->table[i].offset += iolength;
 100         mio->table[i].len -= iolength;
 101         mio->resid -= iolength;
 102         return iolength;
 103 }
 104
 105 static void
 106 mmap_do_io(void *db_node, int prot, off_t offset, size_t len,
 107            char **bufp, int *buflen, u_int64_t *op_counts,
 108            struct rw_bytes_s *rw_bytes)
 109 {
 110         char *p;
 111         int ret;
 112
 113         if (!(prot & IOSHARK_PROT_WRITE)) {
 114                 /* Only preads */
 115                 p = get_buf(bufp, buflen, len, 0);
 116                 ret = pread(files_db_get_fd(db_node),
 117                             p, len, offset);
 118                 rw_bytes->bytes_read += len;
 119                 if (ret < 0) {
 120                         fprintf(stderr,
 121                                 "%s: mapped pread(%s %zu %lu) error fd=%d %s\n",
 122                                 progname, files_db_get_filename(db_node),
 123                                 len, offset, files_db_get_fd(db_node),
 124                                 strerror(errno));
 125                         exit(EXIT_FAILURE);
 126                 }
 127                 op_counts[IOSHARK_MAPPED_PREAD]++;
 128         } else {
 129                 /* 50-50 R/W */
 130                 if ((rand() % 2) == 1) {
 131                         p = get_buf(bufp, buflen, len, 1);
 132                         ret = pwrite(files_db_get_fd(db_node),
 133                                      p, len, offset);
 134                         rw_bytes->bytes_written += len;
 135                         if (ret < 0) {
 136 #if 0
 137                                 fprintf(stderr,
 138                                         "%s: mapped pwrite failed, file unwriteable ? open_flags=%x\n",
 139                                         progname,
 140                                         fcntl(files_db_get_fd(db_node), F_GETFL));
 141                                 exit(EXIT_FAILURE);
 142 #endif
 143                         } else
 144                                 op_counts[IOSHARK_MAPPED_PWRITE]++;
 145                 } else {
 146                         p = get_buf(bufp, buflen, len, 0);
 147                         ret = pread(files_db_get_fd(db_node),
 148                                     p, len, offset);
 149                         rw_bytes->bytes_read += len;
 150                         if (ret < 0) {
 151                                 fprintf(stderr,
 152                                 "%s: mapped pread(%s %zu %lu) error fd=%d %s\n",
 153                                         progname, files_db_get_filename(db_node),
 154                                         len,
 155                                         offset, files_db_get_fd(db_node),
 156                                         strerror(errno));
 157                                 exit(EXIT_FAILURE);
 158                         }
 159                         op_counts[IOSHARK_MAPPED_PREAD]++;
 160                 }
 161         }
 162 }
 163
 164 void
 165 ioshark_handle_mmap(void *db_node,
 166                     struct ioshark_file_operation *file_op,
 167                     char **bufp, int *buflen, u_int64_t *op_counts,
 168                     struct rw_bytes_s *rw_bytes)
 169 {
 170         off_t offset = file_op->mmap_offset;
 171         size_t len = file_op->mmap_len;
 172         int prot = file_op->mmap_prot;
 173         struct mmap_io_ent_s mio;
 174         struct stat statbuf;
 175
 176         if (fstat(files_db_get_fd(db_node), &statbuf) < 0) {
 177                 fprintf(stderr,
 178                         "%s: fstat failure %s\n",
 179                         __func__, strerror(errno));
 180                 exit(EXIT_FAILURE);
 181         }
 182         /*
 183          * The size of the file better accomodate offset + len
 184          * Else there is an issue with pre-creation
 185          */
 186         assert(offset + len <= statbuf.st_size);
 187         if (len <= IOSHARK_MAX_MMAP_IOLEN) {
 188                 mmap_do_io(db_node, prot, offset, len,
 189                            bufp, buflen, op_counts,
 190                            rw_bytes);
 191                 return;
 192         }
 193         setup_mmap_io_state(&mio, len, offset);
 194         assert(mio.num_entries > 0);
 195         while ((len = mmap_getnext_off_len(&mio, &offset))) {
 196                 assert((offset + len) <=
 197                        (file_op->mmap_offset + file_op->mmap_len));
 198                 mmap_do_io(db_node, prot, offset, len, bufp, buflen,
 199                            op_counts, rw_bytes);
 200         }
 201 }