← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ceph/quantal

« back to all changes in this revision

Viewing changes to src/common/obj_bencher.cc

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-07-16 09:56:24 UTC
  • mfrom: (0.3.11)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: package-import@ubuntu.com-20120716095624-azr2w4hbhei1rxmx
Tags: upstream-0.48
Import upstream version 0.48

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/obj_bencher.cc
43
43
  memset(data->object_contents, 'z', length);
44
44
}
45
45
 
 
46
ostream& ObjBencher::out(ostream& os, utime_t& t)
 
47
{
 
48
  if (show_time)
 
49
    return t.localtime(os) << " ";
 
50
  else
 
51
    return os << " ";
 
52
}
 
53
 
 
54
ostream& ObjBencher::out(ostream& os)
 
55
{
 
56
  utime_t cur_time = ceph_clock_now(g_ceph_context);
 
57
  return out(os, cur_time);
 
58
}
 
59
 
46
60
void *ObjBencher::status_printer(void *_bencher) {
47
61
  ObjBencher *bencher = (ObjBencher *)_bencher;
48
62
  bench_data& data = bencher->data;
56
70
  ONE_SECOND.set_from_double(1.0);
57
71
  bencher->lock.Lock();
58
72
  while(!data.done) {
 
73
    utime_t cur_time = ceph_clock_now(g_ceph_context);
 
74
 
59
75
    if (i % 20 == 0) {
60
76
      if (i > 0)
61
 
        cout << "min lat: " << data.min_latency
 
77
        cur_time.localtime(cout) << "min lat: " << data.min_latency
62
78
             << " max lat: " << data.max_latency
63
79
             << " avg lat: " << data.avg_latency << std::endl;
64
80
      //I'm naughty and don't reset the fill
65
 
      cout << setfill(' ')
 
81
      bencher->out(cout, cur_time) << setfill(' ')
66
82
           << setw(5) << "sec"
67
83
           << setw(8) << "Cur ops"
68
84
           << setw(10) << "started"
76
92
      * (data.trans_size)
77
93
      / (1024*1024)
78
94
      / cycleSinceChange;
 
95
 
 
96
    if (!isnan(bandwidth)) {
 
97
      if (bandwidth > data.idata.max_bandwidth)
 
98
        data.idata.max_bandwidth = bandwidth;
 
99
      if (bandwidth < data.idata.min_bandwidth)
 
100
        data.idata.min_bandwidth = bandwidth;
 
101
 
 
102
      data.history.bandwidth.push_back(bandwidth);
 
103
    }
 
104
 
79
105
    avg_bandwidth = (double) (data.trans_size) * (data.finished)
80
 
      / (double)(ceph_clock_now(g_ceph_context) - data.start_time) / (1024*1024);
 
106
      / (double)(cur_time - data.start_time) / (1024*1024);
81
107
    if (previous_writes != data.finished) {
82
108
      previous_writes = data.finished;
83
109
      cycleSinceChange = 0;
84
 
      cout << setfill(' ')
 
110
      bencher->out(cout, cur_time) << setfill(' ')
85
111
           << setw(5) << i
86
112
           << setw(8) << data.in_flight
87
113
           << setw(10) << data.started
92
118
           << setw(10) << data.avg_latency << std::endl;
93
119
    }
94
120
    else {
95
 
      cout << setfill(' ')
 
121
      bencher->out(cout, cur_time) << setfill(' ')
96
122
           << setw(5) << i
97
123
           << setw(8) << data.in_flight
98
124
           << setw(10) << data.started
145
171
  data.min_latency = 9999.0; // this better be higher than initial latency!
146
172
  data.max_latency = 0;
147
173
  data.avg_latency = 0;
 
174
  data.idata.min_bandwidth = 99999999.0;
 
175
  data.idata.max_bandwidth = 0;
148
176
  data.object_contents = contentsChars;
149
177
  lock.Unlock();
150
178
 
182
210
  lc->lock->Unlock();
183
211
}
184
212
 
 
213
static double vec_stddev(vector<double>& v)
 
214
{
 
215
  double mean = 0;
 
216
 
 
217
  if (v.size() < 2)
 
218
    return 0;
 
219
 
 
220
  vector<double>::iterator iter;
 
221
  for (iter = v.begin(); iter != v.end(); ++iter) {
 
222
    mean += *iter;
 
223
  }
 
224
 
 
225
  mean /= v.size();
 
226
 
 
227
  double stddev = 0;
 
228
  for (iter = v.begin(); iter != v.end(); ++iter) {
 
229
    double dev = *iter - mean;
 
230
    dev *= dev;
 
231
    stddev += dev;
 
232
  }
 
233
  stddev /= (v.size() - 1);
 
234
  return sqrt(stddev);
 
235
}
 
236
 
185
237
int ObjBencher::write_bench(int secondsToRun, int concurrentios) {
186
 
  cout << "Maintaining " << concurrentios << " concurrent writes of "
 
238
  out(cout) << "Maintaining " << concurrentios << " concurrent writes of "
187
239
       << data.object_size << " bytes for at least "
188
240
       << secondsToRun << " seconds." << std::endl;
189
241
 
274
326
      goto ERR;
275
327
    }
276
328
    data.cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
 
329
    data.history.latency.push_back(data.cur_latency);
277
330
    total_latency += data.cur_latency;
278
331
    if( data.cur_latency > data.max_latency) data.max_latency = data.cur_latency;
279
332
    if (data.cur_latency < data.min_latency) data.min_latency = data.cur_latency;
314
367
      goto ERR;
315
368
    }
316
369
    data.cur_latency = ceph_clock_now(g_ceph_context) - start_times[slot];
 
370
    data.history.latency.push_back(data.cur_latency);
317
371
    total_latency += data.cur_latency;
318
372
    if (data.cur_latency > data.max_latency) data.max_latency = data.cur_latency;
319
373
    if (data.cur_latency < data.min_latency) data.min_latency = data.cur_latency;
339
393
  char bw[20];
340
394
  snprintf(bw, sizeof(bw), "%.3lf \n", bandwidth);
341
395
 
342
 
  cout << "Total time run:        " << timePassed << std::endl
343
 
       << "Total writes made:     " << data.finished << std::endl
344
 
       << "Write size:            " << data.object_size << std::endl
345
 
       << "Bandwidth (MB/sec):    " << bw << std::endl
346
 
       << "Average Latency:       " << data.avg_latency << std::endl
347
 
       << "Max latency:           " << data.max_latency << std::endl
348
 
       << "Min latency:           " << data.min_latency << std::endl;
 
396
  out(cout) << "Total time run:         " << timePassed << std::endl
 
397
       << "Total writes made:      " << data.finished << std::endl
 
398
       << "Write size:             " << data.object_size << std::endl
 
399
       << "Bandwidth (MB/sec):     " << bw << std::endl
 
400
       << "Stddev Bandwidth:       " << vec_stddev(data.history.bandwidth) << std::endl
 
401
       << "Max bandwidth (MB/sec): " << data.idata.max_bandwidth << std::endl
 
402
       << "Min bandwidth (MB/sec): " << data.idata.min_bandwidth << std::endl
 
403
       << "Average Latency:        " << data.avg_latency << std::endl
 
404
       << "Stddev Latency:         " << vec_stddev(data.history.latency) << std::endl
 
405
       << "Max latency:            " << data.max_latency << std::endl
 
406
       << "Min latency:            " << data.min_latency << std::endl;
349
407
 
350
408
  //write object size/number data for read benchmarks
351
409
  ::encode(data.object_size, b_write);
532
590
  char bw[20];
533
591
  snprintf(bw, sizeof(bw), "%.3lf \n", bandwidth);
534
592
 
535
 
  cout << "Total time run:        " << runtime << std::endl
 
593
  out(cout) << "Total time run:        " << runtime << std::endl
536
594
       << "Total reads made:     " << data.finished << std::endl
537
595
       << "Read size:            " << data.object_size << std::endl
538
596
       << "Bandwidth (MB/sec):    " << bw << std::endl