folly/io/test/NetworkBenchmark.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   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 <folly/io/IOBuf.h>
  18
  19 #include <gflags/gflags.h>
  20 #include <folly/Benchmark.h>
  21 #include <folly/io/Cursor.h>
  22
  23 #include <vector>
  24
  25 using folly::IOBuf;
  26 using std::unique_ptr;
  27 using namespace folly::io;
  28 using namespace std;
  29
  30 size_t buf_size = 0;
  31 size_t num_bufs = 0;
  32
  33 BENCHMARK(reserveBenchmark, iters) {
  34   while (iters--) {
  35     unique_ptr<IOBuf> iobuf1(IOBuf::create(buf_size));
  36     iobuf1->append(buf_size);
  37     for (size_t bufs = num_bufs; bufs > 1; bufs --) {
  38       iobuf1->reserve(0, buf_size);
  39       iobuf1->append(buf_size);
  40     }
  41   }
  42 }
  43
  44 BENCHMARK(chainBenchmark, iters) {
  45   while (iters--) {
  46     unique_ptr<IOBuf> iobuf1(IOBuf::create(buf_size));
  47     iobuf1->append(buf_size);
  48     for (size_t bufs = num_bufs; bufs > 1; bufs --) {
  49       unique_ptr<IOBuf> iobufNext(IOBuf::create(buf_size));
  50       iobuf1->prependChain(std::move(iobufNext));
  51     }
  52   }
  53 }
  54
  55 vector<unique_ptr<IOBuf>> bufPool;
  56 inline unique_ptr<IOBuf> poolGetIOBuf() {
  57   if (bufPool.size() > 0) {
  58     unique_ptr<IOBuf> ret = std::move(bufPool.back());
  59     bufPool.pop_back();
  60     return std::move(ret);
  61   } else {
  62     unique_ptr<IOBuf> iobuf(IOBuf::create(buf_size));
  63     iobuf->append(buf_size);
  64     return std::move(iobuf);
  65   }
  66 }
  67
  68 inline void poolPutIOBuf(unique_ptr<IOBuf>&& buf) {
  69   unique_ptr<IOBuf> head = std::move(buf);
  70   while (head) {
  71     unique_ptr<IOBuf> next = std::move(head->pop());
  72     bufPool.push_back(std::move(head));
  73     head = std::move(next);
  74   }
  75 }
  76
  77 BENCHMARK(poolBenchmark, iters) {
  78   while (iters--) {
  79     unique_ptr<IOBuf> head = std::move(poolGetIOBuf());
  80     for (size_t bufs = num_bufs; bufs > 1; bufs --) {
  81       unique_ptr<IOBuf> iobufNext = std::move(poolGetIOBuf());
  82       head->prependChain(std::move(iobufNext));
  83     }
  84     // cleanup
  85     poolPutIOBuf(std::move(head));
  86   }
  87 }
  88
  89 void setNumbers(size_t size, size_t num) {
  90   buf_size = size;
  91   num_bufs = num;
  92   bufPool.clear();
  93
  94   printf("\nBuffer size: %zu, number of buffers: %zu\n\n", size, num);
  95 }
  96
  97 /*
  98 ------------------------------------------------------------------------------
  99 reserveBenchmark                       100000  9.186 ms  91.86 ns  10.38 M
 100 chainBenchmark                         100000  59.44 ms  594.4 ns  1.604 M
 101 poolBenchmark                          100000  15.87 ms  158.7 ns   6.01 M
 102
 103 Buffer size: 100, number of buffers: 10
 104
 105 Benchmark                               Iters   Total t    t/iter iter/sec
 106 ------------------------------------------------------------------------------
 107 reserveBenchmark                       100000     62 ms    620 ns  1.538 M
 108 chainBenchmark                         100000  59.48 ms  594.8 ns  1.603 M
 109 poolBenchmark                          100000  16.07 ms  160.7 ns  5.933 M
 110
 111 Buffer size: 2048, number of buffers: 10
 112
 113 Benchmark                               Iters   Total t    t/iter iter/sec
 114 ------------------------------------------------------------------------------
 115 reserveBenchmark                       100000  148.4 ms  1.484 us  658.2 k
 116 chainBenchmark                         100000  140.9 ms  1.409 us    693 k
 117 poolBenchmark                          100000  16.73 ms  167.3 ns    5.7 M
 118
 119 Buffer size: 10000, number of buffers: 10
 120
 121 Benchmark                               Iters   Total t    t/iter iter/sec
 122 ------------------------------------------------------------------------------
 123 reserveBenchmark                       100000    234 ms   2.34 us  417.3 k
 124 chainBenchmark                         100000  142.3 ms  1.423 us  686.1 k
 125 poolBenchmark                          100000  16.78 ms  167.8 ns  5.684 M
 126
 127 Buffer size: 100000, number of buffers: 10
 128
 129 Benchmark                               Iters   Total t    t/iter iter/sec
 130 ------------------------------------------------------------------------------
 131 reserveBenchmark                       100000  186.5 ms  1.865 us  523.5 k
 132 chainBenchmark                         100000  360.5 ms  3.605 us  270.9 k
 133 poolBenchmark                          100000  16.52 ms  165.2 ns  5.772 M
 134
 135 Buffer size: 1000000, number of buffers: 10
 136
 137 Benchmark                               Iters   Total t    t/iter iter/sec
 138 ------------------------------------------------------------------------------
 139 reserveBenchmark                          156  2.084 s   13.36 ms  74.84
 140 chainBenchmark                          30082  2.001 s    66.5 us  14.68 k
 141 poolBenchmark                          100000  18.18 ms  181.8 ns  5.244 M
 142
 143
 144 Buffer size: 10, number of buffers: 20
 145
 146 Benchmark                               Iters   Total t    t/iter iter/sec
 147 ------------------------------------------------------------------------------
 148 reserveBenchmark                       100000  12.54 ms  125.4 ns  7.603 M
 149 chainBenchmark                         100000  118.6 ms  1.186 us  823.2 k
 150 poolBenchmark                          100000   32.2 ms    322 ns  2.962 M
 151 */
 152 int main(int argc, char** argv) {
 153   gflags::ParseCommandLineFlags(&argc, &argv, true);
 154
 155   setNumbers(10, 10);
 156   folly::runBenchmarks();
 157   setNumbers(100, 10);
 158   folly::runBenchmarks();
 159   setNumbers(2048, 10);
 160   folly::runBenchmarks();
 161   setNumbers(10000, 10);
 162   folly::runBenchmarks();
 163   setNumbers(100000, 10);
 164   folly::runBenchmarks();
 165   setNumbers(1000000, 10);
 166   folly::runBenchmarks();
 167
 168   setNumbers(10, 20);
 169   folly::runBenchmarks();
 170
 171   return 0;
 172 }