Manual Registration

Manual case registration can only be done inside init function. Check out Set Manual initialization function for setting manual init function.

Manual Registartion with Simple Module

Simplest manual case registration can be done with the following code

bool bench_init();

#define MANAK_SIMPLE_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun()
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddCase(MANAK_BENCHMARK_CASE(B1, fun));
  return true;
}

NOTE: 'MANAK_AUTO_MAIN' or 'MANAK_INIT' has to be defined only once in case of multi file project. Check out Using Manak Effectively in Multi File Project for more information.

The function to be registered as a case must have no parameters. The function with parameters can used to generate parametrized benchmark cases. See Complete guide on Parametrized Benchmarking for more information. Also see Advance Function Registration for registration of complex functions such as overloaded functions, template functions and class member functions.

When iteration, tolerance or succes percentage is not specified for any benchmark case the default will be used. See MANAK_DEFAULT_ITERATIONS, MANAK_DEFAULT_TOLERANCE and MANAK_DEFAULT_SP for more details.

The library name is taken as default library name in the simple module. Check out Introduction for how to set default library name of simple module.

Simple Module Manual Benchmark Case Registration Macros

MANAK_BENCHMARK_CASE_TIS

Creates a benchmark case with name, benchmark function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_TIS(B1, fun, 10, 50, 90));

MANAK_BENCHMARK_CASE_TI

Creates a benchmark case with name, benchmark function, tolerance and iterations. The value of success percentage is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_TI(B1, fun, 10, 50));

MANAK_BENCHMARK_CASE_IS

Creates a benchmark case with name, benchmark function, iterations and success percentage. The value of tolerance is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_IS(B1, fun, 10, 50));

MANAK_BENCHMARK_CASE_T

Creates a benchmark case with name, benchmark function and tolerance. The values of iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_T(B1, fun, 10));

MANAK_BENCHMARK_CASE_I

Creates a benchmark case with name, benchmark function and iterations. The values of tolerance and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_I(B1, fun, 10));

MANAK_BENCHMARK_CASE

Creates a benchmark case with name and benchmark function. The values of tolerance, iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE(B1, fun));

Simple Module Manual Suite Registration Macros

MANAK_BENCHMARK_SUITE

Creates an empty unregistered benchmark suite with name. This benchmark suite can be registred by passing it to any registered benchmark suite by manak::ManakSuite::AddSuite function.

bool bench_init();

#define MANAK_SIMPLE_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun()
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite* suite1 = manak::ManakSuite::GetMasterSuite().AddSuite(MANAK_BENCHMARK_SUITE(Suite1));
  
  suite1->AddCase(MANAK_BENCHMARK_CASE(B1, fun));
  return true;
}

Simple Module Manual Parametrized Benchmark Case Registration Macros

You can also use parametrized benchmarks with manual registartion.

bool bench_init();

#define MANAK_SIMPLE_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun(int a, int b)
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE(B1, fun)->AddArgs(0,0));
  return true;
}

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TIS

Creates a parametrized benchmark with name, function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TIS(B1, fun, 10, 50, 90)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TI

Creates a parametrized benchmark with name, function, tolerance and iterations. The value of success percentage is taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TI(B1, fun, 10, 50)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_IS

Creates a parametrized benchmark with name, function, iterations and success percentage. The value of tolerance is taken s default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_IS(B1, fun, 10, 50)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_T

Creates a parametrized benchmark with name, function and tolerance. The values of iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_T(B1, fun, 10)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_I

Creates a parametrized benchmark with name, function and iterations. The values of tolerance and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_I(B1, fun, 10)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE

Creates a parametrized benchmark with name, function. The values of tolerance, iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE(B1, fun)->AddArgs(100));

For more advance parametrized benchmark options check Complete guide on Parametrized Benchmarking.

Simple Module Manual Group Registration Macros

MANAK_GROUP and MANAK_GROUP_END

Marks the start and end of the group with name. Manak manual group can also be templatized. Use 'MANAK_ADD_GROUP' to register a group. For more advance manual group registration see Tutorial on Using Groups

MANAK_GROUP(TestGroup);

GINIT(size_t a)
{

}


MANAK_GROUP_END();

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddGroup<MG_TestGroup>(100);
}

Simple Module Manual Group Benchmark Case Registration Macros

Note: Manual registration group benchmark cases needs to be done in 'GINIT' function. Remember while initialization only one 'GINIT' function is called depending on the parameters given. This may sometimes be usefull but can also create confusion.

MANAK_GROUP_BENCHMARK_CASE_TIS

Creates a benchmark case with name, benchmark function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_TIS("B1", fun, 10, 50, 90));
}

MANAK_GROUP_BENCHMARK_CASE_TI

Creates a benchmark case with name, benchmark function, tolerance and iterations. The value of success percentage is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_TI("B1", fun, 10, 50));
}

MANAK_GROUP_BENCHMARK_CASE_IS

Creates a benchmark case with name, benchmark function, iterations and success percentage. The value of tolerance is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_IS("B1", fun, 10, 50));
}

MANAK_GROUP_BENCHMARK_CASE_T

Creates a benchmark case with name, benchmark function and tolerance. The values of iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_T("B1", fun, 10));
}

MANAK_GROUP_BENCHMARK_CASE_I

Creates a benchmark case with name, benchmark function and iterations. The values of tolerance and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_I("B1", fun, 10));
}

MANAK_GROUP_BENCHMARK_CASE

Creates a benchmark case with name and benchmark function. The values of tolerance, iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE("B1", fun));
}

Module Manual Group Parametrized Benchmark Case Registration Macros

Note: Manual registration group benchmark cases needs to be done in 'GINIT' function. Remember while initialization only one 'GINIT' function is called depending on the parameters given. This may sometimes be usefull but can also create confusion.

You can also use group parametrized benchmarks with manual registartion.

bool bench_init();

#define MANAK_SIMPLE_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

MANAK_GROUP(TestGroup);

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE("B1", fun)->AddArgs(100));
}

int fun(size_t a)
{
  
}

MANAK_GROUP_END();

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddGroup<MG_TestGroup>();
  return true;
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TIS

Creates a parametrized benchmark with name, function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TIS("B1", fun, 10, 50, 90)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TI

Creates a parametrized benchmark with name, function, tolerance and iterations. The value of success percentage is taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TI("B1", fun, 10, 50)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_IS

Creates a parametrized benchmark with name, function, iterations and success percentage. The value of tolerance is taken s default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_IS("B1", fun, 10, 50)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_T

Creates a parametrized benchmark with name, function and tolerance. The values of iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_T("B1", fun, 10)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_I

Creates a parametrized benchmark with name, function and iterations. The values of tolerance and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_I("B1", fun, 10)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE

Creates a parametrized benchmark with name, function. The values of tolerance, iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE("B1", fun)->AddArgs(100));
}

For more advance parametrized benchmark options check Complete guide on Parametrized Benchmarking.

For example on simple module manual registration check Example.

Manual Registartion with Normal Module

Simplest manual case registration can be done with the following code

bool bench_init();

#define MANAK_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun()
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddCase(MANAK_BENCHMARK_CASE(B1, Lib1, fun));
  return true;
}

NOTE: 'MANAK_AUTO_MAIN' or 'MANAK_INIT' has to be defined only once in case of multi file project. Check out Using Manak Effectively in Multi File Project for more information.

The function to be registered as a case must have no parameters. The function with parameters can used to generate parametrized benchmark cases. See Complete guide on Parametrized Benchmarking for more information. Also see Advance Function Registration for registration of complex functions such as overloaded functions, template functions and class member functions.

When iteration, tolerance or succes percentage is not specified for any benchmark case the default will be used. See MANAK_DEFAULT_ITERATIONS, MANAK_DEFAULT_TOLERANCE and MANAK_DEFAULT_SP for more details.

Normal Module Manual Benchmark Case Registration Macros

MANAK_BENCHMARK_CASE_TIS

Creates a benchmark case with name, library, benchmark function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_TIS(B1, Lib1, fun, 10, 50, 90));

MANAK_BENCHMARK_CASE_TI

Creates a benchmark case with name, library, benchmark function, tolerance and iterations. The value of success percentage is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_TI(B1, Lib1, fun, 10, 50));

MANAK_BENCHMARK_CASE_IS

Creates a benchmark case with name, library, benchmark function, iterations and success percentage. The value of tolerance is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_IS(B1, Lib1, fun, 10, 50));

MANAK_BENCHMARK_CASE_T

Creates a benchmark case with name, library, benchmark function and tolerance. The values of iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_T(B1, Lib1, fun, 10));

MANAK_BENCHMARK_CASE_I

Creates a benchmark case with name, library, benchmark function and iterations. The values of tolerance and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE_I(B1, Lib1, fun, 10));

MANAK_BENCHMARK_CASE

Creates a benchmark case with name, library and benchmark function. The values of tolerance, iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite1->AddCase(MANAK_BENCHMARK_CASE(B1, Lib1, fun));

Normal Module Manual Suite Registration Macros

MANAK_BENCHMARK_SUITE

Creates an empty unregistered benchmark suite with name. This benchmark suite can be registred by passing it to any registered benchmark suite by manak::ManakSuite::AddSuite function.

bool bench_init();

#define MANAK_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun()
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite* suite1 = manak::ManakSuite::GetMasterSuite().AddSuite(MANAK_BENCHMARK_SUITE(Suite1));
  
  suite1->AddCase(MANAK_BENCHMARK_CASE(B1, Lib1, fun));
  return true;
}

Normal Module Manual Parametrized Benchmark Case Registration Macros

You can also use parametrized benchmarks with manual registartion.

bool bench_init();

#define MANAK_SIMPLE_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

void fun(int a, int b)
{
  MEASURE
  (
    for(size_t i = 0;i < 1000;i++);
  )
}

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE(B1, Lib1, fun)->AddArgs(0,0));
  return true;
}

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TIS

Creates a parametrized benchmark with name, library, function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TIS(B1, Lib1, fun, 10, 50, 90)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TI

Creates a parametrized benchmark with name, library, function, tolerance and iterations. The value of success percentage is taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_TI(B1, Lib1, fun, 10, 50)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_IS

Creates a parametrized benchmark with name, library, function, iterations and success percentage. The value of tolerance is taken s default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_IS(B1, Lib1, fun, 10, 50)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_T

Creates a parametrized benchmark with name, library, function and tolerance. The values of iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_T(B1, Lib1, fun, 10)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_I

Creates a parametrized benchmark with name, library, function and iterations. The values of tolerance and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE_I(B1, Lib1, fun, 10)->AddArgs(100));

MANAK_CREATE_BENCHMARK_WITH_TEMPLATE

Creates a parametrized benchmark with name, libary, function. The values of tolerance, iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be passed to manak::ManakSuite::AddCase.

suite->AddCase(MANAK_CREATE_BENCHMARK_WITH_TEMPLATE(B1, Lib1, fun)->AddArgs(100));

For more advance parametrized benchmark options check Complete guide on Parametrized Benchmarking.

Normal Module Manual Group Registration Macros

MANAK_GROUP and MANAK_GROUP_END

Marks the start and end of the group with name. Manak manual group can also be templatized. Use 'MANAK_ADD_GROUP' to register a group. For more advance manual group registration see Tutorial on Using Groups

MANAK_GROUP(TestGroup);

GINIT(size_t a)
{

}


MANAK_GROUP_END();

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddGroup<MG_TestGroup>(100);
}

Normal Module Manual Group Benchmark Case Registration Macros

Note: Manual registration group benchmark cases needs to be done in 'GINIT' function. Remember while initialization only one 'GINIT' function is called depending on the parameters given. This may sometimes be usefull but can also create confusion.

MANAK_GROUP_BENCHMARK_CASE_TIS

Creates a benchmark case with name, library, benchmark function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_TIS("B1", "Lib1", fun, 10, 50, 90));
}

MANAK_GROUP_BENCHMARK_CASE_TI

Creates a benchmark case with name, library, benchmark function, tolerance and iterations. The value of success percentage is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_TI("B1", "Lib1", fun, 10, 50));
}

MANAK_GROUP_BENCHMARK_CASE_IS

Creates a benchmark case with name, library, benchmark function, iterations and success percentage. The value of tolerance is taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_IS("B1", "Lib1", fun, 10, 50));
}

MANAK_GROUP_BENCHMARK_CASE_T

Creates a benchmark case with name, library, benchmark function and tolerance. The values of iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_T("B1", "Lib1", fun, 10));
}

MANAK_GROUP_BENCHMARK_CASE_I

Creates a benchmark case with name, benchmark function and iterations. The values of tolerance and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE_I("B1", fun, 10));
}

MANAK_GROUP_BENCHMARK_CASE

Creates a benchmark case with name, library and benchmark function. The values of tolerance, iterations and success percentage are taken to be default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_GROUP_BENCHMARK_CASE("B1", "Lib1", fun));
}

Normal Module Manual Group Parametrized Benchmark Case Registration Macros

Note: Manual registration group benchmark cases needs to be done in 'GINIT' function. Remember while initialization only one 'GINIT' function is called depending on the parameters given. This may sometimes be usefull but can also create confusion.

You can also use group parametrized benchmarks with manual registartion.

bool bench_init();

#define MANAK_MODULE bench
#define MANAK_AUTO_MAIN
#define MANAK_INIT
#define MANAK_MANUAL_INIT_FUNCTION bench_init

#include <manak/manak.hpp>

MANAK_GROUP(TestGroup);

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE("B1", "Lib1", fun)->AddArgs(100));
}

int fun(size_t a)
{
  
}

MANAK_GROUP_END();

bool bench_init()
{
  manak::ManakSuite::GetMasterSuite().AddGroup<MG_TestGroup>();
  return true;
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TIS

Creates a parametrized benchmark with name, library, function, tolerance, iterations and success percentage. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TIS("B1", "Lib1", fun, 10, 50, 90)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TI

Creates a parametrized benchmark with name, library, function, tolerance and iterations. The value of success percentage is taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_TI("B1", "Lib1", fun, 10, 50)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_IS

Creates a parametrized benchmark with name, library, function, iterations and success percentage. The value of tolerance is taken s default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_IS("B1", "Lib1", fun, 10, 50)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_T

Creates a parametrized benchmark with name, library, function and tolerance. The values of iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_T("B1", "Lib1", fun, 10)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_I

Creates a parametrized benchmark with name, library, function and iterations. The values of tolerance and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE_I("B1", "Lib1", fun, 10)->AddArgs(100));
}

MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE

Creates a parametrized benchmark with name, library, function. The values of tolerance, iterations and succes percentage are taken as default. Returns pointer to created manak::BenchmarkCase object. This can be added to member std::list named 'cases'.

GINIT()
{
  cases.push_back(MANAK_CREATE_GROUP_BENCHMARK_WITH_TEMPLATE("B1", "Lib1", fun)->AddArgs(100));
}

For more advance parametrized benchmark options check Complete guide on Parametrized Benchmarking.

For example on normal module manual registration check Example.