-
-
Save EricWF/a77fd42ec87fc98da8039e26d0349498 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| The results of comparing the old and new std::function implementation. (Run 5 times each for 1 second). | |
| name old time/op new time/op delta | |
| ==================================================================================================================================== | |
| BM_ConstructAndDestroy_Null_Opaque 0.72ns ± 0% 0.72ns ± 0% ~ (p=0.167 n=5+5) | |
| BM_ConstructAndDestroy_FuncPtr_Opaque 2.51ns ± 0% 2.15ns ± 0% -14.37% (p=0.000 n=5+4) | |
| BM_ConstructAndDestroy_MemFuncPtr_Opaque 2.87ns ± 0% 2.15ns ± 0% -25.07% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_MemPtr_Opaque 2.51ns ± 0% 2.15ns ± 0% -14.35% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_SmallTrivialFunctor_Opaque 2.51ns ± 0% 0.72ns ± 0% -71.45% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_SmallNonTrivialFunctor_Opaque 20.8ns ± 0% 20.4ns ± 0% -1.78% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_LargeTrivialFunctor_Opaque 23.2ns ± 0% 23.4ns ± 0% +0.79% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_LargeNonTrivialFunctor_Opaque 20.8ns ± 0% 21.7ns ± 0% +4.35% (p=0.008 n=5+5) | |
| BM_ConstructAndDestroy_Null_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_FuncPtr_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_MemFuncPtr_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_MemPtr_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_SmallTrivialFunctor_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_SmallNonTrivialFunctor_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_LargeTrivialFunctor_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_ConstructAndDestroy_LargeNonTrivialFunctor_Transparent 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_Copy_Null 1.43ns ± 0% 1.43ns ± 0% ~ (p=0.119 n=5+5) | |
| BM_Copy_FuncPtr 4.31ns ± 1% 1.43ns ± 0% -66.82% (p=0.008 n=5+5) | |
| BM_Copy_MemFuncPtr 4.33ns ± 2% 1.55ns ± 8% -64.21% (p=0.008 n=5+5) | |
| BM_Copy_MemPtr 4.30ns ± 0% 1.43ns ± 0% -66.71% (p=0.008 n=5+5) | |
| BM_Copy_SmallTrivialFunctor 4.44ns ± 2% 1.67ns ±23% -62.27% (p=0.008 n=5+5) | |
| BM_Copy_SmallNonTrivialFunctor 21.7ns ± 0% 21.7ns ± 0% ~ (p=0.841 n=5+5) | |
| BM_Copy_LargeTrivialFunctor 24.2ns ± 0% 24.7ns ± 0% +2.18% (p=0.008 n=5+5) | |
| BM_Copy_LargeNonTrivialFunctor 21.8ns ± 0% 21.9ns ± 0% +0.55% (p=0.008 n=5+5) | |
| BM_Move_Null 1.98ns ± 0% 2.51ns ± 0% +26.84% (p=0.008 n=5+5) | |
| BM_Move_FuncPtr 5.02ns ± 0% 2.51ns ± 0% -49.93% (p=0.008 n=5+5) | |
| BM_Move_MemFuncPtr 5.02ns ± 0% 2.51ns ± 0% -49.92% (p=0.008 n=5+5) | |
| BM_Move_MemPtr 5.02ns ± 0% 2.51ns ± 0% -49.91% (p=0.008 n=5+5) | |
| BM_Move_SmallTrivialFunctor 5.38ns ± 0% 2.51ns ± 0% -53.27% (p=0.008 n=5+5) | |
| BM_Move_SmallNonTrivialFunctor 2.65ns ± 0% 2.51ns ± 0% -5.29% (p=0.008 n=5+5) | |
| BM_Move_LargeTrivialFunctor 2.65ns ± 0% 2.51ns ± 0% -5.29% (p=0.008 n=5+5) | |
| BM_Move_LargeNonTrivialFunctor 2.65ns ± 0% 2.51ns ± 0% -5.29% (p=0.008 n=5+5) | |
| BM_Swap_Null_Null 2.17ns ± 0% 2.40ns ± 0% +10.40% (p=0.008 n=5+5) | |
| BM_Swap_Null_FuncPtr 4.12ns ± 0% 2.39ns ± 0% -42.02% (p=0.008 n=5+5) | |
| BM_Swap_Null_MemFuncPtr 3.98ns ± 1% 2.43ns ± 1% -39.04% (p=0.008 n=5+5) | |
| BM_Swap_Null_MemPtr 4.24ns ± 7% 2.39ns ± 0% -43.63% (p=0.008 n=5+5) | |
| BM_Swap_Null_SmallTrivialFunctor 3.96ns ± 1% 2.39ns ± 0% -39.72% (p=0.008 n=5+5) | |
| BM_Swap_Null_SmallNonTrivialFunctor 2.17ns ± 0% 2.40ns ± 1% +10.71% (p=0.008 n=5+5) | |
| BM_Swap_Null_LargeTrivialFunctor 2.17ns ± 0% 2.39ns ± 0% +9.99% (p=0.008 n=5+5) | |
| BM_Swap_Null_LargeNonTrivialFunctor 2.17ns ± 0% 2.40ns ± 0% +10.47% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_FuncPtr 10.9ns ± 0% 2.4ns ± 0% -77.99% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_MemFuncPtr 11.1ns ± 0% 2.4ns ± 0% -78.22% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_MemPtr 11.1ns ± 0% 2.4ns ± 0% -78.47% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_SmallTrivialFunctor 11.1ns ± 0% 2.4ns ± 0% -78.45% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_SmallNonTrivialFunctor 4.01ns ± 2% 2.39ns ± 1% -40.38% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_LargeTrivialFunctor 4.12ns ± 0% 2.40ns ± 0% -41.86% (p=0.008 n=5+5) | |
| BM_Swap_FuncPtr_LargeNonTrivialFunctor 3.95ns ± 0% 2.39ns ± 0% -39.46% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_MemFuncPtr 11.1ns ± 0% 2.4ns ± 0% -78.44% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_MemPtr 11.1ns ± 0% 2.4ns ± 0% -78.51% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_SmallTrivialFunctor 11.1ns ± 0% 2.4ns ± 0% -78.12% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_SmallNonTrivialFunctor 4.05ns ± 3% 2.42ns ± 0% -40.12% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_LargeTrivialFunctor 4.12ns ± 0% 2.42ns ± 0% -41.14% (p=0.008 n=5+5) | |
| BM_Swap_MemFuncPtr_LargeNonTrivialFunctor 4.09ns ± 5% 2.43ns ± 0% -40.54% (p=0.008 n=5+5) | |
| BM_Swap_MemPtr_MemPtr 11.1ns ± 0% 2.4ns ± 0% -78.39% (p=0.008 n=5+5) | |
| BM_Swap_MemPtr_SmallTrivialFunctor 11.1ns ± 0% 2.4ns ± 0% -78.46% (p=0.008 n=5+5) | |
| BM_Swap_MemPtr_SmallNonTrivialFunctor 4.31ns ± 8% 2.40ns ± 0% -44.36% (p=0.008 n=5+5) | |
| BM_Swap_MemPtr_LargeTrivialFunctor 4.05ns ± 3% 2.39ns ± 0% -41.04% (p=0.008 n=5+5) | |
| BM_Swap_MemPtr_LargeNonTrivialFunctor 4.22ns ± 6% 2.40ns ± 0% -43.00% (p=0.008 n=5+5) | |
| BM_Swap_SmallTrivialFunctor_SmallTrivialFunctor 10.9ns ± 0% 2.4ns ± 0% -78.10% (p=0.008 n=5+5) | |
| BM_Swap_SmallTrivialFunctor_SmallNonTrivialFunctor 4.12ns ± 0% 2.41ns ± 0% -41.59% (p=0.008 n=5+5) | |
| BM_Swap_SmallTrivialFunctor_LargeTrivialFunctor 4.12ns ± 0% 2.40ns ± 0% -41.78% (p=0.008 n=5+5) | |
| BM_Swap_SmallTrivialFunctor_LargeNonTrivialFunctor 4.12ns ± 0% 2.39ns ± 1% -41.96% (p=0.008 n=5+5) | |
| BM_Swap_SmallNonTrivialFunctor_SmallNonTrivialFunctor 2.22ns ± 0% 2.39ns ± 1% +7.64% (p=0.008 n=5+5) | |
| BM_Swap_SmallNonTrivialFunctor_LargeTrivialFunctor 2.17ns ± 0% 2.39ns ± 0% +10.19% (p=0.008 n=5+5) | |
| BM_Swap_SmallNonTrivialFunctor_LargeNonTrivialFunctor 2.17ns ± 0% 2.39ns ± 0% +9.93% (p=0.008 n=5+5) | |
| BM_Swap_LargeTrivialFunctor_LargeTrivialFunctor 2.17ns ± 0% 2.40ns ± 0% +10.47% (p=0.008 n=5+5) | |
| BM_Swap_LargeTrivialFunctor_LargeNonTrivialFunctor 2.22ns ± 0% 2.39ns ± 0% +7.49% (p=0.008 n=5+5) | |
| BM_Swap_LargeNonTrivialFunctor_LargeNonTrivialFunctor 2.17ns ± 0% 2.39ns ± 0% +10.15% (p=0.008 n=5+5) | |
| BM_OperatorBool_Null 0.38ns ± 0% 0.41ns ± 0% +8.87% (p=0.008 n=5+5) | |
| BM_OperatorBool_FuncPtr 0.38ns ± 0% 0.41ns ± 0% +8.77% (p=0.008 n=5+5) | |
| BM_OperatorBool_MemFuncPtr 0.38ns ± 0% 0.41ns ± 0% +8.60% (p=0.008 n=5+5) | |
| BM_OperatorBool_MemPtr 0.38ns ± 0% 0.41ns ± 0% +8.66% (p=0.008 n=5+5) | |
| BM_OperatorBool_SmallTrivialFunctor 0.38ns ± 0% 0.41ns ± 0% +8.66% (p=0.008 n=5+5) | |
| BM_OperatorBool_SmallNonTrivialFunctor 0.38ns ± 0% 0.41ns ± 0% +8.93% (p=0.008 n=5+5) | |
| BM_OperatorBool_LargeTrivialFunctor 0.38ns ± 0% 0.41ns ± 0% +9.03% (p=0.008 n=5+5) | |
| BM_OperatorBool_LargeNonTrivialFunctor 0.38ns ± 0% 0.41ns ± 4% +10.15% (p=0.008 n=5+5) | |
| BM_Invoke_FuncPtr 2.87ns ± 0% 2.51ns ± 0% -12.55% (p=0.008 n=5+5) | |
| BM_Invoke_MemFuncPtr 3.22ns ± 0% 2.86ns ± 0% -11.17% (p=0.008 n=5+5) | |
| BM_Invoke_MemPtr 1.79ns ± 0% 1.79ns ± 0% ~ (p=0.444 n=5+5) | |
| BM_Invoke_SmallTrivialFunctor 1.79ns ± 0% 1.79ns ± 0% ~ (p=0.444 n=5+5) | |
| BM_Invoke_SmallNonTrivialFunctor 2.15ns ± 0% 1.79ns ± 0% -16.71% (p=0.008 n=5+5) | |
| BM_Invoke_LargeTrivialFunctor 1.79ns ± 0% 1.79ns ± 0% ~ (p=0.444 n=5+5) | |
| BM_Invoke_LargeNonTrivialFunctor 2.15ns ± 0% 1.79ns ± 0% -16.71% (p=0.008 n=5+5) | |
| BM_InvokeInlined_FuncPtr 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_MemFuncPtr 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_MemPtr 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_SmallTrivialFunctor 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_SmallNonTrivialFunctor 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_LargeTrivialFunctor 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) | |
| BM_InvokeInlined_LargeNonTrivialFunctor 0.00ns ±NaN% 0.00ns ±NaN% ~ (all samples are equal) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment