Advertisement
Guest User

Untitled

a guest
Nov 21st, 2019
142
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 8.49 KB | None | 0 0
  1. //
  2. // Created by student on 21.11.2019.
  3. //
  4.  
  5. #include "Small.h"
  6. #include "BenchIncludes.h"
  7. #include <deque>
  8. #include <iostream>
  9.  
  10. static void SmallBenchDequeAt(benchmark::State& state)
  11. {
  12.     auto N = state.range(0);
  13.     std::deque<Small> containerDeque;
  14.     Small s1{};
  15.  
  16.     for(long i = 0; i < N; i++)
  17.     {
  18.         s1.randomize();
  19.         containerDeque.push_front(s1);
  20.     }
  21.  
  22.     for( auto AAA : state )
  23.     {
  24.         auto random = rand()%N;
  25.         containerDeque.at(random);
  26.     }
  27.  
  28.     state.SetComplexityN(N);
  29. }
  30. BENCHMARK(SmallBenchDequeAt)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  31.  
  32.  
  33.  
  34. static void SmallBenchDequeOperatorSquareBracket(benchmark::State& state)
  35. {
  36.     auto N = state.range(0);
  37.     std::deque<Small> containerDeque;
  38.     Small s1{};
  39.  
  40.     for(long i = 0; i < N; i++)
  41.     {
  42.         s1.randomize();
  43.         containerDeque.push_front(s1);
  44.     }
  45.  
  46.     for( auto AAA : state )
  47.     {
  48.         auto random = rand() % N;
  49.         containerDeque[random];
  50.     }
  51.  
  52.     state.SetComplexityN(N);
  53. }
  54. BENCHMARK(SmallBenchDequeOperatorSquareBracket)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  55.  
  56.  
  57. static void SmallBenchDequeFront(benchmark::State& state)
  58. {
  59.     auto N = state.range(0);
  60.     std::deque<Small> containerDeque;
  61.     Small s1{};
  62.  
  63.     for (long i = 0; i < N; i++)
  64.     {
  65.         s1.randomize();
  66.         containerDeque.push_front(s1);
  67.     }
  68.  
  69.     for( auto AAA : state )
  70.     {
  71.         containerDeque.front();
  72.     }
  73.  
  74.     state.SetComplexityN(N);
  75. }
  76. BENCHMARK(SmallBenchDequeFront)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  77.  
  78.  
  79. static void SmallBenchDequeBack(benchmark::State& state)
  80. {
  81.     auto N = state.range(0);
  82.     std::deque<Small> containerDeque;
  83.     Small s1{};
  84.  
  85.     for (long i = 0; i < N; i++)
  86.     {
  87.         s1.randomize();
  88.         containerDeque.push_front(s1);
  89.     }
  90.  
  91.     for( auto AAA : state )
  92.     {
  93.         containerDeque.back();
  94.     }
  95.  
  96.     state.SetComplexityN(N);
  97. }
  98. BENCHMARK(SmallBenchDequeBack)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  99.  
  100.  
  101.  static void SmallBenchDequeEmpty(benchmark::State& state)
  102. {
  103.      auto N = state.range(0);
  104.      std::deque<Small> containerDeque;
  105.      Small s1{};
  106.  
  107.      for (long i = 0; i < N; i++)
  108.      {
  109.          s1.randomize();
  110.          containerDeque.push_front(s1);
  111.      }
  112.  
  113.  
  114.      for( auto AAA : state )
  115.      {
  116.          containerDeque.empty();
  117.      }
  118.  
  119.      state.SetComplexityN(N);
  120. }
  121. BENCHMARK(SmallBenchDequeEmpty)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  122.  
  123.  
  124.  
  125. static void SmallBenchDequeSize(benchmark::State& state)
  126. {
  127.     auto N = state.range(0);
  128.     std::deque<Small> containerDeque;
  129.     Small s1{};
  130.  
  131.     for (long i = 0; i < N; i++)
  132.     {
  133.         s1.randomize();
  134.         containerDeque.push_front(s1);
  135.     }
  136.  
  137.     for( auto AAA : state )
  138.         containerDeque.size();
  139.  
  140.     state.SetComplexityN(N);
  141. }
  142. BENCHMARK(SmallBenchDequeSize)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  143.  
  144.  
  145.  
  146. static void SmallBenchDequeMaxSize(benchmark::State& state)
  147. {
  148.     auto N = state.range(0);
  149.     std::deque<Small> containerDeque;
  150.     Small s1{};
  151.  
  152.     for (long i = 0; i < N; i++)
  153.     {
  154.         s1.randomize();
  155.         containerDeque.push_front(s1);
  156.     }
  157.  
  158.     for( auto AAA : state )
  159.         containerDeque.max_size();
  160.  
  161.     state.SetComplexityN(N);
  162. }
  163. BENCHMARK(SmallBenchDequeMaxSize)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  164.  
  165.  
  166. static void SmallBenchDequeShrinkToFit(benchmark::State& state)
  167. {
  168.     auto N = state.range(0);
  169.     std::deque<Small> containerDeque;
  170.     Small s1{};
  171.  
  172.     for (long i = 0; i < N; i++)
  173.     {
  174.         s1.randomize();
  175.         containerDeque.push_front(s1);
  176.     }
  177.  
  178.     for( auto AAA : state )
  179.     {
  180.         containerDeque.shrink_to_fit();
  181.     }
  182.  
  183.     state.SetComplexityN(N);
  184. }
  185. BENCHMARK(SmallBenchDequeShrinkToFit)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  186.  
  187.  
  188. static void SmallBenchDequeClear(benchmark::State& state)
  189. {
  190.     auto N = state.range(0);
  191.     std::deque<Small> containerDeque;
  192.     Small s1{};
  193.  
  194.     for(long i = 0; i < N; i++)
  195.     {
  196.         s1.randomize();
  197.         containerDeque.push_front(s1);
  198.     }
  199.  
  200.     for( auto AAA : state )
  201.     {
  202.         containerDeque.clear();
  203.     }
  204.     state.SetComplexityN(N);
  205. }
  206. BENCHMARK(SmallBenchDequeClear)->RangeMultiplier(2)->Range(1, 1024)->Complexity();
  207.  
  208.  
  209. static void SmallBenchDequeInsert(benchmark::State& state)
  210. {
  211.     auto N = state.range(0);
  212.     std::deque<Small> containerDeque;
  213.     Small s1{};
  214.  
  215.     for(long i = 0; i < N; i++)
  216.     {
  217.         s1.randomize();
  218.         containerDeque.push_front(s1);
  219.     }
  220.  
  221.     for( auto AAA : state )
  222.     {
  223.         containerDeque.insert(containerDeque.begin() + N/2, s1);
  224.     }
  225.     state.SetComplexityN(N);
  226. }
  227. BENCHMARK(SmallBenchDequeInsert)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  228.  
  229.  
  230. static void SmallBenchDequeErase(benchmark::State& state)
  231. {
  232.     auto N = state.range(0);
  233.     std::deque<Small> containerDeque;
  234.     Small s1{};
  235.  
  236.     for(long i = 0; i < N; i++)
  237.     {
  238.         s1.randomize();
  239.         containerDeque.push_front(s1);
  240.     }
  241.  
  242.     auto iter = containerDeque.begin() + N / 2;
  243.  
  244.     for( auto AAA : state )
  245.     {
  246.         state.PauseTiming();
  247.             containerDeque.insert(iter, s1);
  248.         state.ResumeTiming();
  249.  
  250.         containerDeque.erase(iter);
  251.     }
  252.     state.SetComplexityN(N);
  253. }
  254. BENCHMARK(SmallBenchDequeErase)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  255.  
  256.  
  257.  
  258. static void SmallBenchDequePushBack(benchmark::State& state)
  259. {
  260.     auto N = state.range(0);
  261.     std::deque<Small> containerDeque;
  262.     Small s1{};
  263.  
  264.     for(long i = 0; i < N; i++)
  265.     {
  266.         s1.randomize();
  267.         containerDeque.push_front(s1);
  268.     }
  269.  
  270.     for( auto AAA : state )
  271.     {
  272.         containerDeque.push_back(s1);
  273.     }
  274.     state.SetComplexityN(N);
  275. }
  276. BENCHMARK(SmallBenchDequePushBack)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  277.  
  278.  
  279. static void SmallBenchDequePopBack(benchmark::State& state)
  280. {
  281.     auto N = state.range(0);
  282.     std::deque<Small> containerDeque;
  283.     Small s1{};
  284.  
  285.     for(long i = 0; i < N; i++)
  286.     {
  287.         s1.randomize();
  288.         containerDeque.push_front(s1);
  289.     }
  290.  
  291.     for( auto AAA : state )
  292.     {
  293.         state.PauseTiming();
  294.         containerDeque.push_back(s1);
  295.         state.ResumeTiming();
  296.  
  297.         containerDeque.pop_back();
  298.     }
  299.     state.SetComplexityN(N);
  300. }
  301. BENCHMARK(SmallBenchDequePopBack)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  302.  
  303.  
  304. static void SmallBenchDequePushFront(benchmark::State& state)
  305. {
  306.     auto N = state.range(0);
  307.     std::deque<Small> containerDeque;
  308.     Small s1{};
  309.  
  310.     for(long i = 0; i < N; i++)
  311.     {
  312.         s1.randomize();
  313.         containerDeque.push_front(s1);
  314.     }
  315.  
  316.     for( auto AAA : state )
  317.     {
  318.         containerDeque.push_front(s1);
  319.     }
  320.     state.SetComplexityN(N);
  321. }
  322. BENCHMARK(SmallBenchDequePushFront)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  323.  
  324.  
  325.  
  326. static void SmallBenchDequePopFront(benchmark::State& state)
  327. {
  328.     auto N = state.range(0);
  329.     std::deque<Small> containerDeque;
  330.     Small s1{};
  331.  
  332.     for(long i = 0; i < N; i++)
  333.     {
  334.         s1.randomize();
  335.         containerDeque.push_front(s1);
  336.     }
  337.  
  338.     for( auto AAA : state )
  339.     {
  340.         state.PauseTiming();
  341.         containerDeque.push_front(s1);
  342.         state.ResumeTiming();
  343.  
  344.         containerDeque.pop_front();
  345.     }
  346.     state.SetComplexityN(N);
  347. }
  348. BENCHMARK(SmallBenchDequePopFront)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  349.  
  350. static void SmallBenchDequeResize(benchmark::State& state)
  351. {
  352.     auto N = state.range(0);
  353.     std::deque<Small> containerDeque;
  354.     Small s1{};
  355.  
  356.     for(long i = 0; i < N; i++)
  357.     {
  358.         s1.randomize();
  359.         containerDeque.push_front(s1);
  360.     }
  361.  
  362.     for( auto AAA : state )
  363.     {
  364.        containerDeque.resize(2*N, s1);
  365.     }
  366.     state.SetComplexityN(N);
  367. }
  368. BENCHMARK(SmallBenchDequeResize)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
  369.  
  370.  
  371.  
  372. static void SmallBenchDequeSwap(benchmark::State& state)
  373. {
  374.     auto N = state.range(0);
  375.     std::deque<Small> containerDeque;
  376.     std::deque<Small> containerDeque2;
  377.     Small s1{};
  378.  
  379.     for(long i = 0; i < N; i++)
  380.     {
  381.         s1.randomize();
  382.         containerDeque.push_front(s1);
  383.         s1.randomize();
  384.         containerDeque2.push_front(s1);
  385.     }
  386.  
  387.     for( auto AAA : state )
  388.     {
  389.         containerDeque.swap(containerDeque2);
  390.     }
  391.     state.SetComplexityN(N);
  392. }
  393. BENCHMARK(SmallBenchDequeSwap)->RangeMultiplier(2)->Range(1, 1<<18)->Complexity();
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement