Commit 34897eeb authored by tqcq's avatar tqcq
Browse files

feat update picobench

parent 7c158276

CMakeLists.txt

+14 −8
Original line number Diff line number Diff line
@@ -18,6 +18,10 @@ set(BUILD_RTTR_DYNAMIC OFF) 
set(BUILD_UNIT_TESTS OFF)

set(BUILD_EXAMPLES OFF)

add_library(test_main STATIC src/sled/testing/test_main.cc)

add_library(benchmark_main STATIC src/sled/testing/benchmark_main.cc)

target_include_directories(test_main PUBLIC src/)

target_include_directories(benchmark_main PUBLIC src/)



add_library(sled STATIC "")



add_subdirectory(3party/gperftools EXCLUDE_FROM_ALL)
@@ -43,7 +47,6 @@ endif() 
# add_subdirectory(3party/eigen EXCLUDE_FROM_ALL)

target_include_directories(sled PUBLIC src/ 3party/eigen 3party/inja

                                       3party/rxcpp)

target_include_directories(test_main PUBLIC src/)

target_sources(

  sled

  PRIVATE src/sled/async/async.cc
@@ -71,6 +74,7 @@ target_sources( 
          src/sled/task_queue/pending_task_safety_flag.cc

          src/sled/task_queue/task_queue_base.cc

          src/sled/testing/test.cc

          src/sled/testing/benchmark.cc

          src/sled/timer/task_queue_timeout.cc

          src/sled/timer/timer.cc

          src/sled/units/time_delta.cc
@@ -104,17 +108,19 @@ target_link_libraries( 
set_target_properties(sled PROPERTIES POSITION_INDEPENDENT_CODE ON)



if(SLED_BUILD_BENCHMARK)

  if(NOT TARGET benchmark)

    find_package(benchmark REQUIRED)

  endif()

  # if(NOT TARGET benchmark) find_package(mbenchmark REQUIRED) endif()



  add_executable(

    sled_benchmark

    src/sled/random_bench.cc src/sled/strings/base64_bench.cc

    src/sled/system/fiber/fiber_bench.cc src/sled/system/thread_pool_bench.cc

    src/sled/random_bench.cc

    src/sled/strings/base64_bench.cc

    # src/sled/system/fiber/fiber_bench.cc

    src/sled/system/thread_bench.cc

    src/sled/system/thread_pool_bench.cc

    src/sled/system_time_bench.cc)

  target_link_libraries(sled_benchmark PRIVATE sled benchmark::benchmark

                                               benchmark::benchmark_main)

  target_link_libraries(sled_benchmark PRIVATE sled benchmark_main)

  target_compile_options(sled_benchmark PRIVATE -include

                                                sled/testing/benchmark.h)

endif(SLED_BUILD_BENCHMARK)



function(sled_add_test)

README.md

+22 −0
Original line number Diff line number Diff line
@@ -3,3 +3,25 @@ 
- [ ] add log module

- [ ] add http module(cpp-httplib)

- [ ] add ORM module





## Benchmark

 Name (* = baseline)      |  ns/op  | Baseline |  Ops/second

--------------------------|--------:|---------:|-----------:

 Random bool *            |       9 |        - | 109123586.4

 Random int8_t            |       7 |    0.778 | 134375880.8

 Random int32_t           |       8 |    0.889 | 120300189.7

 Random uint32_t          |       7 |    0.778 | 131234452.1

 Random uint32_t range    |       8 |    0.889 | 123079276.7

 Gaussian(0, 1)           |      17 |    1.889 |  58742994.8

 Exponential(1)           |      12 |    1.333 |  81447219.4

 Random float             |       7 |    0.778 | 136571495.3

 Random double            |       7 |    0.778 | 131796121.5

 Base64Encode             |  106299 |11811.000 |      9407.4

 Base64Decode             |  104897 |11655.222 |      9533.1

 ThreadBlockingCallByDefaultSocketServer |    6624 |  736.000 |    150950.1

 ThreadBlockingCallByNullSocketServer |    5309 |  589.889 |    188358.8

 ThreadPoolBench          |    3096 |  344.000 |    322941.4

 SystemTimeNanos          |      24 |    2.667 |  40659163.6

src/sled/random_bench.cc

+46 −55
Original line number Diff line number Diff line 
#include <benchmark/benchmark.h>

#include <sled/random.h>



class RandomFixture : public benchmark::Fixture {

    void SetUp(::benchmark::State &state) { rand_ = new sled::Random(1314); }



    void TearDown(::benchmark::State &state) { delete rand_; }



protected:

    sled::Random *rand_;

};



BENCHMARK_F(RandomFixture, bool)(benchmark::State &state)

{

    for (auto _ : state) { bool b = rand_->Rand<bool>(); }

}



BENCHMARK_F(RandomFixture, int32_t)(benchmark::State &state)

{

    for (auto _ : state) { int32_t i = rand_->Rand<int8_t>(); }

}



BENCHMARK_F(RandomFixture, int32_t_range)(benchmark::State &state)

{

    for (auto _ : state) { int32_t i = rand_->Rand(-1000, 1000); }

}



BENCHMARK_F(RandomFixture, uint32_t)(benchmark::State &state)

{

    for (auto _ : state) { uint32_t i = rand_->Rand<uint32_t>(); }

}



BENCHMARK_F(RandomFixture, uint32_t_range)(benchmark::State &state)

{

    for (auto _ : state) { uint32_t i = rand_->Rand(0u, 1000u); }

}



BENCHMARK_F(RandomFixture, Gaussian)(benchmark::State &state)

{

    for (auto _ : state) { double d = rand_->Gaussian(0, 1); }

}



BENCHMARK_F(RandomFixture, Exponential)(benchmark::State &state)

{

    for (auto _ : state) { double d = rand_->Exponential(1); }

}



BENCHMARK_F(RandomFixture, float)(benchmark::State &state)

{

    for (auto _ : state) { float f = rand_->Rand<float>(); }

}



BENCHMARK_F(RandomFixture, double)(benchmark::State &state)

{

    for (auto _ : state) { double d = rand_->Rand<double>(); }

}
 
#include <sled/testing/benchmark.h>



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { bool b = rand.Rand<bool>(); }

}).label("Random bool");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { int32_t i = rand.Rand<int8_t>(); }

}).label("Random int8_t");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { int32_t i = rand.Rand(-1000, 1000); }

}).label("Random int32_t");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { uint32_t i = rand.Rand<uint32_t>(); }

}).label("Random uint32_t");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { uint32_t i = rand.Rand(0u, 1000u); }

}).label("Random uint32_t range");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { double d = rand.Gaussian(0, 1); }

}).label("Gaussian(0, 1)");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { double d = rand.Exponential(1); }

}).label("Exponential(1)");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { float f = rand.Rand<float>(); }

}).label("Random float");



PICOBENCH([](picobench::state &s) {

    sled::Random rand(s.user_data());

    for (auto _ : s) { double d = rand.Rand<double>(); }

}).label("Random double");

src/sled/strings/base64_bench.cc

+15 −14
Original line number Diff line number Diff line 
#include <benchmark/benchmark.h>

#include <sled/random.h>

#include <sled/strings/base64.h>

#include <sled/testing/benchmark.h>

#include <sstream>



static std::string

RandomString(size_t length)

{

    static const char chars[] = "0123456789"

    static const char chars[]

        = "0123456789"

          "abcdefghijklmnopqrstuvwxyz"

          "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    std::stringstream ss;
@@ -16,27 +17,27 @@ RandomString(size_t length) 
}



static void

Base64Encode(benchmark::State &state)

Base64Encode(picobench::state &state)

{

    for (auto _ : state) {

        state.PauseTiming();

        std::string input = RandomString(state.range(0));

        state.ResumeTiming();

        state.pause_timer();

        std::string input = RandomString(10000);

        state.resume_timer();

        (void) sled::Base64::Encode(input);

    }

}



static void

Base64Decode(benchmark::State &state)

Base64Decode(picobench::state &state)

{

    for (auto _ : state) {

        state.PauseTiming();

        std::string input = RandomString(state.range(0));

        state.pause_timer();

        std::string input        = RandomString(10000);

        std::string base64_input = sled::Base64::Encode(input);

        state.ResumeTiming();

        state.resume_timer();

        (void) sled::Base64::Decode(base64_input);

    }

}



BENCHMARK(Base64Encode)->RangeMultiplier(100)->Range(10, 100000);

BENCHMARK(Base64Decode)->RangeMultiplier(100)->Range(10, 100000);
 
PICOBENCH(Base64Encode);

PICOBENCH(Base64Decode);

src/sled/system/fiber/fiber_bench.cc

+0 −1
Original line number Diff line number Diff line 
#include <benchmark/benchmark.h>

#include <sled/system/fiber/scheduler.h>

#include <sled/system/fiber/wait_group.h>