fairness  v1.0.0
A collection of advanced syncronization mechanisms.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Macros | Functions
benchmark.cpp File Reference

Alias benchmark. More...

#include <benchmark/benchmark.h>
#include "pipeline_benchmark.hpp"
Include dependency graph for benchmark.cpp:

Macros

#define BOOST_FAIRNESS_GETREQUEST_SPINS   1
 
#define BOOST_FAIRNESS_GETREQUEST_SPINS_RELAXED   0
 
#define BOOST_FAIRNESS_MAX_PQNODES   4
 
#define BOOST_FAIRNESS_SPINWAIT_SPINS   16
 
#define BOOST_FAIRNESS_SPINWAIT_SPINS_RELAXED   12
 

Functions

 BENCHMARK (____________________________________________________________________________________________)
 
 BENCHMARK (priority_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (priority_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (priority_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (priority_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (priority_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (recursive_priority_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (recursive_priority_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (recursive_priority_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (recursive_priority_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (recursive_priority_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::shared_lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::shared_pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::shared_pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::shared_pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (shared_priority_mutex_benchmark::shared_pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (slim_priority_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (slim_priority_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (slim_priority_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (slim_priority_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (slim_priority_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (spinlock_priority_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (spinlock_priority_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (spinlock_priority_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (spinlock_priority_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (standard_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (standard_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (standard_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (standard_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (standard_recursive_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (standard_recursive_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (standard_recursive_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (standard_recursive_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (standard_recursive_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::shared_lock_unlock_benchmark) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::shared_pipeline_benchmark_audio) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::shared_pipeline_benchmark_fast) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::shared_pipeline_benchmark_gaming) -> Threads(8)
 
 BENCHMARK (standard_shared_mutex_benchmark::shared_pipeline_benchmark_long) -> Threads(8)
 
 BENCHMARK_MAIN ()
 

Detailed Description

Alias benchmark.

Author
F. Abrignani (feder.nosp@m.igno.nosp@m.li@ho.nosp@m.tmai.nosp@m.l.it)
S. Martorana (salva.nosp@m.tore.nosp@m.marto.nosp@m.rana.nosp@m.@hotm.nosp@m.ail..nosp@m.com)
Version
0.1
Date
2023-10-06
Copyright
Copyright (c) 2023 Federico Abrignani (feder.nosp@m.igno.nosp@m.li@ho.nosp@m.tmai.nosp@m.l.it). Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).

Macro Definition Documentation

◆ BOOST_FAIRNESS_GETREQUEST_SPINS

#define BOOST_FAIRNESS_GETREQUEST_SPINS   1

◆ BOOST_FAIRNESS_GETREQUEST_SPINS_RELAXED

#define BOOST_FAIRNESS_GETREQUEST_SPINS_RELAXED   0

◆ BOOST_FAIRNESS_MAX_PQNODES

#define BOOST_FAIRNESS_MAX_PQNODES   4

◆ BOOST_FAIRNESS_SPINWAIT_SPINS

#define BOOST_FAIRNESS_SPINWAIT_SPINS   16

◆ BOOST_FAIRNESS_SPINWAIT_SPINS_RELAXED

#define BOOST_FAIRNESS_SPINWAIT_SPINS_RELAXED   12

Function Documentation

◆ BENCHMARK() [1/49]

BENCHMARK ( ____________________________________________________________________________________________  )

◆ BENCHMARK() [2/49]

BENCHMARK ( priority_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [3/49]

BENCHMARK ( priority_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [4/49]

BENCHMARK ( priority_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [5/49]

BENCHMARK ( priority_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [6/49]

BENCHMARK ( priority_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [7/49]

BENCHMARK ( recursive_priority_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [8/49]

BENCHMARK ( recursive_priority_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [9/49]

BENCHMARK ( recursive_priority_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [10/49]

BENCHMARK ( recursive_priority_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [11/49]

BENCHMARK ( recursive_priority_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [12/49]

BENCHMARK ( shared_priority_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [13/49]

BENCHMARK ( shared_priority_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [14/49]

BENCHMARK ( shared_priority_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [15/49]

BENCHMARK ( shared_priority_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [16/49]

BENCHMARK ( shared_priority_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [17/49]

BENCHMARK ( shared_priority_mutex_benchmark::shared_lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [18/49]

BENCHMARK ( shared_priority_mutex_benchmark::shared_pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [19/49]

BENCHMARK ( shared_priority_mutex_benchmark::shared_pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [20/49]

BENCHMARK ( shared_priority_mutex_benchmark::shared_pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [21/49]

BENCHMARK ( shared_priority_mutex_benchmark::shared_pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [22/49]

BENCHMARK ( slim_priority_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [23/49]

BENCHMARK ( slim_priority_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [24/49]

BENCHMARK ( slim_priority_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [25/49]

BENCHMARK ( slim_priority_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [26/49]

BENCHMARK ( slim_priority_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [27/49]

BENCHMARK ( spinlock_priority_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [28/49]

BENCHMARK ( spinlock_priority_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [29/49]

BENCHMARK ( spinlock_priority_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [30/49]

BENCHMARK ( spinlock_priority_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [31/49]

BENCHMARK ( standard_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [32/49]

BENCHMARK ( standard_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [33/49]

BENCHMARK ( standard_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [34/49]

BENCHMARK ( standard_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [35/49]

BENCHMARK ( standard_recursive_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [36/49]

BENCHMARK ( standard_recursive_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [37/49]

BENCHMARK ( standard_recursive_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [38/49]

BENCHMARK ( standard_recursive_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [39/49]

BENCHMARK ( standard_recursive_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [40/49]

BENCHMARK ( standard_shared_mutex_benchmark::lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [41/49]

BENCHMARK ( standard_shared_mutex_benchmark::pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [42/49]

BENCHMARK ( standard_shared_mutex_benchmark::pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [43/49]

BENCHMARK ( standard_shared_mutex_benchmark::pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [44/49]

BENCHMARK ( standard_shared_mutex_benchmark::pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK() [45/49]

BENCHMARK ( standard_shared_mutex_benchmark::shared_lock_unlock_benchmark  ) -> Threads(8)

◆ BENCHMARK() [46/49]

BENCHMARK ( standard_shared_mutex_benchmark::shared_pipeline_benchmark_audio  ) -> Threads(8)

◆ BENCHMARK() [47/49]

BENCHMARK ( standard_shared_mutex_benchmark::shared_pipeline_benchmark_fast  ) -> Threads(8)

◆ BENCHMARK() [48/49]

BENCHMARK ( standard_shared_mutex_benchmark::shared_pipeline_benchmark_gaming  ) -> Threads(8)

◆ BENCHMARK() [49/49]

BENCHMARK ( standard_shared_mutex_benchmark::shared_pipeline_benchmark_long  ) -> Threads(8)

◆ BENCHMARK_MAIN()

BENCHMARK_MAIN ( )