code.grnet.gr Git - archipelago/blob - xseg/peers/user/bench-xseg.h

   1 /*
   2  * Copyright 2012 GRNET S.A. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or
   5  * without modification, are permitted provided that the following
   6  * conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above
   9  *      copyright notice, this list of conditions and the following
  10  *      disclaimer.
  11  *   2. Redistributions in binary form must reproduce the above
  12  *      copyright notice, this list of conditions and the following
  13  *      disclaimer in the documentation and/or other materials
  14  *      provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  17  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  23  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  26  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27  * POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * The views and conclusions contained in the software and
  30  * documentation are those of the authors and should not be
  31  * interpreted as representing official policies, either expressed
  32  * or implied, of GRNET S.A.
  33  */
  34
  35 #include <bench-lfsr.h>
  36
  37
  38 #ifdef __GNUC__
  39 #define LIKELY(x)       __builtin_expect(!!(x),1)
  40 #define UNLIKELY(x)     __builtin_expect(!!(x),0)
  41 #else
  42 #define LIKELY(x)       (x)
  43 #define UNLIKELY(x)     (x)
  44 #endif
  45
  46 /*
  47  * If CLOCK_MONOTONIC_RAW is not defined in our system, use CLOCK_MONOTONIC
  48  * instead. CLOCK_MONOTONIC_RAW is preferred since we are guaranteed that the
  49  * clock won't skew.
  50  */
  51 #ifdef CLOCK_MONOTONIC_RAW
  52 #define CLOCK_BENCH CLOCK_MONOTONIC_RAW
  53 #else
  54 #define CLOCK_BENCH CLOCK_MONOTONIC
  55 #endif
  56
  57
  58 #define MAX_ARG_LEN 10
  59
  60 /*
  61  * Pattern type occupies 1st flag bit.
  62  * If 1, it's sequential, if 0, it's random.
  63  */
  64 #define PATTERN_FLAG_POS 0
  65 #define PATTERN_BITMASK 1
  66 #define PATTERN_SEQ 0
  67 #define PATTERN_RAND 1
  68
  69 /*
  70  * Verify mode occupies 2nd and 3rd flag bit.
  71  * If 01, it uses metadata for verification, if 11 it writes pseudorandom nums
  72  * in chunk's memory range and if 00, it's off.
  73  */
  74 #define VERIFY_FLAG_POS 1
  75 #define VERIFY_BITMASK 3        /* i.e. "11" in binary form */
  76 #define VERIFY_NO 0
  77 #define VERIFY_META 1
  78 #define VERIFY_FULL 2
  79
  80 /* Timer insanity occupies 4th and 5th flag bit */
  81 #define INSANITY_FLAG_POS 3
  82 #define INSANITY_BITMASK 3      /* i.e. "11" in binary form */
  83 #define INSANITY_SANE 0
  84 #define INSANITY_ECCENTRIC 1
  85 #define INSANITY_MANIC 2
  86 #define INSANITY_PARANOID 3
  87
  88 /* Progress bar option occupies 6th flag bit */
  89 #define PROGRESS_FLAG_POS 5
  90 #define PROGRESS_BITMASK 1      /* i.e. "11" in binary form */
  91 #define PROGRESS_NO 0
  92 #define PROGRESS_YES 1
  93
  94 /*
  95  * Current bench flags representation:
  96  * 64 7  6  5  4  3  2  1 : bits
  97  * ...0  0  0  0  0  0  0
  98  *      |_||____||____||_|
  99  *               ^        ^         ^   ^
 100  *               |        |             |   |
 101  *               | insanity     | pattern
 102  *        progress       verify
 103  */
 104
 105 /*
 106  * Find position of flag, make it zero, get requested flag value, store it to
 107  * this position
 108  */
 109 #define SET_FLAG(__ftype, __flag, __val)        \
 110         __flag = (__flag & ~(__ftype##_BITMASK << __ftype##_FLAG_POS)) | \
 111         (__val << __ftype##_FLAG_POS);
 112
 113 /* Apply bitmask to flags, shift result to the right to get correct value */
 114 #define GET_FLAG(__ftype, __flag)                       \
 115         (__flag & (__ftype##_BITMASK << __ftype##_FLAG_POS)) >> __ftype##_FLAG_POS
 116
 117 /*
 118  * The benchark ID (IDLEN) is global for the test, calculated once and is a
 119  * string of the following form: {"bench-" + 9-digit number + "\0"}.
 120  * The target string (TARGETLEN) is per object, concatenated with the string
 121  * above and is of the following form: {"-" +16-digit number}.
 122  */
 123 #define IDLEN 15
 124 #define TARGETLEN (IDLEN + 1 + 16)
 125 extern char global_id[IDLEN + 1];
 126
 127 struct bench {
 128         uint64_t to; //Total number of objects (not for read/write)
 129         uint64_t ts; //Total I/O size
 130         uint64_t os; //Object size
 131         uint64_t bs; //Block size
 132         uint32_t iodepth; //Num of in-flight xseg reqs
 133         xport dst_port;
 134         xport src_port;
 135         uint32_t op;    //xseg operation
 136         uint64_t flags;
 137         struct peerd *peer;
 138         struct req_status *status;
 139         struct bench_lfsr *lfsr;
 140         struct timer *total_tm; //Total time for benchmark
 141         struct timer *get_tm;   //Time for xseg_get_request
 142         struct timer *sub_tm;   //Time for xseg_submit_request
 143         struct timer *rec_tm;   //Time for xseg_receive_request
 144 };
 145
 146 struct req_status {
 147         uint64_t max;           /* Max requests for benchmark */
 148         uint64_t submitted;
 149         uint64_t received;
 150         uint64_t corrupted;     /* Requests that did not pass verification */
 151         uint64_t failed;
 152 };
 153
 154 /*
 155  * Custom timespec. Made to calculate variance, where we need the square of a
 156  * timespec struct. This struct should be more than enough to hold the square
 157  * of the biggest timespec.
 158  */
 159 struct timespec2 {
 160         unsigned long tv_sec2;
 161         uint64_t tv_nsec2;
 162 };
 163
 164 /*
 165  * struct timer fields
 166  * ====================
 167  * completed: number of completed requests
 168  * start_time: submission time of a request
 169  * sum: the sum of elapsed times of every completed request
 170  * sum_sq: the sum of the squares of elapsed times
 171  * insanity: benchmarking level, higher means that the request associated with
 172  *           this timer is more trivial.
 173  */
 174 struct timer {
 175         struct timespec sum;
 176         struct timespec2 sum_sq;
 177         struct timespec start_time;
 178         uint64_t completed;
 179         int insanity;
 180 };
 181
 182 struct tm_result {
 183         unsigned int s;
 184         unsigned int ms;
 185         unsigned int us;
 186         unsigned int ns;
 187 };
 188
 189 struct signature {
 190         uint64_t id;
 191         uint64_t object;
 192         uint64_t offset;
 193 };
 194
 195 struct bw {
 196         double val;
 197         char unit[5];
 198 };
 199
 200 int bench_peerd_loop(void *arg);
 201
 202 void timer_start(struct bench *prefs, struct timer *sample_req);
 203 void timer_stop(struct bench *prefs, struct timer *sample_tm,
 204                 struct timespec *start);
 205 int init_timer(struct timer **tm, int insanity);
 206 uint64_t str2num(char *str);
 207 int read_op(char *op);
 208 int read_pattern(char *pattern);
 209 int read_insanity(char *insanity);
 210 int read_verify(char *insanity);
 211 int read_progress(char *progress);
 212 void print_res(struct bench *prefs);
 213 void print_stats(struct bench *prefs);
 214 void print_progress(struct bench *prefs);
 215 void print_remaining(struct bench *prefs);
 216 void create_target(struct bench *prefs, struct xseg_request *req,
 217                 uint64_t new);
 218 void create_chunk(struct bench *prefs, struct xseg_request *req, uint64_t new);
 219 int read_chunk(struct bench *prefs, struct xseg_request *req);
 220 uint64_t determine_next(struct bench *prefs);
 221 uint64_t calculate_offset(struct bench *prefs, uint64_t new);
 222 uint64_t calculate_prog_quantum(struct bench *prefs);
 223 void create_id(unsigned long seed);
 224