Copy disabled (too large)
Download .txt
Showing preview only (12,745K chars total). Download the full file to get everything.
Repository: cameron314/concurrentqueue
Branch: master
Commit: 593df78ec309
Files: 1830
Total size: 11.8 MB
Directory structure:
gitextract_c2x5p8gn/
├── .gitignore
├── CMakeLists.txt
├── LICENSE.md
├── README.md
├── benchmarks/
│ ├── benchmarks.cpp
│ ├── boost/
│ │ ├── LICENSE_1_0.txt
│ │ ├── README.txt
│ │ ├── array.hpp
│ │ ├── assert.hpp
│ │ ├── atomic/
│ │ │ ├── atomic.hpp
│ │ │ ├── atomic_flag.hpp
│ │ │ ├── capabilities.hpp
│ │ │ ├── detail/
│ │ │ │ ├── atomic_flag.hpp
│ │ │ │ ├── atomic_template.hpp
│ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ ├── caps_windows.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── int_sizes.hpp
│ │ │ │ ├── interlocked.hpp
│ │ │ │ ├── link.hpp
│ │ │ │ ├── lockpool.hpp
│ │ │ │ ├── operations.hpp
│ │ │ │ ├── operations_fwd.hpp
│ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ ├── ops_emulated.hpp
│ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ ├── ops_windows.hpp
│ │ │ │ ├── pause.hpp
│ │ │ │ ├── platform.hpp
│ │ │ │ └── storage_type.hpp
│ │ │ └── fences.hpp
│ │ ├── atomic.hpp
│ │ ├── config/
│ │ │ ├── abi/
│ │ │ │ ├── borland_prefix.hpp
│ │ │ │ ├── borland_suffix.hpp
│ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ └── msvc_suffix.hpp
│ │ │ ├── abi_prefix.hpp
│ │ │ ├── abi_suffix.hpp
│ │ │ ├── auto_link.hpp
│ │ │ ├── compiler/
│ │ │ │ ├── borland.hpp
│ │ │ │ ├── clang.hpp
│ │ │ │ ├── codegear.hpp
│ │ │ │ ├── comeau.hpp
│ │ │ │ ├── common_edg.hpp
│ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ ├── cray.hpp
│ │ │ │ ├── digitalmars.hpp
│ │ │ │ ├── gcc.hpp
│ │ │ │ ├── gcc_xml.hpp
│ │ │ │ ├── greenhills.hpp
│ │ │ │ ├── hp_acc.hpp
│ │ │ │ ├── intel.hpp
│ │ │ │ ├── kai.hpp
│ │ │ │ ├── metrowerks.hpp
│ │ │ │ ├── mpw.hpp
│ │ │ │ ├── nvcc.hpp
│ │ │ │ ├── pathscale.hpp
│ │ │ │ ├── pgi.hpp
│ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ ├── vacpp.hpp
│ │ │ │ ├── visualc.hpp
│ │ │ │ └── xlcpp.hpp
│ │ │ ├── no_tr1/
│ │ │ │ ├── cmath.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ └── utility.hpp
│ │ │ ├── platform/
│ │ │ │ ├── aix.hpp
│ │ │ │ ├── amigaos.hpp
│ │ │ │ ├── beos.hpp
│ │ │ │ ├── bsd.hpp
│ │ │ │ ├── cloudabi.hpp
│ │ │ │ ├── cray.hpp
│ │ │ │ ├── cygwin.hpp
│ │ │ │ ├── haiku.hpp
│ │ │ │ ├── hpux.hpp
│ │ │ │ ├── irix.hpp
│ │ │ │ ├── linux.hpp
│ │ │ │ ├── macos.hpp
│ │ │ │ ├── qnxnto.hpp
│ │ │ │ ├── solaris.hpp
│ │ │ │ ├── symbian.hpp
│ │ │ │ ├── vms.hpp
│ │ │ │ ├── vxworks.hpp
│ │ │ │ └── win32.hpp
│ │ │ ├── posix_features.hpp
│ │ │ ├── requires_threads.hpp
│ │ │ ├── select_compiler_config.hpp
│ │ │ ├── select_platform_config.hpp
│ │ │ ├── select_stdlib_config.hpp
│ │ │ ├── stdlib/
│ │ │ │ ├── dinkumware.hpp
│ │ │ │ ├── libcomo.hpp
│ │ │ │ ├── libcpp.hpp
│ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ ├── modena.hpp
│ │ │ │ ├── msl.hpp
│ │ │ │ ├── roguewave.hpp
│ │ │ │ ├── sgi.hpp
│ │ │ │ ├── stlport.hpp
│ │ │ │ └── vacpp.hpp
│ │ │ ├── suffix.hpp
│ │ │ ├── user.hpp
│ │ │ └── warning_disable.hpp
│ │ ├── config.hpp
│ │ ├── core/
│ │ │ ├── enable_if.hpp
│ │ │ ├── noncopyable.hpp
│ │ │ └── swap.hpp
│ │ ├── cstdint.hpp
│ │ ├── current_function.hpp
│ │ ├── detail/
│ │ │ ├── is_xxx.hpp
│ │ │ ├── iterator.hpp
│ │ │ └── workaround.hpp
│ │ ├── exception/
│ │ │ └── exception.hpp
│ │ ├── functional/
│ │ │ ├── hash/
│ │ │ │ └── hash_fwd.hpp
│ │ │ └── hash_fwd.hpp
│ │ ├── limits.hpp
│ │ ├── lockfree/
│ │ │ ├── detail/
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── copy_payload.hpp
│ │ │ │ ├── freelist.hpp
│ │ │ │ ├── parameter.hpp
│ │ │ │ ├── prefix.hpp
│ │ │ │ ├── tagged_ptr.hpp
│ │ │ │ ├── tagged_ptr_dcas.hpp
│ │ │ │ └── tagged_ptr_ptrcompression.hpp
│ │ │ ├── policies.hpp
│ │ │ └── queue.hpp
│ │ ├── memory_order.hpp
│ │ ├── mpl/
│ │ │ ├── O1_size.hpp
│ │ │ ├── O1_size_fwd.hpp
│ │ │ ├── always.hpp
│ │ │ ├── and.hpp
│ │ │ ├── apply.hpp
│ │ │ ├── apply_fwd.hpp
│ │ │ ├── apply_wrap.hpp
│ │ │ ├── arg.hpp
│ │ │ ├── arg_fwd.hpp
│ │ │ ├── assert.hpp
│ │ │ ├── at_fwd.hpp
│ │ │ ├── aux_/
│ │ │ │ ├── O1_size_impl.hpp
│ │ │ │ ├── adl_barrier.hpp
│ │ │ │ ├── arg_typedef.hpp
│ │ │ │ ├── arity.hpp
│ │ │ │ ├── arity_spec.hpp
│ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ ├── clear_impl.hpp
│ │ │ │ ├── common_name_wknd.hpp
│ │ │ │ ├── config/
│ │ │ │ │ ├── adl.hpp
│ │ │ │ │ ├── arrays.hpp
│ │ │ │ │ ├── bcc.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ ├── ctps.hpp
│ │ │ │ │ ├── dmc_ambiguous_ctps.hpp
│ │ │ │ │ ├── dtp.hpp
│ │ │ │ │ ├── eti.hpp
│ │ │ │ │ ├── forwarding.hpp
│ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ ├── gpu.hpp
│ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ ├── integral.hpp
│ │ │ │ │ ├── intel.hpp
│ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ ├── msvc.hpp
│ │ │ │ │ ├── msvc_typename.hpp
│ │ │ │ │ ├── nttp.hpp
│ │ │ │ │ ├── operators.hpp
│ │ │ │ │ ├── overload_resolution.hpp
│ │ │ │ │ ├── pp_counter.hpp
│ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ ├── static_constant.hpp
│ │ │ │ │ ├── ttp.hpp
│ │ │ │ │ ├── use_preprocessed.hpp
│ │ │ │ │ └── workaround.hpp
│ │ │ │ ├── count_args.hpp
│ │ │ │ ├── find_if_pred.hpp
│ │ │ │ ├── fold_impl.hpp
│ │ │ │ ├── fold_impl_body.hpp
│ │ │ │ ├── full_lambda.hpp
│ │ │ │ ├── has_apply.hpp
│ │ │ │ ├── has_begin.hpp
│ │ │ │ ├── has_key_impl.hpp
│ │ │ │ ├── has_rebind.hpp
│ │ │ │ ├── has_size.hpp
│ │ │ │ ├── has_tag.hpp
│ │ │ │ ├── has_type.hpp
│ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ ├── insert_impl.hpp
│ │ │ │ ├── integral_wrapper.hpp
│ │ │ │ ├── is_msvc_eti_arg.hpp
│ │ │ │ ├── iter_apply.hpp
│ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ ├── lambda_arity_param.hpp
│ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ ├── lambda_spec.hpp
│ │ │ │ ├── lambda_support.hpp
│ │ │ │ ├── logical_op.hpp
│ │ │ │ ├── msvc_dtw.hpp
│ │ │ │ ├── msvc_eti_base.hpp
│ │ │ │ ├── msvc_is_class.hpp
│ │ │ │ ├── msvc_never_true.hpp
│ │ │ │ ├── msvc_type.hpp
│ │ │ │ ├── na.hpp
│ │ │ │ ├── na_assert.hpp
│ │ │ │ ├── na_fwd.hpp
│ │ │ │ ├── na_spec.hpp
│ │ │ │ ├── nested_type_wknd.hpp
│ │ │ │ ├── nttp_decl.hpp
│ │ │ │ ├── overload_names.hpp
│ │ │ │ ├── preprocessed/
│ │ │ │ │ ├── bcc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── bcc551/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── bcc_pre590/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── gcc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── msvc60/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── msvc70/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── mwcw/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── no_ctps/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── no_ttp/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ └── plain/
│ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ ├── and.hpp
│ │ │ │ │ ├── apply.hpp
│ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ ├── arg.hpp
│ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ ├── deque.hpp
│ │ │ │ │ ├── divides.hpp
│ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ ├── greater.hpp
│ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ ├── less.hpp
│ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ ├── list.hpp
│ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ ├── map.hpp
│ │ │ │ │ ├── minus.hpp
│ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ ├── or.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── plus.hpp
│ │ │ │ │ ├── quote.hpp
│ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ ├── set.hpp
│ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ ├── times.hpp
│ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ ├── vector.hpp
│ │ │ │ │ └── vector_c.hpp
│ │ │ │ ├── preprocessor/
│ │ │ │ │ ├── add.hpp
│ │ │ │ │ ├── def_params_tail.hpp
│ │ │ │ │ ├── default_params.hpp
│ │ │ │ │ ├── enum.hpp
│ │ │ │ │ ├── ext_params.hpp
│ │ │ │ │ ├── filter_params.hpp
│ │ │ │ │ ├── params.hpp
│ │ │ │ │ ├── partial_spec_params.hpp
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ ├── sub.hpp
│ │ │ │ │ └── tuple.hpp
│ │ │ │ ├── ptr_to_ref.hpp
│ │ │ │ ├── push_front_impl.hpp
│ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ ├── reverse_fold_impl_body.hpp
│ │ │ │ ├── sequence_wrapper.hpp
│ │ │ │ ├── static_cast.hpp
│ │ │ │ ├── template_arity.hpp
│ │ │ │ ├── template_arity_fwd.hpp
│ │ │ │ ├── traits_lambda_spec.hpp
│ │ │ │ ├── type_wrapper.hpp
│ │ │ │ ├── value_wknd.hpp
│ │ │ │ └── yes_no.hpp
│ │ │ ├── base.hpp
│ │ │ ├── begin.hpp
│ │ │ ├── begin_end.hpp
│ │ │ ├── begin_end_fwd.hpp
│ │ │ ├── bind.hpp
│ │ │ ├── bind_fwd.hpp
│ │ │ ├── bool.hpp
│ │ │ ├── bool_fwd.hpp
│ │ │ ├── clear.hpp
│ │ │ ├── clear_fwd.hpp
│ │ │ ├── deref.hpp
│ │ │ ├── empty_fwd.hpp
│ │ │ ├── end.hpp
│ │ │ ├── erase_fwd.hpp
│ │ │ ├── erase_key_fwd.hpp
│ │ │ ├── eval_if.hpp
│ │ │ ├── find.hpp
│ │ │ ├── find_if.hpp
│ │ │ ├── fold.hpp
│ │ │ ├── front_fwd.hpp
│ │ │ ├── has_key.hpp
│ │ │ ├── has_key_fwd.hpp
│ │ │ ├── has_xxx.hpp
│ │ │ ├── identity.hpp
│ │ │ ├── if.hpp
│ │ │ ├── insert.hpp
│ │ │ ├── insert_fwd.hpp
│ │ │ ├── insert_range_fwd.hpp
│ │ │ ├── int.hpp
│ │ │ ├── int_fwd.hpp
│ │ │ ├── integral_c.hpp
│ │ │ ├── integral_c_fwd.hpp
│ │ │ ├── integral_c_tag.hpp
│ │ │ ├── is_placeholder.hpp
│ │ │ ├── iter_fold_if.hpp
│ │ │ ├── iterator_range.hpp
│ │ │ ├── iterator_tags.hpp
│ │ │ ├── key_type_fwd.hpp
│ │ │ ├── lambda.hpp
│ │ │ ├── lambda_fwd.hpp
│ │ │ ├── limits/
│ │ │ │ ├── arity.hpp
│ │ │ │ ├── list.hpp
│ │ │ │ └── unrolling.hpp
│ │ │ ├── list/
│ │ │ │ ├── aux_/
│ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ ├── clear.hpp
│ │ │ │ │ ├── empty.hpp
│ │ │ │ │ ├── front.hpp
│ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ ├── item.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── numbered.hpp
│ │ │ │ │ ├── numbered_c.hpp
│ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ └── plain/
│ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ ├── size.hpp
│ │ │ │ │ └── tag.hpp
│ │ │ │ ├── list0.hpp
│ │ │ │ ├── list0_c.hpp
│ │ │ │ ├── list10.hpp
│ │ │ │ ├── list10_c.hpp
│ │ │ │ ├── list20.hpp
│ │ │ │ ├── list20_c.hpp
│ │ │ │ ├── list30.hpp
│ │ │ │ ├── list30_c.hpp
│ │ │ │ ├── list40.hpp
│ │ │ │ ├── list40_c.hpp
│ │ │ │ ├── list50.hpp
│ │ │ │ └── list50_c.hpp
│ │ │ ├── list.hpp
│ │ │ ├── logical.hpp
│ │ │ ├── long.hpp
│ │ │ ├── long_fwd.hpp
│ │ │ ├── next.hpp
│ │ │ ├── next_prior.hpp
│ │ │ ├── not.hpp
│ │ │ ├── or.hpp
│ │ │ ├── pair.hpp
│ │ │ ├── placeholders.hpp
│ │ │ ├── pop_front_fwd.hpp
│ │ │ ├── prior.hpp
│ │ │ ├── protect.hpp
│ │ │ ├── push_back_fwd.hpp
│ │ │ ├── push_front.hpp
│ │ │ ├── push_front_fwd.hpp
│ │ │ ├── quote.hpp
│ │ │ ├── reverse_fold.hpp
│ │ │ ├── same_as.hpp
│ │ │ ├── sequence_tag.hpp
│ │ │ ├── sequence_tag_fwd.hpp
│ │ │ ├── set/
│ │ │ │ ├── aux_/
│ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ ├── erase_impl.hpp
│ │ │ │ │ ├── erase_key_impl.hpp
│ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ ├── insert_range_impl.hpp
│ │ │ │ │ ├── item.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── key_type_impl.hpp
│ │ │ │ │ ├── set0.hpp
│ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ ├── tag.hpp
│ │ │ │ │ └── value_type_impl.hpp
│ │ │ │ └── set0.hpp
│ │ │ ├── size_fwd.hpp
│ │ │ ├── size_t.hpp
│ │ │ ├── size_t_fwd.hpp
│ │ │ ├── value_type_fwd.hpp
│ │ │ ├── void.hpp
│ │ │ └── void_fwd.hpp
│ │ ├── noncopyable.hpp
│ │ ├── parameter/
│ │ │ ├── aux_/
│ │ │ │ ├── arg_list.hpp
│ │ │ │ ├── cast.hpp
│ │ │ │ ├── default.hpp
│ │ │ │ ├── is_maybe.hpp
│ │ │ │ ├── overloads.hpp
│ │ │ │ ├── parameter_requirements.hpp
│ │ │ │ ├── parenthesized_type.hpp
│ │ │ │ ├── preprocessor/
│ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ └── for_each.hpp
│ │ │ │ ├── result_of0.hpp
│ │ │ │ ├── set.hpp
│ │ │ │ ├── tag.hpp
│ │ │ │ ├── tagged_argument.hpp
│ │ │ │ ├── template_keyword.hpp
│ │ │ │ ├── unwrap_cv_reference.hpp
│ │ │ │ ├── void.hpp
│ │ │ │ └── yesno.hpp
│ │ │ ├── binding.hpp
│ │ │ ├── config.hpp
│ │ │ ├── keyword.hpp
│ │ │ ├── macros.hpp
│ │ │ ├── match.hpp
│ │ │ ├── name.hpp
│ │ │ ├── parameters.hpp
│ │ │ ├── preprocessor.hpp
│ │ │ └── value_type.hpp
│ │ ├── parameter.hpp
│ │ ├── preprocessor/
│ │ │ ├── arithmetic/
│ │ │ │ ├── add.hpp
│ │ │ │ ├── dec.hpp
│ │ │ │ ├── inc.hpp
│ │ │ │ └── sub.hpp
│ │ │ ├── array/
│ │ │ │ ├── data.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ └── size.hpp
│ │ │ ├── cat.hpp
│ │ │ ├── comma_if.hpp
│ │ │ ├── comparison/
│ │ │ │ ├── equal.hpp
│ │ │ │ ├── less_equal.hpp
│ │ │ │ └── not_equal.hpp
│ │ │ ├── config/
│ │ │ │ └── config.hpp
│ │ │ ├── control/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ ├── msvc/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ └── while.hpp
│ │ │ │ ├── expr_if.hpp
│ │ │ │ ├── expr_iif.hpp
│ │ │ │ ├── if.hpp
│ │ │ │ ├── iif.hpp
│ │ │ │ └── while.hpp
│ │ │ ├── debug/
│ │ │ │ └── error.hpp
│ │ │ ├── dec.hpp
│ │ │ ├── detail/
│ │ │ │ ├── auto_rec.hpp
│ │ │ │ ├── check.hpp
│ │ │ │ ├── dmc/
│ │ │ │ │ └── auto_rec.hpp
│ │ │ │ ├── is_binary.hpp
│ │ │ │ ├── is_nullary.hpp
│ │ │ │ └── split.hpp
│ │ │ ├── empty.hpp
│ │ │ ├── enum.hpp
│ │ │ ├── enum_params.hpp
│ │ │ ├── enum_params_with_a_default.hpp
│ │ │ ├── enum_shifted_params.hpp
│ │ │ ├── expr_if.hpp
│ │ │ ├── facilities/
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_empty.hpp
│ │ │ │ ├── empty.hpp
│ │ │ │ ├── expand.hpp
│ │ │ │ ├── identity.hpp
│ │ │ │ ├── intercept.hpp
│ │ │ │ ├── is_1.hpp
│ │ │ │ ├── is_empty.hpp
│ │ │ │ ├── is_empty_variadic.hpp
│ │ │ │ └── overload.hpp
│ │ │ ├── for.hpp
│ │ │ ├── identity.hpp
│ │ │ ├── inc.hpp
│ │ │ ├── iterate.hpp
│ │ │ ├── iteration/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── bounds/
│ │ │ │ │ │ ├── lower1.hpp
│ │ │ │ │ │ ├── lower2.hpp
│ │ │ │ │ │ ├── lower3.hpp
│ │ │ │ │ │ ├── lower4.hpp
│ │ │ │ │ │ ├── lower5.hpp
│ │ │ │ │ │ ├── upper1.hpp
│ │ │ │ │ │ ├── upper2.hpp
│ │ │ │ │ │ ├── upper3.hpp
│ │ │ │ │ │ ├── upper4.hpp
│ │ │ │ │ │ └── upper5.hpp
│ │ │ │ │ ├── finish.hpp
│ │ │ │ │ ├── iter/
│ │ │ │ │ │ ├── forward1.hpp
│ │ │ │ │ │ ├── forward2.hpp
│ │ │ │ │ │ ├── forward3.hpp
│ │ │ │ │ │ ├── forward4.hpp
│ │ │ │ │ │ ├── forward5.hpp
│ │ │ │ │ │ ├── reverse1.hpp
│ │ │ │ │ │ ├── reverse2.hpp
│ │ │ │ │ │ ├── reverse3.hpp
│ │ │ │ │ │ ├── reverse4.hpp
│ │ │ │ │ │ └── reverse5.hpp
│ │ │ │ │ ├── local.hpp
│ │ │ │ │ ├── rlocal.hpp
│ │ │ │ │ ├── self.hpp
│ │ │ │ │ └── start.hpp
│ │ │ │ ├── iterate.hpp
│ │ │ │ ├── local.hpp
│ │ │ │ └── self.hpp
│ │ │ ├── list/
│ │ │ │ ├── adt.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── fold_left.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ └── fold_right.hpp
│ │ │ │ ├── fold_left.hpp
│ │ │ │ ├── fold_right.hpp
│ │ │ │ ├── for_each_i.hpp
│ │ │ │ └── reverse.hpp
│ │ │ ├── logical/
│ │ │ │ ├── and.hpp
│ │ │ │ ├── bitand.hpp
│ │ │ │ ├── bool.hpp
│ │ │ │ ├── compl.hpp
│ │ │ │ └── not.hpp
│ │ │ ├── punctuation/
│ │ │ │ ├── comma.hpp
│ │ │ │ ├── comma_if.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ └── is_begin_parens.hpp
│ │ │ ├── repeat.hpp
│ │ │ ├── repetition/
│ │ │ │ ├── deduce_r.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── for.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ └── for.hpp
│ │ │ │ │ ├── for.hpp
│ │ │ │ │ └── msvc/
│ │ │ │ │ └── for.hpp
│ │ │ │ ├── enum.hpp
│ │ │ │ ├── enum_binary_params.hpp
│ │ │ │ ├── enum_params.hpp
│ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ ├── enum_shifted.hpp
│ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ ├── enum_trailing.hpp
│ │ │ │ ├── enum_trailing_params.hpp
│ │ │ │ ├── for.hpp
│ │ │ │ ├── repeat.hpp
│ │ │ │ └── repeat_from_to.hpp
│ │ │ ├── selection/
│ │ │ │ └── max.hpp
│ │ │ ├── seq/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ └── split.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ ├── enum.hpp
│ │ │ │ ├── first_n.hpp
│ │ │ │ ├── fold_left.hpp
│ │ │ │ ├── for_each.hpp
│ │ │ │ ├── for_each_i.hpp
│ │ │ │ ├── for_each_product.hpp
│ │ │ │ ├── push_back.hpp
│ │ │ │ ├── rest_n.hpp
│ │ │ │ ├── seq.hpp
│ │ │ │ ├── size.hpp
│ │ │ │ └── subseq.hpp
│ │ │ ├── slot/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── counter.hpp
│ │ │ │ │ ├── def.hpp
│ │ │ │ │ ├── shared.hpp
│ │ │ │ │ ├── slot1.hpp
│ │ │ │ │ ├── slot2.hpp
│ │ │ │ │ ├── slot3.hpp
│ │ │ │ │ ├── slot4.hpp
│ │ │ │ │ └── slot5.hpp
│ │ │ │ └── slot.hpp
│ │ │ ├── stringize.hpp
│ │ │ ├── tuple/
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_single_return.hpp
│ │ │ │ ├── eat.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ ├── rem.hpp
│ │ │ │ ├── size.hpp
│ │ │ │ └── to_list.hpp
│ │ │ └── variadic/
│ │ │ ├── elem.hpp
│ │ │ └── size.hpp
│ │ ├── static_assert.hpp
│ │ ├── swap.hpp
│ │ ├── throw_exception.hpp
│ │ ├── type_traits/
│ │ │ ├── add_const.hpp
│ │ │ ├── add_lvalue_reference.hpp
│ │ │ ├── add_reference.hpp
│ │ │ ├── add_rvalue_reference.hpp
│ │ │ ├── add_volatile.hpp
│ │ │ ├── conditional.hpp
│ │ │ ├── declval.hpp
│ │ │ ├── detail/
│ │ │ │ ├── config.hpp
│ │ │ │ ├── is_function_ptr_helper.hpp
│ │ │ │ ├── is_function_ptr_tester.hpp
│ │ │ │ ├── is_mem_fun_pointer_impl.hpp
│ │ │ │ ├── is_mem_fun_pointer_tester.hpp
│ │ │ │ └── yes_no_type.hpp
│ │ │ ├── has_trivial_assign.hpp
│ │ │ ├── has_trivial_destructor.hpp
│ │ │ ├── integral_constant.hpp
│ │ │ ├── intrinsics.hpp
│ │ │ ├── is_abstract.hpp
│ │ │ ├── is_arithmetic.hpp
│ │ │ ├── is_array.hpp
│ │ │ ├── is_assignable.hpp
│ │ │ ├── is_base_and_derived.hpp
│ │ │ ├── is_class.hpp
│ │ │ ├── is_const.hpp
│ │ │ ├── is_convertible.hpp
│ │ │ ├── is_destructible.hpp
│ │ │ ├── is_enum.hpp
│ │ │ ├── is_floating_point.hpp
│ │ │ ├── is_function.hpp
│ │ │ ├── is_integral.hpp
│ │ │ ├── is_lvalue_reference.hpp
│ │ │ ├── is_member_function_pointer.hpp
│ │ │ ├── is_member_pointer.hpp
│ │ │ ├── is_pod.hpp
│ │ │ ├── is_pointer.hpp
│ │ │ ├── is_polymorphic.hpp
│ │ │ ├── is_reference.hpp
│ │ │ ├── is_rvalue_reference.hpp
│ │ │ ├── is_same.hpp
│ │ │ ├── is_scalar.hpp
│ │ │ ├── is_signed.hpp
│ │ │ ├── is_union.hpp
│ │ │ ├── is_unsigned.hpp
│ │ │ ├── is_void.hpp
│ │ │ ├── is_volatile.hpp
│ │ │ ├── make_signed.hpp
│ │ │ ├── remove_const.hpp
│ │ │ ├── remove_cv.hpp
│ │ │ └── remove_reference.hpp
│ │ ├── utility/
│ │ │ ├── declval.hpp
│ │ │ ├── detail/
│ │ │ │ └── result_of_iterate.hpp
│ │ │ ├── enable_if.hpp
│ │ │ └── result_of.hpp
│ │ └── version.hpp
│ ├── boostqueue.h
│ ├── contrib/
│ │ ├── benchmarks.aws-32.log
│ │ └── benchmarks.aws-8.log
│ ├── cpuid.cpp
│ ├── cpuid.h
│ ├── dlib/
│ │ ├── algs.h
│ │ ├── array/
│ │ │ ├── array_kernel.h
│ │ │ ├── array_kernel_abstract.h
│ │ │ ├── array_tools.h
│ │ │ └── array_tools_abstract.h
│ │ ├── array.h
│ │ ├── assert.h
│ │ ├── binary_search_tree/
│ │ │ ├── binary_search_tree_kernel_1.h
│ │ │ ├── binary_search_tree_kernel_2.h
│ │ │ ├── binary_search_tree_kernel_abstract.h
│ │ │ └── binary_search_tree_kernel_c.h
│ │ ├── binary_search_tree.h
│ │ ├── bound_function_pointer/
│ │ │ ├── bound_function_pointer_kernel_1.h
│ │ │ └── bound_function_pointer_kernel_abstract.h
│ │ ├── bound_function_pointer.h
│ │ ├── byte_orderer/
│ │ │ ├── byte_orderer_kernel_1.h
│ │ │ └── byte_orderer_kernel_abstract.h
│ │ ├── byte_orderer.h
│ │ ├── cassert
│ │ ├── config.h
│ │ ├── console_progress_indicator.h
│ │ ├── cstring
│ │ ├── dlib_basic_cpp_build_tutorial.txt
│ │ ├── dlib_include_path_tutorial.txt
│ │ ├── enable_if.h
│ │ ├── error.h
│ │ ├── float_details.h
│ │ ├── fstream
│ │ ├── hash.h
│ │ ├── interfaces/
│ │ │ ├── cmd_line_parser_option.h
│ │ │ ├── enumerable.h
│ │ │ ├── map_pair.h
│ │ │ └── remover.h
│ │ ├── iomanip
│ │ ├── iosfwd
│ │ ├── iostream
│ │ ├── is_kind.h
│ │ ├── istream
│ │ ├── locale
│ │ ├── logger/
│ │ │ ├── extra_logger_headers.h
│ │ │ ├── logger_config_file.h
│ │ │ ├── logger_kernel_1.h
│ │ │ └── logger_kernel_abstract.h
│ │ ├── logger.h
│ │ ├── map/
│ │ │ ├── map_kernel_1.h
│ │ │ ├── map_kernel_abstract.h
│ │ │ └── map_kernel_c.h
│ │ ├── map.h
│ │ ├── member_function_pointer/
│ │ │ ├── make_mfp.h
│ │ │ ├── make_mfp_abstract.h
│ │ │ ├── member_function_pointer_kernel_1.h
│ │ │ └── member_function_pointer_kernel_abstract.h
│ │ ├── member_function_pointer.h
│ │ ├── memory_manager/
│ │ │ ├── memory_manager_kernel_1.h
│ │ │ ├── memory_manager_kernel_2.h
│ │ │ ├── memory_manager_kernel_3.h
│ │ │ └── memory_manager_kernel_abstract.h
│ │ ├── memory_manager.h
│ │ ├── memory_manager_global/
│ │ │ ├── memory_manager_global_kernel_1.h
│ │ │ └── memory_manager_global_kernel_abstract.h
│ │ ├── memory_manager_global.h
│ │ ├── memory_manager_stateless/
│ │ │ ├── memory_manager_stateless_kernel_1.h
│ │ │ ├── memory_manager_stateless_kernel_2.h
│ │ │ └── memory_manager_stateless_kernel_abstract.h
│ │ ├── memory_manager_stateless.h
│ │ ├── metaprogramming.h
│ │ ├── misc_api/
│ │ │ ├── misc_api_kernel_1.h
│ │ │ ├── misc_api_kernel_2.h
│ │ │ ├── misc_api_kernel_abstract.h
│ │ │ ├── misc_api_shared.h
│ │ │ ├── posix.h
│ │ │ └── windows.h
│ │ ├── misc_api.h
│ │ ├── noncopyable.h
│ │ ├── numeric_constants.h
│ │ ├── numerical_integration/
│ │ │ ├── integrate_function_adapt_simpson.h
│ │ │ └── integrate_function_adapt_simpson_abstract.h
│ │ ├── numerical_integration.h
│ │ ├── ostream
│ │ ├── pipe/
│ │ │ ├── pipe_kernel_1.h
│ │ │ └── pipe_kernel_abstract.h
│ │ ├── pipe.h
│ │ ├── platform.h
│ │ ├── queue/
│ │ │ ├── queue_kernel_1.h
│ │ │ ├── queue_kernel_2.h
│ │ │ ├── queue_kernel_abstract.h
│ │ │ ├── queue_kernel_c.h
│ │ │ ├── queue_sort_1.h
│ │ │ └── queue_sort_abstract.h
│ │ ├── queue.h
│ │ ├── ref.h
│ │ ├── revision.h
│ │ ├── serialize.h
│ │ ├── set/
│ │ │ ├── set_compare_1.h
│ │ │ ├── set_compare_abstract.h
│ │ │ ├── set_kernel_1.h
│ │ │ ├── set_kernel_abstract.h
│ │ │ └── set_kernel_c.h
│ │ ├── set.h
│ │ ├── sliding_buffer/
│ │ │ ├── circular_buffer.h
│ │ │ ├── circular_buffer_abstract.h
│ │ │ ├── sliding_buffer_kernel_1.h
│ │ │ ├── sliding_buffer_kernel_abstract.h
│ │ │ └── sliding_buffer_kernel_c.h
│ │ ├── sliding_buffer.h
│ │ ├── sockets/
│ │ │ ├── posix.h
│ │ │ ├── sockets_extensions.h
│ │ │ ├── sockets_extensions_abstract.h
│ │ │ ├── sockets_kernel_1.h
│ │ │ ├── sockets_kernel_2.h
│ │ │ ├── sockets_kernel_abstract.h
│ │ │ └── windows.h
│ │ ├── sockets.h
│ │ ├── sort.h
│ │ ├── sparse_vector.h
│ │ ├── sstream
│ │ ├── stack/
│ │ │ ├── stack_kernel_1.h
│ │ │ ├── stack_kernel_abstract.h
│ │ │ └── stack_kernel_c.h
│ │ ├── stack.h
│ │ ├── stack_trace.h
│ │ ├── std_allocator.h
│ │ ├── stl_checked/
│ │ │ ├── std_vector_c.h
│ │ │ └── std_vector_c_abstract.h
│ │ ├── stl_checked.h
│ │ ├── string/
│ │ │ ├── cassert
│ │ │ ├── iomanip
│ │ │ ├── iosfwd
│ │ │ ├── iostream
│ │ │ ├── locale
│ │ │ ├── string.h
│ │ │ └── string_abstract.h
│ │ ├── string.h
│ │ ├── test_for_odr_violations.cpp
│ │ ├── test_for_odr_violations.h
│ │ ├── threads/
│ │ │ ├── async.h
│ │ │ ├── async_abstract.h
│ │ │ ├── auto_mutex_extension.h
│ │ │ ├── auto_mutex_extension_abstract.h
│ │ │ ├── auto_unlock_extension.h
│ │ │ ├── auto_unlock_extension_abstract.h
│ │ │ ├── create_new_thread_extension.h
│ │ │ ├── create_new_thread_extension_abstract.h
│ │ │ ├── multithreaded_object_extension.h
│ │ │ ├── multithreaded_object_extension_abstract.h
│ │ │ ├── parallel_for_extension.h
│ │ │ ├── parallel_for_extension_abstract.h
│ │ │ ├── posix.h
│ │ │ ├── read_write_mutex_extension.h
│ │ │ ├── read_write_mutex_extension_abstract.h
│ │ │ ├── rmutex_extension.h
│ │ │ ├── rmutex_extension_abstract.h
│ │ │ ├── rsignaler_extension.h
│ │ │ ├── rsignaler_extension_abstract.h
│ │ │ ├── thread_function_extension.h
│ │ │ ├── thread_function_extension_abstract.h
│ │ │ ├── thread_pool_extension.h
│ │ │ ├── thread_pool_extension_abstract.h
│ │ │ ├── thread_specific_data_extension.h
│ │ │ ├── thread_specific_data_extension_abstract.h
│ │ │ ├── threaded_object_extension.h
│ │ │ ├── threaded_object_extension_abstract.h
│ │ │ ├── threads_kernel.h
│ │ │ ├── threads_kernel_1.h
│ │ │ ├── threads_kernel_2.h
│ │ │ ├── threads_kernel_abstract.h
│ │ │ ├── threads_kernel_shared.h
│ │ │ └── windows.h
│ │ ├── threads.h
│ │ ├── time_this.h
│ │ ├── timeout/
│ │ │ ├── timeout.h
│ │ │ └── timeout_abstract.h
│ │ ├── timeout.h
│ │ ├── timer/
│ │ │ ├── timer.h
│ │ │ ├── timer_abstract.h
│ │ │ └── timer_heavy.h
│ │ ├── timer.h
│ │ ├── timing.h
│ │ ├── tokenizer/
│ │ │ ├── tokenizer_kernel_1.h
│ │ │ ├── tokenizer_kernel_abstract.h
│ │ │ └── tokenizer_kernel_c.h
│ │ ├── tokenizer.h
│ │ ├── uintn.h
│ │ ├── unicode/
│ │ │ ├── unicode.h
│ │ │ └── unicode_abstract.h
│ │ ├── unicode.h
│ │ ├── unordered_pair.h
│ │ ├── vectorstream/
│ │ │ ├── unserialize.h
│ │ │ ├── unserialize_abstract.h
│ │ │ ├── vectorstream.h
│ │ │ └── vectorstream_abstract.h
│ │ ├── vectorstream.h
│ │ └── windows_magic.h
│ ├── dlibqueue.h
│ ├── extract_graph_data.py
│ ├── lockbasedqueue.h
│ ├── makefile
│ ├── simplelockfree.h
│ ├── stdqueue.h
│ ├── tbb/
│ │ ├── COPYING
│ │ ├── README.txt
│ │ ├── aggregator.h
│ │ ├── aligned_space.h
│ │ ├── arena.cpp
│ │ ├── arena.h
│ │ ├── atomic.h
│ │ ├── blocked_range.h
│ │ ├── blocked_range2d.h
│ │ ├── blocked_range3d.h
│ │ ├── cache_aligned_allocator.cpp
│ │ ├── cache_aligned_allocator.h
│ │ ├── cilk-tbb-interop.h
│ │ ├── combinable.h
│ │ ├── compat/
│ │ │ ├── condition_variable
│ │ │ ├── ppl.h
│ │ │ ├── thread
│ │ │ └── tuple
│ │ ├── concurrent_hash_map.cpp
│ │ ├── concurrent_hash_map.h
│ │ ├── concurrent_lru_cache.h
│ │ ├── concurrent_monitor.cpp
│ │ ├── concurrent_monitor.h
│ │ ├── concurrent_priority_queue.h
│ │ ├── concurrent_queue.cpp
│ │ ├── concurrent_queue.h
│ │ ├── concurrent_unordered_map.h
│ │ ├── concurrent_unordered_set.h
│ │ ├── concurrent_vector.cpp
│ │ ├── concurrent_vector.h
│ │ ├── condition_variable.cpp
│ │ ├── critical_section.cpp
│ │ ├── critical_section.h
│ │ ├── custom_scheduler.h
│ │ ├── dynamic_link.cpp
│ │ ├── dynamic_link.h
│ │ ├── enumerable_thread_specific.h
│ │ ├── flow_graph.h
│ │ ├── governor.cpp
│ │ ├── governor.h
│ │ ├── ia32-masm/
│ │ │ ├── atomic_support.asm
│ │ │ ├── itsx.asm
│ │ │ └── lock_byte.asm
│ │ ├── ia64-gas/
│ │ │ ├── atomic_support.s
│ │ │ ├── ia64_misc.s
│ │ │ ├── lock_byte.s
│ │ │ ├── log2.s
│ │ │ └── pause.s
│ │ ├── ibm_aix51/
│ │ │ └── atomic_support.c
│ │ ├── intel64-masm/
│ │ │ ├── atomic_support.asm
│ │ │ ├── intel64_misc.asm
│ │ │ └── itsx.asm
│ │ ├── internal/
│ │ │ ├── _aggregator_impl.h
│ │ │ ├── _concurrent_queue_impl.h
│ │ │ ├── _concurrent_unordered_impl.h
│ │ │ ├── _flow_graph_impl.h
│ │ │ ├── _flow_graph_indexer_impl.h
│ │ │ ├── _flow_graph_item_buffer_impl.h
│ │ │ ├── _flow_graph_join_impl.h
│ │ │ ├── _flow_graph_node_impl.h
│ │ │ ├── _flow_graph_tagged_buffer_impl.h
│ │ │ ├── _flow_graph_trace_impl.h
│ │ │ ├── _flow_graph_types_impl.h
│ │ │ ├── _mutex_padding.h
│ │ │ ├── _range_iterator.h
│ │ │ ├── _tbb_strings.h
│ │ │ ├── _tbb_windef.h
│ │ │ ├── _x86_eliding_mutex_impl.h
│ │ │ └── _x86_rtm_rw_mutex_impl.h
│ │ ├── intrusive_list.h
│ │ ├── itt_notify.cpp
│ │ ├── itt_notify.h
│ │ ├── lin32-tbb-export.def
│ │ ├── lin32-tbb-export.lst
│ │ ├── lin64-tbb-export.def
│ │ ├── lin64-tbb-export.lst
│ │ ├── lin64ipf-tbb-export.def
│ │ ├── lin64ipf-tbb-export.lst
│ │ ├── mac32-tbb-export.def
│ │ ├── mac32-tbb-export.lst
│ │ ├── mac64-tbb-export.def
│ │ ├── mac64-tbb-export.lst
│ │ ├── machine/
│ │ │ ├── gcc_armv7.h
│ │ │ ├── gcc_generic.h
│ │ │ ├── gcc_ia32_common.h
│ │ │ ├── gcc_itsx.h
│ │ │ ├── ibm_aix51.h
│ │ │ ├── icc_generic.h
│ │ │ ├── linux_common.h
│ │ │ ├── linux_ia32.h
│ │ │ ├── linux_ia64.h
│ │ │ ├── linux_intel64.h
│ │ │ ├── mac_ppc.h
│ │ │ ├── macos_common.h
│ │ │ ├── mic_common.h
│ │ │ ├── msvc_armv7.h
│ │ │ ├── msvc_ia32_common.h
│ │ │ ├── sunos_sparc.h
│ │ │ ├── windows_api.h
│ │ │ ├── windows_ia32.h
│ │ │ ├── windows_intel64.h
│ │ │ └── xbox360_ppc.h
│ │ ├── mailbox.h
│ │ ├── market.cpp
│ │ ├── market.h
│ │ ├── memory_pool.h
│ │ ├── mutex.cpp
│ │ ├── mutex.h
│ │ ├── null_mutex.h
│ │ ├── null_rw_mutex.h
│ │ ├── observer_proxy.cpp
│ │ ├── observer_proxy.h
│ │ ├── parallel_do.h
│ │ ├── parallel_for.h
│ │ ├── parallel_for_each.h
│ │ ├── parallel_invoke.h
│ │ ├── parallel_reduce.h
│ │ ├── parallel_scan.h
│ │ ├── parallel_sort.h
│ │ ├── parallel_while.h
│ │ ├── partitioner.h
│ │ ├── pipeline.cpp
│ │ ├── pipeline.h
│ │ ├── private_server.cpp
│ │ ├── queuing_mutex.cpp
│ │ ├── queuing_mutex.h
│ │ ├── queuing_rw_mutex.cpp
│ │ ├── queuing_rw_mutex.h
│ │ ├── reader_writer_lock.cpp
│ │ ├── reader_writer_lock.h
│ │ ├── recursive_mutex.cpp
│ │ ├── recursive_mutex.h
│ │ ├── runtime_loader.h
│ │ ├── scalable_allocator.h
│ │ ├── scheduler.cpp
│ │ ├── scheduler.h
│ │ ├── scheduler_common.h
│ │ ├── scheduler_utility.h
│ │ ├── semaphore.cpp
│ │ ├── semaphore.h
│ │ ├── spin_mutex.cpp
│ │ ├── spin_mutex.h
│ │ ├── spin_rw_mutex.cpp
│ │ ├── spin_rw_mutex.h
│ │ ├── task.cpp
│ │ ├── task.h
│ │ ├── task_arena.h
│ │ ├── task_group.h
│ │ ├── task_group_context.cpp
│ │ ├── task_scheduler_init.h
│ │ ├── task_scheduler_observer.h
│ │ ├── task_stream.h
│ │ ├── tbb.h
│ │ ├── tbb_allocator.h
│ │ ├── tbb_assert_impl.h
│ │ ├── tbb_config.h
│ │ ├── tbb_exception.h
│ │ ├── tbb_machine.h
│ │ ├── tbb_main.cpp
│ │ ├── tbb_main.h
│ │ ├── tbb_misc.cpp
│ │ ├── tbb_misc.h
│ │ ├── tbb_misc_ex.cpp
│ │ ├── tbb_profiling.h
│ │ ├── tbb_resource.rc
│ │ ├── tbb_statistics.cpp
│ │ ├── tbb_statistics.h
│ │ ├── tbb_stddef.h
│ │ ├── tbb_thread.cpp
│ │ ├── tbb_thread.h
│ │ ├── tbb_version.h
│ │ ├── tbbmalloc_proxy.h
│ │ ├── tick_count.h
│ │ ├── tls.h
│ │ ├── tools_api/
│ │ │ ├── disable_warnings.h
│ │ │ ├── internal/
│ │ │ │ └── ittnotify.h
│ │ │ ├── ittnotify.h
│ │ │ ├── ittnotify_config.h
│ │ │ ├── ittnotify_static.c
│ │ │ ├── ittnotify_static.h
│ │ │ ├── ittnotify_types.h
│ │ │ ├── legacy/
│ │ │ │ └── ittnotify.h
│ │ │ └── prototype/
│ │ │ └── ittnotify.h
│ │ ├── version_string.ver
│ │ ├── win32-tbb-export.def
│ │ ├── win32-tbb-export.lst
│ │ ├── win64-gcc-tbb-export.def
│ │ ├── win64-gcc-tbb-export.lst
│ │ ├── win64-tbb-export.def
│ │ ├── win64-tbb-export.lst
│ │ ├── winrt-tbb-export.lst
│ │ ├── x86_rtm_rw_mutex.cpp
│ │ └── xbox360-tbb-export.def
│ ├── tbbqueue.h
│ └── wrappers.h
├── blockingconcurrentqueue.h
├── build/
│ ├── makefile
│ ├── makefile.inc
│ ├── msvc11/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc12/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc14/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc15/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc16/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ └── xcode/
│ ├── Info.plist
│ ├── concurrentqueue.xcodeproj/
│ │ ├── project.pbxproj
│ │ ├── project.xcworkspace/
│ │ │ └── contents.xcworkspacedata
│ │ └── xcshareddata/
│ │ └── xcschemes/
│ │ └── concurrentqueue-unittests-ios.xcscheme
│ └── main_ios.mm
├── c_api/
│ ├── blockingconcurrentqueue.cpp
│ ├── concurrentqueue.cpp
│ └── concurrentqueue.h
├── concurrentqueue.h
├── concurrentqueueConfig.cmake.in
├── internal/
│ └── concurrentqueue_internal_debug.h
├── lightweightsemaphore.h
├── samples.md
└── tests/
├── CDSChecker/
│ ├── README.txt
│ ├── corealgo.h
│ ├── enqueue_dequeue_many.cpp
│ ├── enqueue_dequeue_one.cpp
│ └── makefile
├── common/
│ ├── simplethread.cpp
│ ├── simplethread.h
│ ├── systemtime.cpp
│ └── systemtime.h
├── corealgos.h
├── fuzztests/
│ ├── fuzztests.cpp
│ └── makefile
├── relacy/
│ ├── freelist.cpp
│ ├── integrated.cpp
│ ├── makefile
│ ├── relacy/
│ │ ├── CHANGES
│ │ ├── LICENSE
│ │ ├── VERSION
│ │ ├── example/
│ │ │ ├── cli_ws_deque/
│ │ │ │ ├── cli_ws_deque.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── cli_ws_deque.sln
│ │ │ │ │ └── cli_ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── condvar/
│ │ │ │ ├── condvar.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── condvar.sln
│ │ │ │ │ └── condvar.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── condvar.sln
│ │ │ │ │ └── condvar.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── eao_blocking/
│ │ │ │ └── eao_blocking.cpp
│ │ │ ├── eventcount/
│ │ │ │ ├── eventcount.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── examples/
│ │ │ │ ├── amp_condvar.hpp
│ │ │ │ ├── examples.cpp
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── examples.sln
│ │ │ │ │ └── examples.vcproj
│ │ │ │ ├── spsc_overwrite_queue.hpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── java_ws_deque/
│ │ │ │ ├── java_ws_deque.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── java_ws_deque.sln
│ │ │ │ │ └── java_ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── mpmc/
│ │ │ │ ├── mpmc.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── mpmc.sln
│ │ │ │ │ └── mpmc.vcproj
│ │ │ │ ├── pcx.h
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── mutex_business_logic/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── mutex_business_logic.sln
│ │ │ │ │ └── mutex_business_logic.vcproj
│ │ │ │ ├── mutex_business_logic.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── peterson/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── peterson.sln
│ │ │ │ │ └── peterson.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── peterson.sln
│ │ │ │ │ └── peterson.vcproj
│ │ │ │ ├── peterson.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── proxy_collector/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ ├── proxy_collector.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── ref_counting/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ ├── ref_counting.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── smr/
│ │ │ │ ├── g++/
│ │ │ │ │ └── Makefile
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── smr.sln
│ │ │ │ │ └── smr.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── smr.sln
│ │ │ │ │ └── smr.vcproj
│ │ │ │ ├── smr.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── spsc_queue/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ ├── spsc_queue.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── stack/
│ │ │ │ ├── DESCRIPTION.TXT
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── stack.sln
│ │ │ │ │ └── stack.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── stack.sln
│ │ │ │ │ └── stack.vcproj
│ │ │ │ ├── stack.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── tbb_eventcount/
│ │ │ │ ├── eventcount.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── ws_deque/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ ├── stdafx.h
│ │ │ │ └── ws_deque.cpp
│ │ │ └── ws_deque2/
│ │ │ ├── msvc8/
│ │ │ │ ├── ws_deque.sln
│ │ │ │ └── ws_deque.vcproj
│ │ │ ├── stdafx.cpp
│ │ │ ├── stdafx.h
│ │ │ └── ws_deque.cpp
│ │ ├── relacy/
│ │ │ ├── atomic.hpp
│ │ │ ├── atomic_events.hpp
│ │ │ ├── atomic_fence.hpp
│ │ │ ├── backoff.hpp
│ │ │ ├── base.hpp
│ │ │ ├── cli.hpp
│ │ │ ├── cli_interlocked.hpp
│ │ │ ├── cli_var.hpp
│ │ │ ├── cli_volatile.hpp
│ │ │ ├── context.hpp
│ │ │ ├── context_addr_hash.hpp
│ │ │ ├── context_base.hpp
│ │ │ ├── context_base_impl.hpp
│ │ │ ├── context_bound_scheduler.hpp
│ │ │ ├── defs.hpp
│ │ │ ├── dyn_thread.hpp
│ │ │ ├── dyn_thread_ctx.hpp
│ │ │ ├── foreach.hpp
│ │ │ ├── full_search_scheduler.hpp
│ │ │ ├── history.hpp
│ │ │ ├── java.hpp
│ │ │ ├── java_atomic.hpp
│ │ │ ├── java_var.hpp
│ │ │ ├── java_volatile.hpp
│ │ │ ├── memory.hpp
│ │ │ ├── memory_order.hpp
│ │ │ ├── pch.hpp
│ │ │ ├── platform.hpp
│ │ │ ├── pthread.h
│ │ │ ├── random.hpp
│ │ │ ├── random_scheduler.hpp
│ │ │ ├── relacy.hpp
│ │ │ ├── relacy_cli.hpp
│ │ │ ├── relacy_java.hpp
│ │ │ ├── relacy_std.hpp
│ │ │ ├── rmw.hpp
│ │ │ ├── scheduler.hpp
│ │ │ ├── signature.hpp
│ │ │ ├── slab_allocator.hpp
│ │ │ ├── stdlib/
│ │ │ │ ├── condition_variable.hpp
│ │ │ │ ├── event.hpp
│ │ │ │ ├── mutex.hpp
│ │ │ │ ├── pthread.hpp
│ │ │ │ ├── semaphore.hpp
│ │ │ │ └── windows.hpp
│ │ │ ├── sync_var.hpp
│ │ │ ├── test_params.hpp
│ │ │ ├── test_result.hpp
│ │ │ ├── test_suite.hpp
│ │ │ ├── thread.hpp
│ │ │ ├── thread_base.hpp
│ │ │ ├── thread_local.hpp
│ │ │ ├── thread_local_ctx.hpp
│ │ │ ├── var.hpp
│ │ │ ├── volatile.hpp
│ │ │ ├── waitset.hpp
│ │ │ └── windows.h
│ │ └── test/
│ │ ├── addr_hash.hpp
│ │ ├── advanced.txt
│ │ ├── compare_swap.hpp
│ │ ├── condvar.hpp
│ │ ├── data_race.hpp
│ │ ├── detection.txt
│ │ ├── dyn_thread.hpp
│ │ ├── event.hpp
│ │ ├── features.txt
│ │ ├── fence.hpp
│ │ ├── foo.cpp
│ │ ├── futex.hpp
│ │ ├── g++/
│ │ │ ├── build_all_cygwin_debug.bat
│ │ │ ├── build_all_debug.bat
│ │ │ ├── build_all_release.sh
│ │ │ ├── build_cygwin_release.cmd
│ │ │ ├── build_debug.cmd
│ │ │ ├── build_release.cmd
│ │ │ └── test.cpp
│ │ ├── iriw.cpp
│ │ ├── jtest/
│ │ │ ├── jtest.cpp
│ │ │ ├── msvc8/
│ │ │ │ ├── jtest.sln
│ │ │ │ └── jtest.vcproj
│ │ │ ├── msvc9/
│ │ │ │ ├── jtest.sln
│ │ │ │ └── jtest.vcproj
│ │ │ ├── stdafx.cpp
│ │ │ └── stdafx.h
│ │ ├── main.cpp
│ │ ├── memory.hpp
│ │ ├── memory_order.hpp
│ │ ├── msvc71/
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── msvc8/
│ │ │ ├── rrd.sln
│ │ │ ├── rrd.vcproj
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── msvc9/
│ │ │ ├── rrd.sln
│ │ │ ├── rrd.vcproj
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── mutex.hpp
│ │ ├── ntest/
│ │ │ ├── msvc8/
│ │ │ │ ├── ntest.sln
│ │ │ │ └── ntest.vcproj
│ │ │ ├── msvc9/
│ │ │ │ ├── ntest.sln
│ │ │ │ └── ntest.vcproj
│ │ │ ├── ntest.cpp
│ │ │ ├── stdafx.cpp
│ │ │ └── stdafx.h
│ │ ├── pthread.hpp
│ │ ├── scheduler.hpp
│ │ ├── semaphore.hpp
│ │ ├── stdafx.cpp
│ │ ├── stdafx.h
│ │ ├── thread_local.hpp
│ │ ├── todo.txt
│ │ ├── trash/
│ │ │ ├── original.hpp
│ │ │ └── rtl.hpp
│ │ ├── tutorial.txt
│ │ ├── wfmo.hpp
│ │ └── windows.hpp
│ ├── relacy_shims.h
│ └── spmchash.cpp
└── unittests/
├── makefile
├── mallocmacro.cpp
├── minitest.h
└── unittests.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.ipch
*.suo
*.user
*.sdf
*.opensdf
*.exe
*.pdb
*.vs
*.VC.db
build/bin/
build/*.o
build/*.log
build/msvc16/*.log
build/msvc16/obj/
build/msvc15/*.log
build/msvc15/obj/
build/msvc14/*.log
build/msvc14/obj/
build/msvc12/*.log
build/msvc12/obj/
build/msvc11/*.log
build/msvc11/obj/
build/xcode/build/
.idea/
cmake-build*/
tests/fuzztests/fuzztests.log
benchmarks/benchmarks.log
tests/CDSChecker/*.o
tests/CDSChecker/*.log
tests/CDSChecker/model-checker/
tests/relacy/freelist.exe
tests/relacy/spmchash.exe
tests/relacy/log.txt
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.9)
project(concurrentqueue VERSION 1.0.0)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
add_library(${PROJECT_NAME} INTERFACE)
target_include_directories(${PROJECT_NAME}
INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/>
)
install(TARGETS ${PROJECT_NAME}
EXPORT ${PROJECT_NAME}Targets
)
write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION
${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
ARCH_INDEPENDENT
)
configure_package_config_file(${PROJECT_NAME}Config.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
INSTALL_DESTINATION
${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/
)
install(EXPORT
${PROJECT_NAME}Targets
FILE
${PROJECT_NAME}Targets.cmake
NAMESPACE
"${PROJECT_NAME}::"
DESTINATION
${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
COMPONENT
Devel
)
install(
FILES
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION
${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
COMPONENT
Devel
)
install(
FILES
blockingconcurrentqueue.h
concurrentqueue.h
lightweightsemaphore.h
LICENSE.md
DESTINATION
${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/moodycamel
)
set(CPACK_PACKAGE_NAME ${PROJECT_NAME})
set(CPACK_PACKAGE_VENDOR "Cameron Desrochers <cameron@moodycamel.com>")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "An industrial-strength lock-free queue for C++.")
set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
set(CPACK_DEBIAN_PACKAGE_MAINTAINER ${CPACK_PACKAGE_VENDOR})
set(CPACK_GENERATOR "RPM;DEB")
include(CPack)
================================================
FILE: LICENSE.md
================================================
This license file applies to everything in this repository except that which
is explicitly annotated as being written by other authors, i.e. the Boost
queue (included in the benchmarks for comparison), Intel's TBB library (ditto),
dlib::pipe (ditto),
the CDSChecker tool (used for verification), the Relacy model checker (ditto),
and Jeff Preshing's semaphore implementation (used in the blocking queue) which
has a zlib license (embedded in lightweightsempahore.h).
---
Simplified BSD License:
Copyright (c) 2013-2016, Cameron Desrochers.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of
conditions and the following disclaimer in the documentation and/or other materials
provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---
I have also chosen to dual-license under the Boost Software License as an alternative to
the Simplified BSD license above:
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: README.md
================================================
# moodycamel::ConcurrentQueue<T>
An industrial-strength lock-free queue for C++.
Note: If all you need is a single-producer, single-consumer queue, I have [one of those too][spsc].
## Features
- Knock-your-socks-off [blazing fast performance][benchmarks].
- Single-header implementation. Just drop it in your project.
- Fully thread-safe lock-free queue. Use concurrently from any number of threads.
- C++11 implementation -- elements are moved (instead of copied) where possible.
- Templated, obviating the need to deal exclusively with pointers -- memory is managed for you.
- No artificial limitations on element types or maximum count.
- Memory can be allocated once up-front, or dynamically as needed.
- Fully portable (no assembly; all is done through standard C++11 primitives).
- Supports super-fast bulk operations.
- Includes a low-overhead blocking version (BlockingConcurrentQueue).
- Exception safe.
## Reasons to use
There are not that many full-fledged lock-free queues for C++. Boost has one, but it's limited to objects with trivial
assignment operators and trivial destructors, for example.
Intel's TBB queue isn't lock-free, and requires trivial constructors too.
There're many academic papers that implement lock-free queues in C++, but usable source code is
hard to find, and tests even more so.
This queue not only has less limitations than others (for the most part), but [it's also faster][benchmarks].
It's been fairly well-tested, and offers advanced features like **bulk enqueueing/dequeueing**
(which, with my new design, is much faster than one element at a time, approaching and even surpassing
the speed of a non-concurrent queue even under heavy contention).
In short, there was a lock-free queue shaped hole in the C++ open-source universe, and I set out
to fill it with the fastest, most complete, and well-tested design and implementation I could.
The result is `moodycamel::ConcurrentQueue` :-)
## Reasons *not* to use
The fastest synchronization of all is the kind that never takes place. Fundamentally,
concurrent data structures require some synchronization, and that takes time. Every effort
was made, of course, to minimize the overhead, but if you can avoid sharing data between
threads, do so!
Why use concurrent data structures at all, then? Because they're gosh darn convenient! (And, indeed,
sometimes sharing data concurrently is unavoidable.)
My queue is **not linearizable** (see the next section on high-level design). The foundations of
its design assume that producers are independent; if this is not the case, and your producers
co-ordinate amongst themselves in some fashion, be aware that the elements won't necessarily
come out of the queue in the same order they were put in *relative to the ordering formed by that co-ordination*
(but they will still come out in the order they were put in by any *individual* producer). If this affects
your use case, you may be better off with another implementation; either way, it's an important limitation
to be aware of.
My queue is also **not NUMA aware**, and does a lot of memory re-use internally, meaning it probably doesn't
scale particularly well on NUMA architectures; however, I don't know of any other lock-free queue that *is*
NUMA aware (except for [SALSA][salsa], which is very cool, but has no publicly available implementation that I know of).
Finally, the queue is **not sequentially consistent**; there *is* a happens-before relationship between when an element is put
in the queue and when it comes out, but other things (such as pumping the queue until it's empty) require more thought
to get right in all eventualities, because explicit memory ordering may have to be done to get the desired effect. In other words,
it can sometimes be difficult to use the queue correctly. This is why it's a good idea to follow the [samples][samples.md] where possible.
On the other hand, the upside of this lack of sequential consistency is better performance.
## High-level design
Elements are stored internally using contiguous blocks instead of linked lists for better performance.
The queue is made up of a collection of sub-queues, one for each producer. When a consumer
wants to dequeue an element, it checks all the sub-queues until it finds one that's not empty.
All of this is largely transparent to the user of the queue, however -- it mostly just works<sup>TM</sup>.
One particular consequence of this design, however, (which seems to be non-intuitive) is that if two producers
enqueue at the same time, there is no defined ordering between the elements when they're later dequeued.
Normally this is fine, because even with a fully linearizable queue there'd be a race between the producer
threads and so you couldn't rely on the ordering anyway. However, if for some reason you do extra explicit synchronization
between the two producer threads yourself, thus defining a total order between enqueue operations, you might expect
that the elements would come out in the same total order, which is a guarantee my queue does not offer. At that
point, though, there semantically aren't really two separate producers, but rather one that happens to be spread
across multiple threads. In this case, you can still establish a total ordering with my queue by creating
a single producer token, and using that from both threads to enqueue (taking care to synchronize access to the token,
of course, but there was already extra synchronization involved anyway).
I've written a more detailed [overview of the internal design][blog], as well as [the full
nitty-gritty details of the design][design], on my blog. Finally, the
[source][source] itself is available for perusal for those interested in its implementation.
## Basic use
The entire queue's implementation is contained in **one header**, [`concurrentqueue.h`][concurrentqueue.h].
Simply download and include that to use the queue. The blocking version is in a separate header,
[`blockingconcurrentqueue.h`][blockingconcurrentqueue.h], that depends on [`concurrentqueue.h`][concurrentqueue.h] and
[`lightweightsemaphore.h`][lightweightsemaphore.h]. The implementation makes use of certain key C++11 features,
so it requires a relatively recent compiler (e.g. VS2012+ or g++ 4.8; note that g++ 4.6 has a known bug with `std::atomic`
and is thus not supported). The algorithm implementations themselves are platform independent.
Use it like you would any other templated queue, with the exception that you can use
it from many threads at once :-)
Simple example:
```C++
#include "concurrentqueue.h"
moodycamel::ConcurrentQueue<int> q;
q.enqueue(25);
int item;
bool found = q.try_dequeue(item);
assert(found && item == 25);
```
Description of basic methods:
- `ConcurrentQueue(size_t initialSizeEstimate)`
Constructor which optionally accepts an estimate of the number of elements the queue will hold
- `enqueue(T&& item)`
Enqueues one item, allocating extra space if necessary
- `try_enqueue(T&& item)`
Enqueues one item, but only if enough memory is already allocated
- `try_dequeue(T& item)`
Dequeues one item, returning true if an item was found or false if the queue appeared empty
Note that it is up to the user to ensure that the queue object is completely constructed before
being used by any other threads (this includes making the memory effects of construction
visible, possibly via a memory barrier). Similarly, it's important that all threads have
finished using the queue (and the memory effects have fully propagated) before it is
destructed.
There's usually two versions of each method, one "explicit" version that takes a user-allocated per-producer or
per-consumer token, and one "implicit" version that works without tokens. Using the explicit methods is almost
always faster (though not necessarily by a huge factor). Apart from performance, the primary distinction between them
is their sub-queue allocation behaviour for enqueue operations: Using the implicit enqueue methods causes an
automatically-allocated thread-local producer sub-queue to be allocated.
Explicit producers, on the other hand, are tied directly to their tokens' lifetimes (but are recycled internally).
In order to avoid the number of sub-queues growing without bound, implicit producers are marked for reuse once
their thread exits. However, this is not supported on all platforms. If using the queue from short-lived threads,
it is recommended to use explicit producer tokens instead.
Full API (pseudocode):
# Allocates more memory if necessary
enqueue(item) : bool
enqueue(prod_token, item) : bool
enqueue_bulk(item_first, count) : bool
enqueue_bulk(prod_token, item_first, count) : bool
# Fails if not enough memory to enqueue
try_enqueue(item) : bool
try_enqueue(prod_token, item) : bool
try_enqueue_bulk(item_first, count) : bool
try_enqueue_bulk(prod_token, item_first, count) : bool
# Attempts to dequeue from the queue (never allocates)
try_dequeue(item&) : bool
try_dequeue(cons_token, item&) : bool
try_dequeue_bulk(item_first, max) : size_t
try_dequeue_bulk(cons_token, item_first, max) : size_t
# If you happen to know which producer you want to dequeue from
try_dequeue_from_producer(prod_token, item&) : bool
try_dequeue_bulk_from_producer(prod_token, item_first, max) : size_t
# A not-necessarily-accurate count of the total number of elements
size_approx() : size_t
## Blocking version
As mentioned above, a full blocking wrapper of the queue is provided that adds
`wait_dequeue` and `wait_dequeue_bulk` methods in addition to the regular interface.
This wrapper is extremely low-overhead, but slightly less fast than the non-blocking
queue (due to the necessary bookkeeping involving a lightweight semaphore).
There are also timed versions that allow a timeout to be specified (either in microseconds
or with a `std::chrono` object).
The only major caveat with the blocking version is that you must be careful not to
destroy the queue while somebody is waiting on it. This generally means you need to
know for certain that another element is going to come along before you call one of
the blocking methods. (To be fair, the non-blocking version cannot be destroyed while
in use either, but it can be easier to coordinate the cleanup.)
Blocking example:
```C++
#include "blockingconcurrentqueue.h"
moodycamel::BlockingConcurrentQueue<int> q;
std::thread producer([&]() {
for (int i = 0; i != 100; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(i % 10));
q.enqueue(i);
}
});
std::thread consumer([&]() {
for (int i = 0; i != 100; ++i) {
int item;
q.wait_dequeue(item);
assert(item == i);
if (q.wait_dequeue_timed(item, std::chrono::milliseconds(5))) {
++i;
assert(item == i);
}
}
});
producer.join();
consumer.join();
assert(q.size_approx() == 0);
```
## Advanced features
#### Tokens
The queue can take advantage of extra per-producer and per-consumer storage if
it's available to speed up its operations. This takes the form of "tokens":
You can create a consumer token and/or a producer token for each thread or task
(tokens themselves are not thread-safe), and use the methods that accept a token
as their first parameter:
```C++
moodycamel::ConcurrentQueue<int> q;
moodycamel::ProducerToken ptok(q);
q.enqueue(ptok, 17);
moodycamel::ConsumerToken ctok(q);
int item;
q.try_dequeue(ctok, item);
assert(item == 17);
```
If you happen to know which producer you want to consume from (e.g. in
a single-producer, multi-consumer scenario), you can use the `try_dequeue_from_producer`
methods, which accept a producer token instead of a consumer token, and cut some overhead.
Note that tokens work with the blocking version of the queue too.
When producing or consuming many elements, the most efficient way is to:
1. Use the bulk methods of the queue with tokens
2. Failing that, use the bulk methods without tokens
3. Failing that, use the single-item methods with tokens
4. Failing that, use the single-item methods without tokens
Having said that, don't create tokens willy-nilly -- ideally there would be
one token (of each kind) per thread. The queue will work with what it is
given, but it performs best when used with tokens.
Note that tokens aren't actually tied to any given thread; it's not technically
required that they be local to the thread, only that they be used by a single
producer/consumer at a time.
#### Bulk operations
Thanks to the [novel design][blog] of the queue, it's just as easy to enqueue/dequeue multiple
items as it is to do one at a time. This means that overhead can be cut drastically for
bulk operations. Example syntax:
```C++
moodycamel::ConcurrentQueue<int> q;
int items[] = { 1, 2, 3, 4, 5 };
q.enqueue_bulk(items, 5);
int results[5]; // Could also be any iterator
size_t count = q.try_dequeue_bulk(results, 5);
for (size_t i = 0; i != count; ++i) {
assert(results[i] == items[i]);
}
```
#### Preallocation (correctly using `try_enqueue`)
`try_enqueue`, unlike just plain `enqueue`, will never allocate memory. If there's not enough room in the
queue, it simply returns false. The key to using this method properly, then, is to ensure enough space is
pre-allocated for your desired maximum element count.
The constructor accepts a count of the number of elements that it should reserve space for. Because the
queue works with blocks of elements, however, and not individual elements themselves, the value to pass
in order to obtain an effective number of pre-allocated element slots is non-obvious.
First, be aware that the count passed is rounded up to the next multiple of the block size. Note that the
default block size is 32 (this can be changed via the traits). Second, once a slot in a block has been
enqueued to, that slot cannot be re-used until the rest of the block has been completely filled
up and then completely emptied. This affects the number of blocks you need in order to account for the
overhead of partially-filled blocks. Third, each producer (whether implicit or explicit) claims and recycles
blocks in a different manner, which again affects the number of blocks you need to account for a desired number of
usable slots.
Suppose you want the queue to be able to hold at least `N` elements at any given time. Without delving too
deep into the rather arcane implementation details, here are some simple formulas for the number of elements
to request for pre-allocation in such a case. Note the division is intended to be arithmetic division and not
integer division (in order for `ceil()` to work).
For explicit producers (using tokens to enqueue):
```C++
(ceil(N / BLOCK_SIZE) + 1) * MAX_NUM_PRODUCERS * BLOCK_SIZE
```
For implicit producers (no tokens):
```C++
(ceil(N / BLOCK_SIZE) - 1 + 2 * MAX_NUM_PRODUCERS) * BLOCK_SIZE
```
When using mixed producer types:
```C++
((ceil(N / BLOCK_SIZE) - 1) * (MAX_EXPLICIT_PRODUCERS + 1) + 2 * (MAX_IMPLICIT_PRODUCERS + MAX_EXPLICIT_PRODUCERS)) * BLOCK_SIZE
```
If these formulas seem rather inconvenient, you can use the constructor overload that accepts the minimum
number of elements (`N`) and the maximum number of explicit and implicit producers directly, and let it do the
computation for you.
In addition to blocks, there are other internal data structures that require allocating memory if they need to resize (grow).
If using `try_enqueue` exclusively, the initial sizes may be exceeded, causing subsequent `try_enqueue` operations to fail.
Specifically, the `INITIAL_IMPLICIT_PRODUCER_HASH_SIZE` trait limits the number of implicit producers that can be active at once
before the internal hash needs resizing. Along the same lines, the `IMPLICIT_INITIAL_INDEX_SIZE` trait limits the number of
unconsumed elements that an implicit producer can insert before its internal hash needs resizing. Similarly, the
`EXPLICIT_INITIAL_INDEX_SIZE` trait limits the number of unconsumed elements that an explicit producer can insert before its
internal hash needs resizing. In order to avoid hitting these limits when using `try_enqueue`, it is crucial to adjust the
initial sizes in the traits appropriately, in addition to sizing the number of blocks properly as outlined above.
Finally, it's important to note that because the queue is only eventually consistent and takes advantage of
weak memory ordering for speed, there's always a possibility that under contention `try_enqueue` will fail
even if the queue is correctly pre-sized for the desired number of elements. (e.g. A given thread may think that
the queue's full even when that's no longer the case.) So no matter what, you still need to handle the failure
case (perhaps looping until it succeeds), unless you don't mind dropping elements.
#### Exception safety
The queue is exception safe, and will never become corrupted if used with a type that may throw exceptions.
The queue itself never throws any exceptions (operations fail gracefully (return false) if memory allocation
fails instead of throwing `std::bad_alloc`).
It is important to note that the guarantees of exception safety only hold if the element type never throws
from its destructor, and that any iterators passed into the queue (for bulk operations) never throw either.
Note that in particular this means `std::back_inserter` iterators must be used with care, since the vector
being inserted into may need to allocate and throw a `std::bad_alloc` exception from inside the iterator;
so be sure to reserve enough capacity in the target container first if you do this.
The guarantees are presently as follows:
- Enqueue operations are rolled back completely if an exception is thrown from an element's constructor.
For bulk enqueue operations, this means that elements are copied instead of moved (in order to avoid
having only some objects moved in the event of an exception). Non-bulk enqueues always use
the move constructor if one is available.
- If the assignment operator throws during a dequeue operation (both single and bulk), the element(s) are
considered dequeued regardless. In such a case, the dequeued elements are all properly destructed before
the exception is propagated, but there's no way to get the elements themselves back.
- Any exception that is thrown is propagated up the call stack, at which point the queue is in a consistent
state.
Note: If any of your type's copy constructors/move constructors/assignment operators don't throw, be sure
to annotate them with `noexcept`; this will avoid the exception-checking overhead in the queue where possible
(even with zero-cost exceptions, there's still a code size impact that has to be taken into account).
#### Traits
The queue also supports a traits template argument which defines various types, constants,
and the memory allocation and deallocation functions that are to be used by the queue. The typical pattern
to providing your own traits is to create a class that inherits from the default traits
and override only the values you wish to change. Example:
```C++
struct MyTraits : public moodycamel::ConcurrentQueueDefaultTraits
{
static const size_t BLOCK_SIZE = 256; // Use bigger blocks
};
moodycamel::ConcurrentQueue<int, MyTraits> q;
```
#### How to dequeue types without calling the constructor
The normal way to dequeue an item is to pass in an existing object by reference, which
is then assigned to internally by the queue (using the move-assignment operator if possible).
This can pose a problem for types that are
expensive to construct or don't have a default constructor; fortunately, there is a simple
workaround: Create a wrapper class that copies the memory contents of the object when it
is assigned by the queue (a poor man's move, essentially). Note that this only works if
the object contains no internal pointers. Example:
```C++
struct MyObjectMover {
inline void operator=(MyObject&& obj) {
std::memcpy(data, &obj, sizeof(MyObject));
// TODO: Cleanup obj so that when it's destructed by the queue
// it doesn't corrupt the data of the object we just moved it into
}
inline MyObject& obj() { return *reinterpret_cast<MyObject*>(data); }
private:
align(alignof(MyObject)) char data[sizeof(MyObject)];
};
```
A less dodgy alternative, if moves are cheap but default construction is not, is to use a
wrapper that defers construction until the object is assigned, enabling use of the move
constructor:
```C++
struct MyObjectMover {
inline void operator=(MyObject&& x) {
new (data) MyObject(std::move(x));
created = true;
}
inline MyObject& obj() {
assert(created);
return *reinterpret_cast<MyObject*>(data);
}
~MyObjectMover() {
if (created)
obj().~MyObject();
}
private:
align(alignof(MyObject)) char data[sizeof(MyObject)];
bool created = false;
};
```
## Samples
There are some more detailed samples [here][samples.md]. The source of
the [unit tests][unittest-src] and [benchmarks][benchmark-src] are available for reference as well.
## Benchmarks
See my blog post for some [benchmark results][benchmarks] (including versus `boost::lockfree::queue` and `tbb::concurrent_queue`),
or run the benchmarks yourself (requires MinGW and certain GnuWin32 utilities to build on Windows, or a recent
g++ on Linux):
```Shell
cd build
make benchmarks
bin/benchmarks
```
The short version of the benchmarks is that it's so fast (especially the bulk methods), that if you're actually
using the queue to *do* anything, the queue won't be your bottleneck.
## Tests (and bugs)
I've written quite a few unit tests as well as a randomized long-running fuzz tester. I also ran the
core queue algorithm through the [CDSChecker][cdschecker] C++11 memory model model checker. Some of the
inner algorithms were tested separately using the [Relacy][relacy] model checker, and full integration
tests were also performed with Relacy.
I've tested
on Linux (Fedora 19) and Windows (7), but only on x86 processors so far (Intel and AMD). The code was
written to be platform-independent, however, and should work across all processors and OSes.
Due to the complexity of the implementation and the difficult-to-test nature of lock-free code in general,
there may still be bugs. If anyone is seeing buggy behaviour, I'd like to hear about it! (Especially if
a unit test for it can be cooked up.) Just open an issue on GitHub.
## Using vcpkg
You can download and install `moodycamel::ConcurrentQueue` using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
```Shell
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install concurrentqueue
```
The `moodycamel::ConcurrentQueue` port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
## License
I'm releasing the source of this repository (with the exception of third-party code, i.e. the Boost queue
(used in the benchmarks for comparison), Intel's TBB library (ditto), CDSChecker, Relacy, and Jeff Preshing's
cross-platform semaphore, which all have their own licenses)
under a simplified BSD license. I'm also dual-licensing under the Boost Software License.
See the [LICENSE.md][license] file for more details.
Note that lock-free programming is a patent minefield, and this code may very
well violate a pending patent (I haven't looked), though it does not to my present knowledge.
I did design and implement this queue from scratch.
## Diving into the code
If you're interested in the source code itself, it helps to have a rough idea of how it's laid out. This
section attempts to describe that.
The queue is formed of several basic parts (listed here in roughly the order they appear in the source). There's the
helper functions (e.g. for rounding to a power of 2). There's the default traits of the queue, which contain the
constants and malloc/free functions used by the queue. There's the producer and consumer tokens. Then there's the queue's
public API itself, starting with the constructor, destructor, and swap/assignment methods. There's the public enqueue methods,
which are all wrappers around a small set of private enqueue methods found later on. There's the dequeue methods, which are
defined inline and are relatively straightforward.
Then there's all the main internal data structures. First, there's a lock-free free list, used for recycling spent blocks (elements
are enqueued to blocks internally). Then there's the block structure itself, which has two different ways of tracking whether
it's fully emptied or not (remember, given two parallel consumers, there's no way to know which one will finish first) depending on where it's used.
Then there's a small base class for the two types of internal SPMC producer queues (one for explicit producers that holds onto memory
but attempts to be faster, and one for implicit ones which attempt to recycle more memory back into the parent but is a little slower).
The explicit producer is defined first, then the implicit one. They both contain the same general four methods: One to enqueue, one to
dequeue, one to enqueue in bulk, and one to dequeue in bulk. (Obviously they have constructors and destructors too, and helper methods.)
The main difference between them is how the block handling is done (they both use the same blocks, but in different ways, and map indices
to them in different ways).
Finally, there's the miscellaneous internal methods: There's the ones that handle the initial block pool (populated when the queue is constructed),
and an abstract block pool that comprises the initial pool and any blocks on the free list. There's ones that handle the producer list
(a lock-free add-only linked list of all the producers in the system). There's ones that handle the implicit producer lookup table (which
is really a sort of specialized TLS lookup). And then there's some helper methods for allocating and freeing objects, and the data members
of the queue itself, followed lastly by the free-standing swap functions.
[blog]: http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++
[design]: http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue
[samples.md]: https://github.com/cameron314/concurrentqueue/blob/master/samples.md
[source]: https://github.com/cameron314/concurrentqueue
[concurrentqueue.h]: https://github.com/cameron314/concurrentqueue/blob/master/concurrentqueue.h
[blockingconcurrentqueue.h]: https://github.com/cameron314/concurrentqueue/blob/master/blockingconcurrentqueue.h
[lightweightsemaphore.h]: https://github.com/cameron314/concurrentqueue/blob/master/lightweightsemaphore.h
[unittest-src]: https://github.com/cameron314/concurrentqueue/tree/master/tests/unittests
[benchmarks]: http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++#benchmarks
[benchmark-src]: https://github.com/cameron314/concurrentqueue/tree/master/benchmarks
[license]: https://github.com/cameron314/concurrentqueue/blob/master/LICENSE.md
[cdschecker]: http://demsky.eecs.uci.edu/c11modelchecker.html
[relacy]: http://www.1024cores.net/home/relacy-race-detector
[spsc]: https://github.com/cameron314/readerwriterqueue
[salsa]: https://iditkeidar.com/wp-content/uploads/files/ftp/spaa049-gidron.pdf
================================================
FILE: benchmarks/benchmarks.cpp
================================================
// ©2013-2014 Cameron Desrochers.
// Distributed under the simplified BSD license (see the LICENSE file that
// should have come with this file).
// Benchmarks for moodycamel::ConcurrentQueue.
// Provides comparative timings of various operations under
// highly artificial circumstances. You've been warned :-)
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdint>
#include <cmath>
#include <cstdarg>
#include <fstream>
#include <ctime>
#include <random>
#include <vector>
#include <map>
#include <cassert>
#include <thread>
#include <algorithm>
#include <cctype>
#include "../blockingconcurrentqueue.h"
#include "lockbasedqueue.h"
#include "simplelockfree.h"
#include "boostqueue.h"
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
// this uses an old version of OS memory fences on OSX
#include "tbbqueue.h"
#pragma clang diagnostic pop
#include "stdqueue.h"
#include "dlibqueue.h"
#include "../tests/common/simplethread.h"
#include "../tests/common/systemtime.h"
#include "cpuid.h"
using namespace moodycamel;
typedef std::minstd_rand RNG_t;
bool precise = false;
enum benchmark_type_t
{
bench_balanced,
bench_only_enqueue,
bench_only_enqueue_prealloc,
bench_only_enqueue_bulk,
bench_only_enqueue_bulk_prealloc,
bench_only_dequeue,
bench_only_dequeue_bulk,
bench_mostly_enqueue,
bench_mostly_enqueue_bulk,
bench_mostly_dequeue,
bench_mostly_dequeue_bulk,
bench_spmc,
bench_spmc_preproduced,
bench_mpsc,
bench_empty_dequeue,
bench_enqueue_dequeue_pairs,
bench_heavy_concurrent,
BENCHMARK_TYPE_COUNT
};
const char BENCHMARK_SHORT_NAMES[BENCHMARK_TYPE_COUNT][32] = {
"balanced",
"only_enqueue",
"only_enqueue_prealloc",
"only_enqueue_bulk",
"only_enqueue_bulk_prealloc",
"only_dequeue",
"only_dequeue_bulk",
"mostly_enqueue",
"mostly_enqueue_bulk",
"mostly_dequeue",
"mostly_dequeue_bulk",
"spmc",
"spmc_preproduced",
"mpsc",
"empty_dequeue",
"enqueue_dequeue_pairs",
"heavy_concurrent"
};
const char BENCHMARK_NAMES[BENCHMARK_TYPE_COUNT][64] = {
"balanced",
"only enqueue",
"only enqueue (pre-allocated)",
"only enqueue bulk",
"only enqueue bulk (pre-allocated)",
"only dequeue",
"only dequeue bulk",
"mostly enqueue",
"mostly enqueue bulk",
"mostly dequeue",
"mostly dequeue bulk",
"single-producer, multi-consumer",
"single-producer, multi-consumer (pre-produced)",
"multi-producer, single-consumer",
"dequeue from empty",
"enqueue-dequeue pairs",
"heavy concurrent"
};
const char BENCHMARK_DESCS[BENCHMARK_TYPE_COUNT][256] = {
"Measures the average operation speed with multiple symmetrical threads\n under reasonable load -- small random intervals between accesses",
"Measures the average operation speed when all threads are producers",
"Measures the average operation speed when all threads are producers,\n and the queue has been stretched out first",
"Measures the average speed of enqueueing an item in bulk when all threads are producers",
"Measures the average speed of enqueueing an item in bulk when all threads are producers,\n and the queue has been stretched out first",
"Measures the average operation speed when all threads are consumers",
"Measures the average speed of dequeueing an item in bulk when all threads are consumers",
"Measures the average operation speed when most threads are enqueueing",
"Measures the average speed of enqueueing an item in bulk under light contention",
"Measures the average operation speed when most threads are dequeueing",
"Measures the average speed of dequeueing an item in bulk under light contention",
"Measures the average speed of dequeueing with only one producer, but multiple consumers",
"Measures the average speed of dequeueing from a queue pre-filled by one thread",
"Measures the average speed of dequeueing with only one consumer, but multiple producers",
"Measures the average speed of attempting to dequeue from an empty queue\n (that eight separate threads had at one point enqueued to)",
"Measures the average operation speed with each thread doing an enqueue\n followed by a dequeue",
"Measures the average operation speed with many threads under heavy load"
};
const char BENCHMARK_SINGLE_THREAD_NOTES[BENCHMARK_TYPE_COUNT][256] = {
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"No contention -- measures raw failed dequeue speed on empty queue",
"No contention -- measures speed of immediately dequeueing the item that was just enqueued",
""
};
int BENCHMARK_THREADS_MEASURED[BENCHMARK_TYPE_COUNT] = {
0, // measures nthreads
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
-1, // nthreads - 1
0,
1, // 1
0,
0,
0,
};
int BENCHMARK_THREADS[BENCHMARK_TYPE_COUNT][9] = {
{ 2, 3, 4, 8, 12, 16, 32, 0, 0 },
{ 1, 2, 4, 8, 12, 16, 32, 48, 0 },
{ 1, 2, 4, 8, 32, 0, 0, 0, 0 },
{ 1, 2, 4, 8, 12, 16, 32, 48, 0 },
{ 1, 2, 4, 8, 32, 0, 0, 0, 0 },
{ 1, 2, 4, 8, 12, 16, 32, 48, 0 },
{ 1, 2, 4, 8, 12, 16, 32, 48, 0 },
{ 2, 4, 8, 32, 0, 0, 0, 0, 0 },
{ 2, 4, 8, 32, 0, 0, 0, 0, 0 },
{ 2, 4, 8, 0, 0, 0, 0, 0, 0 },
{ 2, 4, 8, 0, 0, 0, 0, 0, 0 },
{ 2, 4, 8, 16, 0, 0, 0, 0, 0 },
{ 1, 3, 7, 15, 0, 0, 0, 0, 0 },
{ 2, 4, 8, 16, 0, 0, 0, 0, 0 },
{ 1, 2, 8, 32, 0, 0, 0, 0, 0 },
{ 1, 2, 4, 8, 32, 0, 0, 0, 0 },
{ 2, 3, 4, 8, 12, 16, 32, 48, 0 },
};
enum queue_id_t
{
queue_moodycamel_ConcurrentQueue,
queue_moodycamel_BlockingConcurrentQueue,
queue_boost,
queue_tbb,
queue_simplelockfree,
queue_lockbased,
queue_std,
queue_dlib,
QUEUE_COUNT
};
const char QUEUE_NAMES[QUEUE_COUNT][64] = {
"moodycamel::ConcurrentQueue",
"moodycamel::BlockingConcurrentQueue",
"boost::lockfree::queue",
"tbb::concurrent_queue",
"SimpleLockFreeQueue",
"LockBasedQueue",
"std::queue",
"dlib::pipe"
};
const char QUEUE_SUMMARY_NOTES[QUEUE_COUNT][128] = {
"including bulk",
"including bulk",
"",
"",
"",
"",
"single thread only",
""
};
const bool QUEUE_TOKEN_SUPPORT[QUEUE_COUNT] = {
true,
true,
false,
false,
false,
false,
false,
false
};
const int QUEUE_MAX_THREADS[QUEUE_COUNT] = {
-1, // no limit
-1,
-1,
-1,
-1,
-1,
1,
-1
};
const bool QUEUE_BENCH_SUPPORT[QUEUE_COUNT][BENCHMARK_TYPE_COUNT] = {
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1 },
{ 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1 },
{ 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0 },
{ 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1 }
};
struct Traits : public moodycamel::ConcurrentQueueDefaultTraits
{
// Use a slightly larger default block size; the default offers
// a good trade off between speed and memory usage, but a bigger
// block size will improve throughput (which is mostly what
// we're after with these benchmarks).
static const size_t BLOCK_SIZE = 64;
// Reuse blocks once allocated.
static const bool RECYCLE_ALLOCATED_BLOCKS = true;
};
typedef std::uint64_t counter_t;
const counter_t BULK_BATCH_SIZE = 2300;
struct BenchmarkResult
{
double elapsedTime;
counter_t operations;
inline bool operator<(BenchmarkResult const& other) const
{
return elapsedTime < other.elapsedTime;
}
};
template<typename TFunc>
counter_t rampUpToMeasurableNumberOfMaxOps(TFunc const& func, counter_t startOps = 256)
{
counter_t ops = startOps;
double time;
do {
time = func(ops);
ops *= 2;
} while (time < (precise ? 30 : 10));
#ifdef NDEBUG
return ops / 2;
#else
return ops / 4;
#endif
}
counter_t adjustForThreads(counter_t suggestedOps, int nthreads)
{
return std::max((counter_t)(suggestedOps / std::pow(2, std::sqrt((nthreads - 1) * 3))), suggestedOps / 16);
}
template<typename TQueue, typename item_t>
counter_t determineMaxOpsForBenchmark(benchmark_type_t benchmark, int nthreads, bool useTokens, unsigned int randSeed)
{
switch (benchmark) {
case bench_balanced: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([&](counter_t ops) {
TQueue q;
RNG_t rng(randSeed * 1);
std::uniform_int_distribution<int> rand(0, 20);
double total = 0;
SystemTime start;
item_t item = 1;
for (counter_t i = 0; i != ops; ++i) {
start = getSystemTime();
q.enqueue(item);
total += getTimeDelta(start);
}
return total;
}), nthreads);
}
case bench_only_enqueue:
case bench_only_enqueue_prealloc:
case bench_mostly_enqueue: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
item_t item = 1;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.enqueue(item);
}
return getTimeDelta(start);
}), nthreads);
}
case bench_only_dequeue:
case bench_mostly_dequeue:
case bench_spmc:
case bench_spmc_preproduced:
case bench_mpsc: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
item_t item = 1;
for (counter_t i = 0; i != ops; ++i) {
q.enqueue(item);
}
item_t item_rec;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.try_dequeue(item_rec);
}
return getTimeDelta(start);
}), nthreads);
}
case bench_only_enqueue_bulk:
case bench_only_enqueue_bulk_prealloc:
case bench_mostly_enqueue_bulk: {
std::vector<item_t> data;
for (counter_t i = 0; i != BULK_BATCH_SIZE; ++i) {
data.push_back(i);
}
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([&](counter_t ops) {
TQueue q;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
return getTimeDelta(start);
}), nthreads);
}
case bench_only_dequeue_bulk:
case bench_mostly_dequeue_bulk: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
std::vector<item_t> data(BULK_BATCH_SIZE);
for (counter_t i = 0; i != ops; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.try_dequeue_bulk(data.begin(), data.size());
}
return getTimeDelta(start);
}), nthreads);
return 0;
}
case bench_empty_dequeue: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
item_t item_rec;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.try_dequeue(item_rec);
}
return getTimeDelta(start);
}), nthreads);
}
case bench_enqueue_dequeue_pairs: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
item_t item = 1;
item_t item_rec;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.enqueue(item);
q.try_dequeue(item_rec);
}
return getTimeDelta(start);
}), nthreads);
}
case bench_heavy_concurrent: {
return adjustForThreads(rampUpToMeasurableNumberOfMaxOps([](counter_t ops) {
TQueue q;
item_t item=1;
item_t item_rec;
auto start = getSystemTime();
for (counter_t i = 0; i != ops; ++i) {
q.enqueue(item);
q.try_dequeue(item_rec);
}
return getTimeDelta(start);
}), nthreads);
}
default:
assert(false && "Every benchmark type must be handled here!");
return 0;
}
}
// Returns time elapsed, in (fractional) milliseconds
template<typename TQueue, typename item_t>
double runBenchmark(benchmark_type_t benchmark, int nthreads, bool useTokens, unsigned int randSeed, counter_t maxOps, int maxThreads, counter_t& out_opCount)
{
double result = 0;
volatile int forceNoOptimizeDummy;
switch (benchmark) {
case bench_balanced: {
// Measures the average operation speed with multiple symmetrical threads under reasonable load
TQueue q;
std::vector<SimpleThread> threads(nthreads);
std::vector<counter_t> ops(nthreads);
std::vector<double> times(nthreads);
std::atomic<int> ready(0);
item_t item_rec;
item_t item = 1;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
SystemTime start;
RNG_t rng(randSeed * (id + 1));
std::uniform_int_distribution<int> rand(0, 20);
ops[id] = 0;
times[id] = 0;
typename TQueue::consumer_token_t consTok(q);
typename TQueue::producer_token_t prodTok(q);
for (counter_t i = 0; i != maxOps; ++i) {
if (rand(rng) == 0) {
start = getSystemTime();
if ((i & 1) == 0) {
if (useTokens) {
q.try_dequeue(consTok, item_rec);
}
else {
q.try_dequeue(item_rec);
}
}
else {
if (useTokens) {
q.enqueue(prodTok, item);
}
else {
q.enqueue(item);
}
}
times[id] += getTimeDelta(start);
++ops[id];
}
}
}, tid);
}
out_opCount = 0;
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
out_opCount += ops[tid];
result += times[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_only_enqueue_prealloc: {
out_opCount = maxOps * nthreads;
TQueue q;
item_t item = 1;
item_t item_rec;
{
// Enqueue opcount elements first, then dequeue them; this
// will "stretch out" the queue, letting implementatations
// that re-use memory internally avoid having to allocate
// more later during the timed enqueue operations.
std::vector<SimpleThread> threads(nthreads);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
}, tid);
}
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
}
// Now empty the queue
while (q.try_dequeue(item_rec))
continue;
}
if (nthreads == 1) {
// No contention -- measures raw single-item enqueue speed
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_only_enqueue: {
out_opCount = maxOps * nthreads;
TQueue q;
item_t item = 1;
item_t item_rec;
if (nthreads == 1) {
// No contention -- measures raw single-item enqueue speed
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_spmc_preproduced:
case bench_only_dequeue: {
out_opCount = maxOps * nthreads;
TQueue q;
item_t item = 1;
item_t item_rec;
{
// Fill up the queue first
std::vector<SimpleThread> threads(benchmark == bench_spmc_preproduced ? 1 : nthreads);
counter_t itemsPerThread = benchmark == bench_spmc_preproduced ? maxOps * nthreads : maxOps;
for (size_t tid = 0; tid != threads.size(); ++tid) {
threads[tid] = SimpleThread([&](size_t id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != itemsPerThread; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != itemsPerThread; ++i) {
q.enqueue(item);
}
}
}, tid);
}
for (size_t tid = 0; tid != threads.size(); ++tid) {
threads[tid].join();
}
}
if (nthreads == 1) {
// No contention -- measures raw single-item dequeue speed
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item_rec);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item_rec);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_mostly_enqueue: {
// Measures the average operation speed when most threads are enqueueing
TQueue q;
item_t item = 1;
item_t item_rec;
out_opCount = maxOps * nthreads;
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
auto dequeueThreads = std::max(1, nthreads / 4);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads - dequeueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
for (int tid = nthreads - dequeueThreads; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item_rec);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_mostly_dequeue: {
// Measures the average operation speed when most threads are dequeueing
TQueue q;
item_t item = 1;
item_t item_rec;
out_opCount = maxOps * nthreads;
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
auto enqueueThreads = std::max(1, nthreads / 4);
{
// Fill up the queue first
std::vector<SimpleThread> threads(enqueueThreads);
for (int tid = 0; tid != enqueueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
}, tid);
}
for (int tid = 0; tid != enqueueThreads; ++tid) {
threads[tid].join();
}
}
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads - enqueueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item_rec);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
for (int tid = nthreads - enqueueThreads; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_only_enqueue_bulk_prealloc: {
TQueue q;
item_t item = 1;
item_t item_rec;
{
// Enqueue opcount elements first, then dequeue them; this
// will "stretch out" the queue, letting implementatations
// that re-use memory internally avoid having to allocate
// more later during the timed enqueue operations.
std::vector<SimpleThread> threads(nthreads);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
}, tid);
}
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
}
// Now empty the queue
while (q.try_dequeue(item_rec))
continue;
}
std::vector<counter_t> data;
for (counter_t i = 0; i != BULK_BATCH_SIZE; ++i) {
data.push_back(i);
}
out_opCount = maxOps * BULK_BATCH_SIZE * nthreads;
if (nthreads == 1) {
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_only_enqueue_bulk: {
TQueue q;
item_t item_rec;
std::vector<counter_t> data;
for (counter_t i = 0; i != BULK_BATCH_SIZE; ++i) {
data.push_back(i);
}
out_opCount = maxOps * BULK_BATCH_SIZE * nthreads;
if (nthreads == 1) {
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_mostly_enqueue_bulk: {
// Measures the average speed of enqueueing in bulk under light contention
TQueue q;
item_t item_rec;
std::vector<counter_t> data;
for (counter_t i = 0; i != BULK_BATCH_SIZE; ++i) {
data.push_back(i);
}
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
auto dequeueThreads = std::max(1, nthreads / 4);
std::vector<counter_t> ops(nthreads - dequeueThreads);
out_opCount = maxOps * BULK_BATCH_SIZE * (nthreads - dequeueThreads); // dequeue ops added after
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads - dequeueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
for (int tid = nthreads - dequeueThreads; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id, int idBase0) {
std::vector<int> items(BULK_BATCH_SIZE);
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
counter_t totalOps = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(tok, items.begin(), items.size());
totalOps += actual + (actual == items.size() ? 0 : 1);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(items.begin(), items.size());
totalOps += actual + (actual == items.size() ? 0 : 1);
}
}
timings[id] = getTimeDelta(start);
ops[idBase0] = totalOps;
}, tid, tid - (nthreads - dequeueThreads));
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
if (tid < dequeueThreads) {
out_opCount += ops[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_only_dequeue_bulk: {
// Measures the average speed of dequeueing in bulk when all threads are consumers
TQueue q;
item_t item_rec;
{
// Fill up the queue first
std::vector<int> data(BULK_BATCH_SIZE);
for (int i = 0; i != BULK_BATCH_SIZE; ++i) {
data[i] = i;
}
std::vector<SimpleThread> threads(nthreads);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, data.cbegin(), data.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(data.cbegin(), data.size());
}
}
}, tid);
}
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
}
}
if (nthreads == 1) {
out_opCount = maxOps * BULK_BATCH_SIZE;
auto start = getSystemTime();
std::vector<int> items(BULK_BATCH_SIZE);
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue_bulk(tok, items.begin(), items.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue_bulk(items.begin(), items.size());
}
}
result = getTimeDelta(start);
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::vector<counter_t> ops(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
std::vector<int> items(BULK_BATCH_SIZE);
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
counter_t totalOps = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(tok, items.begin(), items.size());
totalOps += actual + (actual == items.size() ? 0 : 1);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(items.begin(), items.size());
totalOps += actual + (actual == items.size() ? 0 : 1);
}
}
timings[id] = getTimeDelta(start);
ops[id] = totalOps;
}, tid);
}
result = 0;
out_opCount = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
out_opCount += ops[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_mostly_dequeue_bulk: {
// Measures the average speed of dequeueing in bulk under light contention
TQueue q;
item_t item_rec;
auto enqueueThreads = std::max(1, nthreads / 4);
out_opCount = maxOps * BULK_BATCH_SIZE * enqueueThreads;
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::vector<counter_t> ops(nthreads - enqueueThreads);
std::vector<int> enqueueData(BULK_BATCH_SIZE);
for (int i = 0; i != BULK_BATCH_SIZE; ++i) {
enqueueData[i] = i;
}
{
// Fill up the queue first
std::vector<SimpleThread> threads(enqueueThreads);
for (int tid = 0; tid != enqueueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, enqueueData.cbegin(), enqueueData.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(enqueueData.cbegin(), enqueueData.size());
}
}
}, tid);
}
for (int tid = 0; tid != enqueueThreads; ++tid) {
threads[tid].join();
}
}
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads - enqueueThreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
std::vector<int> data(BULK_BATCH_SIZE);
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
counter_t totalOps = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(tok, data.begin(), data.size());
totalOps += actual + (actual == data.size() ? 0 : 1);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
auto actual = q.try_dequeue_bulk(data.begin(), data.size());
totalOps += actual + (actual == data.size() ? 0 : 1);
}
}
timings[id] = getTimeDelta(start);
ops[id] = totalOps;
}, tid);
}
for (int tid = nthreads - enqueueThreads; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(tok, enqueueData.cbegin(), enqueueData.size());
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue_bulk(enqueueData.cbegin(), enqueueData.size());
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
if (tid < nthreads - enqueueThreads) {
out_opCount += ops[tid];
}
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_spmc: {
counter_t elementsToDequeue = maxOps * (nthreads - 1);
TQueue q;
item_t item = 1;
item_t item_rec;
std::vector<SimpleThread> threads(nthreads - 1);
std::vector<double> timings(nthreads - 1);
std::vector<counter_t> ops(nthreads - 1);
std::atomic<bool> lynchpin(false);
std::atomic<counter_t> totalDequeued(0);
for (int tid = 0; tid != nthreads - 1; ++tid) {
threads[tid] = SimpleThread([&](int id) {
while (!lynchpin.load(std::memory_order_relaxed)) {
continue;
}
int item;
counter_t i = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
while (true) {
if (q.try_dequeue(tok, item)) {
totalDequeued.fetch_add(1, std::memory_order_relaxed);
}
else if (totalDequeued.load(std::memory_order_relaxed) == elementsToDequeue) {
break;
}
++i;
}
}
else {
while (true) {
if (q.try_dequeue(item_rec)) {
totalDequeued.fetch_add(1, std::memory_order_relaxed);
}
else if (totalDequeued.load(std::memory_order_relaxed) == elementsToDequeue) {
break;
}
++i;
}
}
timings[id] = getTimeDelta(start);
ops[id] = i;
}, tid);
}
lynchpin.store(true, std::memory_order_seq_cst);
for (counter_t i = 0; i != elementsToDequeue; ++i) {
q.enqueue(item);
}
result = 0;
out_opCount = 0;
for (int tid = 0; tid != nthreads - 1; ++tid) {
threads[tid].join();
result += timings[tid];
out_opCount += ops[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_mpsc: {
TQueue q;
item_t item = 1;
item_t item_rec;
counter_t elementsToDequeue = maxOps * (nthreads - 1);
std::vector<SimpleThread> threads(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
if (tid == 0) {
// Consumer thread
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_seq_cst);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
int item;
out_opCount = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != elementsToDequeue;) {
i += q.try_dequeue(tok, item) ? 1 : 0;
++out_opCount;
}
}
else {
for (counter_t i = 0; i != elementsToDequeue;) {
i += q.try_dequeue(item_rec) ? 1 : 0;
++out_opCount;
}
}
result = getTimeDelta(start);
}, tid);
}
else {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_seq_cst);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
}, tid);
}
}
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
case bench_empty_dequeue: {
// Measures the average speed of attempting to dequeue from an empty queue
TQueue q;
item_t item = 1;
item_t item_rec;
// Fill up then empty the queue first
{
std::vector<SimpleThread> threads(maxThreads > 0 ? maxThreads : 8);
for (size_t tid = 0; tid != threads.size(); ++tid) {
threads[tid] = SimpleThread([&](size_t id) {
if (useTokens) {
typename TQueue::producer_token_t tok(q);
for (counter_t i = 0; i != 10000; ++i) {
q.enqueue(tok, item);
}
}
else {
for (counter_t i = 0; i != 10000; ++i) {
q.enqueue(item);
}
}
}, tid);
}
for (size_t tid = 0; tid != threads.size(); ++tid) {
threads[tid].join();
}
// Empty the queue
while (q.try_dequeue(item_rec))
continue;
}
if (nthreads == 1) {
// No contention -- measures raw failed dequeue speed on empty queue
int item;
out_opCount = maxOps;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
result = getTimeDelta(start);
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
}
else {
out_opCount = maxOps * nthreads;
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
int item;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::consumer_token_t tok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(tok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
}
break;
}
case bench_enqueue_dequeue_pairs: {
// Measures the average speed of attempting to dequeue from an empty queue
// (that eight separate threads had at one point enqueued to)
out_opCount = maxOps * 2 * nthreads;
TQueue q;
item_t item_rec;
if (nthreads == 1) {
// No contention -- measures speed of immediately dequeueing the item that was just enqueued
int item = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t prodTok(q);
typename TQueue::consumer_token_t consTok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(prodTok, item);
q.try_dequeue(consTok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
q.try_dequeue(item_rec);
}
}
result = getTimeDelta(start);
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
}
else {
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
int item = 0;
auto start = getSystemTime();
if (useTokens) {
typename TQueue::producer_token_t prodTok(q);
typename TQueue::consumer_token_t consTok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(prodTok, item);
q.try_dequeue(consTok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
q.try_dequeue(item_rec);
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
}
break;
}
case bench_heavy_concurrent: {
// Measures the average operation speed with many threads under heavy load
out_opCount = maxOps * nthreads;
TQueue q;
item_t item = 1;
item_t item_rec;
std::vector<SimpleThread> threads(nthreads);
std::vector<double> timings(nthreads);
std::atomic<int> ready(0);
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid] = SimpleThread([&](int id) {
ready.fetch_add(1, std::memory_order_relaxed);
while (ready.load(std::memory_order_relaxed) != nthreads)
continue;
auto start = getSystemTime();
if (id < 2) {
// Alternate
int item = 0;
if (useTokens) {
typename TQueue::consumer_token_t consTok(q);
typename TQueue::producer_token_t prodTok(q);
for (counter_t i = 0; i != maxOps / 2; ++i) {
q.try_dequeue(consTok, item);
q.enqueue(prodTok, item);
}
}
else {
for (counter_t i = 0; i != maxOps / 2; ++i) {
q.try_dequeue(item_rec);
q.enqueue(item);
}
}
}
else {
if ((id & 1) == 0) {
// Enqueue
if (useTokens) {
typename TQueue::producer_token_t prodTok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(prodTok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.enqueue(item);
}
}
}
else {
// Dequeue
int item;
if (useTokens) {
typename TQueue::consumer_token_t consTok(q);
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(consTok, item);
}
}
else {
for (counter_t i = 0; i != maxOps; ++i) {
q.try_dequeue(item_rec);
}
}
}
}
timings[id] = getTimeDelta(start);
}, tid);
}
result = 0;
for (int tid = 0; tid != nthreads; ++tid) {
threads[tid].join();
result += timings[tid];
}
forceNoOptimizeDummy = q.try_dequeue(item_rec) ? 1 : 0;
break;
}
default:
assert(false && "Every benchmark type must be handled here!");
result = 0;
out_opCount = 0;
}
(void)forceNoOptimizeDummy;
return result;
}
const char* LOG_FILE = "benchmarks.log";
std::ofstream* logOut;
bool logErrorReported = false;
void sayf(int indent, const char* fmt, ...)
{
static char indentBuffer[] = " ";
static char buf[2048];
indentBuffer[indent] = '\0';
va_list arglist;
va_start(arglist, fmt);
vsprintf(buf, fmt, arglist);
va_end(arglist);
if (*logOut) {
(*logOut) << indentBuffer << buf;
}
else if (!logErrorReported) {
std::printf("Note: Error writing to log file. Future output will appear only on stdout\n");
logErrorReported = true;
}
std::printf("%s%s", indentBuffer, buf);
indentBuffer[indent] = ' ';
}
// Returns a formatted timestamp.
// Returned buffer is only valid until the next call.
// Not thread-safe.
static const char* timestamp()
{
static char buf[32];
time_t time = std::time(NULL);
strcpy(buf, std::asctime(std::localtime(&time)));
buf[strlen(buf) - 1] = '\0'; // Remove trailing newline
return buf;
}
static inline bool isvowel(char ch)
{
ch = std::tolower(ch);
for (const char* v = "aeiou"; *v != '\0'; ++v) {
if (*v == ch) {
return true;
}
}
return false;
}
static inline double safe_divide(double a, double b)
{
return b == 0 ? 0 : a / b;
}
// Returns a positive number formatted in a string in a human-readable way.
// The string is always 7 characters or less (excluding null byte).
// Returned buffer is only valid until the sixteenth next call.
// Not thread safe.
static const char* pretty(double num)
{
assert(num >= 0);
#if defined(_MSC_VER) && _MSC_VER < 1800
if (!_finite(num)) {
return "inf";
}
if (_isnan(num)) {
return "nan";
}
#else
if (std::isinf(num)) {
return "inf";
}
if (std::isnan(num)) {
return "nan";
}
#endif
static char bufs[16][8];
static int nextBuf = 0;
char* buf = bufs[nextBuf++];
nextBuf &= 15;
int suffix = 0;
if (num < 1) {
static const char minisufs[] = "\0munpfazy";
while (num < 0.01) {
++suffix;
num *= 1000;
}
sprintf(buf, "%1.4f%c", num, minisufs[suffix]);
}
else {
static const char megasufs[] = "\0kMGTPEZY";
while (num >= 1000) {
++suffix;
num /= 1000;
}
sprintf(buf, "%.2f%c", num, megasufs[suffix]);
}
return buf;
}
void printBenchmarkNames()
{
std::printf(" Supported benchmarks are:\n");
for (int i = 0; i != BENCHMARK_TYPE_COUNT; ++i) {
std::printf(" %s\n", BENCHMARK_SHORT_NAMES[i]);
}
}
int main(int argc, char** argv)
{
// Disable buffering (so that when run in, e.g., Sublime Text, the output appears as it is written)
std::setvbuf(stdout, nullptr, _IONBF, 0);
// Isolate the executable name
std::string progName = argv[0];
auto slash = progName.find_last_of("/\\");
if (slash != std::string::npos) {
progName = progName.substr(slash + 1);
}
std::map<std::string, benchmark_type_t> benchmarkMap;
for (int i = 0; i != BENCHMARK_TYPE_COUNT; ++i) {
benchmarkMap.insert(std::make_pair(std::string(BENCHMARK_SHORT_NAMES[i]), (benchmark_type_t)i));
}
std::vector<benchmark_type_t> selectedBenchmarks;
bool showHelp = false;
bool error = false;
bool printedBenchmarks = false;
for (int i = 1; i < argc; ++i) {
if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "--help") == 0) {
showHelp = true;
}
else if (std::strcmp(argv[i], "-p") == 0 || std::strcmp(argv[i], "--precise") == 0) {
precise = true;
}
else if (std::strcmp(argv[i], "--run") == 0) {
if (i + 1 == argc || argv[i + 1][0] == '-') {
std::printf("Expected benchmark name argument for --run option.\n");
if (!printedBenchmarks) {
printBenchmarkNames();
printedBenchmarks = true;
}
error = true;
continue;
}
auto it = benchmarkMap.find(argv[++i]);
if (it == benchmarkMap.end()) {
std::printf("Unrecognized benchmark name '%s'.\n", argv[i]);
if (!printedBenchmarks) {
printBenchmarkNames();
printedBenchmarks = true;
}
error = true;
continue;
}
selectedBenchmarks.push_back(it->second);
}
else {
std::printf("Unrecognized option '%s'\n", argv[i]);
error = true;
}
}
if (showHelp || error) {
if (error) {
std::printf("\n");
}
std::printf("%s\n Description: Runs benchmarks for moodycamel::ConcurrentQueue\n", progName.c_str());
std::printf(" --help Prints this help blurb\n");
std::printf(" --precise Generate more precise benchmark results (slower)\n");
std::printf(" --run benchmark Runs only the selected benchmark (can be used multiple times)\n");
return error ? 1 : 0;
}
bool logExists = true;
{
std::ifstream fin(LOG_FILE);
if (!fin) {
logExists = false;
}
}
std::ofstream fout(LOG_FILE, std::ios::app);
logOut = &fout;
if (fout) {
if (logExists) {
fout << "\n\n\n";
}
fout << "--- New run (" << timestamp() << ") ---\n";
}
else {
std::printf("Note: Error opening log file '%s'. Output will appear only on stdout.\n\n", LOG_FILE);
logErrorReported = true;
}
const char* bitStr = "";
if (sizeof(void*) == 4 || sizeof(void*) == 8) {
bitStr = sizeof(void*) == 4 ? " 32-bit" : " 64-bit";
}
const char* cpuStr = getCPUString();
sayf(0, "Running%s benchmarks on a%s %s\n", bitStr, isvowel(cpuStr[0]) ? "n" : "", cpuStr);
if (precise) {
sayf(4, "(precise mode)\n");
}
if (selectedBenchmarks.size() > 0) {
sayf(4, "(selected benchmarks only)\n");
}
sayf(0, "Note that these are synthetic benchmarks. Take them with a grain of salt.\n\n");
sayf(0, "Legend:\n");
sayf(4, "'Avg': Average time taken per operation, normalized to be per thread\n");
sayf(4, "'Range': The minimum and maximum times taken per operation (per thread)\n");
sayf(4, "'Ops/s': Overall operations per second\n");
sayf(4, "'Ops/s/t': Operations per second per thread (inverse of 'Avg')\n");
sayf(4, "Operations include those that fail (e.g. because the queue is empty).\n");
sayf(4, "Each logical enqueue/dequeue counts as an individual operation when in bulk.\n");
sayf(0, "\n");
#ifdef NDEBUG
const int ITERATIONS = precise ? 100 : 10;
#else
const int ITERATIONS = precise ? 20 : 2;
#endif
const double FASTEST_PERCENT_CONSIDERED = precise ? 8 : 50; // Only consider the top % of runs
// Make sure each run of a given benchmark has the same seed (otherwise different runs are not comparable)
std::srand(std::time(NULL));
unsigned int randSeeds[BENCHMARK_TYPE_COUNT];
for (unsigned int i = 0; i != BENCHMARK_TYPE_COUNT; ++i) {
randSeeds[i] = std::rand() * (i + 1) + 1;
}
double opsst = 0; // ops/s/thread
double totalWeightedOpsst[QUEUE_COUNT];
double totalWeight[QUEUE_COUNT];
for (int i = 0; i != QUEUE_COUNT; ++i) {
totalWeightedOpsst[i] = 0;
totalWeight[i] = 0;
}
auto logicalCores = std::thread::hardware_concurrency();
if (selectedBenchmarks.size() == 0) {
for (int i = 0; i != BENCHMARK_TYPE_COUNT; ++i) {
selectedBenchmarks.push_back((benchmark_type_t)i);
}
}
int indent = 0;
for (auto selectedIt = selectedBenchmarks.cbegin(); selectedIt != selectedBenchmarks.cend(); ++selectedIt) {
int benchmark = static_cast<int>(*selectedIt);
auto seed = randSeeds[benchmark];
bool anyQueueSupportsBenchmark = false;
for (int queue = 0; queue != QUEUE_COUNT; ++queue) {
if (QUEUE_BENCH_SUPPORT[queue][benchmark]) {
anyQueueSupportsBenchmark = true;
break;
}
}
if (!anyQueueSupportsBenchmark) {
continue;
}
sayf(0, "%s", BENCHMARK_NAMES[benchmark]);
if (BENCHMARK_THREADS_MEASURED[benchmark] != 0) {
if (BENCHMARK_THREADS_MEASURED[benchmark] < 0) {
sayf(0, " (measuring all but %d %s)", -BENCHMARK_THREADS_MEASURED[benchmark], BENCHMARK_THREADS_MEASURED[benchmark] == -1 ? "thread" : "threads");
}
else {
sayf(0, " (measuring %d %s)", BENCHMARK_THREADS_MEASURED[benchmark], BENCHMARK_THREADS_MEASURED[benchmark] == 1 ? "thread" : "threads");
}
}
sayf(0, ":\n");
indent += 2;
sayf(indent, "(%s)\n", BENCHMARK_DESCS[benchmark]);
for (int queue = 0; queue != QUEUE_COUNT; ++queue) {
sayf(indent, "> %s\n", QUEUE_NAMES[queue]);
if (!QUEUE_BENCH_SUPPORT[queue][benchmark]) {
sayf(indent + 3, "(skipping, benchmark not supported...)\n\n");
continue;
}
if (QUEUE_TOKEN_SUPPORT[queue]) {
indent += 4;
}
for (int useTokens = 0; useTokens != 2; ++useTokens) {
if (QUEUE_TOKEN_SUPPORT[queue]) {
sayf(indent, "%s tokens\n", useTokens == 0 ? "Without" : "With");
}
if (useTokens == 1 && !QUEUE_TOKEN_SUPPORT[queue]) {
continue;
}
indent += 3;
std::vector<double> opssts;
std::vector<int> threadCounts;
for (int nthreadIndex = 0; BENCHMARK_THREADS[benchmark][nthreadIndex] != 0; ++nthreadIndex) {
int nthreads = BENCHMARK_THREADS[benchmark][nthreadIndex];
int measuredThreads = nthreads;
if (BENCHMARK_THREADS_MEASURED[benchmark] != 0) {
measuredThreads = BENCHMARK_THREADS_MEASURED[benchmark] < 0 ? nthreads + BENCHMARK_THREADS_MEASURED[benchmark] : BENCHMARK_THREADS_MEASURED[benchmark];
}
if (logicalCores > 0 && (unsigned int)nthreads > 3 * logicalCores) {
continue;
}
if (QUEUE_MAX_THREADS[queue] >= 0 && QUEUE_MAX_THREADS[queue] < nthreads) {
continue;
}
counter_t maxOps;
switch ((queue_id_t)queue) {
case queue_moodycamel_ConcurrentQueue:
maxOps = determineMaxOpsForBenchmark<moodycamel::ConcurrentQueue<int, Traits>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_moodycamel_BlockingConcurrentQueue:
maxOps = determineMaxOpsForBenchmark<moodycamel::BlockingConcurrentQueue<int, Traits>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_lockbased:
maxOps = determineMaxOpsForBenchmark<LockBasedQueue<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_simplelockfree:
maxOps = determineMaxOpsForBenchmark<SimpleLockFreeQueue<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_boost:
maxOps = determineMaxOpsForBenchmark<BoostQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_tbb:
maxOps = determineMaxOpsForBenchmark<TbbQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_std:
maxOps = determineMaxOpsForBenchmark<StdQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
case queue_dlib:
maxOps = determineMaxOpsForBenchmark<DlibQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed);
break;
default:
assert(false && "There should be a case here for every queue in the benchmarks!");
}
//std::printf("maxOps: %llu\n", maxOps);
int maxThreads = QUEUE_MAX_THREADS[queue];
std::vector<BenchmarkResult> results(ITERATIONS);
for (int i = 0; i < ITERATIONS; ++i) {
double elapsed = 0.0;
counter_t ops = 0;
switch ((queue_id_t)queue) {
case queue_moodycamel_ConcurrentQueue:
elapsed = runBenchmark<moodycamel::ConcurrentQueue<int, Traits>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_moodycamel_BlockingConcurrentQueue:
elapsed = runBenchmark<moodycamel::BlockingConcurrentQueue<int, Traits>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_lockbased:
elapsed = runBenchmark<LockBasedQueue<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_simplelockfree:
elapsed = runBenchmark<SimpleLockFreeQueue<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_boost:
elapsed = runBenchmark<BoostQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_tbb:
elapsed = runBenchmark<TbbQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_std:
elapsed = runBenchmark<StdQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
case queue_dlib:
elapsed = runBenchmark<DlibQueueWrapper<int>, int>((benchmark_type_t)benchmark, nthreads, (bool)useTokens, seed, maxOps, maxThreads, ops);
break;
default:
assert(false && "There should be a case here for every queue in the benchmarks!");
}
results[i].elapsedTime = elapsed;
results[i].operations = ops;
}
std::sort(&results[0], &results[0] + ITERATIONS);
int consideredCount = std::max(2, (int)(ITERATIONS * FASTEST_PERCENT_CONSIDERED / 100));
double min = safe_divide(results[0].elapsedTime / 1000.0, (double)results[0].operations / measuredThreads);
double max = safe_divide(results[0].elapsedTime / 1000.0, (double)results[0].operations / measuredThreads);
double ops = 0;
double time = 0;
for (int i = 0; i != consideredCount; ++i) {
double msPerOperation = safe_divide(results[i].elapsedTime / 1000.0, (double)results[i].operations / measuredThreads);
if (msPerOperation < min) {
min = msPerOperation;
}
else if (msPerOperation > max) {
max = msPerOperation;
}
time += results[i].elapsedTime;
ops += results[i].operations;
}
double avg = safe_divide(time / 1000.0, ops / measuredThreads);
double opsPerSecond = safe_divide(ops, time / 1000.0);
opsst = opsPerSecond / (double)measuredThreads;
opssts.push_back(opsst);
threadCounts.push_back(measuredThreads);
sayf(indent, "%-3d %7s: Avg: %7ss Range: [%7ss, %7ss] Ops/s: %7s Ops/s/t: %7s\n", nthreads, nthreads != 1 ? "threads" : "thread", pretty(avg), pretty(min), pretty(max), pretty(opsPerSecond), pretty(opsst));
if (nthreads == 1 && BENCHMARK_SINGLE_THREAD_NOTES[benchmark][0] != '\0') {
sayf(indent + 7, "^ Note: %s\n", BENCHMARK_SINGLE_THREAD_NOTES[benchmark]);
}
}
opsst = 0;
double divisor = 0;
for (size_t i = 0; i != opssts.size(); ++i) {
opsst += opssts[i] * std::sqrt(threadCounts[i]);
totalWeightedOpsst[queue] += opssts[i] * std::sqrt(threadCounts[i]);
divisor += std::sqrt(threadCounts[i]);
totalWeight[queue] += std::sqrt(threadCounts[i]);
}
opsst /= divisor;
sayf(indent, "Operations per second per thread (weighted average): %7s\n\n", opsst == 0 ? "(n/a)" : pretty(opsst));
indent -= 3;
}
if (QUEUE_TOKEN_SUPPORT[queue]) {
indent -= 4;
}
}
indent -= 2;
}
sayf(0, "Overall average operations per second per thread (where higher-concurrency runs have more weight):\n");
sayf(0, "(Take this summary with a grain of salt -- look at the individual benchmark results for a much\nbetter idea of how the queues measure up to each other):\n");
for (int queue = 0; queue != QUEUE_COUNT; ++queue) {
opsst = safe_divide(totalWeightedOpsst[queue], totalWeight[queue]);
if (QUEUE_SUMMARY_NOTES[queue] != nullptr && QUEUE_SUMMARY_NOTES[queue][0] != '\0') {
sayf(4, "%s (%s): %7s\n", QUEUE_NAMES[queue], QUEUE_SUMMARY_NOTES[queue], opsst == 0 ? "(n/a)" : pretty(opsst));
}
else {
sayf(4, "%s: %7s\n", QUEUE_NAMES[queue], opsst == 0 ? "(n/a)" : pretty(opsst));
}
}
return 0;
}
================================================
FILE: benchmarks/boost/LICENSE_1_0.txt
================================================
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: benchmarks/boost/README.txt
================================================
This is a partial copy of Boost 1.60, specifically only the parts that
boost/lockfree/queue.hpp depends on (extracted using bcp).
================================================
FILE: benchmarks/boost/array.hpp
================================================
/* The following code declares class array,
* an STL container (as wrapper) for arrays of constant size.
*
* See
* http://www.boost.org/libs/array/
* for documentation.
*
* The original author site is at: http://www.josuttis.com/
*
* (C) Copyright Nicolai M. Josuttis 2001.
*
* 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)
*
* 14 Apr 2012 - (mtc) Added support for boost::hash
* 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
* 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
* See <http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#776> or Trac issue #3168
* Eventually, we should remove "assign" which is now a synonym for "fill" (Marshall Clow)
* 10 Mar 2010 - added workaround for SUNCC and !STLPort [trac #3893] (Marshall Clow)
* 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis)
* 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries.
* 05 Aug 2001 - minor update (Nico Josuttis)
* 20 Jan 2001 - STLport fix (Beman Dawes)
* 29 Sep 2000 - Initial Revision (Nico Josuttis)
*
* Jan 29, 2004
*/
#ifndef BOOST_ARRAY_HPP
#define BOOST_ARRAY_HPP
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
# pragma warning(push)
# pragma warning(disable:4996) // 'std::equal': Function call with parameters that may be unsafe
# pragma warning(disable:4510) // boost::array<T,N>' : default constructor could not be generated
# pragma warning(disable:4610) // warning C4610: class 'boost::array<T,N>' can never be instantiated - user defined constructor required
#endif
#include <cstddef>
#include <stdexcept>
#include <boost/assert.hpp>
#include <boost/swap.hpp>
// Handles broken standard libraries better than <iterator>
#include <boost/detail/iterator.hpp>
#include <boost/throw_exception.hpp>
#include <boost/functional/hash_fwd.hpp>
#include <algorithm>
// FIXES for broken compilers
#include <boost/config.hpp>
namespace boost {
template<class T, std::size_t N>
class array {
public:
T elems[N]; // fixed-size array of elements of type T
public:
// type definitions
typedef T value_type;
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// iterator support
iterator begin() { return elems; }
const_iterator begin() const { return elems; }
const_iterator cbegin() const { return elems; }
iterator end() { return elems+N; }
const_iterator end() const { return elems+N; }
const_iterator cend() const { return elems+N; }
// reverse iterator support
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
// workaround for broken reverse_iterator in VC7
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
reference, iterator, reference> > reverse_iterator;
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
const_reference, iterator, reference> > const_reverse_iterator;
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
value_type, reference, iterator, difference_type> reverse_iterator;
typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
#else
// workaround for broken reverse_iterator implementations
typedef std::reverse_iterator<iterator,T> reverse_iterator;
typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
#endif
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
const_reverse_iterator crbegin() const {
return const_reverse_iterator(end());
}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
const_reverse_iterator crend() const {
return const_reverse_iterator(begin());
}
// operator[]
reference operator[](size_type i)
{
BOOST_ASSERT_MSG( i < N, "out of range" );
return elems[i];
}
const_reference operator[](size_type i) const
{
BOOST_ASSERT_MSG( i < N, "out of range" );
return elems[i];
}
// at() with range check
reference at(size_type i) { rangecheck(i); return elems[i]; }
const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
// front() and back()
reference front()
{
return elems[0];
}
const_reference front() const
{
return elems[0];
}
reference back()
{
return elems[N-1];
}
const_reference back() const
{
return elems[N-1];
}
// size is constant
static size_type size() { return N; }
static bool empty() { return false; }
static size_type max_size() { return N; }
enum { static_size = N };
// swap (note: linear complexity)
void swap (array<T,N>& y) {
for (size_type i = 0; i < N; ++i)
boost::swap(elems[i],y.elems[i]);
}
// direct access to data (read-only)
const T* data() const { return elems; }
T* data() { return elems; }
// use array as C array (direct read/write access to data)
T* c_array() { return elems; }
// assignment with type conversion
template <typename T2>
array<T,N>& operator= (const array<T2,N>& rhs) {
std::copy(rhs.begin(),rhs.end(), begin());
return *this;
}
// assign one value to all elements
void assign (const T& value) { fill ( value ); } // A synonym for fill
void fill (const T& value)
{
std::fill_n(begin(),size(),value);
}
// check range (may be private because it is static)
static void rangecheck (size_type i) {
if (i >= size()) {
std::out_of_range e("array<>: index out of range");
boost::throw_exception(e);
}
}
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template< class T >
class array< T, 0 > {
public:
// type definitions
typedef T value_type;
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
// iterator support
iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
iterator end() { return begin(); }
const_iterator end() const { return begin(); }
const_iterator cend() const { return cbegin(); }
// reverse iterator support
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
// workaround for broken reverse_iterator in VC7
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
reference, iterator, reference> > reverse_iterator;
typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
const_reference, iterator, reference> > const_reverse_iterator;
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
value_type, reference, iterator, difference_type> reverse_iterator;
typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
value_type, const_reference, const_iterator, difference_type> const_reverse_iterator;
#else
// workaround for broken reverse_iterator implementations
typedef std::reverse_iterator<iterator,T> reverse_iterator;
typedef std::reverse_iterator<const_iterator,T> const_reverse_iterator;
#endif
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
const_reverse_iterator crbegin() const {
return const_reverse_iterator(end());
}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
const_reverse_iterator crend() const {
return const_reverse_iterator(begin());
}
// operator[]
reference operator[](size_type /*i*/)
{
return failed_rangecheck();
}
const_reference operator[](size_type /*i*/) const
{
return failed_rangecheck();
}
// at() with range check
reference at(size_type /*i*/) { return failed_rangecheck(); }
const_reference at(size_type /*i*/) const { return failed_rangecheck(); }
// front() and back()
reference front()
{
return failed_rangecheck();
}
const_reference front() const
{
return failed_rangecheck();
}
reference back()
{
return failed_rangecheck();
}
const_reference back() const
{
return failed_rangecheck();
}
// size is constant
static size_type size() { return 0; }
static bool empty() { return true; }
static size_type max_size() { return 0; }
enum { static_size = 0 };
void swap (array<T,0>& /*y*/) {
}
// direct access to data (read-only)
const T* data() const { return 0; }
T* data() { return 0; }
// use array as C array (direct read/write access to data)
T* c_array() { return 0; }
// assignment with type conversion
template <typename T2>
array<T,0>& operator= (const array<T2,0>& ) {
return *this;
}
// assign one value to all elements
void assign (const T& value) { fill ( value ); }
void fill (const T& ) {}
// check range (may be private because it is static)
static reference failed_rangecheck () {
std::out_of_range e("attempt to access element of an empty array");
boost::throw_exception(e);
#if defined(BOOST_NO_EXCEPTIONS) || (!defined(BOOST_MSVC) && !defined(__PATHSCALE__))
//
// We need to return something here to keep
// some compilers happy: however we will never
// actually get here....
//
static T placeholder;
return placeholder;
#endif
}
};
#endif
// comparisons
template<class T, std::size_t N>
bool operator== (const array<T,N>& x, const array<T,N>& y) {
return std::equal(x.begin(), x.end(), y.begin());
}
template<class T, std::size_t N>
bool operator< (const array<T,N>& x, const array<T,N>& y) {
return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
}
template<class T, std::size_t N>
bool operator!= (const array<T,N>& x, const array<T,N>& y) {
return !(x==y);
}
template<class T, std::size_t N>
bool operator> (const array<T,N>& x, const array<T,N>& y) {
return y<x;
}
template<class T, std::size_t N>
bool operator<= (const array<T,N>& x, const array<T,N>& y) {
return !(y<x);
}
template<class T, std::size_t N>
bool operator>= (const array<T,N>& x, const array<T,N>& y) {
return !(x<y);
}
// global swap()
template<class T, std::size_t N>
inline void swap (array<T,N>& x, array<T,N>& y) {
x.swap(y);
}
#if defined(__SUNPRO_CC)
// Trac ticket #4757; the Sun Solaris compiler can't handle
// syntax like 'T(&get_c_array(boost::array<T,N>& arg))[N]'
//
// We can't just use this for all compilers, because the
// borland compilers can't handle this form.
namespace detail {
template <typename T, std::size_t N> struct c_array
{
typedef T type[N];
};
}
// Specific for boost::array: simply returns its elems data member.
template <typename T, std::size_t N>
typename detail::c_array<T,N>::type& get_c_array(boost::array<T,N>& arg)
{
return arg.elems;
}
// Specific for boost::array: simply returns its elems data member.
template <typename T, std::size_t N>
typename const detail::c_array<T,N>::type& get_c_array(const boost::array<T,N>& arg)
{
return arg.elems;
}
#else
// Specific for boost::array: simply returns its elems data member.
template <typename T, std::size_t N>
T(&get_c_array(boost::array<T,N>& arg))[N]
{
return arg.elems;
}
// Const version.
template <typename T, std::size_t N>
const T(&get_c_array(const boost::array<T,N>& arg))[N]
{
return arg.elems;
}
#endif
#if 0
// Overload for std::array, assuming that std::array will have
// explicit conversion functions as discussed at the WG21 meeting
// in Summit, March 2009.
template <typename T, std::size_t N>
T(&get_c_array(std::array<T,N>& arg))[N]
{
return static_cast<T(&)[N]>(arg);
}
// Const version.
template <typename T, std::size_t N>
const T(&get_c_array(const std::array<T,N>& arg))[N]
{
return static_cast<T(&)[N]>(arg);
}
#endif
template<class T, std::size_t N>
std::size_t hash_value(const array<T,N>& arr)
{
return boost::hash_range(arr.begin(), arr.end());
}
} /* namespace boost */
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
# pragma warning(pop)
#endif
#endif /*BOOST_ARRAY_HPP*/
================================================
FILE: benchmarks/boost/assert.hpp
================================================
//
// boost/assert.hpp - BOOST_ASSERT(expr)
// BOOST_ASSERT_MSG(expr, msg)
// BOOST_VERIFY(expr)
// BOOST_VERIFY_MSG(expr, msg)
// BOOST_ASSERT_IS_VOID
//
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
// Copyright (c) 2007, 2014 Peter Dimov
// Copyright (c) Beman Dawes 2011
// Copyright (c) 2015 Ion Gaztanaga
//
// 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
//
// Note: There are no include guards. This is intentional.
//
// See http://www.boost.org/libs/assert/assert.html for documentation.
//
//
// Stop inspect complaining about use of 'assert':
//
// boostinspect:naassert_macro
//
//
// BOOST_ASSERT, BOOST_ASSERT_MSG, BOOST_ASSERT_IS_VOID
//
#undef BOOST_ASSERT
#undef BOOST_ASSERT_MSG
#undef BOOST_ASSERT_IS_VOID
#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
# define BOOST_ASSERT(expr) ((void)0)
# define BOOST_ASSERT_MSG(expr, msg) ((void)0)
# define BOOST_ASSERT_IS_VOID
#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
#include <boost/config.hpp> // for BOOST_LIKELY
#include <boost/current_function.hpp>
namespace boost
{
void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined
} // namespace boost
#define BOOST_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
#define BOOST_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
#else
# include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
# define BOOST_ASSERT(expr) assert(expr)
# define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg))
#if defined(NDEBUG)
# define BOOST_ASSERT_IS_VOID
#endif
#endif
//
// BOOST_VERIFY, BOOST_VERIFY_MSG
//
#undef BOOST_VERIFY
#undef BOOST_VERIFY_MSG
#if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )
# define BOOST_VERIFY(expr) ((void)(expr))
# define BOOST_VERIFY_MSG(expr, msg) ((void)(expr))
#else
# define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
# define BOOST_VERIFY_MSG(expr, msg) BOOST_ASSERT_MSG(expr,msg)
#endif
================================================
FILE: benchmarks/boost/atomic/atomic.hpp
================================================
/*
* 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)
*
* Copyright (c) 2011 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/atomic.hpp
*
* This header contains definition of \c atomic template and \c atomic_flag.
*/
#ifndef BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_
#define BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_
#include <boost/atomic/capabilities.hpp>
#include <boost/atomic/fences.hpp>
#include <boost/atomic/atomic_flag.hpp>
#include <boost/atomic/detail/atomic_template.hpp>
#include <boost/atomic/detail/operations.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
using atomics::atomic;
using atomics::atomic_char;
using atomics::atomic_uchar;
using atomics::atomic_schar;
using atomics::atomic_uint8_t;
using atomics::atomic_int8_t;
using atomics::atomic_ushort;
using atomics::atomic_short;
using atomics::atomic_uint16_t;
using atomics::atomic_int16_t;
using atomics::atomic_uint;
using atomics::atomic_int;
using atomics::atomic_uint32_t;
using atomics::atomic_int32_t;
using atomics::atomic_ulong;
using atomics::atomic_long;
using atomics::atomic_uint64_t;
using atomics::atomic_int64_t;
#ifdef BOOST_HAS_LONG_LONG
using atomics::atomic_ullong;
using atomics::atomic_llong;
#endif
using atomics::atomic_address;
using atomics::atomic_bool;
using atomics::atomic_wchar_t;
#if !defined(BOOST_NO_CXX11_CHAR16_T)
using atomics::atomic_char16_t;
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T)
using atomics::atomic_char32_t;
#endif
using atomics::atomic_int_least8_t;
using atomics::atomic_uint_least8_t;
using atomics::atomic_int_least16_t;
using atomics::atomic_uint_least16_t;
using atomics::atomic_int_least32_t;
using atomics::atomic_uint_least32_t;
using atomics::atomic_int_least64_t;
using atomics::atomic_uint_least64_t;
using atomics::atomic_int_fast8_t;
using atomics::atomic_uint_fast8_t;
using atomics::atomic_int_fast16_t;
using atomics::atomic_uint_fast16_t;
using atomics::atomic_int_fast32_t;
using atomics::atomic_uint_fast32_t;
using atomics::atomic_int_fast64_t;
using atomics::atomic_uint_fast64_t;
using atomics::atomic_intmax_t;
using atomics::atomic_uintmax_t;
using atomics::atomic_size_t;
using atomics::atomic_ptrdiff_t;
#if defined(BOOST_HAS_INTPTR_T)
using atomics::atomic_intptr_t;
using atomics::atomic_uintptr_t;
#endif
} // namespace boost
#endif // BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/atomic_flag.hpp
================================================
/*
* 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)
*
* Copyright (c) 2011 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/atomic_flag.hpp
*
* This header contains definition of \c atomic_flag.
*/
#ifndef BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_
#define BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_
#include <boost/atomic/capabilities.hpp>
#include <boost/atomic/detail/operations.hpp>
#include <boost/atomic/detail/atomic_flag.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
using atomics::atomic_flag;
} // namespace boost
#endif // BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/capabilities.hpp
================================================
/*
* 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)
*
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/capabilities.hpp
*
* This header defines feature capabilities macros.
*/
#ifndef BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_
#define BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#include <boost/atomic/detail/platform.hpp>
#include <boost/atomic/detail/int_sizes.hpp>
#if !defined(BOOST_ATOMIC_EMULATED)
#include BOOST_ATOMIC_DETAIL_HEADER(boost/atomic/detail/caps_)
#endif
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#ifndef BOOST_ATOMIC_INT8_LOCK_FREE
#define BOOST_ATOMIC_INT8_LOCK_FREE 0
#endif
#ifndef BOOST_ATOMIC_INT16_LOCK_FREE
#define BOOST_ATOMIC_INT16_LOCK_FREE 0
#endif
#ifndef BOOST_ATOMIC_INT32_LOCK_FREE
#define BOOST_ATOMIC_INT32_LOCK_FREE 0
#endif
#ifndef BOOST_ATOMIC_INT64_LOCK_FREE
#define BOOST_ATOMIC_INT64_LOCK_FREE 0
#endif
#ifndef BOOST_ATOMIC_INT128_LOCK_FREE
#define BOOST_ATOMIC_INT128_LOCK_FREE 0
#endif
#ifndef BOOST_ATOMIC_CHAR_LOCK_FREE
#define BOOST_ATOMIC_CHAR_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#endif
#ifndef BOOST_ATOMIC_CHAR16_T_LOCK_FREE
#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#endif
#ifndef BOOST_ATOMIC_CHAR32_T_LOCK_FREE
#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#endif
#ifndef BOOST_ATOMIC_WCHAR_T_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#else
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0
#endif
#endif
#ifndef BOOST_ATOMIC_SHORT_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 1
#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2
#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4
#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8
#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#else
#define BOOST_ATOMIC_SHORT_LOCK_FREE 0
#endif
#endif
#ifndef BOOST_ATOMIC_INT_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_INT == 1
#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2
#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4
#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8
#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#else
#define BOOST_ATOMIC_INT_LOCK_FREE 0
#endif
#endif
#ifndef BOOST_ATOMIC_LONG_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 1
#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2
#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4
#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8
#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#else
#define BOOST_ATOMIC_LONG_LOCK_FREE 0
#endif
#endif
#ifndef BOOST_ATOMIC_LLONG_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 1
#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2
#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4
#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8
#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#else
#define BOOST_ATOMIC_LLONG_LOCK_FREE 0
#endif
#endif
#ifndef BOOST_ATOMIC_POINTER_LOCK_FREE
#if (BOOST_ATOMIC_DETAIL_SIZEOF_POINTER + 0) == 8
#define BOOST_ATOMIC_POINTER_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#elif (BOOST_ATOMIC_DETAIL_SIZEOF_POINTER + 0) == 4
#define BOOST_ATOMIC_POINTER_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#else
#define BOOST_ATOMIC_POINTER_LOCK_FREE 0
#endif
#endif
#define BOOST_ATOMIC_ADDRESS_LOCK_FREE BOOST_ATOMIC_POINTER_LOCK_FREE
#ifndef BOOST_ATOMIC_BOOL_LOCK_FREE
// We store bools in 1-byte storage in all backends
#define BOOST_ATOMIC_BOOL_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#endif
#ifndef BOOST_ATOMIC_FLAG_LOCK_FREE
#define BOOST_ATOMIC_FLAG_LOCK_FREE BOOST_ATOMIC_BOOL_LOCK_FREE
#endif
#ifndef BOOST_ATOMIC_THREAD_FENCE
#define BOOST_ATOMIC_THREAD_FENCE 0
#endif
#ifndef BOOST_ATOMIC_SIGNAL_FENCE
#define BOOST_ATOMIC_SIGNAL_FENCE 0
#endif
#endif // BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/atomic_flag.hpp
================================================
/*
* 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)
*
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/atomic_flag.hpp
*
* This header contains interface definition of \c atomic_flag.
*/
#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_
#include <boost/assert.hpp>
#include <boost/memory_order.hpp>
#include <boost/atomic/detail/config.hpp>
#include <boost/atomic/detail/operations_lockfree.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
/*
* IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE,
* see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp.
*/
namespace boost {
namespace atomics {
#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
#define BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT
#else
#define BOOST_ATOMIC_FLAG_INIT {}
#endif
struct atomic_flag
{
typedef atomics::detail::operations< 1u, false > operations;
typedef operations::storage_type storage_type;
operations::aligned_storage_type m_storage;
BOOST_FORCEINLINE BOOST_CONSTEXPR atomic_flag() BOOST_NOEXCEPT : m_storage(0)
{
}
BOOST_FORCEINLINE bool test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return operations::test_and_set(m_storage.value, order);
}
BOOST_FORCEINLINE void clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::clear(m_storage.value, order);
}
BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&))
BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&))
};
} // namespace atomics
} // namespace boost
#endif // BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/atomic_template.hpp
================================================
/*
* 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)
*
* Copyright (c) 2011 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/atomic_template.hpp
*
* This header contains interface definition of \c atomic template.
*/
#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
#include <cstddef>
#include <boost/cstdint.hpp>
#include <boost/assert.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/atomic/detail/config.hpp>
#include <boost/atomic/detail/bitwise_cast.hpp>
#include <boost/atomic/detail/operations_fwd.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(BOOST_MSVC)
#pragma warning(push)
// 'boost::atomics::atomic<T>' : multiple assignment operators specified
#pragma warning(disable: 4522)
#endif
/*
* IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE,
* see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp.
*/
namespace boost {
namespace atomics {
namespace detail {
BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memory_order order) BOOST_NOEXCEPT
{
return order == memory_order_acq_rel ? memory_order_acquire : (order == memory_order_release ? memory_order_relaxed : order);
}
BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
{
// 15 == (memory_order_seq_cst | memory_order_consume), see memory_order.hpp
// Given the enum values we can test the strength of memory order requirements with this single condition.
return (failure_order & 15u) <= (success_order & 15u);
}
template< typename T, bool IsInt = boost::is_integral< T >::value >
struct classify
{
typedef void type;
};
template< typename T >
struct classify< T, true > { typedef int type; };
template< typename T >
struct classify< T*, false > { typedef void* type; };
template< typename T, typename Kind >
class base_atomic;
//! Implementation for integers
template< typename T >
class base_atomic< T, int >
{
private:
typedef T value_type;
typedef T difference_type;
typedef atomics::detail::operations< storage_size_of< value_type >::value, boost::is_signed< T >::value > operations;
protected:
typedef value_type value_arg_type;
public:
typedef typename operations::storage_type storage_type;
protected:
typename operations::aligned_storage_type m_storage;
public:
BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {}
BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_consume);
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::store(m_storage.value, static_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_release);
BOOST_ASSERT(order != memory_order_acq_rel);
return static_cast< value_type >(operations::load(m_storage.value, order));
}
BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::fetch_add(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::fetch_sub(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::exchange(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = static_cast< storage_type >(expected);
const bool res = operations::compare_exchange_strong(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
expected = static_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = static_cast< storage_type >(expected);
const bool res = operations::compare_exchange_weak(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
expected = static_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::fetch_and(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::fetch_or(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return static_cast< value_type >(operations::fetch_xor(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
{
return operations::is_lock_free(m_storage.value);
}
BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
{
return fetch_add(1);
}
BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
{
return fetch_add(1) + 1;
}
BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
{
return fetch_sub(1);
}
BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
{
return fetch_sub(1) - 1;
}
BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
{
return fetch_add(v) + v;
}
BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
{
return fetch_sub(v) - v;
}
BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOEXCEPT
{
return fetch_and(v) & v;
}
BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOEXCEPT
{
return fetch_or(v) | v;
}
BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOEXCEPT
{
return fetch_xor(v) ^ v;
}
BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
};
//! Implementation for bool
template< >
class base_atomic< bool, int >
{
private:
typedef bool value_type;
typedef atomics::detail::operations< 1u, false > operations;
protected:
typedef value_type value_arg_type;
public:
typedef operations::storage_type storage_type;
protected:
operations::aligned_storage_type m_storage;
public:
BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {}
BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_consume);
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::store(m_storage.value, static_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_release);
BOOST_ASSERT(order != memory_order_acq_rel);
return !!operations::load(m_storage.value, order);
}
BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return !!operations::exchange(m_storage.value, static_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = static_cast< storage_type >(expected);
const bool res = operations::compare_exchange_strong(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
expected = !!old_value;
return res;
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = static_cast< storage_type >(expected);
const bool res = operations::compare_exchange_weak(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order);
expected = !!old_value;
return res;
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
{
return operations::is_lock_free(m_storage.value);
}
BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
};
//! Implementation for user-defined types, such as structs and enums
template< typename T >
class base_atomic< T, void >
{
private:
typedef T value_type;
typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
protected:
typedef value_type const& value_arg_type;
public:
typedef typename operations::storage_type storage_type;
protected:
typename operations::aligned_storage_type m_storage;
public:
BOOST_FORCEINLINE explicit base_atomic(value_type const& v = value_type()) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v))
{
}
BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_consume);
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::store(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_release);
BOOST_ASSERT(order != memory_order_acq_rel);
return atomics::detail::bitwise_cast< value_type >(operations::load(m_storage.value, order));
}
BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
{
return operations::is_lock_free(m_storage.value);
}
BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
};
//! Implementation for pointers
template< typename T >
class base_atomic< T*, void* >
{
private:
typedef T* value_type;
typedef std::ptrdiff_t difference_type;
typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
protected:
typedef value_type value_arg_type;
public:
typedef typename operations::storage_type storage_type;
protected:
typename operations::aligned_storage_type m_storage;
public:
BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
BOOST_FORCEINLINE explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v))
{
}
BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_consume);
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::store(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_release);
BOOST_ASSERT(order != memory_order_acq_rel);
return atomics::detail::bitwise_cast< value_type >(operations::load(m_storage.value, order));
}
BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::fetch_add(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order));
}
BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::fetch_sub(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order));
}
BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
{
return operations::is_lock_free(m_storage.value);
}
BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
{
return fetch_add(1);
}
BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
{
return fetch_add(1) + 1;
}
BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
{
return fetch_sub(1);
}
BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
{
return fetch_sub(1) - 1;
}
BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
{
return fetch_add(v) + v;
}
BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
{
return fetch_sub(v) - v;
}
BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
};
//! Implementation for void pointers
template< >
class base_atomic< void*, void* >
{
private:
typedef void* value_type;
typedef std::ptrdiff_t difference_type;
typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
protected:
typedef value_type value_arg_type;
public:
typedef operations::storage_type storage_type;
protected:
operations::aligned_storage_type m_storage;
public:
BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
BOOST_FORCEINLINE explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v))
{
}
BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_consume);
BOOST_ASSERT(order != memory_order_acquire);
BOOST_ASSERT(order != memory_order_acq_rel);
operations::store(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order);
}
BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(order != memory_order_release);
BOOST_ASSERT(order != memory_order_acq_rel);
return atomics::detail::bitwise_cast< value_type >(operations::load(m_storage.value, order));
}
BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::fetch_add(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::fetch_sub(m_storage.value, static_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return atomics::detail::bitwise_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order));
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
{
BOOST_ASSERT(failure_order != memory_order_release);
BOOST_ASSERT(failure_order != memory_order_acq_rel);
BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected);
const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order);
expected = atomics::detail::bitwise_cast< value_type >(old_value);
return res;
}
BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
{
return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
}
BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
{
return operations::is_lock_free(m_storage.value);
}
BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
{
return fetch_add(1);
}
BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
{
return (char*)fetch_add(1) + 1;
}
BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
{
return fetch_sub(1);
}
BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
{
return (char*)fetch_sub(1) - 1;
}
BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
{
return (char*)fetch_add(v) + v;
}
BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
{
return (char*)fetch_sub(v) - v;
}
BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
};
} // namespace detail
template< typename T >
class atomic :
public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type >
{
private:
typedef T value_type;
typedef atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type > base_type;
typedef typename base_type::value_arg_type value_arg_type;
public:
typedef typename base_type::storage_type storage_type;
public:
BOOST_DEFAULTED_FUNCTION(atomic(), BOOST_NOEXCEPT {})
// NOTE: The constructor is made explicit because gcc 4.7 complains that
// operator=(value_arg_type) is considered ambiguous with operator=(atomic const&)
// in assignment expressions, even though conversion to atomic<> is less preferred
// than conversion to value_arg_type.
BOOST_FORCEINLINE explicit BOOST_CONSTEXPR atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v) {}
BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile BOOST_NOEXCEPT
{
this->store(v);
return v;
}
BOOST_FORCEINLINE operator value_type() volatile const BOOST_NOEXCEPT
{
return this->load();
}
BOOST_FORCEINLINE storage_type& storage() BOOST_NOEXCEPT { return this->m_storage.value; }
BOOST_FORCEINLINE storage_type volatile& storage() volatile BOOST_NOEXCEPT { return this->m_storage.value; }
BOOST_FORCEINLINE storage_type const& storage() const BOOST_NOEXCEPT { return this->m_storage.value; }
BOOST_FORCEINLINE storage_type const volatile& storage() const volatile BOOST_NOEXCEPT { return this->m_storage.value; }
BOOST_DELETED_FUNCTION(atomic(atomic const&))
BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&))
BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&) volatile)
};
typedef atomic< char > atomic_char;
typedef atomic< unsigned char > atomic_uchar;
typedef atomic< signed char > atomic_schar;
typedef atomic< uint8_t > atomic_uint8_t;
typedef atomic< int8_t > atomic_int8_t;
typedef atomic< unsigned short > atomic_ushort;
typedef atomic< short > atomic_short;
typedef atomic< uint16_t > atomic_uint16_t;
typedef atomic< int16_t > atomic_int16_t;
typedef atomic< unsigned int > atomic_uint;
typedef atomic< int > atomic_int;
typedef atomic< uint32_t > atomic_uint32_t;
typedef atomic< int32_t > atomic_int32_t;
typedef atomic< unsigned long > atomic_ulong;
typedef atomic< long > atomic_long;
typedef atomic< uint64_t > atomic_uint64_t;
typedef atomic< int64_t > atomic_int64_t;
#ifdef BOOST_HAS_LONG_LONG
typedef atomic< boost::ulong_long_type > atomic_ullong;
typedef atomic< boost::long_long_type > atomic_llong;
#endif
typedef atomic< void* > atomic_address;
typedef atomic< bool > atomic_bool;
typedef atomic< wchar_t > atomic_wchar_t;
#if !defined(BOOST_NO_CXX11_CHAR16_T)
typedef atomic< char16_t > atomic_char16_t;
#endif
#if !defined(BOOST_NO_CXX11_CHAR32_T)
typedef atomic< char32_t > atomic_char32_t;
#endif
typedef atomic< int_least8_t > atomic_int_least8_t;
typedef atomic< uint_least8_t > atomic_uint_least8_t;
typedef atomic< int_least16_t > atomic_int_least16_t;
typedef atomic< uint_least16_t > atomic_uint_least16_t;
typedef atomic< int_least32_t > atomic_int_least32_t;
typedef atomic< uint_least32_t > atomic_uint_least32_t;
typedef atomic< int_least64_t > atomic_int_least64_t;
typedef atomic< uint_least64_t > atomic_uint_least64_t;
typedef atomic< int_fast8_t > atomic_int_fast8_t;
typedef atomic< uint_fast8_t > atomic_uint_fast8_t;
typedef atomic< int_fast16_t > atomic_int_fast16_t;
typedef atomic< uint_fast16_t > atomic_uint_fast16_t;
typedef atomic< int_fast32_t > atomic_int_fast32_t;
typedef atomic< uint_fast32_t > atomic_uint_fast32_t;
typedef atomic< int_fast64_t > atomic_int_fast64_t;
typedef atomic< uint_fast64_t > atomic_uint_fast64_t;
typedef atomic< intmax_t > atomic_intmax_t;
typedef atomic< uintmax_t > atomic_uintmax_t;
typedef atomic< std::size_t > atomic_size_t;
typedef atomic< std::ptrdiff_t > atomic_ptrdiff_t;
#if defined(BOOST_HAS_INTPTR_T)
typedef atomic< intptr_t > atomic_intptr_t;
typedef atomic< uintptr_t > atomic_uintptr_t;
#endif
} // namespace atomics
} // namespace boost
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif
#endif // BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/bitwise_cast.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2012 Tim Blechmann
* Copyright (c) 2013 - 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/bitwise_cast.hpp
*
* This header defines \c bitwise_cast used to convert between storage and value types
*/
#ifndef BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#if !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY)
#include <cstring>
#endif
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
namespace atomics {
namespace detail {
template< typename To, typename From >
BOOST_FORCEINLINE To bitwise_cast(From const& from) BOOST_NOEXCEPT
{
struct
{
To to;
}
value = {};
BOOST_ATOMIC_DETAIL_MEMCPY
(
&reinterpret_cast< char& >(value.to),
&reinterpret_cast< const char& >(from),
(sizeof(From) < sizeof(To) ? sizeof(From) : sizeof(To))
);
return value.to;
}
} // namespace detail
} // namespace atomics
} // namespace boost
#endif // BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_alpha.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_alpha.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_arm.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2009 Phil Endecott
* Copyright (c) 2013 Tim Blechmann
* ARM Code by Phil Endecott, based on other architectures.
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_arm.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__))
// ARMv7 and later have dmb instruction
#define BOOST_ATOMIC_DETAIL_ARM_HAS_DMB 1
#endif
#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__))
// ARMv6k and ARMv7 have 8 and 16 ldrex/strex variants
#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXB_STREXB 1
#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXH_STREXH 1
#if !(((defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__)) && defined(__thumb__)) || defined(__ARM_ARCH_7M__))
// ARMv6k and ARMv7 except ARMv7-M have 64-bit ldrex/strex variants.
// Unfortunately, GCC (at least 4.7.3 on Ubuntu) does not allocate register pairs properly when targeting ARMv6k Thumb,
// which is required for ldrexd/strexd instructions, so we disable 64-bit support. When targeting ARMv6k ARM
// or ARMv7 (both ARM and Thumb 2) it works as expected.
#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD 1
#endif
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD)
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#endif
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_atomic.hpp
================================================
/*
* 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)
*
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_atomic.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#include <boost/atomic/detail/int_sizes.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
#endif
#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
#endif
#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
#define BOOST_ATOMIC_INT128_LOCK_FREE 2
#else
#define BOOST_ATOMIC_INT128_LOCK_FREE 0
#endif
#if __GCC_ATOMIC_LLONG_LOCK_FREE == 2
#define BOOST_ATOMIC_LLONG_LOCK_FREE 2
#else
#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT128_LOCK_FREE
#endif
#if __GCC_ATOMIC_LONG_LOCK_FREE == 2
#define BOOST_ATOMIC_LONG_LOCK_FREE 2
#else
#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
#endif
#if __GCC_ATOMIC_INT_LOCK_FREE == 2
#define BOOST_ATOMIC_INT_LOCK_FREE 2
#else
#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
#endif
#if __GCC_ATOMIC_SHORT_LOCK_FREE == 2
#define BOOST_ATOMIC_SHORT_LOCK_FREE 2
#else
#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
#endif
#if __GCC_ATOMIC_CHAR_LOCK_FREE == 2
#define BOOST_ATOMIC_CHAR_LOCK_FREE 2
#else
#define BOOST_ATOMIC_CHAR_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
#endif
#if __GCC_ATOMIC_POINTER_LOCK_FREE == 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#else
#define BOOST_ATOMIC_POINTER_LOCK_FREE 0
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE BOOST_ATOMIC_CHAR_LOCK_FREE
#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2
#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2
#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2
#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2
#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
#else
#define BOOST_ATOMIC_INT16_LOCK_FREE 0
#endif
#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4
#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4
#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4
#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4
#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
#else
#define BOOST_ATOMIC_INT32_LOCK_FREE 0
#endif
#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8
#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8
#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8
#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8
#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
#else
#define BOOST_ATOMIC_INT64_LOCK_FREE 0
#endif
#if __GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
#else
#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0
#endif
#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_ppc.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_ppc.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#if defined(__powerpc64__) || defined(__PPC64__)
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#endif
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_sparc.hpp
================================================
/*
* 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)
*
* Copyright (c) 2010 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_sparc.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_sync.hpp
================================================
/*
* 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)
*
* Copyright (c) 2011 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_sync.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
#endif
#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
|| defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#endif
#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_INT128_LOCK_FREE 2
#endif
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_gcc_x86.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2012 Tim Blechmann
* Copyright (c) 2013 - 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_gcc_x86.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(__i386__) &&\
(\
defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) ||\
defined(__i586__) || defined(__i686__) || defined(__pentium4__) || defined(__nocona__) || defined(__core2__) || defined(__corei7__) ||\
defined(__k6__) || defined(__athlon__) || defined(__k8__) || defined(__amdfam10__) || defined(__bdver1__) || defined(__bdver2__) || defined(__bdver3__) || defined(__btver1__) || defined(__btver2__)\
)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
#endif
#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#if defined(__x86_64__) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#endif
#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
#define BOOST_ATOMIC_INT128_LOCK_FREE 2
#endif
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_linux_arm.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009, 2011 Helge Bahmann
* Copyright (c) 2009 Phil Endecott
* Copyright (c) 2013 Tim Blechmann
* Linux-specific code by Phil Endecott
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_linux_arm.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_msvc_arm.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2012 - 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_msvc_arm.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_msvc_x86.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2012 - 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_msvc_x86.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(_M_IX86) && _M_IX86 >= 500
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
#endif
#if _MSC_VER >= 1500 && defined(_M_AMD64) && !defined(BOOST_ATOMIC_NO_CMPXCHG16B)
#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#if defined(_M_AMD64) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
#define BOOST_ATOMIC_INT64_LOCK_FREE 2
#endif
#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
#define BOOST_ATOMIC_INT128_LOCK_FREE 2
#endif
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/caps_windows.hpp
================================================
/*
* 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)
*
* Copyright (c) 2009 Helge Bahmann
* Copyright (c) 2013 Tim Blechmann
* Copyright (c) 2012 - 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/caps_windows.hpp
*
* This header defines feature capabilities macros
*/
#ifndef BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#define BOOST_ATOMIC_INT8_LOCK_FREE 2
#define BOOST_ATOMIC_INT16_LOCK_FREE 2
#define BOOST_ATOMIC_INT32_LOCK_FREE 2
#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
#define BOOST_ATOMIC_THREAD_FENCE 2
#define BOOST_ATOMIC_SIGNAL_FENCE 2
#endif // BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/config.hpp
================================================
/*
* 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)
*
* Copyright (c) 2012 Hartmut Kaiser
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/config.hpp
*
* This header defines configuraion macros for Boost.Atomic
*/
#ifndef BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_
#include <boost/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(__has_builtin)
#if __has_builtin(__builtin_memcpy)
#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY
#endif
#if __has_builtin(__builtin_memcmp)
#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP
#endif
#elif defined(BOOST_GCC)
#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY
#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP
#endif
#if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY)
#define BOOST_ATOMIC_DETAIL_MEMCPY __builtin_memcpy
#else
#define BOOST_ATOMIC_DETAIL_MEMCPY std::memcpy
#endif
#if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP)
#define BOOST_ATOMIC_DETAIL_MEMCMP __builtin_memcmp
#else
#define BOOST_ATOMIC_DETAIL_MEMCMP std::memcmp
#endif
#if defined(__CUDACC__)
// nvcc does not support alternatives in asm statement constraints
#define BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES
// nvcc does not support condition code register ("cc") clobber in asm statements
#define BOOST_ATOMIC_DETAIL_NO_ASM_CLOBBER_CC
#endif
#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CLOBBER_CC)
#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC "cc"
#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "cc",
#else
#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC
#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA
#endif
#if (defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 403)
// This macro indicates we're using older binutils that don't support implied zero displacements for memory opereands,
// making code like this invalid:
// movl 4+(%%edx), %%eax
#define BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS
#endif
#if defined(__clang__) || (defined(BOOST_GCC) && (BOOST_GCC+0) < 40500)
// This macro indicates that the compiler does not support allocating rax:rdx register pairs ("A") in asm blocks
#define BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS
#endif
#endif // BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/int_sizes.hpp
================================================
/*
* 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)
*
* Copyright (c) 2014 Andrey Semashev
*/
/*!
* \file atomic/detail/int_sizes.hpp
*
* This header defines macros for testing buitin integer type sizes
*/
#ifndef BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
// GCC and compatible compilers define internal macros with builtin type traits
#if defined(__SIZEOF_SHORT__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT __SIZEOF_SHORT__
#endif
#if defined(__SIZEOF_INT__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_INT __SIZEOF_INT__
#endif
#if defined(__SIZEOF_LONG__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG __SIZEOF_LONG__
#endif
#if defined(__SIZEOF_LONG_LONG__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG __SIZEOF_LONG_LONG__
#endif
#if defined(__SIZEOF_WCHAR_T__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T __SIZEOF_WCHAR_T__
#endif
#if defined(__SIZEOF_POINTER__)
#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER __SIZEOF_POINTER__
#elif defined(_MSC_VER)
#if defined(_M_AMD64) || defined(_M_IA64)
#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 8
#else
#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 4
#endif
#endif
#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT) ||\
!defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LLONG)
// Try to deduce sizes from limits
#include <limits.h>
#include <boost/cstdint.hpp>
#if (USHRT_MAX + 0) == 0xff
#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 1
#elif (USHRT_MAX + 0) == 0xffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 2
#elif (USHRT_MAX + 0) == 0xffffffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 4
#elif (USHRT_MAX + 0) == UINT64_C(0xffffffffffffffff)
#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 8
#endif
#if (UINT_MAX + 0) == 0xff
#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 1
#elif (UINT_MAX + 0) == 0xffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 2
#elif (UINT_MAX + 0) == 0xffffffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 4
#elif (UINT_MAX + 0) == UINT64_C(0xffffffffffffffff)
#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 8
#endif
#if (ULONG_MAX + 0) == 0xff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 1
#elif (ULONG_MAX + 0) == 0xffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 2
#elif (ULONG_MAX + 0) == 0xffffffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 4
#elif (ULONG_MAX + 0) == UINT64_C(0xffffffffffffffff)
#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 8
#endif
#if defined(__hpux) // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8
#else
// The list of the non-standard macros (the ones except ULLONG_MAX) is taken from cstdint.hpp
#if defined(ULLONG_MAX)
#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULLONG_MAX
#elif defined(ULONG_LONG_MAX)
#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULONG_LONG_MAX
#elif defined(ULONGLONG_MAX)
#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULONGLONG_MAX
#elif defined(_LLONG_MAX) // strangely enough, this one seems to be holding the limit for the unsigned integer
#define BOOST_ATOMIC_DETAIL_ULLONG_MAX _LLONG_MAX
#endif
#if (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 1
#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 2
#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffffffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 4
#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == UINT64_C(0xffffffffffffffff)
#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8
#endif
#endif // defined(__hpux)
#endif
#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T)
#include <wchar.h>
#include <boost/cstdint.hpp>
#if defined(_MSC_VER) && ( _MSC_VER <= 1310 || defined(UNDER_CE) && _MSC_VER <= 1500 )
// MSVC 7.1 and MSVC 8 (arm) define WCHAR_MAX to a value not suitable for constant expressions
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2
#elif (WCHAR_MAX + 0) == 0xff || (WCHAR_MAX + 0) == 0x7f
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 1
#elif (WCHAR_MAX + 0) == 0xffff || (WCHAR_MAX + 0) == 0x7fff
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2
#elif (WCHAR_MAX + 0) == 0xffffffff || (WCHAR_MAX + 0) == 0x7fffffff
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 4
#elif (WCHAR_MAX + 0) == UINT64_C(0xffffffffffffffff) || (WCHAR_MAX + 0) == INT64_C(0x7fffffffffffffff)
#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 8
#endif
#endif
#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT) ||\
!defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LLONG) ||\
!defined(BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T)
#error Boost.Atomic: Failed to determine builtin integer sizes, the target platform is not supported. Please, report to the developers.
#endif
#endif // BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_
================================================
FILE: benchmarks/boost/atomic/detail/interlocked.hpp
================================================
#ifndef BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP
#define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP
// Copyright (c) 2009 Helge Bahmann
// Copyright (c) 2012 - 2014 Andrey Semashev
//
// 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)
#include <boost/atomic/detail/config.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
#if defined(_WIN32_WCE)
#if _WIN32_WCE >= 0x600
extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), exchange, compare)
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
#else // _WIN32_WCE >= 0x600
extern "C" long __cdecl InterlockedCompareExchange( long*, long, long );
extern "C" long __cdecl InterlockedExchangeAdd( long*, long );
extern "C" long __cdecl InterlockedExchange( long*, long );
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) InterlockedCompareExchange((long*)(dest), exchange, compare)
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) InterlockedExchangeAdd((long*)(dest), (long)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) InterlockedExchange((long*)(dest), (long)(newval))
#endif // _WIN32_WCE >= 0x600
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange)))
#elif defined(_MSC_VER) && _MSC_VER >= 1310
#if _MSC_VER < 1400
extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long );
extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long );
extern "C" long __cdecl _InterlockedExchange( long volatile *, long );
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange)
#pragma intrinsic(_InterlockedExchangeAdd)
#pragma intrinsic(_InterlockedExchange)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), exchange, compare)
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange)))
#else // _MSC_VER < 1400
#include <intrin.h>
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange)
#pragma intrinsic(_InterlockedExchangeAdd)
#pragma intrinsic(_InterlockedExchange)
#pragma intrinsic(_InterlockedAnd)
#pragma intrinsic(_InterlockedOr)
#pragma intrinsic(_InterlockedXor)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND(dest, arg) _InterlockedAnd((long*)(dest), (long)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR(dest, arg) _InterlockedOr((long*)(dest), (long)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR(dest, arg) _InterlockedXor((long*)(dest), (long)(arg))
#if (defined(_M_IX86) && _M_IX86 >= 500) || defined(_M_AMD64) || defined(_M_IA64)
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange64)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
#endif
#if _MSC_VER >= 1500 && defined(_M_AMD64)
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange128)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(dest, exchange, compare) _InterlockedCompareExchange128((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare))
#endif
#if _MSC_VER >= 1600
// MSVC 2010 and later provide intrinsics for 8 and 16 bit integers.
// Note that for each bit count these macros must be either all defined or all not defined.
// Otherwise atomic<> operations will be implemented inconsistently.
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange8)
#pragma intrinsic(_InterlockedExchangeAdd8)
#pragma intrinsic(_InterlockedExchange8)
#pragma intrinsic(_InterlockedAnd8)
#pragma intrinsic(_InterlockedOr8)
#pragma intrinsic(_InterlockedXor8)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(dest, exchange, compare) _InterlockedCompareExchange8((char*)(dest), (char)(exchange), (char)(compare))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(dest, addend) _InterlockedExchangeAdd8((char*)(dest), (char)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(dest, newval) _InterlockedExchange8((char*)(dest), (char)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND8(dest, arg) _InterlockedAnd8((char*)(dest), (char)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR8(dest, arg) _InterlockedOr8((char*)(dest), (char)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR8(dest, arg) _InterlockedXor8((char*)(dest), (char)(arg))
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange16)
#pragma intrinsic(_InterlockedExchangeAdd16)
#pragma intrinsic(_InterlockedExchange16)
#pragma intrinsic(_InterlockedAnd16)
#pragma intrinsic(_InterlockedOr16)
#pragma intrinsic(_InterlockedXor16)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(dest, exchange, compare) _InterlockedCompareExchange16((short*)(dest), (short)(exchange), (short)(compare))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(dest, addend) _InterlockedExchangeAdd16((short*)(dest), (short)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(dest, newval) _InterlockedExchange16((short*)(dest), (short)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND16(dest, arg) _InterlockedAnd16((short*)(dest), (short)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR16(dest, arg) _InterlockedOr16((short*)(dest), (short)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR16(dest, arg) _InterlockedXor16((short*)(dest), (short)(arg))
#endif // _MSC_VER >= 1600
#if defined(_M_AMD64) || defined(_M_IA64)
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedExchangeAdd64)
#pragma intrinsic(_InterlockedExchange64)
#pragma intrinsic(_InterlockedAnd64)
#pragma intrinsic(_InterlockedOr64)
#pragma intrinsic(_InterlockedXor64)
#endif
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) _InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) _InterlockedExchange64((__int64*)(dest), (__int64)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND64(dest, arg) _InterlockedAnd64((__int64*)(dest), (__int64)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR64(dest, arg) _InterlockedOr64((__int64*)(dest), (__int64)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR64(dest, arg) _InterlockedXor64((__int64*)(dest), (__int64)(arg))
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchangePointer)
#pragma intrinsic(_InterlockedExchangePointer)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((long*)(dest), byte_offset))
#elif defined(_M_IX86)
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)_InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)_InterlockedExchange((long*)(dest), (long)(newval)))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset))
#endif
#if _MSC_VER >= 1700 && defined(_M_ARM)
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedExchangeAdd64)
#pragma intrinsic(_InterlockedExchange64)
#pragma intrinsic(_InterlockedAnd64)
#pragma intrinsic(_InterlockedOr64)
#pragma intrinsic(_InterlockedXor64)
#endif
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) _InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend))
#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) _InterlockedExchange64((__int64*)(dest), (__int64)(newval))
#define BOOST_ATOMIC_INTERLOCKED_AND64(dest, arg) _InterlockedAnd64((__int64*)(dest), (__int64)(arg))
#define BOOST_ATOMIC_INTERLOCKED_OR64(dest, arg) _InterlockedOr64((__int64*)(dest), (__int64)(arg))
#define BOOST_ATOMIC_INTERLOCKED_XOR64(dest, arg) _InterlockedXor64((__int64*)(dest), (__int64)(arg))
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedCompareExchange8_nf)
#pragma intrinsic(_InterlockedCompareExchange8_acq)
#pragma intrinsic(_InterlockedCompareExchange8_rel)
#pragma intrinsic(_InterlockedCompareExchange16_nf)
#pragma intrinsic(_InterlockedCompareExchange16_acq)
#pragma intrinsic(_InterlockedCompareExchange16_rel)
#pragma intrinsic(_InterlockedCompareExchange_nf)
#pragma intrinsic(_InterlockedCompareExchange_acq)
#pragma intrinsic(_InterlockedCompareExchange_rel)
#pragma intrinsic(_InterlockedCompareExchange64)
#pragma intrinsic(_InterlockedCompareExchange64_nf)
#pragma intrinsic(_InterlockedCompareExchange64_acq)
#pragma intrinsic(_InterlockedCompareExchange64_rel)
#pragma intrinsic(_InterlockedCompareExchangePointer)
#pragma intrinsic(_InterlockedCompareExchangePointer_nf)
#pragma intrinsic(_InterlockedCompareExchangePointer_acq)
#pragma intrinsic(_InterlockedCompareExchangePointer_rel)
#endif
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(dest, exchange, compare) _InterlockedCompareExchange8_nf((char*)(dest), (char)(exchange), (char)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange8_acq((char*)(dest), (char)(exchange), (char)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(dest, exchange, compare) _InterlockedCompareExchange8_rel((char*)(dest), (char)(exchange), (char)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(dest, exchange, compare) _InterlockedCompareExchange16_nf((short*)(dest), (short)(exchange), (short)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange16_acq((short*)(dest), (short)(exchange), (short)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(dest, exchange, compare) _InterlockedCompareExchange16_rel((short*)(dest), (short)(exchange), (short)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(dest, exchange, compare) _InterlockedCompareExchange_nf((long*)(dest), (long)(exchange), (long)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange_acq((long*)(dest), (long)(exchange), (long)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(dest, exchange, compare) _InterlockedCompareExchange_rel((long*)(dest), (long)(exchange), (long)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(dest, exchange, compare) _InterlockedCompareExchange64_nf((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange64_acq((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(dest, exchange, compare) _InterlockedCompareExchange64_rel((__int64*)(dest), (__int64)(exchange), (__int64)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELAXED(dest, exchange, compare) _InterlockedCompareExchangePointer_nf((void**)(dest), (void*)(exchange), (void*)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchangePointer_acq((void**)(dest), (void*)(exchange), (void*)(compare))
#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELEASE(dest, exchange, compare) _InterlockedCompareExchangePointer_rel((void**)(dest), (void*)(exchange), (void*)(compare))
#if defined(BOOST_MSVC)
#pragma intrinsic(_InterlockedExchangeAdd8_nf)
#pragma intrinsic(_InterlockedExchangeAdd8_acq)
#pragma intrinsic(_InterlockedExchangeAdd8_rel)
#pragma intrinsic(_InterlockedExchangeAdd16_nf)
#pragma intrinsic(_InterlockedExchangeAdd16_acq)
#pragma intrinsic(_InterlockedExchangeAdd16_rel)
#prag
gitextract_c2x5p8gn/
├── .gitignore
├── CMakeLists.txt
├── LICENSE.md
├── README.md
├── benchmarks/
│ ├── benchmarks.cpp
│ ├── boost/
│ │ ├── LICENSE_1_0.txt
│ │ ├── README.txt
│ │ ├── array.hpp
│ │ ├── assert.hpp
│ │ ├── atomic/
│ │ │ ├── atomic.hpp
│ │ │ ├── atomic_flag.hpp
│ │ │ ├── capabilities.hpp
│ │ │ ├── detail/
│ │ │ │ ├── atomic_flag.hpp
│ │ │ │ ├── atomic_template.hpp
│ │ │ │ ├── bitwise_cast.hpp
│ │ │ │ ├── caps_gcc_alpha.hpp
│ │ │ │ ├── caps_gcc_arm.hpp
│ │ │ │ ├── caps_gcc_atomic.hpp
│ │ │ │ ├── caps_gcc_ppc.hpp
│ │ │ │ ├── caps_gcc_sparc.hpp
│ │ │ │ ├── caps_gcc_sync.hpp
│ │ │ │ ├── caps_gcc_x86.hpp
│ │ │ │ ├── caps_linux_arm.hpp
│ │ │ │ ├── caps_msvc_arm.hpp
│ │ │ │ ├── caps_msvc_x86.hpp
│ │ │ │ ├── caps_windows.hpp
│ │ │ │ ├── config.hpp
│ │ │ │ ├── int_sizes.hpp
│ │ │ │ ├── interlocked.hpp
│ │ │ │ ├── link.hpp
│ │ │ │ ├── lockpool.hpp
│ │ │ │ ├── operations.hpp
│ │ │ │ ├── operations_fwd.hpp
│ │ │ │ ├── operations_lockfree.hpp
│ │ │ │ ├── ops_cas_based.hpp
│ │ │ │ ├── ops_emulated.hpp
│ │ │ │ ├── ops_extending_cas_based.hpp
│ │ │ │ ├── ops_gcc_alpha.hpp
│ │ │ │ ├── ops_gcc_arm.hpp
│ │ │ │ ├── ops_gcc_atomic.hpp
│ │ │ │ ├── ops_gcc_ppc.hpp
│ │ │ │ ├── ops_gcc_sparc.hpp
│ │ │ │ ├── ops_gcc_sync.hpp
│ │ │ │ ├── ops_gcc_x86.hpp
│ │ │ │ ├── ops_gcc_x86_dcas.hpp
│ │ │ │ ├── ops_linux_arm.hpp
│ │ │ │ ├── ops_msvc_arm.hpp
│ │ │ │ ├── ops_msvc_common.hpp
│ │ │ │ ├── ops_msvc_x86.hpp
│ │ │ │ ├── ops_windows.hpp
│ │ │ │ ├── pause.hpp
│ │ │ │ ├── platform.hpp
│ │ │ │ └── storage_type.hpp
│ │ │ └── fences.hpp
│ │ ├── atomic.hpp
│ │ ├── config/
│ │ │ ├── abi/
│ │ │ │ ├── borland_prefix.hpp
│ │ │ │ ├── borland_suffix.hpp
│ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ └── msvc_suffix.hpp
│ │ │ ├── abi_prefix.hpp
│ │ │ ├── abi_suffix.hpp
│ │ │ ├── auto_link.hpp
│ │ │ ├── compiler/
│ │ │ │ ├── borland.hpp
│ │ │ │ ├── clang.hpp
│ │ │ │ ├── codegear.hpp
│ │ │ │ ├── comeau.hpp
│ │ │ │ ├── common_edg.hpp
│ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ ├── cray.hpp
│ │ │ │ ├── digitalmars.hpp
│ │ │ │ ├── gcc.hpp
│ │ │ │ ├── gcc_xml.hpp
│ │ │ │ ├── greenhills.hpp
│ │ │ │ ├── hp_acc.hpp
│ │ │ │ ├── intel.hpp
│ │ │ │ ├── kai.hpp
│ │ │ │ ├── metrowerks.hpp
│ │ │ │ ├── mpw.hpp
│ │ │ │ ├── nvcc.hpp
│ │ │ │ ├── pathscale.hpp
│ │ │ │ ├── pgi.hpp
│ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ ├── vacpp.hpp
│ │ │ │ ├── visualc.hpp
│ │ │ │ └── xlcpp.hpp
│ │ │ ├── no_tr1/
│ │ │ │ ├── cmath.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ └── utility.hpp
│ │ │ ├── platform/
│ │ │ │ ├── aix.hpp
│ │ │ │ ├── amigaos.hpp
│ │ │ │ ├── beos.hpp
│ │ │ │ ├── bsd.hpp
│ │ │ │ ├── cloudabi.hpp
│ │ │ │ ├── cray.hpp
│ │ │ │ ├── cygwin.hpp
│ │ │ │ ├── haiku.hpp
│ │ │ │ ├── hpux.hpp
│ │ │ │ ├── irix.hpp
│ │ │ │ ├── linux.hpp
│ │ │ │ ├── macos.hpp
│ │ │ │ ├── qnxnto.hpp
│ │ │ │ ├── solaris.hpp
│ │ │ │ ├── symbian.hpp
│ │ │ │ ├── vms.hpp
│ │ │ │ ├── vxworks.hpp
│ │ │ │ └── win32.hpp
│ │ │ ├── posix_features.hpp
│ │ │ ├── requires_threads.hpp
│ │ │ ├── select_compiler_config.hpp
│ │ │ ├── select_platform_config.hpp
│ │ │ ├── select_stdlib_config.hpp
│ │ │ ├── stdlib/
│ │ │ │ ├── dinkumware.hpp
│ │ │ │ ├── libcomo.hpp
│ │ │ │ ├── libcpp.hpp
│ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ ├── modena.hpp
│ │ │ │ ├── msl.hpp
│ │ │ │ ├── roguewave.hpp
│ │ │ │ ├── sgi.hpp
│ │ │ │ ├── stlport.hpp
│ │ │ │ └── vacpp.hpp
│ │ │ ├── suffix.hpp
│ │ │ ├── user.hpp
│ │ │ └── warning_disable.hpp
│ │ ├── config.hpp
│ │ ├── core/
│ │ │ ├── enable_if.hpp
│ │ │ ├── noncopyable.hpp
│ │ │ └── swap.hpp
│ │ ├── cstdint.hpp
│ │ ├── current_function.hpp
│ │ ├── detail/
│ │ │ ├── is_xxx.hpp
│ │ │ ├── iterator.hpp
│ │ │ └── workaround.hpp
│ │ ├── exception/
│ │ │ └── exception.hpp
│ │ ├── functional/
│ │ │ ├── hash/
│ │ │ │ └── hash_fwd.hpp
│ │ │ └── hash_fwd.hpp
│ │ ├── limits.hpp
│ │ ├── lockfree/
│ │ │ ├── detail/
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── copy_payload.hpp
│ │ │ │ ├── freelist.hpp
│ │ │ │ ├── parameter.hpp
│ │ │ │ ├── prefix.hpp
│ │ │ │ ├── tagged_ptr.hpp
│ │ │ │ ├── tagged_ptr_dcas.hpp
│ │ │ │ └── tagged_ptr_ptrcompression.hpp
│ │ │ ├── policies.hpp
│ │ │ └── queue.hpp
│ │ ├── memory_order.hpp
│ │ ├── mpl/
│ │ │ ├── O1_size.hpp
│ │ │ ├── O1_size_fwd.hpp
│ │ │ ├── always.hpp
│ │ │ ├── and.hpp
│ │ │ ├── apply.hpp
│ │ │ ├── apply_fwd.hpp
│ │ │ ├── apply_wrap.hpp
│ │ │ ├── arg.hpp
│ │ │ ├── arg_fwd.hpp
│ │ │ ├── assert.hpp
│ │ │ ├── at_fwd.hpp
│ │ │ ├── aux_/
│ │ │ │ ├── O1_size_impl.hpp
│ │ │ │ ├── adl_barrier.hpp
│ │ │ │ ├── arg_typedef.hpp
│ │ │ │ ├── arity.hpp
│ │ │ │ ├── arity_spec.hpp
│ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ ├── clear_impl.hpp
│ │ │ │ ├── common_name_wknd.hpp
│ │ │ │ ├── config/
│ │ │ │ │ ├── adl.hpp
│ │ │ │ │ ├── arrays.hpp
│ │ │ │ │ ├── bcc.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── compiler.hpp
│ │ │ │ │ ├── ctps.hpp
│ │ │ │ │ ├── dmc_ambiguous_ctps.hpp
│ │ │ │ │ ├── dtp.hpp
│ │ │ │ │ ├── eti.hpp
│ │ │ │ │ ├── forwarding.hpp
│ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ ├── gpu.hpp
│ │ │ │ │ ├── has_apply.hpp
│ │ │ │ │ ├── has_xxx.hpp
│ │ │ │ │ ├── integral.hpp
│ │ │ │ │ ├── intel.hpp
│ │ │ │ │ ├── lambda.hpp
│ │ │ │ │ ├── msvc.hpp
│ │ │ │ │ ├── msvc_typename.hpp
│ │ │ │ │ ├── nttp.hpp
│ │ │ │ │ ├── operators.hpp
│ │ │ │ │ ├── overload_resolution.hpp
│ │ │ │ │ ├── pp_counter.hpp
│ │ │ │ │ ├── preprocessor.hpp
│ │ │ │ │ ├── static_constant.hpp
│ │ │ │ │ ├── ttp.hpp
│ │ │ │ │ ├── use_preprocessed.hpp
│ │ │ │ │ └── workaround.hpp
│ │ │ │ ├── count_args.hpp
│ │ │ │ ├── find_if_pred.hpp
│ │ │ │ ├── fold_impl.hpp
│ │ │ │ ├── fold_impl_body.hpp
│ │ │ │ ├── full_lambda.hpp
│ │ │ │ ├── has_apply.hpp
│ │ │ │ ├── has_begin.hpp
│ │ │ │ ├── has_key_impl.hpp
│ │ │ │ ├── has_rebind.hpp
│ │ │ │ ├── has_size.hpp
│ │ │ │ ├── has_tag.hpp
│ │ │ │ ├── has_type.hpp
│ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ ├── insert_impl.hpp
│ │ │ │ ├── integral_wrapper.hpp
│ │ │ │ ├── is_msvc_eti_arg.hpp
│ │ │ │ ├── iter_apply.hpp
│ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ ├── lambda_arity_param.hpp
│ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ ├── lambda_spec.hpp
│ │ │ │ ├── lambda_support.hpp
│ │ │ │ ├── logical_op.hpp
│ │ │ │ ├── msvc_dtw.hpp
│ │ │ │ ├── msvc_eti_base.hpp
│ │ │ │ ├── msvc_is_class.hpp
│ │ │ │ ├── msvc_never_true.hpp
│ │ │ │ ├── msvc_type.hpp
│ │ │ │ ├── na.hpp
│ │ │ │ ├── na_assert.hpp
│ │ │ │ ├── na_fwd.hpp
│ │ │ │ ├── na_spec.hpp
│ │ │ │ ├── nested_type_wknd.hpp
│ │ │ │ ├── nttp_decl.hpp
│ │ │ │ ├── overload_names.hpp
│ │ │ │ ├── preprocessed/
│ │ │ │ │ ├── bcc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── bcc551/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── bcc_pre590/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── gcc/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── msvc60/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── msvc70/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── mwcw/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── no_ctps/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ ├── no_ttp/
│ │ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ │ ├── and.hpp
│ │ │ │ │ │ ├── apply.hpp
│ │ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ │ ├── arg.hpp
│ │ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ │ ├── bind.hpp
│ │ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ │ ├── deque.hpp
│ │ │ │ │ │ ├── divides.hpp
│ │ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ │ ├── greater.hpp
│ │ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ │ ├── less.hpp
│ │ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ │ ├── list.hpp
│ │ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ │ ├── map.hpp
│ │ │ │ │ │ ├── minus.hpp
│ │ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ │ ├── or.hpp
│ │ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ │ ├── plus.hpp
│ │ │ │ │ │ ├── quote.hpp
│ │ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ │ ├── set.hpp
│ │ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ │ ├── times.hpp
│ │ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ │ ├── vector.hpp
│ │ │ │ │ │ └── vector_c.hpp
│ │ │ │ │ └── plain/
│ │ │ │ │ ├── advance_backward.hpp
│ │ │ │ │ ├── advance_forward.hpp
│ │ │ │ │ ├── and.hpp
│ │ │ │ │ ├── apply.hpp
│ │ │ │ │ ├── apply_fwd.hpp
│ │ │ │ │ ├── apply_wrap.hpp
│ │ │ │ │ ├── arg.hpp
│ │ │ │ │ ├── basic_bind.hpp
│ │ │ │ │ ├── bind.hpp
│ │ │ │ │ ├── bind_fwd.hpp
│ │ │ │ │ ├── bitand.hpp
│ │ │ │ │ ├── bitor.hpp
│ │ │ │ │ ├── bitxor.hpp
│ │ │ │ │ ├── deque.hpp
│ │ │ │ │ ├── divides.hpp
│ │ │ │ │ ├── equal_to.hpp
│ │ │ │ │ ├── fold_impl.hpp
│ │ │ │ │ ├── full_lambda.hpp
│ │ │ │ │ ├── greater.hpp
│ │ │ │ │ ├── greater_equal.hpp
│ │ │ │ │ ├── inherit.hpp
│ │ │ │ │ ├── iter_fold_if_impl.hpp
│ │ │ │ │ ├── iter_fold_impl.hpp
│ │ │ │ │ ├── lambda_no_ctps.hpp
│ │ │ │ │ ├── less.hpp
│ │ │ │ │ ├── less_equal.hpp
│ │ │ │ │ ├── list.hpp
│ │ │ │ │ ├── list_c.hpp
│ │ │ │ │ ├── map.hpp
│ │ │ │ │ ├── minus.hpp
│ │ │ │ │ ├── modulus.hpp
│ │ │ │ │ ├── not_equal_to.hpp
│ │ │ │ │ ├── or.hpp
│ │ │ │ │ ├── placeholders.hpp
│ │ │ │ │ ├── plus.hpp
│ │ │ │ │ ├── quote.hpp
│ │ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ │ ├── reverse_iter_fold_impl.hpp
│ │ │ │ │ ├── set.hpp
│ │ │ │ │ ├── set_c.hpp
│ │ │ │ │ ├── shift_left.hpp
│ │ │ │ │ ├── shift_right.hpp
│ │ │ │ │ ├── template_arity.hpp
│ │ │ │ │ ├── times.hpp
│ │ │ │ │ ├── unpack_args.hpp
│ │ │ │ │ ├── vector.hpp
│ │ │ │ │ └── vector_c.hpp
│ │ │ │ ├── preprocessor/
│ │ │ │ │ ├── add.hpp
│ │ │ │ │ ├── def_params_tail.hpp
│ │ │ │ │ ├── default_params.hpp
│ │ │ │ │ ├── enum.hpp
│ │ │ │ │ ├── ext_params.hpp
│ │ │ │ │ ├── filter_params.hpp
│ │ │ │ │ ├── params.hpp
│ │ │ │ │ ├── partial_spec_params.hpp
│ │ │ │ │ ├── range.hpp
│ │ │ │ │ ├── repeat.hpp
│ │ │ │ │ ├── sub.hpp
│ │ │ │ │ └── tuple.hpp
│ │ │ │ ├── ptr_to_ref.hpp
│ │ │ │ ├── push_front_impl.hpp
│ │ │ │ ├── reverse_fold_impl.hpp
│ │ │ │ ├── reverse_fold_impl_body.hpp
│ │ │ │ ├── sequence_wrapper.hpp
│ │ │ │ ├── static_cast.hpp
│ │ │ │ ├── template_arity.hpp
│ │ │ │ ├── template_arity_fwd.hpp
│ │ │ │ ├── traits_lambda_spec.hpp
│ │ │ │ ├── type_wrapper.hpp
│ │ │ │ ├── value_wknd.hpp
│ │ │ │ └── yes_no.hpp
│ │ │ ├── base.hpp
│ │ │ ├── begin.hpp
│ │ │ ├── begin_end.hpp
│ │ │ ├── begin_end_fwd.hpp
│ │ │ ├── bind.hpp
│ │ │ ├── bind_fwd.hpp
│ │ │ ├── bool.hpp
│ │ │ ├── bool_fwd.hpp
│ │ │ ├── clear.hpp
│ │ │ ├── clear_fwd.hpp
│ │ │ ├── deref.hpp
│ │ │ ├── empty_fwd.hpp
│ │ │ ├── end.hpp
│ │ │ ├── erase_fwd.hpp
│ │ │ ├── erase_key_fwd.hpp
│ │ │ ├── eval_if.hpp
│ │ │ ├── find.hpp
│ │ │ ├── find_if.hpp
│ │ │ ├── fold.hpp
│ │ │ ├── front_fwd.hpp
│ │ │ ├── has_key.hpp
│ │ │ ├── has_key_fwd.hpp
│ │ │ ├── has_xxx.hpp
│ │ │ ├── identity.hpp
│ │ │ ├── if.hpp
│ │ │ ├── insert.hpp
│ │ │ ├── insert_fwd.hpp
│ │ │ ├── insert_range_fwd.hpp
│ │ │ ├── int.hpp
│ │ │ ├── int_fwd.hpp
│ │ │ ├── integral_c.hpp
│ │ │ ├── integral_c_fwd.hpp
│ │ │ ├── integral_c_tag.hpp
│ │ │ ├── is_placeholder.hpp
│ │ │ ├── iter_fold_if.hpp
│ │ │ ├── iterator_range.hpp
│ │ │ ├── iterator_tags.hpp
│ │ │ ├── key_type_fwd.hpp
│ │ │ ├── lambda.hpp
│ │ │ ├── lambda_fwd.hpp
│ │ │ ├── limits/
│ │ │ │ ├── arity.hpp
│ │ │ │ ├── list.hpp
│ │ │ │ └── unrolling.hpp
│ │ │ ├── list/
│ │ │ │ ├── aux_/
│ │ │ │ │ ├── O1_size.hpp
│ │ │ │ │ ├── begin_end.hpp
│ │ │ │ │ ├── clear.hpp
│ │ │ │ │ ├── empty.hpp
│ │ │ │ │ ├── front.hpp
│ │ │ │ │ ├── include_preprocessed.hpp
│ │ │ │ │ ├── item.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── numbered.hpp
│ │ │ │ │ ├── numbered_c.hpp
│ │ │ │ │ ├── pop_front.hpp
│ │ │ │ │ ├── preprocessed/
│ │ │ │ │ │ └── plain/
│ │ │ │ │ │ ├── list10.hpp
│ │ │ │ │ │ ├── list10_c.hpp
│ │ │ │ │ │ ├── list20.hpp
│ │ │ │ │ │ ├── list20_c.hpp
│ │ │ │ │ │ ├── list30.hpp
│ │ │ │ │ │ ├── list30_c.hpp
│ │ │ │ │ │ ├── list40.hpp
│ │ │ │ │ │ ├── list40_c.hpp
│ │ │ │ │ │ ├── list50.hpp
│ │ │ │ │ │ └── list50_c.hpp
│ │ │ │ │ ├── push_back.hpp
│ │ │ │ │ ├── push_front.hpp
│ │ │ │ │ ├── size.hpp
│ │ │ │ │ └── tag.hpp
│ │ │ │ ├── list0.hpp
│ │ │ │ ├── list0_c.hpp
│ │ │ │ ├── list10.hpp
│ │ │ │ ├── list10_c.hpp
│ │ │ │ ├── list20.hpp
│ │ │ │ ├── list20_c.hpp
│ │ │ │ ├── list30.hpp
│ │ │ │ ├── list30_c.hpp
│ │ │ │ ├── list40.hpp
│ │ │ │ ├── list40_c.hpp
│ │ │ │ ├── list50.hpp
│ │ │ │ └── list50_c.hpp
│ │ │ ├── list.hpp
│ │ │ ├── logical.hpp
│ │ │ ├── long.hpp
│ │ │ ├── long_fwd.hpp
│ │ │ ├── next.hpp
│ │ │ ├── next_prior.hpp
│ │ │ ├── not.hpp
│ │ │ ├── or.hpp
│ │ │ ├── pair.hpp
│ │ │ ├── placeholders.hpp
│ │ │ ├── pop_front_fwd.hpp
│ │ │ ├── prior.hpp
│ │ │ ├── protect.hpp
│ │ │ ├── push_back_fwd.hpp
│ │ │ ├── push_front.hpp
│ │ │ ├── push_front_fwd.hpp
│ │ │ ├── quote.hpp
│ │ │ ├── reverse_fold.hpp
│ │ │ ├── same_as.hpp
│ │ │ ├── sequence_tag.hpp
│ │ │ ├── sequence_tag_fwd.hpp
│ │ │ ├── set/
│ │ │ │ ├── aux_/
│ │ │ │ │ ├── at_impl.hpp
│ │ │ │ │ ├── begin_end_impl.hpp
│ │ │ │ │ ├── clear_impl.hpp
│ │ │ │ │ ├── empty_impl.hpp
│ │ │ │ │ ├── erase_impl.hpp
│ │ │ │ │ ├── erase_key_impl.hpp
│ │ │ │ │ ├── has_key_impl.hpp
│ │ │ │ │ ├── insert_impl.hpp
│ │ │ │ │ ├── insert_range_impl.hpp
│ │ │ │ │ ├── item.hpp
│ │ │ │ │ ├── iterator.hpp
│ │ │ │ │ ├── key_type_impl.hpp
│ │ │ │ │ ├── set0.hpp
│ │ │ │ │ ├── size_impl.hpp
│ │ │ │ │ ├── tag.hpp
│ │ │ │ │ └── value_type_impl.hpp
│ │ │ │ └── set0.hpp
│ │ │ ├── size_fwd.hpp
│ │ │ ├── size_t.hpp
│ │ │ ├── size_t_fwd.hpp
│ │ │ ├── value_type_fwd.hpp
│ │ │ ├── void.hpp
│ │ │ └── void_fwd.hpp
│ │ ├── noncopyable.hpp
│ │ ├── parameter/
│ │ │ ├── aux_/
│ │ │ │ ├── arg_list.hpp
│ │ │ │ ├── cast.hpp
│ │ │ │ ├── default.hpp
│ │ │ │ ├── is_maybe.hpp
│ │ │ │ ├── overloads.hpp
│ │ │ │ ├── parameter_requirements.hpp
│ │ │ │ ├── parenthesized_type.hpp
│ │ │ │ ├── preprocessor/
│ │ │ │ │ ├── flatten.hpp
│ │ │ │ │ └── for_each.hpp
│ │ │ │ ├── result_of0.hpp
│ │ │ │ ├── set.hpp
│ │ │ │ ├── tag.hpp
│ │ │ │ ├── tagged_argument.hpp
│ │ │ │ ├── template_keyword.hpp
│ │ │ │ ├── unwrap_cv_reference.hpp
│ │ │ │ ├── void.hpp
│ │ │ │ └── yesno.hpp
│ │ │ ├── binding.hpp
│ │ │ ├── config.hpp
│ │ │ ├── keyword.hpp
│ │ │ ├── macros.hpp
│ │ │ ├── match.hpp
│ │ │ ├── name.hpp
│ │ │ ├── parameters.hpp
│ │ │ ├── preprocessor.hpp
│ │ │ └── value_type.hpp
│ │ ├── parameter.hpp
│ │ ├── preprocessor/
│ │ │ ├── arithmetic/
│ │ │ │ ├── add.hpp
│ │ │ │ ├── dec.hpp
│ │ │ │ ├── inc.hpp
│ │ │ │ └── sub.hpp
│ │ │ ├── array/
│ │ │ │ ├── data.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ └── size.hpp
│ │ │ ├── cat.hpp
│ │ │ ├── comma_if.hpp
│ │ │ ├── comparison/
│ │ │ │ ├── equal.hpp
│ │ │ │ ├── less_equal.hpp
│ │ │ │ └── not_equal.hpp
│ │ │ ├── config/
│ │ │ │ └── config.hpp
│ │ │ ├── control/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ ├── msvc/
│ │ │ │ │ │ └── while.hpp
│ │ │ │ │ └── while.hpp
│ │ │ │ ├── expr_if.hpp
│ │ │ │ ├── expr_iif.hpp
│ │ │ │ ├── if.hpp
│ │ │ │ ├── iif.hpp
│ │ │ │ └── while.hpp
│ │ │ ├── debug/
│ │ │ │ └── error.hpp
│ │ │ ├── dec.hpp
│ │ │ ├── detail/
│ │ │ │ ├── auto_rec.hpp
│ │ │ │ ├── check.hpp
│ │ │ │ ├── dmc/
│ │ │ │ │ └── auto_rec.hpp
│ │ │ │ ├── is_binary.hpp
│ │ │ │ ├── is_nullary.hpp
│ │ │ │ └── split.hpp
│ │ │ ├── empty.hpp
│ │ │ ├── enum.hpp
│ │ │ ├── enum_params.hpp
│ │ │ ├── enum_params_with_a_default.hpp
│ │ │ ├── enum_shifted_params.hpp
│ │ │ ├── expr_if.hpp
│ │ │ ├── facilities/
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_empty.hpp
│ │ │ │ ├── empty.hpp
│ │ │ │ ├── expand.hpp
│ │ │ │ ├── identity.hpp
│ │ │ │ ├── intercept.hpp
│ │ │ │ ├── is_1.hpp
│ │ │ │ ├── is_empty.hpp
│ │ │ │ ├── is_empty_variadic.hpp
│ │ │ │ └── overload.hpp
│ │ │ ├── for.hpp
│ │ │ ├── identity.hpp
│ │ │ ├── inc.hpp
│ │ │ ├── iterate.hpp
│ │ │ ├── iteration/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── bounds/
│ │ │ │ │ │ ├── lower1.hpp
│ │ │ │ │ │ ├── lower2.hpp
│ │ │ │ │ │ ├── lower3.hpp
│ │ │ │ │ │ ├── lower4.hpp
│ │ │ │ │ │ ├── lower5.hpp
│ │ │ │ │ │ ├── upper1.hpp
│ │ │ │ │ │ ├── upper2.hpp
│ │ │ │ │ │ ├── upper3.hpp
│ │ │ │ │ │ ├── upper4.hpp
│ │ │ │ │ │ └── upper5.hpp
│ │ │ │ │ ├── finish.hpp
│ │ │ │ │ ├── iter/
│ │ │ │ │ │ ├── forward1.hpp
│ │ │ │ │ │ ├── forward2.hpp
│ │ │ │ │ │ ├── forward3.hpp
│ │ │ │ │ │ ├── forward4.hpp
│ │ │ │ │ │ ├── forward5.hpp
│ │ │ │ │ │ ├── reverse1.hpp
│ │ │ │ │ │ ├── reverse2.hpp
│ │ │ │ │ │ ├── reverse3.hpp
│ │ │ │ │ │ ├── reverse4.hpp
│ │ │ │ │ │ └── reverse5.hpp
│ │ │ │ │ ├── local.hpp
│ │ │ │ │ ├── rlocal.hpp
│ │ │ │ │ ├── self.hpp
│ │ │ │ │ └── start.hpp
│ │ │ │ ├── iterate.hpp
│ │ │ │ ├── local.hpp
│ │ │ │ └── self.hpp
│ │ │ ├── list/
│ │ │ │ ├── adt.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── fold_left.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ │ └── fold_right.hpp
│ │ │ │ │ ├── fold_left.hpp
│ │ │ │ │ └── fold_right.hpp
│ │ │ │ ├── fold_left.hpp
│ │ │ │ ├── fold_right.hpp
│ │ │ │ ├── for_each_i.hpp
│ │ │ │ └── reverse.hpp
│ │ │ ├── logical/
│ │ │ │ ├── and.hpp
│ │ │ │ ├── bitand.hpp
│ │ │ │ ├── bool.hpp
│ │ │ │ ├── compl.hpp
│ │ │ │ └── not.hpp
│ │ │ ├── punctuation/
│ │ │ │ ├── comma.hpp
│ │ │ │ ├── comma_if.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_begin_parens.hpp
│ │ │ │ └── is_begin_parens.hpp
│ │ │ ├── repeat.hpp
│ │ │ ├── repetition/
│ │ │ │ ├── deduce_r.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── dmc/
│ │ │ │ │ │ └── for.hpp
│ │ │ │ │ ├── edg/
│ │ │ │ │ │ └── for.hpp
│ │ │ │ │ ├── for.hpp
│ │ │ │ │ └── msvc/
│ │ │ │ │ └── for.hpp
│ │ │ │ ├── enum.hpp
│ │ │ │ ├── enum_binary_params.hpp
│ │ │ │ ├── enum_params.hpp
│ │ │ │ ├── enum_params_with_a_default.hpp
│ │ │ │ ├── enum_shifted.hpp
│ │ │ │ ├── enum_shifted_params.hpp
│ │ │ │ ├── enum_trailing.hpp
│ │ │ │ ├── enum_trailing_params.hpp
│ │ │ │ ├── for.hpp
│ │ │ │ ├── repeat.hpp
│ │ │ │ └── repeat_from_to.hpp
│ │ │ ├── selection/
│ │ │ │ └── max.hpp
│ │ │ ├── seq/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── is_empty.hpp
│ │ │ │ │ └── split.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ ├── enum.hpp
│ │ │ │ ├── first_n.hpp
│ │ │ │ ├── fold_left.hpp
│ │ │ │ ├── for_each.hpp
│ │ │ │ ├── for_each_i.hpp
│ │ │ │ ├── for_each_product.hpp
│ │ │ │ ├── push_back.hpp
│ │ │ │ ├── rest_n.hpp
│ │ │ │ ├── seq.hpp
│ │ │ │ ├── size.hpp
│ │ │ │ └── subseq.hpp
│ │ │ ├── slot/
│ │ │ │ ├── detail/
│ │ │ │ │ ├── counter.hpp
│ │ │ │ │ ├── def.hpp
│ │ │ │ │ ├── shared.hpp
│ │ │ │ │ ├── slot1.hpp
│ │ │ │ │ ├── slot2.hpp
│ │ │ │ │ ├── slot3.hpp
│ │ │ │ │ ├── slot4.hpp
│ │ │ │ │ └── slot5.hpp
│ │ │ │ └── slot.hpp
│ │ │ ├── stringize.hpp
│ │ │ ├── tuple/
│ │ │ │ ├── detail/
│ │ │ │ │ └── is_single_return.hpp
│ │ │ │ ├── eat.hpp
│ │ │ │ ├── elem.hpp
│ │ │ │ ├── rem.hpp
│ │ │ │ ├── size.hpp
│ │ │ │ └── to_list.hpp
│ │ │ └── variadic/
│ │ │ ├── elem.hpp
│ │ │ └── size.hpp
│ │ ├── static_assert.hpp
│ │ ├── swap.hpp
│ │ ├── throw_exception.hpp
│ │ ├── type_traits/
│ │ │ ├── add_const.hpp
│ │ │ ├── add_lvalue_reference.hpp
│ │ │ ├── add_reference.hpp
│ │ │ ├── add_rvalue_reference.hpp
│ │ │ ├── add_volatile.hpp
│ │ │ ├── conditional.hpp
│ │ │ ├── declval.hpp
│ │ │ ├── detail/
│ │ │ │ ├── config.hpp
│ │ │ │ ├── is_function_ptr_helper.hpp
│ │ │ │ ├── is_function_ptr_tester.hpp
│ │ │ │ ├── is_mem_fun_pointer_impl.hpp
│ │ │ │ ├── is_mem_fun_pointer_tester.hpp
│ │ │ │ └── yes_no_type.hpp
│ │ │ ├── has_trivial_assign.hpp
│ │ │ ├── has_trivial_destructor.hpp
│ │ │ ├── integral_constant.hpp
│ │ │ ├── intrinsics.hpp
│ │ │ ├── is_abstract.hpp
│ │ │ ├── is_arithmetic.hpp
│ │ │ ├── is_array.hpp
│ │ │ ├── is_assignable.hpp
│ │ │ ├── is_base_and_derived.hpp
│ │ │ ├── is_class.hpp
│ │ │ ├── is_const.hpp
│ │ │ ├── is_convertible.hpp
│ │ │ ├── is_destructible.hpp
│ │ │ ├── is_enum.hpp
│ │ │ ├── is_floating_point.hpp
│ │ │ ├── is_function.hpp
│ │ │ ├── is_integral.hpp
│ │ │ ├── is_lvalue_reference.hpp
│ │ │ ├── is_member_function_pointer.hpp
│ │ │ ├── is_member_pointer.hpp
│ │ │ ├── is_pod.hpp
│ │ │ ├── is_pointer.hpp
│ │ │ ├── is_polymorphic.hpp
│ │ │ ├── is_reference.hpp
│ │ │ ├── is_rvalue_reference.hpp
│ │ │ ├── is_same.hpp
│ │ │ ├── is_scalar.hpp
│ │ │ ├── is_signed.hpp
│ │ │ ├── is_union.hpp
│ │ │ ├── is_unsigned.hpp
│ │ │ ├── is_void.hpp
│ │ │ ├── is_volatile.hpp
│ │ │ ├── make_signed.hpp
│ │ │ ├── remove_const.hpp
│ │ │ ├── remove_cv.hpp
│ │ │ └── remove_reference.hpp
│ │ ├── utility/
│ │ │ ├── declval.hpp
│ │ │ ├── detail/
│ │ │ │ └── result_of_iterate.hpp
│ │ │ ├── enable_if.hpp
│ │ │ └── result_of.hpp
│ │ └── version.hpp
│ ├── boostqueue.h
│ ├── contrib/
│ │ ├── benchmarks.aws-32.log
│ │ └── benchmarks.aws-8.log
│ ├── cpuid.cpp
│ ├── cpuid.h
│ ├── dlib/
│ │ ├── algs.h
│ │ ├── array/
│ │ │ ├── array_kernel.h
│ │ │ ├── array_kernel_abstract.h
│ │ │ ├── array_tools.h
│ │ │ └── array_tools_abstract.h
│ │ ├── array.h
│ │ ├── assert.h
│ │ ├── binary_search_tree/
│ │ │ ├── binary_search_tree_kernel_1.h
│ │ │ ├── binary_search_tree_kernel_2.h
│ │ │ ├── binary_search_tree_kernel_abstract.h
│ │ │ └── binary_search_tree_kernel_c.h
│ │ ├── binary_search_tree.h
│ │ ├── bound_function_pointer/
│ │ │ ├── bound_function_pointer_kernel_1.h
│ │ │ └── bound_function_pointer_kernel_abstract.h
│ │ ├── bound_function_pointer.h
│ │ ├── byte_orderer/
│ │ │ ├── byte_orderer_kernel_1.h
│ │ │ └── byte_orderer_kernel_abstract.h
│ │ ├── byte_orderer.h
│ │ ├── cassert
│ │ ├── config.h
│ │ ├── console_progress_indicator.h
│ │ ├── cstring
│ │ ├── dlib_basic_cpp_build_tutorial.txt
│ │ ├── dlib_include_path_tutorial.txt
│ │ ├── enable_if.h
│ │ ├── error.h
│ │ ├── float_details.h
│ │ ├── fstream
│ │ ├── hash.h
│ │ ├── interfaces/
│ │ │ ├── cmd_line_parser_option.h
│ │ │ ├── enumerable.h
│ │ │ ├── map_pair.h
│ │ │ └── remover.h
│ │ ├── iomanip
│ │ ├── iosfwd
│ │ ├── iostream
│ │ ├── is_kind.h
│ │ ├── istream
│ │ ├── locale
│ │ ├── logger/
│ │ │ ├── extra_logger_headers.h
│ │ │ ├── logger_config_file.h
│ │ │ ├── logger_kernel_1.h
│ │ │ └── logger_kernel_abstract.h
│ │ ├── logger.h
│ │ ├── map/
│ │ │ ├── map_kernel_1.h
│ │ │ ├── map_kernel_abstract.h
│ │ │ └── map_kernel_c.h
│ │ ├── map.h
│ │ ├── member_function_pointer/
│ │ │ ├── make_mfp.h
│ │ │ ├── make_mfp_abstract.h
│ │ │ ├── member_function_pointer_kernel_1.h
│ │ │ └── member_function_pointer_kernel_abstract.h
│ │ ├── member_function_pointer.h
│ │ ├── memory_manager/
│ │ │ ├── memory_manager_kernel_1.h
│ │ │ ├── memory_manager_kernel_2.h
│ │ │ ├── memory_manager_kernel_3.h
│ │ │ └── memory_manager_kernel_abstract.h
│ │ ├── memory_manager.h
│ │ ├── memory_manager_global/
│ │ │ ├── memory_manager_global_kernel_1.h
│ │ │ └── memory_manager_global_kernel_abstract.h
│ │ ├── memory_manager_global.h
│ │ ├── memory_manager_stateless/
│ │ │ ├── memory_manager_stateless_kernel_1.h
│ │ │ ├── memory_manager_stateless_kernel_2.h
│ │ │ └── memory_manager_stateless_kernel_abstract.h
│ │ ├── memory_manager_stateless.h
│ │ ├── metaprogramming.h
│ │ ├── misc_api/
│ │ │ ├── misc_api_kernel_1.h
│ │ │ ├── misc_api_kernel_2.h
│ │ │ ├── misc_api_kernel_abstract.h
│ │ │ ├── misc_api_shared.h
│ │ │ ├── posix.h
│ │ │ └── windows.h
│ │ ├── misc_api.h
│ │ ├── noncopyable.h
│ │ ├── numeric_constants.h
│ │ ├── numerical_integration/
│ │ │ ├── integrate_function_adapt_simpson.h
│ │ │ └── integrate_function_adapt_simpson_abstract.h
│ │ ├── numerical_integration.h
│ │ ├── ostream
│ │ ├── pipe/
│ │ │ ├── pipe_kernel_1.h
│ │ │ └── pipe_kernel_abstract.h
│ │ ├── pipe.h
│ │ ├── platform.h
│ │ ├── queue/
│ │ │ ├── queue_kernel_1.h
│ │ │ ├── queue_kernel_2.h
│ │ │ ├── queue_kernel_abstract.h
│ │ │ ├── queue_kernel_c.h
│ │ │ ├── queue_sort_1.h
│ │ │ └── queue_sort_abstract.h
│ │ ├── queue.h
│ │ ├── ref.h
│ │ ├── revision.h
│ │ ├── serialize.h
│ │ ├── set/
│ │ │ ├── set_compare_1.h
│ │ │ ├── set_compare_abstract.h
│ │ │ ├── set_kernel_1.h
│ │ │ ├── set_kernel_abstract.h
│ │ │ └── set_kernel_c.h
│ │ ├── set.h
│ │ ├── sliding_buffer/
│ │ │ ├── circular_buffer.h
│ │ │ ├── circular_buffer_abstract.h
│ │ │ ├── sliding_buffer_kernel_1.h
│ │ │ ├── sliding_buffer_kernel_abstract.h
│ │ │ └── sliding_buffer_kernel_c.h
│ │ ├── sliding_buffer.h
│ │ ├── sockets/
│ │ │ ├── posix.h
│ │ │ ├── sockets_extensions.h
│ │ │ ├── sockets_extensions_abstract.h
│ │ │ ├── sockets_kernel_1.h
│ │ │ ├── sockets_kernel_2.h
│ │ │ ├── sockets_kernel_abstract.h
│ │ │ └── windows.h
│ │ ├── sockets.h
│ │ ├── sort.h
│ │ ├── sparse_vector.h
│ │ ├── sstream
│ │ ├── stack/
│ │ │ ├── stack_kernel_1.h
│ │ │ ├── stack_kernel_abstract.h
│ │ │ └── stack_kernel_c.h
│ │ ├── stack.h
│ │ ├── stack_trace.h
│ │ ├── std_allocator.h
│ │ ├── stl_checked/
│ │ │ ├── std_vector_c.h
│ │ │ └── std_vector_c_abstract.h
│ │ ├── stl_checked.h
│ │ ├── string/
│ │ │ ├── cassert
│ │ │ ├── iomanip
│ │ │ ├── iosfwd
│ │ │ ├── iostream
│ │ │ ├── locale
│ │ │ ├── string.h
│ │ │ └── string_abstract.h
│ │ ├── string.h
│ │ ├── test_for_odr_violations.cpp
│ │ ├── test_for_odr_violations.h
│ │ ├── threads/
│ │ │ ├── async.h
│ │ │ ├── async_abstract.h
│ │ │ ├── auto_mutex_extension.h
│ │ │ ├── auto_mutex_extension_abstract.h
│ │ │ ├── auto_unlock_extension.h
│ │ │ ├── auto_unlock_extension_abstract.h
│ │ │ ├── create_new_thread_extension.h
│ │ │ ├── create_new_thread_extension_abstract.h
│ │ │ ├── multithreaded_object_extension.h
│ │ │ ├── multithreaded_object_extension_abstract.h
│ │ │ ├── parallel_for_extension.h
│ │ │ ├── parallel_for_extension_abstract.h
│ │ │ ├── posix.h
│ │ │ ├── read_write_mutex_extension.h
│ │ │ ├── read_write_mutex_extension_abstract.h
│ │ │ ├── rmutex_extension.h
│ │ │ ├── rmutex_extension_abstract.h
│ │ │ ├── rsignaler_extension.h
│ │ │ ├── rsignaler_extension_abstract.h
│ │ │ ├── thread_function_extension.h
│ │ │ ├── thread_function_extension_abstract.h
│ │ │ ├── thread_pool_extension.h
│ │ │ ├── thread_pool_extension_abstract.h
│ │ │ ├── thread_specific_data_extension.h
│ │ │ ├── thread_specific_data_extension_abstract.h
│ │ │ ├── threaded_object_extension.h
│ │ │ ├── threaded_object_extension_abstract.h
│ │ │ ├── threads_kernel.h
│ │ │ ├── threads_kernel_1.h
│ │ │ ├── threads_kernel_2.h
│ │ │ ├── threads_kernel_abstract.h
│ │ │ ├── threads_kernel_shared.h
│ │ │ └── windows.h
│ │ ├── threads.h
│ │ ├── time_this.h
│ │ ├── timeout/
│ │ │ ├── timeout.h
│ │ │ └── timeout_abstract.h
│ │ ├── timeout.h
│ │ ├── timer/
│ │ │ ├── timer.h
│ │ │ ├── timer_abstract.h
│ │ │ └── timer_heavy.h
│ │ ├── timer.h
│ │ ├── timing.h
│ │ ├── tokenizer/
│ │ │ ├── tokenizer_kernel_1.h
│ │ │ ├── tokenizer_kernel_abstract.h
│ │ │ └── tokenizer_kernel_c.h
│ │ ├── tokenizer.h
│ │ ├── uintn.h
│ │ ├── unicode/
│ │ │ ├── unicode.h
│ │ │ └── unicode_abstract.h
│ │ ├── unicode.h
│ │ ├── unordered_pair.h
│ │ ├── vectorstream/
│ │ │ ├── unserialize.h
│ │ │ ├── unserialize_abstract.h
│ │ │ ├── vectorstream.h
│ │ │ └── vectorstream_abstract.h
│ │ ├── vectorstream.h
│ │ └── windows_magic.h
│ ├── dlibqueue.h
│ ├── extract_graph_data.py
│ ├── lockbasedqueue.h
│ ├── makefile
│ ├── simplelockfree.h
│ ├── stdqueue.h
│ ├── tbb/
│ │ ├── COPYING
│ │ ├── README.txt
│ │ ├── aggregator.h
│ │ ├── aligned_space.h
│ │ ├── arena.cpp
│ │ ├── arena.h
│ │ ├── atomic.h
│ │ ├── blocked_range.h
│ │ ├── blocked_range2d.h
│ │ ├── blocked_range3d.h
│ │ ├── cache_aligned_allocator.cpp
│ │ ├── cache_aligned_allocator.h
│ │ ├── cilk-tbb-interop.h
│ │ ├── combinable.h
│ │ ├── compat/
│ │ │ ├── condition_variable
│ │ │ ├── ppl.h
│ │ │ ├── thread
│ │ │ └── tuple
│ │ ├── concurrent_hash_map.cpp
│ │ ├── concurrent_hash_map.h
│ │ ├── concurrent_lru_cache.h
│ │ ├── concurrent_monitor.cpp
│ │ ├── concurrent_monitor.h
│ │ ├── concurrent_priority_queue.h
│ │ ├── concurrent_queue.cpp
│ │ ├── concurrent_queue.h
│ │ ├── concurrent_unordered_map.h
│ │ ├── concurrent_unordered_set.h
│ │ ├── concurrent_vector.cpp
│ │ ├── concurrent_vector.h
│ │ ├── condition_variable.cpp
│ │ ├── critical_section.cpp
│ │ ├── critical_section.h
│ │ ├── custom_scheduler.h
│ │ ├── dynamic_link.cpp
│ │ ├── dynamic_link.h
│ │ ├── enumerable_thread_specific.h
│ │ ├── flow_graph.h
│ │ ├── governor.cpp
│ │ ├── governor.h
│ │ ├── ia32-masm/
│ │ │ ├── atomic_support.asm
│ │ │ ├── itsx.asm
│ │ │ └── lock_byte.asm
│ │ ├── ia64-gas/
│ │ │ ├── atomic_support.s
│ │ │ ├── ia64_misc.s
│ │ │ ├── lock_byte.s
│ │ │ ├── log2.s
│ │ │ └── pause.s
│ │ ├── ibm_aix51/
│ │ │ └── atomic_support.c
│ │ ├── intel64-masm/
│ │ │ ├── atomic_support.asm
│ │ │ ├── intel64_misc.asm
│ │ │ └── itsx.asm
│ │ ├── internal/
│ │ │ ├── _aggregator_impl.h
│ │ │ ├── _concurrent_queue_impl.h
│ │ │ ├── _concurrent_unordered_impl.h
│ │ │ ├── _flow_graph_impl.h
│ │ │ ├── _flow_graph_indexer_impl.h
│ │ │ ├── _flow_graph_item_buffer_impl.h
│ │ │ ├── _flow_graph_join_impl.h
│ │ │ ├── _flow_graph_node_impl.h
│ │ │ ├── _flow_graph_tagged_buffer_impl.h
│ │ │ ├── _flow_graph_trace_impl.h
│ │ │ ├── _flow_graph_types_impl.h
│ │ │ ├── _mutex_padding.h
│ │ │ ├── _range_iterator.h
│ │ │ ├── _tbb_strings.h
│ │ │ ├── _tbb_windef.h
│ │ │ ├── _x86_eliding_mutex_impl.h
│ │ │ └── _x86_rtm_rw_mutex_impl.h
│ │ ├── intrusive_list.h
│ │ ├── itt_notify.cpp
│ │ ├── itt_notify.h
│ │ ├── lin32-tbb-export.def
│ │ ├── lin32-tbb-export.lst
│ │ ├── lin64-tbb-export.def
│ │ ├── lin64-tbb-export.lst
│ │ ├── lin64ipf-tbb-export.def
│ │ ├── lin64ipf-tbb-export.lst
│ │ ├── mac32-tbb-export.def
│ │ ├── mac32-tbb-export.lst
│ │ ├── mac64-tbb-export.def
│ │ ├── mac64-tbb-export.lst
│ │ ├── machine/
│ │ │ ├── gcc_armv7.h
│ │ │ ├── gcc_generic.h
│ │ │ ├── gcc_ia32_common.h
│ │ │ ├── gcc_itsx.h
│ │ │ ├── ibm_aix51.h
│ │ │ ├── icc_generic.h
│ │ │ ├── linux_common.h
│ │ │ ├── linux_ia32.h
│ │ │ ├── linux_ia64.h
│ │ │ ├── linux_intel64.h
│ │ │ ├── mac_ppc.h
│ │ │ ├── macos_common.h
│ │ │ ├── mic_common.h
│ │ │ ├── msvc_armv7.h
│ │ │ ├── msvc_ia32_common.h
│ │ │ ├── sunos_sparc.h
│ │ │ ├── windows_api.h
│ │ │ ├── windows_ia32.h
│ │ │ ├── windows_intel64.h
│ │ │ └── xbox360_ppc.h
│ │ ├── mailbox.h
│ │ ├── market.cpp
│ │ ├── market.h
│ │ ├── memory_pool.h
│ │ ├── mutex.cpp
│ │ ├── mutex.h
│ │ ├── null_mutex.h
│ │ ├── null_rw_mutex.h
│ │ ├── observer_proxy.cpp
│ │ ├── observer_proxy.h
│ │ ├── parallel_do.h
│ │ ├── parallel_for.h
│ │ ├── parallel_for_each.h
│ │ ├── parallel_invoke.h
│ │ ├── parallel_reduce.h
│ │ ├── parallel_scan.h
│ │ ├── parallel_sort.h
│ │ ├── parallel_while.h
│ │ ├── partitioner.h
│ │ ├── pipeline.cpp
│ │ ├── pipeline.h
│ │ ├── private_server.cpp
│ │ ├── queuing_mutex.cpp
│ │ ├── queuing_mutex.h
│ │ ├── queuing_rw_mutex.cpp
│ │ ├── queuing_rw_mutex.h
│ │ ├── reader_writer_lock.cpp
│ │ ├── reader_writer_lock.h
│ │ ├── recursive_mutex.cpp
│ │ ├── recursive_mutex.h
│ │ ├── runtime_loader.h
│ │ ├── scalable_allocator.h
│ │ ├── scheduler.cpp
│ │ ├── scheduler.h
│ │ ├── scheduler_common.h
│ │ ├── scheduler_utility.h
│ │ ├── semaphore.cpp
│ │ ├── semaphore.h
│ │ ├── spin_mutex.cpp
│ │ ├── spin_mutex.h
│ │ ├── spin_rw_mutex.cpp
│ │ ├── spin_rw_mutex.h
│ │ ├── task.cpp
│ │ ├── task.h
│ │ ├── task_arena.h
│ │ ├── task_group.h
│ │ ├── task_group_context.cpp
│ │ ├── task_scheduler_init.h
│ │ ├── task_scheduler_observer.h
│ │ ├── task_stream.h
│ │ ├── tbb.h
│ │ ├── tbb_allocator.h
│ │ ├── tbb_assert_impl.h
│ │ ├── tbb_config.h
│ │ ├── tbb_exception.h
│ │ ├── tbb_machine.h
│ │ ├── tbb_main.cpp
│ │ ├── tbb_main.h
│ │ ├── tbb_misc.cpp
│ │ ├── tbb_misc.h
│ │ ├── tbb_misc_ex.cpp
│ │ ├── tbb_profiling.h
│ │ ├── tbb_resource.rc
│ │ ├── tbb_statistics.cpp
│ │ ├── tbb_statistics.h
│ │ ├── tbb_stddef.h
│ │ ├── tbb_thread.cpp
│ │ ├── tbb_thread.h
│ │ ├── tbb_version.h
│ │ ├── tbbmalloc_proxy.h
│ │ ├── tick_count.h
│ │ ├── tls.h
│ │ ├── tools_api/
│ │ │ ├── disable_warnings.h
│ │ │ ├── internal/
│ │ │ │ └── ittnotify.h
│ │ │ ├── ittnotify.h
│ │ │ ├── ittnotify_config.h
│ │ │ ├── ittnotify_static.c
│ │ │ ├── ittnotify_static.h
│ │ │ ├── ittnotify_types.h
│ │ │ ├── legacy/
│ │ │ │ └── ittnotify.h
│ │ │ └── prototype/
│ │ │ └── ittnotify.h
│ │ ├── version_string.ver
│ │ ├── win32-tbb-export.def
│ │ ├── win32-tbb-export.lst
│ │ ├── win64-gcc-tbb-export.def
│ │ ├── win64-gcc-tbb-export.lst
│ │ ├── win64-tbb-export.def
│ │ ├── win64-tbb-export.lst
│ │ ├── winrt-tbb-export.lst
│ │ ├── x86_rtm_rw_mutex.cpp
│ │ └── xbox360-tbb-export.def
│ ├── tbbqueue.h
│ └── wrappers.h
├── blockingconcurrentqueue.h
├── build/
│ ├── makefile
│ ├── makefile.inc
│ ├── msvc11/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc12/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc14/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc15/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ ├── msvc16/
│ │ ├── benchmarks.vcxproj
│ │ ├── benchmarks.vcxproj.filters
│ │ ├── concurrentqueue.sln
│ │ ├── fuzztests.vcxproj
│ │ ├── fuzztests.vcxproj.filters
│ │ ├── msvc_tbb_stubs.cpp
│ │ ├── unittests.vcxproj
│ │ └── unittests.vcxproj.filters
│ └── xcode/
│ ├── Info.plist
│ ├── concurrentqueue.xcodeproj/
│ │ ├── project.pbxproj
│ │ ├── project.xcworkspace/
│ │ │ └── contents.xcworkspacedata
│ │ └── xcshareddata/
│ │ └── xcschemes/
│ │ └── concurrentqueue-unittests-ios.xcscheme
│ └── main_ios.mm
├── c_api/
│ ├── blockingconcurrentqueue.cpp
│ ├── concurrentqueue.cpp
│ └── concurrentqueue.h
├── concurrentqueue.h
├── concurrentqueueConfig.cmake.in
├── internal/
│ └── concurrentqueue_internal_debug.h
├── lightweightsemaphore.h
├── samples.md
└── tests/
├── CDSChecker/
│ ├── README.txt
│ ├── corealgo.h
│ ├── enqueue_dequeue_many.cpp
│ ├── enqueue_dequeue_one.cpp
│ └── makefile
├── common/
│ ├── simplethread.cpp
│ ├── simplethread.h
│ ├── systemtime.cpp
│ └── systemtime.h
├── corealgos.h
├── fuzztests/
│ ├── fuzztests.cpp
│ └── makefile
├── relacy/
│ ├── freelist.cpp
│ ├── integrated.cpp
│ ├── makefile
│ ├── relacy/
│ │ ├── CHANGES
│ │ ├── LICENSE
│ │ ├── VERSION
│ │ ├── example/
│ │ │ ├── cli_ws_deque/
│ │ │ │ ├── cli_ws_deque.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── cli_ws_deque.sln
│ │ │ │ │ └── cli_ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── condvar/
│ │ │ │ ├── condvar.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── condvar.sln
│ │ │ │ │ └── condvar.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── condvar.sln
│ │ │ │ │ └── condvar.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── eao_blocking/
│ │ │ │ └── eao_blocking.cpp
│ │ │ ├── eventcount/
│ │ │ │ ├── eventcount.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── examples/
│ │ │ │ ├── amp_condvar.hpp
│ │ │ │ ├── examples.cpp
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── examples.sln
│ │ │ │ │ └── examples.vcproj
│ │ │ │ ├── spsc_overwrite_queue.hpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── java_ws_deque/
│ │ │ │ ├── java_ws_deque.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── java_ws_deque.sln
│ │ │ │ │ └── java_ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── mpmc/
│ │ │ │ ├── mpmc.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── mpmc.sln
│ │ │ │ │ └── mpmc.vcproj
│ │ │ │ ├── pcx.h
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── mutex_business_logic/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── mutex_business_logic.sln
│ │ │ │ │ └── mutex_business_logic.vcproj
│ │ │ │ ├── mutex_business_logic.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── peterson/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── peterson.sln
│ │ │ │ │ └── peterson.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── peterson.sln
│ │ │ │ │ └── peterson.vcproj
│ │ │ │ ├── peterson.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── proxy_collector/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── proxy_collector.sln
│ │ │ │ │ └── proxy_collector.vcproj
│ │ │ │ ├── proxy_collector.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── ref_counting/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── ref_counting.sln
│ │ │ │ │ └── ref_counting.vcproj
│ │ │ │ ├── ref_counting.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── smr/
│ │ │ │ ├── g++/
│ │ │ │ │ └── Makefile
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── smr.sln
│ │ │ │ │ └── smr.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── smr.sln
│ │ │ │ │ └── smr.vcproj
│ │ │ │ ├── smr.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── spsc_queue/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── spsc_queue.sln
│ │ │ │ │ └── spsc_queue.vcproj
│ │ │ │ ├── spsc_queue.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── stack/
│ │ │ │ ├── DESCRIPTION.TXT
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── stack.sln
│ │ │ │ │ └── stack.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── stack.sln
│ │ │ │ │ └── stack.vcproj
│ │ │ │ ├── stack.cpp
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── tbb_eventcount/
│ │ │ │ ├── eventcount.cpp
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── eventcount.sln
│ │ │ │ │ └── eventcount.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ └── stdafx.h
│ │ │ ├── ws_deque/
│ │ │ │ ├── msvc8/
│ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ ├── msvc9/
│ │ │ │ │ ├── ws_deque.sln
│ │ │ │ │ └── ws_deque.vcproj
│ │ │ │ ├── stdafx.cpp
│ │ │ │ ├── stdafx.h
│ │ │ │ └── ws_deque.cpp
│ │ │ └── ws_deque2/
│ │ │ ├── msvc8/
│ │ │ │ ├── ws_deque.sln
│ │ │ │ └── ws_deque.vcproj
│ │ │ ├── stdafx.cpp
│ │ │ ├── stdafx.h
│ │ │ └── ws_deque.cpp
│ │ ├── relacy/
│ │ │ ├── atomic.hpp
│ │ │ ├── atomic_events.hpp
│ │ │ ├── atomic_fence.hpp
│ │ │ ├── backoff.hpp
│ │ │ ├── base.hpp
│ │ │ ├── cli.hpp
│ │ │ ├── cli_interlocked.hpp
│ │ │ ├── cli_var.hpp
│ │ │ ├── cli_volatile.hpp
│ │ │ ├── context.hpp
│ │ │ ├── context_addr_hash.hpp
│ │ │ ├── context_base.hpp
│ │ │ ├── context_base_impl.hpp
│ │ │ ├── context_bound_scheduler.hpp
│ │ │ ├── defs.hpp
│ │ │ ├── dyn_thread.hpp
│ │ │ ├── dyn_thread_ctx.hpp
│ │ │ ├── foreach.hpp
│ │ │ ├── full_search_scheduler.hpp
│ │ │ ├── history.hpp
│ │ │ ├── java.hpp
│ │ │ ├── java_atomic.hpp
│ │ │ ├── java_var.hpp
│ │ │ ├── java_volatile.hpp
│ │ │ ├── memory.hpp
│ │ │ ├── memory_order.hpp
│ │ │ ├── pch.hpp
│ │ │ ├── platform.hpp
│ │ │ ├── pthread.h
│ │ │ ├── random.hpp
│ │ │ ├── random_scheduler.hpp
│ │ │ ├── relacy.hpp
│ │ │ ├── relacy_cli.hpp
│ │ │ ├── relacy_java.hpp
│ │ │ ├── relacy_std.hpp
│ │ │ ├── rmw.hpp
│ │ │ ├── scheduler.hpp
│ │ │ ├── signature.hpp
│ │ │ ├── slab_allocator.hpp
│ │ │ ├── stdlib/
│ │ │ │ ├── condition_variable.hpp
│ │ │ │ ├── event.hpp
│ │ │ │ ├── mutex.hpp
│ │ │ │ ├── pthread.hpp
│ │ │ │ ├── semaphore.hpp
│ │ │ │ └── windows.hpp
│ │ │ ├── sync_var.hpp
│ │ │ ├── test_params.hpp
│ │ │ ├── test_result.hpp
│ │ │ ├── test_suite.hpp
│ │ │ ├── thread.hpp
│ │ │ ├── thread_base.hpp
│ │ │ ├── thread_local.hpp
│ │ │ ├── thread_local_ctx.hpp
│ │ │ ├── var.hpp
│ │ │ ├── volatile.hpp
│ │ │ ├── waitset.hpp
│ │ │ └── windows.h
│ │ └── test/
│ │ ├── addr_hash.hpp
│ │ ├── advanced.txt
│ │ ├── compare_swap.hpp
│ │ ├── condvar.hpp
│ │ ├── data_race.hpp
│ │ ├── detection.txt
│ │ ├── dyn_thread.hpp
│ │ ├── event.hpp
│ │ ├── features.txt
│ │ ├── fence.hpp
│ │ ├── foo.cpp
│ │ ├── futex.hpp
│ │ ├── g++/
│ │ │ ├── build_all_cygwin_debug.bat
│ │ │ ├── build_all_debug.bat
│ │ │ ├── build_all_release.sh
│ │ │ ├── build_cygwin_release.cmd
│ │ │ ├── build_debug.cmd
│ │ │ ├── build_release.cmd
│ │ │ └── test.cpp
│ │ ├── iriw.cpp
│ │ ├── jtest/
│ │ │ ├── jtest.cpp
│ │ │ ├── msvc8/
│ │ │ │ ├── jtest.sln
│ │ │ │ └── jtest.vcproj
│ │ │ ├── msvc9/
│ │ │ │ ├── jtest.sln
│ │ │ │ └── jtest.vcproj
│ │ │ ├── stdafx.cpp
│ │ │ └── stdafx.h
│ │ ├── main.cpp
│ │ ├── memory.hpp
│ │ ├── memory_order.hpp
│ │ ├── msvc71/
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── msvc8/
│ │ │ ├── rrd.sln
│ │ │ ├── rrd.vcproj
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── msvc9/
│ │ │ ├── rrd.sln
│ │ │ ├── rrd.vcproj
│ │ │ ├── test.sln
│ │ │ └── test.vcproj
│ │ ├── mutex.hpp
│ │ ├── ntest/
│ │ │ ├── msvc8/
│ │ │ │ ├── ntest.sln
│ │ │ │ └── ntest.vcproj
│ │ │ ├── msvc9/
│ │ │ │ ├── ntest.sln
│ │ │ │ └── ntest.vcproj
│ │ │ ├── ntest.cpp
│ │ │ ├── stdafx.cpp
│ │ │ └── stdafx.h
│ │ ├── pthread.hpp
│ │ ├── scheduler.hpp
│ │ ├── semaphore.hpp
│ │ ├── stdafx.cpp
│ │ ├── stdafx.h
│ │ ├── thread_local.hpp
│ │ ├── todo.txt
│ │ ├── trash/
│ │ │ ├── original.hpp
│ │ │ └── rtl.hpp
│ │ ├── tutorial.txt
│ │ ├── wfmo.hpp
│ │ └── windows.hpp
│ ├── relacy_shims.h
│ └── spmchash.cpp
└── unittests/
├── makefile
├── mallocmacro.cpp
├── minitest.h
└── unittests.cpp
Showing preview only (3,392K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (17099 symbols across 1187 files)
FILE: benchmarks/benchmarks.cpp
type benchmark_type_t (line 50) | enum benchmark_type_t
type queue_id_t (line 193) | enum queue_id_t
type Traits (line 262) | struct Traits : public moodycamel::ConcurrentQueueDefaultTraits
type BenchmarkResult (line 279) | struct BenchmarkResult
function counter_t (line 292) | counter_t rampUpToMeasurableNumberOfMaxOps(TFunc const& func, counter_t ...
function counter_t (line 307) | counter_t adjustForThreads(counter_t suggestedOps, int nthreads)
function counter_t (line 314) | counter_t determineMaxOpsForBenchmark(benchmark_type_t benchmark, int nt...
function runBenchmark (line 445) | double runBenchmark(benchmark_type_t benchmark, int nthreads, bool useTo...
function sayf (line 1665) | void sayf(int indent, const char* fmt, ...)
function isvowel (line 1702) | static inline bool isvowel(char ch)
function safe_divide (line 1713) | static inline double safe_divide(double a, double b)
function printBenchmarkNames (line 1768) | void printBenchmarkNames()
function main (line 1778) | int main(int argc, char** argv)
FILE: benchmarks/boost/array.hpp
type boost (line 57) | namespace boost {
class array (line 60) | class array {
method iterator (line 75) | iterator begin() { return elems; }
method const_iterator (line 76) | const_iterator begin() const { return elems; }
method const_iterator (line 77) | const_iterator cbegin() const { return elems; }
method iterator (line 79) | iterator end() { return elems+N; }
method const_iterator (line 80) | const_iterator end() const { return elems+N; }
method const_iterator (line 81) | const_iterator cend() const { return elems+N; }
method reverse_iterator (line 104) | reverse_iterator rbegin() { return reverse_iterator(end()); }
method const_reverse_iterator (line 105) | const_reverse_iterator rbegin() const {
method const_reverse_iterator (line 108) | const_reverse_iterator crbegin() const {
method reverse_iterator (line 112) | reverse_iterator rend() { return reverse_iterator(begin()); }
method const_reverse_iterator (line 113) | const_reverse_iterator rend() const {
method const_reverse_iterator (line 116) | const_reverse_iterator crend() const {
method reference (line 121) | reference operator[](size_type i)
method const_reference (line 127) | const_reference operator[](size_type i) const
method reference (line 134) | reference at(size_type i) { rangecheck(i); return elems[i]; }
method const_reference (line 135) | const_reference at(size_type i) const { rangecheck(i); return elems[...
method reference (line 138) | reference front()
method const_reference (line 143) | const_reference front() const
method reference (line 148) | reference back()
method const_reference (line 153) | const_reference back() const
method size_type (line 159) | static size_type size() { return N; }
method empty (line 160) | static bool empty() { return false; }
method size_type (line 161) | static size_type max_size() { return N; }
method swap (line 165) | void swap (array<T,N>& y) {
method T (line 171) | const T* data() const { return elems; }
method T (line 172) | T* data() { return elems; }
method T (line 175) | T* c_array() { return elems; }
method assign (line 185) | void assign (const T& value) { fill ( value ); }
method fill (line 186) | void fill (const T& value)
method rangecheck (line 192) | static void rangecheck (size_type i) {
class array< T, 0 > (line 203) | class array< T, 0 > {
method iterator (line 216) | iterator begin() { return iterator( reinterpret_c...
method const_iterator (line 217) | const_iterator begin() const { return const_iterator( reinterpret_c...
method const_iterator (line 218) | const_iterator cbegin() const { return const_iterator( reinterpret_c...
method iterator (line 220) | iterator end() { return begin(); }
method const_iterator (line 221) | const_iterator end() const { return begin(); }
method const_iterator (line 222) | const_iterator cend() const { return cbegin(); }
method reverse_iterator (line 245) | reverse_iterator rbegin() { return reverse_iterator(end()); }
method const_reverse_iterator (line 246) | const_reverse_iterator rbegin() const {
method const_reverse_iterator (line 249) | const_reverse_iterator crbegin() const {
method reverse_iterator (line 253) | reverse_iterator rend() { return reverse_iterator(begin()); }
method const_reverse_iterator (line 254) | const_reverse_iterator rend() const {
method const_reverse_iterator (line 257) | const_reverse_iterator crend() const {
method reference (line 262) | reference operator[](size_type /*i*/)
method const_reference (line 267) | const_reference operator[](size_type /*i*/) const
method reference (line 273) | reference at(size_type /*i*/) { return failed_rangec...
method const_reference (line 274) | const_reference at(size_type /*i*/) const { return failed_rangec...
method reference (line 277) | reference front()
method const_reference (line 282) | const_reference front() const
method reference (line 287) | reference back()
method const_reference (line 292) | const_reference back() const
method size_type (line 298) | static size_type size() { return 0; }
method empty (line 299) | static bool empty() { return true; }
method size_type (line 300) | static size_type max_size() { return 0; }
method swap (line 303) | void swap (array<T,0>& /*y*/) {
method T (line 307) | const T* data() const { return 0; }
method T (line 308) | T* data() { return 0; }
method T (line 311) | T* c_array() { return 0; }
method assign (line 320) | void assign (const T& value) { fill ( value ); }
method fill (line 321) | void fill (const T& ) {}
method reference (line 324) | static reference failed_rangecheck () {
function swap (line 368) | inline void swap (array<T,N>& x, array<T,N>& y) {
type detail (line 378) | namespace detail {
type c_array (line 379) | struct c_array
function T (line 401) | T(&get_c_array(boost::array<T,N>& arg))[N]
function T (line 408) | const T(&get_c_array(const boost::array<T,N>& arg))[N]
function T (line 419) | T(&get_c_array(std::array<T,N>& arg))[N]
function T (line 426) | const T(&get_c_array(const std::array<T,N>& arg))[N]
function hash_value (line 434) | std::size_t hash_value(const array<T,N>& arr)
FILE: benchmarks/boost/assert.hpp
type boost (line 47) | namespace boost
FILE: benchmarks/boost/atomic/atomic.hpp
type boost (line 29) | namespace boost {
FILE: benchmarks/boost/atomic/atomic_flag.hpp
type boost (line 27) | namespace boost {
FILE: benchmarks/boost/atomic/detail/atomic_flag.hpp
type boost (line 31) | namespace boost {
type atomics (line 32) | namespace atomics {
type atomic_flag (line 40) | struct atomic_flag
method atomic_flag (line 47) | atomic_flag() BOOST_NOEXCEPT : m_storage(0)
method BOOST_FORCEINLINE (line 51) | BOOST_FORCEINLINE bool test_and_set(memory_order order = memory_or...
method BOOST_FORCEINLINE (line 56) | BOOST_FORCEINLINE void clear(memory_order order = memory_order_seq...
FILE: benchmarks/boost/atomic/detail/atomic_template.hpp
function BOOST_FORCEINLINE (line 47) | BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memo...
function BOOST_FORCEINLINE (line 52) | BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_str...
type classify (line 60) | struct classify
type classify< T, true > (line 66) | struct classify< T, true > { typedef int type; }
type classify< T*, false > (line 69) | struct classify< T*, false > { typedef void* type; }
class base_atomic (line 72) | class base_atomic
function BOOST_DEFAULTED_FUNCTION (line 93) | BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
function BOOST_FORCEINLINE (line 96) | BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_o...
function BOOST_FORCEINLINE (line 105) | BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_...
function BOOST_FORCEINLINE (line 113) | BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order o...
function BOOST_FORCEINLINE (line 118) | BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order o...
function BOOST_FORCEINLINE (line 123) | BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order =...
function BOOST_FORCEINLINE (line 128) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, val...
function BOOST_FORCEINLINE (line 140) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, val...
function BOOST_FORCEINLINE (line 145) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value...
function BOOST_FORCEINLINE (line 157) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value...
function BOOST_FORCEINLINE (line 162) | BOOST_FORCEINLINE value_type fetch_and(value_type v, memory_order order ...
function BOOST_FORCEINLINE (line 167) | BOOST_FORCEINLINE value_type fetch_or(value_type v, memory_order order =...
function BOOST_FORCEINLINE (line 172) | BOOST_FORCEINLINE value_type fetch_xor(value_type v, memory_order order ...
function BOOST_FORCEINLINE (line 177) | BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 182) | BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 187) | BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 192) | BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 197) | BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 202) | BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOS...
function BOOST_FORCEINLINE (line 207) | BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOS...
function BOOST_FORCEINLINE (line 212) | BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOE...
function BOOST_FORCEINLINE (line 217) | BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOE...
function BOOST_FORCEINLINE (line 222) | BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOE...
function BOOST_DEFAULTED_FUNCTION (line 249) | BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
function BOOST_FORCEINLINE (line 252) | BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_o...
function BOOST_FORCEINLINE (line 261) | BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_...
function BOOST_FORCEINLINE (line 269) | BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order =...
function BOOST_FORCEINLINE (line 274) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, val...
function BOOST_FORCEINLINE (line 286) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, val...
function BOOST_FORCEINLINE (line 291) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value...
function BOOST_FORCEINLINE (line 303) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value...
function BOOST_FORCEINLINE (line 308) | BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
class base_atomic< T, void > (line 320) | class base_atomic< T, void >
method BOOST_FORCEINLINE (line 336) | BOOST_FORCEINLINE explicit base_atomic(value_type const& v = value_typ...
method BOOST_FORCEINLINE (line 340) | BOOST_FORCEINLINE void store(value_type v, memory_order order = memory...
method BOOST_FORCEINLINE (line 349) | BOOST_FORCEINLINE value_type load(memory_order order = memory_order_se...
method BOOST_FORCEINLINE (line 357) | BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order...
method BOOST_FORCEINLINE (line 362) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, v...
method BOOST_FORCEINLINE (line 374) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, v...
method BOOST_FORCEINLINE (line 379) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, val...
method BOOST_FORCEINLINE (line 391) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, val...
method BOOST_FORCEINLINE (line 396) | BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
class base_atomic< T*, void* > (line 408) | class base_atomic< T*, void* >
method BOOST_DEFAULTED_FUNCTION (line 425) | BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
method BOOST_FORCEINLINE (line 430) | BOOST_FORCEINLINE void store(value_type v, memory_order order = memo...
method BOOST_FORCEINLINE (line 439) | BOOST_FORCEINLINE value_type load(memory_order order = memory_order_...
method BOOST_FORCEINLINE (line 447) | BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_ord...
method BOOST_FORCEINLINE (line 452) | BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_ord...
method BOOST_FORCEINLINE (line 457) | BOOST_FORCEINLINE value_type exchange(value_type v, memory_order ord...
method BOOST_FORCEINLINE (line 462) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected,...
method BOOST_FORCEINLINE (line 474) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected,...
method BOOST_FORCEINLINE (line 479) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, v...
method BOOST_FORCEINLINE (line 491) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, v...
method BOOST_FORCEINLINE (line 496) | BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 501) | BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 506) | BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 511) | BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 516) | BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 521) | BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile ...
method BOOST_FORCEINLINE (line 526) | BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile ...
class base_atomic< void*, void* > (line 538) | class base_atomic< void*, void* >
method BOOST_DEFAULTED_FUNCTION (line 555) | BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
method BOOST_FORCEINLINE (line 560) | BOOST_FORCEINLINE void store(value_type v, memory_order order = me...
method BOOST_FORCEINLINE (line 569) | BOOST_FORCEINLINE value_type load(memory_order order = memory_orde...
method BOOST_FORCEINLINE (line 577) | BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_o...
method BOOST_FORCEINLINE (line 582) | BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_o...
method BOOST_FORCEINLINE (line 587) | BOOST_FORCEINLINE value_type exchange(value_type v, memory_order o...
method BOOST_FORCEINLINE (line 592) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expecte...
method BOOST_FORCEINLINE (line 604) | BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expecte...
method BOOST_FORCEINLINE (line 609) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected,...
method BOOST_FORCEINLINE (line 621) | BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected,...
method BOOST_FORCEINLINE (line 626) | BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 631) | BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 636) | BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 641) | BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 646) | BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 651) | BOOST_FORCEINLINE value_type operator+=(difference_type v) volatil...
method BOOST_FORCEINLINE (line 656) | BOOST_FORCEINLINE value_type operator-=(difference_type v) volatil...
method BOOST_DEFAULTED_FUNCTION (line 680) | BOOST_DEFAULTED_FUNCTION(atomic(), BOOST_NOEXCEPT {}
method BOOST_CONSTEXPR (line 686) | BOOST_CONSTEXPR atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(...
method BOOST_FORCEINLINE (line 688) | BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile B...
method BOOST_FORCEINLINE (line 694) | BOOST_FORCEINLINE operator value_type() volatile const BOOST_NOEXCEPT
FILE: benchmarks/boost/atomic/detail/bitwise_cast.hpp
type boost (line 28) | namespace boost {
type atomics (line 29) | namespace atomics {
type detail (line 30) | namespace detail {
function BOOST_FORCEINLINE (line 33) | BOOST_FORCEINLINE To bitwise_cast(From const& from) BOOST_NOEXCEPT
FILE: benchmarks/boost/atomic/detail/interlocked.hpp
type boost (line 430) | namespace boost {
type atomics (line 431) | namespace atomics {
type detail (line 432) | namespace detail {
FILE: benchmarks/boost/atomic/detail/lockpool.hpp
type atomics (line 26) | namespace atomics {
type detail (line 27) | namespace detail {
type lockpool (line 29) | struct lockpool
class scoped_lock (line 31) | class scoped_lock
FILE: benchmarks/boost/atomic/detail/operations_fwd.hpp
type boost (line 24) | namespace boost {
type atomics (line 25) | namespace atomics {
type detail (line 26) | namespace detail {
type operations (line 29) | struct operations
FILE: benchmarks/boost/atomic/detail/ops_cas_based.hpp
type boost (line 25) | namespace boost {
type atomics (line 26) | namespace atomics {
type detail (line 27) | namespace detail {
type cas_based_exchange (line 30) | struct cas_based_exchange :
method exchange (line 35) | exchange(storage_type volatile& storage, storage_type v, memory_...
type cas_based_operations (line 45) | struct cas_based_operations :
method fetch_add (line 50) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 58) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 66) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 74) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 82) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 90) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 95) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
FILE: benchmarks/boost/atomic/detail/ops_emulated.hpp
type boost (line 29) | namespace boost {
type atomics (line 30) | namespace atomics {
type detail (line 31) | namespace detail {
type emulated_operations (line 34) | struct emulated_operations
method BOOST_FORCEINLINE (line 38) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 44) | load(storage_type const volatile& storage, memory_order) BOOST_N...
method fetch_add (line 50) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 59) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method exchange (line 68) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 77) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 91) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method fetch_and (line 107) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 116) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 125) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 134) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 139) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 144) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations (line 151) | struct operations :
FILE: benchmarks/boost/atomic/detail/ops_extending_cas_based.hpp
type boost (line 26) | namespace boost {
type atomics (line 27) | namespace atomics {
type detail (line 28) | namespace detail {
type extending_cas_based_operations (line 31) | struct extending_cas_based_operations :
method fetch_add (line 37) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 50) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
FILE: benchmarks/boost/atomic/detail/ops_gcc_alpha.hpp
type boost (line 29) | namespace boost {
type atomics (line 30) | namespace atomics {
type detail (line 31) | namespace detail {
type gcc_alpha_operations_base (line 64) | struct gcc_alpha_operations_base
method BOOST_FORCEINLINE (line 66) | static BOOST_FORCEINLINE void fence_before(memory_order order) B...
method BOOST_FORCEINLINE (line 72) | static BOOST_FORCEINLINE void fence_after(memory_order order) BO...
method BOOST_FORCEINLINE (line 78) | static BOOST_FORCEINLINE void fence_after_store(memory_order ord...
type operations< 4u, Signed > (line 87) | struct operations< 4u, Signed > :
method BOOST_FORCEINLINE (line 93) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 100) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 107) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 133) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 163) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 201) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 227) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 253) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 279) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 305) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 331) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 336) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 341) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, false > (line 349) | struct operations< 1u, false > :
method fetch_add (line 355) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 382) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 1u, true > (line 411) | struct operations< 1u, true > :
method fetch_add (line 417) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 444) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, false > (line 474) | struct operations< 2u, false > :
method fetch_add (line 480) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 507) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, true > (line 536) | struct operations< 2u, true > :
method fetch_add (line 542) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 569) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 599) | struct operations< 8u, Signed > :
method BOOST_FORCEINLINE (line 605) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 612) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 619) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 645) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 675) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 713) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 739) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 765) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 791) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 817) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 843) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 848) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 853) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
function BOOST_FORCEINLINE (line 860) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 866) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_arm.hpp
type boost (line 31) | namespace boost {
type atomics (line 32) | namespace atomics {
type detail (line 33) | namespace detail {
type gcc_arm_operations_base (line 101) | struct gcc_arm_operations_base
method BOOST_FORCEINLINE (line 103) | static BOOST_FORCEINLINE void fence_before(memory_order order) B...
method BOOST_FORCEINLINE (line 109) | static BOOST_FORCEINLINE void fence_after(memory_order order) BO...
method BOOST_FORCEINLINE (line 115) | static BOOST_FORCEINLINE void fence_after_store(memory_order ord...
method BOOST_FORCEINLINE (line 121) | static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
type operations< 4u, Signed > (line 155) | struct operations< 4u, Signed > :
method BOOST_FORCEINLINE (line 161) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 168) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 175) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 197) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 230) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 266) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 292) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 318) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 344) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 370) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 396) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 401) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 406) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, false > (line 414) | struct operations< 1u, false > :
method fetch_add (line 420) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 447) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 1u, true > (line 476) | struct operations< 1u, true > :
method fetch_add (line 482) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 509) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, false > (line 539) | struct operations< 2u, false > :
method fetch_add (line 545) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 572) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, true > (line 601) | struct operations< 2u, true > :
method fetch_add (line 607) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 634) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 677) | struct operations< 8u, Signed > :
method BOOST_FORCEINLINE (line 683) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 688) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 705) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 729) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 764) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 803) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 830) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 857) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 884) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 911) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 938) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 943) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 948) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
function BOOST_FORCEINLINE (line 957) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 963) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_atomic.hpp
type boost (line 48) | namespace boost {
type atomics (line 49) | namespace atomics {
type detail (line 50) | namespace detail {
function BOOST_FORCEINLINE (line 76) | BOOST_FORCEINLINE BOOST_CONSTEXPR int convert_memory_order_to_gcc(...
type gcc_atomic_operations (line 84) | struct gcc_atomic_operations
method BOOST_FORCEINLINE (line 88) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 93) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_add (line 98) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 103) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method exchange (line 108) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 113) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 124) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method fetch_and (line 135) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 140) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 145) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 150) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 155) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 160) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 16u, Signed > (line 172) | struct operations< 16u, Signed > :
type operations< 16u, Signed > (line 180) | struct operations< 16u, Signed > :
type operations< 8u, Signed > (line 195) | struct operations< 8u, Signed > :
type operations< 8u, Signed > (line 209) | struct operations< 8u, Signed > :
type operations< 8u, Signed > (line 218) | struct operations< 8u, Signed > :
type operations< 4u, Signed > (line 239) | struct operations< 4u, Signed > :
type operations< 4u, Signed > (line 248) | struct operations< 4u, Signed > :
type operations< 4u, Signed > (line 259) | struct operations< 4u, Signed > :
type operations< 2u, Signed > (line 280) | struct operations< 2u, Signed > :
type operations< 2u, Signed > (line 289) | struct operations< 2u, Signed > :
type operations< 2u, Signed > (line 298) | struct operations< 2u, Signed > :
type operations< 2u, Signed > (line 309) | struct operations< 2u, Signed > :
type operations< 1u, Signed > (line 330) | struct operations< 1u, Signed > :
type operations< 1u, Signed > (line 339) | struct operations< 1u, Signed > :
type operations< 1u, Signed > (line 348) | struct operations< 1u, Signed > :
type operations< 1u, Signed > (line 357) | struct operations< 1u, Signed > :
type operations< 1u, Signed > (line 368) | struct operations< 1u, Signed > :
function BOOST_FORCEINLINE (line 381) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 386) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_ppc.hpp
type boost (line 29) | namespace boost {
type atomics (line 30) | namespace atomics {
type detail (line 31) | namespace detail {
type gcc_ppc_operations_base (line 86) | struct gcc_ppc_operations_base
method BOOST_FORCEINLINE (line 88) | static BOOST_FORCEINLINE void fence_before(memory_order order) B...
method BOOST_FORCEINLINE (line 101) | static BOOST_FORCEINLINE void fence_after(memory_order order) BO...
type operations< 4u, Signed > (line 110) | struct operations< 4u, Signed > :
method BOOST_FORCEINLINE (line 116) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 127) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 158) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 176) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 202) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 228) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 247) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 266) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 285) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 304) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 323) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 328) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 333) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, false > (line 341) | struct operations< 1u, false > :
method fetch_add (line 347) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 367) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 1u, true > (line 389) | struct operations< 1u, true > :
method fetch_add (line 395) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 415) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, false > (line 438) | struct operations< 2u, false > :
method fetch_add (line 444) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 464) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, true > (line 486) | struct operations< 2u, true > :
method fetch_add (line 492) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 512) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 537) | struct operations< 8u, Signed > :
method BOOST_FORCEINLINE (line 543) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 554) | load(storage_type const volatile& storage, memory_order order) B...
method exchange (line 585) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 603) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 629) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_add (line 655) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method fetch_sub (line 674) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method fetch_and (line 693) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 712) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 731) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 750) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 755) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 760) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
function BOOST_FORCEINLINE (line 769) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 788) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_sparc.hpp
type boost (line 31) | namespace boost {
type atomics (line 32) | namespace atomics {
type detail (line 33) | namespace detail {
type gcc_sparc_cas_base (line 35) | struct gcc_sparc_cas_base
method BOOST_FORCEINLINE (line 37) | static BOOST_FORCEINLINE void fence_before(memory_order order) B...
method BOOST_FORCEINLINE (line 45) | static BOOST_FORCEINLINE void fence_after(memory_order order) BO...
method BOOST_FORCEINLINE (line 53) | static BOOST_FORCEINLINE void fence_after_store(memory_order ord...
type gcc_sparc_cas32 (line 61) | struct gcc_sparc_cas32 :
method BOOST_FORCEINLINE (line 67) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 74) | load(storage_type const volatile& storage, memory_order order) B...
method BOOST_FORCEINLINE (line 81) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 102) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method exchange (line 108) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 122) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 4u, Signed > (line 129) | struct operations< 4u, Signed > :
type operations< 1u, Signed > (line 135) | struct operations< 1u, Signed > :
type operations< 2u, Signed > (line 141) | struct operations< 2u, Signed > :
type gcc_sparc_cas64 (line 147) | struct gcc_sparc_cas64 :
method BOOST_FORCEINLINE (line 153) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 160) | load(storage_type const volatile& storage, memory_order order) B...
method BOOST_FORCEINLINE (line 167) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 188) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 194) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 8u, Signed > (line 201) | struct operations< 8u, Signed > :
function BOOST_FORCEINLINE (line 207) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 230) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_sync.hpp
type gcc_sync_operations_base (line 34) | struct gcc_sync_operations_base
method BOOST_FORCEINLINE (line 36) | static BOOST_FORCEINLINE void fence_before_store(memory_order order) B...
method BOOST_FORCEINLINE (line 42) | static BOOST_FORCEINLINE void fence_after_store(memory_order order) BO...
method BOOST_FORCEINLINE (line 48) | static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOO...
type gcc_sync_operations (line 56) | struct gcc_sync_operations :
method BOOST_FORCEINLINE (line 61) | static BOOST_FORCEINLINE void store(storage_type volatile& storage, st...
method load (line 68) | load(storage_type const volatile& storage, memory_order order) BOOST_N...
method fetch_add (line 75) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method fetch_sub (line 80) | fetch_sub(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 85) | exchange(storage_type volatile& storage, storage_type v, memory_order ...
method BOOST_FORCEINLINE (line 95) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 112) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method fetch_and (line 118) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 123) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_xor (line 128) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
method BOOST_FORCEINLINE (line 133) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& stor...
method BOOST_FORCEINLINE (line 140) | static BOOST_FORCEINLINE void clear(storage_type volatile& storage, me...
method BOOST_FORCEINLINE (line 147) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile...
function public (line 165) | public extending_cas_based_operations< gcc_sync_operations< typename mak...
function public (line 192) | public extending_cas_based_operations< gcc_sync_operations< typename mak...
function public (line 215) | public extending_cas_based_operations< gcc_sync_operations< typename mak...
function public (line 234) | public extending_cas_based_operations< gcc_sync_operations< typename mak...
type operations< 16u, Signed > (line 247) | struct operations< 16u, Signed > :
function BOOST_FORCEINLINE (line 254) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 260) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
FILE: benchmarks/boost/atomic/detail/ops_gcc_x86.hpp
type boost (line 39) | namespace boost {
type atomics (line 40) | namespace atomics {
type detail (line 41) | namespace detail {
type gcc_x86_operations_base (line 43) | struct gcc_x86_operations_base
method BOOST_FORCEINLINE (line 45) | static BOOST_FORCEINLINE void fence_before(memory_order order) B...
method BOOST_FORCEINLINE (line 51) | static BOOST_FORCEINLINE void fence_after(memory_order order) BO...
type gcc_x86_operations (line 59) | struct gcc_x86_operations :
method BOOST_FORCEINLINE (line 64) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 78) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_sub (line 85) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 90) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 96) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 101) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 106) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, Signed > (line 113) | struct operations< 1u, Signed > :
method fetch_add (line 120) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 132) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 144) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 175) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 182) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 189) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, Signed > (line 200) | struct operations< 2u, Signed > :
method fetch_add (line 207) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 219) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 231) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 262) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 269) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 276) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 4u, Signed > (line 287) | struct operations< 4u, Signed > :
method fetch_add (line 294) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 306) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 318) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 349) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 356) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 363) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 376) | struct operations< 8u, Signed > :
method fetch_add (line 391) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 403) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 415) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 446) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 453) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 460) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 384) | struct operations< 8u, Signed > :
method fetch_add (line 391) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 403) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 415) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 446) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 453) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 460) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 16u, Signed > (line 475) | struct operations< 16u, Signed > :
function BOOST_FORCEINLINE (line 482) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 502) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_gcc_x86_dcas.hpp
function BOOST_FORCEINLINE (line 41) | static BOOST_FORCEINLINE void store(storage_type volatile& storage, stor...
function load (line 145) | load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 257) | static BOOST_FORCEINLINE bool compare_exchange_weak(
function BOOST_FORCEINLINE (line 263) | static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& st...
function BOOST_FORCEINLINE (line 354) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&)...
type gcc_dcas_x86_64 (line 365) | struct gcc_dcas_x86_64
method BOOST_FORCEINLINE (line 370) | static BOOST_FORCEINLINE void store(storage_type volatile& storage, st...
method load (line 400) | load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 458) | static BOOST_FORCEINLINE bool compare_exchange_strong(
FILE: benchmarks/boost/atomic/detail/ops_linux_arm.hpp
type boost (line 33) | namespace boost {
type atomics (line 34) | namespace atomics {
type detail (line 35) | namespace detail {
type linux_arm_cas_base (line 58) | struct linux_arm_cas_base
method BOOST_FORCEINLINE (line 60) | static BOOST_FORCEINLINE void fence_before_store(memory_order or...
method BOOST_FORCEINLINE (line 66) | static BOOST_FORCEINLINE void fence_after_store(memory_order ord...
method BOOST_FORCEINLINE (line 72) | static BOOST_FORCEINLINE void fence_after_load(memory_order orde...
method BOOST_FORCEINLINE (line 78) | static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
type linux_arm_cas (line 86) | struct linux_arm_cas :
method BOOST_FORCEINLINE (line 92) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 99) | load(storage_type const volatile& storage, memory_order order) B...
method BOOST_FORCEINLINE (line 106) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method BOOST_FORCEINLINE (line 122) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 138) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, Signed > (line 145) | struct operations< 1u, Signed > :
type operations< 2u, Signed > (line 151) | struct operations< 2u, Signed > :
type operations< 4u, Signed > (line 157) | struct operations< 4u, Signed > :
function BOOST_FORCEINLINE (line 162) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 168) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_msvc_arm.hpp
type boost (line 42) | namespace boost {
type atomics (line 43) | namespace atomics {
type detail (line 44) | namespace detail {
type msvc_arm_operations_base (line 54) | struct msvc_arm_operations_base
method BOOST_FORCEINLINE (line 56) | static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 61) | static BOOST_FORCEINLINE void fence_before_store(memory_order or...
method BOOST_FORCEINLINE (line 71) | static BOOST_FORCEINLINE void fence_after_store(memory_order ord...
method BOOST_FORCEINLINE (line 81) | static BOOST_FORCEINLINE void fence_after_load(memory_order orde...
method memory_order (line 91) | memory_order cas_common_order(memory_order success_order, memory...
type msvc_arm_operations (line 99) | struct msvc_arm_operations :
method fetch_sub (line 104) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 110) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 116) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 121) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 126) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 1u, Signed > (line 133) | struct operations< 1u, Signed > :
method BOOST_FORCEINLINE (line 140) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 147) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_add (line 154) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 177) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 200) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 228) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 251) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 274) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 2u, Signed > (line 299) | struct operations< 2u, Signed > :
method BOOST_FORCEINLINE (line 306) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 313) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_add (line 320) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 343) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 366) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 394) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 417) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 440) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 4u, Signed > (line 465) | struct operations< 4u, Signed > :
method BOOST_FORCEINLINE (line 472) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 479) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_add (line 486) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 509) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 532) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 560) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 583) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 606) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 8u, Signed > (line 631) | struct operations< 8u, Signed > :
method BOOST_FORCEINLINE (line 638) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 645) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_add (line 652) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 675) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 698) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 726) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 749) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 772) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
function BOOST_FORCEINLINE (line 797) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 805) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/ops_msvc_x86.hpp
type msvc_x86_operations_base (line 73) | struct msvc_x86_operations_base
method BOOST_FORCEINLINE (line 75) | static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 86) | static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 91) | static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 96) | static BOOST_FORCEINLINE void fence_after_load(memory_order) BOOST_NOE...
type msvc_x86_operations (line 109) | struct msvc_x86_operations :
method BOOST_FORCEINLINE (line 114) | static BOOST_FORCEINLINE void store(storage_type volatile& storage, st...
method load (line 128) | load(storage_type const volatile& storage, memory_order order) BOOST_N...
method fetch_sub (line 135) | fetch_sub(storage_type volatile& storage, storage_type v, memory_order...
method BOOST_FORCEINLINE (line 141) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 147) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& stor...
method BOOST_FORCEINLINE (line 152) | static BOOST_FORCEINLINE void clear(storage_type volatile& storage, me...
method BOOST_FORCEINLINE (line 157) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile...
type operations< 4u, Signed > (line 164) | struct operations< 4u, Signed > :
method fetch_add (line 171) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 176) | exchange(storage_type volatile& storage, storage_type v, memory_order)...
method BOOST_FORCEINLINE (line 181) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 191) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_and (line 196) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 205) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_or (line 210) | fetch_or(storage_type volatile& storage, storage_type v, memory_order ...
method fetch_xor (line 219) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
method fetch_xor (line 224) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
type operations< 1u, Signed > (line 236) | struct operations< 1u, Signed > :
method fetch_add (line 243) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 248) | exchange(storage_type volatile& storage, storage_type v, memory_order)...
method BOOST_FORCEINLINE (line 253) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 262) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 267) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_xor (line 272) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
function BOOST_FORCEINLINE (line 384) | static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& s...
type operations< 1u, Signed > (line 412) | struct operations< 1u, Signed > :
method fetch_add (line 243) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 248) | exchange(storage_type volatile& storage, storage_type v, memory_order)...
method BOOST_FORCEINLINE (line 253) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 262) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 267) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_xor (line 272) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
type operations< 2u, Signed > (line 422) | struct operations< 2u, Signed > :
method fetch_add (line 429) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 434) | exchange(storage_type volatile& storage, storage_type v, memory_order)...
method BOOST_FORCEINLINE (line 439) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 448) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 453) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_xor (line 458) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
function BOOST_FORCEINLINE (line 570) | static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& s...
type operations< 2u, Signed > (line 598) | struct operations< 2u, Signed > :
method fetch_add (line 429) | fetch_add(storage_type volatile& storage, storage_type v, memory_order...
method exchange (line 434) | exchange(storage_type volatile& storage, storage_type v, memory_order)...
method BOOST_FORCEINLINE (line 439) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 448) | fetch_and(storage_type volatile& storage, storage_type v, memory_order...
method fetch_or (line 453) | fetch_or(storage_type volatile& storage, storage_type v, memory_order)...
method fetch_xor (line 458) | fetch_xor(storage_type volatile& storage, storage_type v, memory_order...
function BOOST_FORCEINLINE (line 730) | static BOOST_FORCEINLINE bool compare_exchange_strong(
FILE: benchmarks/boost/atomic/detail/ops_windows.hpp
type boost (line 40) | namespace boost {
type atomics (line 41) | namespace atomics {
type detail (line 42) | namespace detail {
type windows_operations_base (line 44) | struct windows_operations_base
method BOOST_FORCEINLINE (line 46) | static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 52) | static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_N...
method BOOST_FORCEINLINE (line 57) | static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NO...
type windows_operations (line 64) | struct windows_operations :
method BOOST_FORCEINLINE (line 69) | static BOOST_FORCEINLINE void store(storage_type volatile& stora...
method load (line 74) | load(storage_type const volatile& storage, memory_order order) B...
method fetch_sub (line 79) | fetch_sub(storage_type volatile& storage, storage_type v, memory...
method BOOST_FORCEINLINE (line 85) | static BOOST_FORCEINLINE bool compare_exchange_weak(
method BOOST_FORCEINLINE (line 91) | static BOOST_FORCEINLINE bool test_and_set(storage_type volatile...
method BOOST_FORCEINLINE (line 96) | static BOOST_FORCEINLINE void clear(storage_type volatile& stora...
method BOOST_FORCEINLINE (line 101) | static BOOST_FORCEINLINE bool is_lock_free(storage_type const vo...
type operations< 4u, Signed > (line 108) | struct operations< 4u, Signed > :
method fetch_add (line 115) | fetch_add(storage_type volatile& storage, storage_type v, memory...
method exchange (line 123) | exchange(storage_type volatile& storage, storage_type v, memory_...
method BOOST_FORCEINLINE (line 131) | static BOOST_FORCEINLINE bool compare_exchange_strong(
method fetch_and (line 143) | fetch_and(storage_type volatile& storage, storage_type v, memory...
method fetch_or (line 157) | fetch_or(storage_type volatile& storage, storage_type v, memory_...
method fetch_xor (line 171) | fetch_xor(storage_type volatile& storage, storage_type v, memory...
type operations< 1u, Signed > (line 187) | struct operations< 1u, Signed > :
type operations< 2u, Signed > (line 193) | struct operations< 2u, Signed > :
function BOOST_FORCEINLINE (line 198) | BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEX...
function BOOST_FORCEINLINE (line 206) | BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEX...
FILE: benchmarks/boost/atomic/detail/pause.hpp
type boost (line 26) | namespace boost {
type atomics (line 27) | namespace atomics {
type detail (line 28) | namespace detail {
function BOOST_FORCEINLINE (line 30) | BOOST_FORCEINLINE void pause() BOOST_NOEXCEPT
FILE: benchmarks/boost/atomic/detail/storage_type.hpp
function BOOST_FORCEINLINE (line 35) | BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) BO...
type buffer_storage (line 41) | struct buffer_storage
method BOOST_FORCEINLINE (line 45) | BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
method BOOST_FORCEINLINE (line 50) | BOOST_FORCEINLINE bool operator== (buffer_storage const& that) const B...
method BOOST_FORCEINLINE (line 55) | BOOST_FORCEINLINE bool operator!= (buffer_storage const& that) const B...
function BOOST_FORCEINLINE (line 62) | BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size > const vola...
type make_storage_type (line 68) | struct make_storage_type
type aligned (line 72) | struct aligned
method BOOST_DEFAULTED_FUNCTION (line 76) | BOOST_DEFAULTED_FUNCTION(aligned(), {})
type make_storage_type< 1u, false > (line 82) | struct make_storage_type< 1u, false >
type aligned (line 86) | struct aligned
method BOOST_DEFAULTED_FUNCTION (line 90) | BOOST_DEFAULTED_FUNCTION(aligned(), {})
type make_storage_type< 1u, true > (line 96) | struct make_storage_type< 1u, true >
type aligned (line 100) | struct aligned
method BOOST_DEFAULTED_FUNCTION (line 104) | BOOST_DEFAULTED_FUNCTION(aligned(), {})
type aligned (line 184) | struct aligned
type aligned (line 214) | struct aligned
type storage128_t (line 225) | struct storage128_t
method BOOST_FORCEINLINE (line 229) | BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 235) | BOOST_FORCEINLINE bool operator== (storage128_t const& left, storage128_...
function BOOST_FORCEINLINE (line 239) | BOOST_FORCEINLINE bool operator!= (storage128_t const& left, storage128_...
function BOOST_FORCEINLINE (line 244) | BOOST_FORCEINLINE void non_atomic_load(storage128_t const volatile& from...
type storage_size_of (line 267) | struct storage_size_of
type _ (line 269) | enum _
FILE: benchmarks/boost/atomic/fences.hpp
type boost (line 32) | namespace boost {
type atomics (line 34) | namespace atomics {
function BOOST_FORCEINLINE (line 37) | BOOST_FORCEINLINE void atomic_thread_fence(memory_order order) BOOST...
function BOOST_FORCEINLINE (line 42) | BOOST_FORCEINLINE void atomic_thread_fence(memory_order) BOOST_NOEXCEPT
function BOOST_FORCEINLINE (line 49) | BOOST_FORCEINLINE void atomic_signal_fence(memory_order order) BOOST...
function BOOST_FORCEINLINE (line 54) | BOOST_FORCEINLINE void atomic_signal_fence(memory_order) BOOST_NOEXCEPT
FILE: benchmarks/boost/config/compiler/intel.hpp
type assert_no_intrinsic_wchar_t (line 209) | struct assert_no_intrinsic_wchar_t
type assert_no_intrinsic_wchar_t<wchar_t> (line 210) | struct assert_no_intrinsic_wchar_t<wchar_t> { typedef void type; }
type assert_intrinsic_wchar_t (line 215) | struct assert_intrinsic_wchar_t
type assert_intrinsic_wchar_t<wchar_t> (line 216) | struct assert_intrinsic_wchar_t<wchar_t> {}
type assert_intrinsic_wchar_t<unsigned short> (line 218) | struct assert_intrinsic_wchar_t<unsigned short> {}
FILE: benchmarks/boost/config/platform/vxworks.hpp
function getrlimit (line 252) | inline int getrlimit(int resource, struct rlimit *rlp){
function setrlimit (line 256) | inline int setrlimit(int resource, const struct rlimit *rlp){
function truncate (line 262) | inline int truncate(const char *p, off_t l){
function symlink (line 277) | inline int symlink(const char*, const char*){
function readlink (line 283) | inline ssize_t readlink(const char*, char*, size_t){
function gettimeofday (line 293) | inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
type tms (line 311) | struct tms{
function clock_t (line 318) | inline clock_t times(struct tms *t){
type std (line 333) | namespace std {
FILE: benchmarks/boost/config/stdlib/stlport.hpp
type std (line 149) | namespace std { using ::abs; }
type std (line 159) | namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD:...
type boost (line 206) | namespace boost { using std::min; using std::max; }
FILE: benchmarks/boost/config/suffix.hpp
type std (line 353) | namespace std { using ::ptrdiff_t; using ::size_t; }
function _Tp (line 374) | inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
function _Tp (line 378) | inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
type std (line 372) | namespace std {
function _Tp (line 374) | inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
function _Tp (line 378) | inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
type boost (line 484) | namespace boost{
type boost (line 496) | namespace boost{
type boost (line 508) | namespace boost {
type std (line 535) | namespace std{ using ::type_info; }
function _Tp (line 374) | inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
function _Tp (line 378) | inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a...
FILE: benchmarks/boost/core/enable_if.hpp
type boost (line 24) | namespace boost
type enable_if_has_type (line 27) | struct enable_if_has_type
type enable_if_c (line 33) | struct enable_if_c {
type enable_if_c<false, T> (line 38) | struct enable_if_c<false, T> {}
type enable_if (line 41) | struct enable_if : public enable_if_c<Cond::value, T> {}
type lazy_enable_if_c (line 44) | struct lazy_enable_if_c {
type lazy_enable_if_c<false, T> (line 49) | struct lazy_enable_if_c<false, T> {}
type lazy_enable_if (line 52) | struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {}
type disable_if_c (line 56) | struct disable_if_c {
type disable_if_c<true, T> (line 61) | struct disable_if_c<true, T> {}
type disable_if (line 64) | struct disable_if : public disable_if_c<Cond::value, T> {}
type lazy_disable_if_c (line 67) | struct lazy_disable_if_c {
type lazy_disable_if_c<true, T> (line 72) | struct lazy_disable_if_c<true, T> {}
type lazy_disable_if (line 75) | struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {}
type detail (line 83) | namespace detail { typedef void enable_if_default_T; }
type enable_if_does_not_work_on_this_compiler (line 86) | struct enable_if_does_not_work_on_this_compiler
type enable_if_has_type (line 89) | struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
type enable_if_c (line 93) | struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
type disable_if_c (line 97) | struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
type lazy_enable_if_c (line 101) | struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
type lazy_disable_if_c (line 105) | struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
type enable_if (line 109) | struct enable_if : enable_if_does_not_work_on_this_compiler<T>
type disable_if (line 113) | struct disable_if : enable_if_does_not_work_on_this_compiler<T>
type lazy_enable_if (line 117) | struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
type lazy_disable_if (line 121) | struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
type boost (line 81) | namespace boost {
type enable_if_has_type (line 27) | struct enable_if_has_type
type enable_if_c (line 33) | struct enable_if_c {
type enable_if_c<false, T> (line 38) | struct enable_if_c<false, T> {}
type enable_if (line 41) | struct enable_if : public enable_if_c<Cond::value, T> {}
type lazy_enable_if_c (line 44) | struct lazy_enable_if_c {
type lazy_enable_if_c<false, T> (line 49) | struct lazy_enable_if_c<false, T> {}
type lazy_enable_if (line 52) | struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {}
type disable_if_c (line 56) | struct disable_if_c {
type disable_if_c<true, T> (line 61) | struct disable_if_c<true, T> {}
type disable_if (line 64) | struct disable_if : public disable_if_c<Cond::value, T> {}
type lazy_disable_if_c (line 67) | struct lazy_disable_if_c {
type lazy_disable_if_c<true, T> (line 72) | struct lazy_disable_if_c<true, T> {}
type lazy_disable_if (line 75) | struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {}
type detail (line 83) | namespace detail { typedef void enable_if_default_T; }
type enable_if_does_not_work_on_this_compiler (line 86) | struct enable_if_does_not_work_on_this_compiler
type enable_if_has_type (line 89) | struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
type enable_if_c (line 93) | struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
type disable_if_c (line 97) | struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
type lazy_enable_if_c (line 101) | struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
type lazy_disable_if_c (line 105) | struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
type enable_if (line 109) | struct enable_if : enable_if_does_not_work_on_this_compiler<T>
type disable_if (line 113) | struct disable_if : enable_if_does_not_work_on_this_compiler<T>
type lazy_enable_if (line 117) | struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
type lazy_disable_if (line 121) | struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
FILE: benchmarks/boost/core/noncopyable.hpp
type boost (line 14) | namespace boost {
type noncopyable_ (line 21) | namespace noncopyable_ // protection from unintended ADL
class noncopyable (line 23) | class noncopyable
method BOOST_CONSTEXPR (line 27) | BOOST_CONSTEXPR noncopyable() = default;
method noncopyable (line 30) | noncopyable() {}
method noncopyable (line 34) | noncopyable( const noncopyable& ) = delete;
method noncopyable (line 35) | noncopyable& operator=( const noncopyable& ) = delete;
FILE: benchmarks/boost/core/swap.hpp
type boost_swap_impl (line 29) | namespace boost_swap_impl
function BOOST_GPU_ENABLED (line 32) | BOOST_GPU_ENABLED
function BOOST_GPU_ENABLED (line 40) | BOOST_GPU_ENABLED
type boost (line 50) | namespace boost
function BOOST_GPU_ENABLED (line 53) | BOOST_GPU_ENABLED
FILE: benchmarks/boost/cstdint.hpp
type boost (line 103) | namespace boost
type boost (line 147) | namespace boost {
type boost (line 197) | namespace boost
type boost (line 379) | namespace boost {
type boost (line 388) | namespace boost {
FILE: benchmarks/boost/current_function.hpp
type boost (line 22) | namespace boost
type detail (line 25) | namespace detail
function current_function_helper (line 28) | inline void current_function_helper()
FILE: benchmarks/boost/detail/iterator.hpp
type boost (line 13) | namespace boost
type detail (line 16) | namespace detail
FILE: benchmarks/boost/exception/exception.hpp
type boost (line 15) | namespace
type exception_detail (line 18) | namespace
class refcount_ptr (line 22) | class
method refcount_ptr (line 27) | refcount_ptr():
method refcount_ptr (line 37) | refcount_ptr( refcount_ptr const & x ):
method refcount_ptr (line 43) | refcount_ptr &
method adopt (line 50) | void
method T (line 58) | T *
method add_ref (line 68) | void
method release (line 75) | void
class error_info_base (line 153) | class error_info_base
type type_info_ (line 154) | struct type_info_
type error_info_container (line 156) | struct
type get_info (line 174) | struct get_info
type get_info<throw_function> (line 177) | struct get_info<throw_function>
type get_info<throw_file> (line 180) | struct get_info<throw_file>
type get_info<throw_line> (line 183) | struct get_info<throw_line>
function E (line 290) | E const &
function E (line 298) | E const &
function E (line 306) | E const &
type error_info_injector (line 325) | struct
method error_info_injector (line 330) | explicit
type large_size (line 346) | struct large_size { char c[256]; }
type small_size (line 349) | struct small_size { }
type enable_error_info_helper (line 353) | struct enable_error_info_helper
type enable_error_info_helper<T,sizeof(large_size)> (line 356) | struct
type enable_error_info_helper<T,sizeof(small_size)> (line 363) | struct
type enable_error_info_return_type (line 370) | struct
class clone_base (line 397) | class
function copy_boost_exception (line 416) | inline
function copy_boost_exception (line 429) | inline
class clone_impl (line 441) | class
type clone_tag (line 446) | struct clone_tag { }
method clone_impl (line 447) | clone_impl( clone_impl const & x, clone_tag ):
method clone_impl (line 455) | explicit
method clone_base (line 468) | clone_base const *
method rethrow (line 474) | void
class error_info (line 87) | class error_info
type throw_function_ (line 89) | struct throw_function_
type throw_file_ (line 90) | struct throw_file_
type throw_line_ (line 91) | struct throw_line_
class error_info<throw_function_,char const *> (line 94) | class
method error_info (line 100) | explicit
class error_info<throw_file_,char const *> (line 108) | class
method error_info (line 114) | explicit
class error_info<throw_line_,int> (line 122) | class
method error_info (line 128) | explicit
class exception (line 140) | class exception
method exception (line 218) | exception():
method exception (line 228) | exception( exception const & x ) throw():
class shared_ptr (line 148) | class shared_ptr
type exception_detail (line 150) | namespace
class refcount_ptr (line 22) | class
method refcount_ptr (line 27) | refcount_ptr():
method refcount_ptr (line 37) | refcount_ptr( refcount_ptr const & x ):
method refcount_ptr (line 43) | refcount_ptr &
method adopt (line 50) | void
method T (line 58) | T *
method add_ref (line 68) | void
method release (line 75) | void
class error_info_base (line 153) | class error_info_base
type type_info_ (line 154) | struct type_info_
type error_info_container (line 156) | struct
type get_info (line 174) | struct get_info
type get_info<throw_function> (line 177) | struct get_info<throw_function>
type get_info<throw_file> (line 180) | struct get_info<throw_file>
type get_info<throw_line> (line 183) | struct get_info<throw_line>
function E (line 290) | E const &
function E (line 298) | E const &
function E (line 306) | E const &
type error_info_injector (line 325) | struct
method error_info_injector (line 330) | explicit
type large_size (line 346) | struct large_size { char c[256]; }
type small_size (line 349) | struct small_size { }
type enable_error_info_helper (line 353) | struct enable_error_info_helper
type enable_error_info_helper<T,sizeof(large_size)> (line 356) | struct
type enable_error_info_helper<T,sizeof(small_size)> (line 363) | struct
type enable_error_info_return_type (line 370) | struct
class clone_base (line 397) | class
function copy_boost_exception (line 416) | inline
function copy_boost_exception (line 429) | inline
class clone_impl (line 441) | class
type clone_tag (line 446) | struct clone_tag { }
method clone_impl (line 447) | clone_impl( clone_impl const & x, clone_tag ):
method clone_impl (line 455) | explicit
method clone_base (line 468) | clone_base const *
method rethrow (line 474) | void
class exception (line 207) | class
method exception (line 218) | exception():
method exception (line 228) | exception( exception const & x ) throw():
type exception_detail (line 286) | namespace
class refcount_ptr (line 22) | class
method refcount_ptr (line 27) | refcount_ptr():
method refcount_ptr (line 37) | refcount_ptr( refcount_ptr const & x ):
method refcount_ptr (line 43) | refcount_ptr &
method adopt (line 50) | void
method T (line 58) | T *
method add_ref (line 68) | void
method release (line 75) | void
class error_info_base (line 153) | class error_info_base
type type_info_ (line 154) | struct type_info_
type error_info_container (line 156) | struct
type get_info (line 174) | struct get_info
type get_info<throw_function> (line 177) | struct get_info<throw_function>
type get_info<throw_file> (line 180) | struct get_info<throw_file>
type get_info<throw_line> (line 183) | struct get_info<throw_line>
function E (line 290) | E const &
function E (line 298) | E const &
function E (line 306) | E const &
type error_info_injector (line 325) | struct
method error_info_injector (line 330) | explicit
type large_size (line 346) | struct large_size { char c[256]; }
type small_size (line 349) | struct small_size { }
type enable_error_info_helper (line 353) | struct enable_error_info_helper
type enable_error_info_helper<T,sizeof(large_size)> (line 356) | struct
type enable_error_info_helper<T,sizeof(small_size)> (line 363) | struct
type enable_error_info_return_type (line 370) | struct
class clone_base (line 397) | class
function copy_boost_exception (line 416) | inline
function copy_boost_exception (line 429) | inline
class clone_impl (line 441) | class
type clone_tag (line 446) | struct clone_tag { }
method clone_impl (line 447) | clone_impl( clone_impl const & x, clone_tag ):
method clone_impl (line 455) | explicit
method clone_base (line 468) | clone_base const *
method rethrow (line 474) | void
type exception_detail (line 316) | namespace
class refcount_ptr (line 22) | class
method refcount_ptr (line 27) | refcount_ptr():
method refcount_ptr (line 37) | refcount_ptr( refcount_ptr const & x ):
method refcount_ptr (line 43) | refcount_ptr &
method adopt (line 50) | void
method T (line 58) | T *
method add_ref (line 68) | void
method release (line 75) | void
class error_info_base (line 153) | class error_info_base
type type_info_ (line 154) | struct type_info_
type error_info_container (line 156) | struct
type get_info (line 174) | struct get_info
type get_info<throw_function> (line 177) | struct get_info<throw_function>
type get_info<throw_file> (line 180) | struct get_info<throw_file>
type get_info<throw_line> (line 183) | struct get_info<throw_line>
function E (line 290) | E const &
function E (line 298) | E const &
function E (line 306) | E const &
type error_info_injector (line 325) | struct
method error_info_injector (line 330) | explicit
type large_size (line 346) | struct large_size { char c[256]; }
type small_size (line 349) | struct small_size { }
type enable_error_info_helper (line 353) | struct enable_error_info_helper
type enable_error_info_helper<T,sizeof(large_size)> (line 356) | struct
type enable_error_info_helper<T,sizeof(small_size)> (line 363) | struct
type enable_error_info_return_type (line 370) | struct
class clone_base (line 397) | class
function copy_boost_exception (line 416) | inline
function copy_boost_exception (line 429) | inline
class clone_impl (line 441) | class
type clone_tag (line 446) | struct clone_tag { }
method clone_impl (line 447) | clone_impl( clone_impl const & x, clone_tag ):
method clone_impl (line 455) | explicit
method clone_base (line 468) | clone_base const *
method rethrow (line 474) | void
function enable_error_info (line 378) | inline
type exception_detail (line 389) | namespace
class refcount_ptr (line 22) | class
method refcount_ptr (line 27) | refcount_ptr():
method refcount_ptr (line 37) | refcount_ptr( refcount_ptr const & x ):
method refcount_ptr (line 43) | refcount_ptr &
method adopt (line 50) | void
method T (line 58) | T *
method add_ref (line 68) | void
method release (line 75) | void
class error_info_base (line 153) | class error_info_base
type type_info_ (line 154) | struct type_info_
type error_info_container (line 156) | struct
type get_info (line 174) | struct get_info
type get_info<throw_function> (line 177) | struct get_info<throw_function>
type get_info<throw_file> (line 180) | struct get_info<throw_file>
type get_info<throw_line> (line 183) | struct get_info<throw_line>
function E (line 290) | E const &
function E (line 298) | E const &
function E (line 306) | E const &
type error_info_injector (line 325) | struct
method error_info_injector (line 330) | explicit
type large_size (line 346) | struct large_size { char c[256]; }
type small_size (line 349) | struct small_size { }
type enable_error_info_helper (line 353) | struct enable_error_info_helper
type enable_error_info_helper<T,sizeof(large_size)> (line 356) | struct
type enable_error_info_helper<T,sizeof(small_size)> (line 363) | struct
type enable_error_info_return_type (line 370) | struct
class clone_base (line 397) | class
function copy_boost_exception (line 416) | inline
function copy_boost_exception (line 429) | inline
class clone_impl (line 441) | class
type clone_tag (line 446) | struct clone_tag { }
method clone_impl (line 447) | clone_impl( clone_impl const & x, clone_tag ):
method clone_impl (line 455) | explicit
method clone_base (line 468) | clone_base const *
method rethrow (line 474) | void
function enable_current_exception (line 488) | inline
FILE: benchmarks/boost/functional/hash/hash_fwd.hpp
type boost (line 21) | namespace boost
type hash (line 23) | struct hash
FILE: benchmarks/boost/limits.hpp
type std (line 35) | namespace std
class numeric_limits<BOOST_LLT> (line 38) | class numeric_limits<BOOST_LLT>
method BOOST_LLT (line 44) | static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8...
method BOOST_LLT (line 45) | static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7...
method BOOST_LLT (line 47) | static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLO...
method BOOST_LLT (line 48) | static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLO...
method BOOST_LLT (line 50) | static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LON...
method BOOST_LLT (line 51) | static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LON...
method BOOST_LLT (line 53) | static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL...
method BOOST_LLT (line 54) | static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(m...
method BOOST_LLT (line 62) | static BOOST_LLT epsilon() throw() { return 0; }
method BOOST_LLT (line 63) | static BOOST_LLT round_error() throw() { return 0; }
method BOOST_LLT (line 75) | static BOOST_LLT infinity() throw() { return 0; }
method BOOST_LLT (line 76) | static BOOST_LLT quiet_NaN() throw() { return 0; }
method BOOST_LLT (line 77) | static BOOST_LLT signaling_NaN() throw() { return 0; }
method BOOST_LLT (line 78) | static BOOST_LLT denorm_min() throw() { return 0; }
class numeric_limits<BOOST_ULLT> (line 91) | class numeric_limits<BOOST_ULLT>
method BOOST_ULLT (line 97) | static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0u...
method BOOST_ULLT (line 98) | static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x...
method BOOST_ULLT (line 100) | static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return UL...
method BOOST_ULLT (line 101) | static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return UL...
method BOOST_ULLT (line 103) | static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return UL...
method BOOST_ULLT (line 104) | static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return UL...
method BOOST_ULLT (line 106) | static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0u...
method BOOST_ULLT (line 107) | static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0...
method BOOST_ULLT (line 115) | static BOOST_ULLT epsilon() throw() { return 0; }
method BOOST_ULLT (line 116) | static BOOST_ULLT round_error() throw() { return 0; }
method BOOST_ULLT (line 128) | static BOOST_ULLT infinity() throw() { return 0; }
method BOOST_ULLT (line 129) | static BOOST_ULLT quiet_NaN() throw() { return 0; }
method BOOST_ULLT (line 130) | static BOOST_ULLT signaling_NaN() throw() { return 0; }
method BOOST_ULLT (line 131) | static BOOST_ULLT denorm_min() throw() { return 0; }
FILE: benchmarks/boost/lockfree/detail/atomic.hpp
type boost (line 54) | namespace boost {
type lockfree (line 55) | namespace lockfree {
type detail (line 56) | namespace detail {
FILE: benchmarks/boost/lockfree/detail/copy_payload.hpp
type boost (line 20) | namespace boost {
type lockfree (line 21) | namespace lockfree {
type detail (line 22) | namespace detail {
type copy_convertible (line 24) | struct copy_convertible
method copy (line 27) | static void copy(T & t, U & u)
type copy_constructible_and_copyable (line 33) | struct copy_constructible_and_copyable
method copy (line 36) | static void copy(T & t, U & u)
function copy_payload (line 43) | void copy_payload(T & t, U & u)
type consume_via_copy (line 53) | struct consume_via_copy
method consume_via_copy (line 55) | consume_via_copy(T & out):
type consume_noop (line 68) | struct consume_noop
FILE: benchmarks/boost/lockfree/detail/freelist.hpp
type boost (line 31) | namespace boost {
type lockfree (line 32) | namespace lockfree {
type detail (line 33) | namespace detail {
class freelist_stack (line 38) | class freelist_stack:
type freelist_node (line 41) | struct freelist_node
method freelist_stack (line 52) | freelist_stack (Allocator const & alloc, std::size_t n = 0):
method reserve (line 67) | void reserve (std::size_t count)
method T (line 76) | T * construct (void)
method T (line 85) | T * construct (ArgumentType const & arg)
method T (line 94) | T * construct (ArgumentType1 const & arg1, ArgumentType2 const &...
method destruct (line 103) | void destruct (tagged_node_handle tagged_ptr)
method destruct (line 111) | void destruct (T * n)
method is_lock_free (line 129) | bool is_lock_free(void) const
method T (line 134) | T * get_handle(T * pointer) const
method T (line 139) | T * get_handle(tagged_node_handle const & handle) const
method T (line 144) | T * get_pointer(tagged_node_handle const & tptr) const
method T (line 149) | T * get_pointer(T * pointer) const
method T (line 154) | T * null_handle(void) const
method T (line 161) | T * allocate (void)
method T (line 171) | T * allocate_impl (void)
method T (line 194) | T * allocate_impl_unsafe (void)
method deallocate (line 215) | void deallocate (T * n)
method deallocate_impl (line 224) | void deallocate_impl (T * n)
method deallocate_impl_unsafe (line 239) | void deallocate_impl_unsafe (T * n)
class tagged_index (line 254) | class tagged_index
method tagged_index (line 261) | tagged_index(void) BOOST_NOEXCEPT //: index(0), tag(0)
method tagged_index (line 266) | tagged_index(tagged_index const & rhs):
method tagged_index (line 270) | tagged_index(tagged_index const & rhs) = default;
method tagged_index (line 273) | explicit tagged_index(index_t i, tag_t t = 0):
method index_t (line 279) | index_t get_index() const
method set_index (line 284) | void set_index(index_t i)
method tag_t (line 292) | tag_t get_tag() const
method tag_t (line 297) | tag_t get_next_tag() const
method set_tag (line 303) | void set_tag(tag_t t)
type compiletime_sized_freelist_storage (line 326) | struct compiletime_sized_freelist_storage
method compiletime_sized_freelist_storage (line 335) | compiletime_sized_freelist_storage(Allocator const & /* alloc */...
method T (line 338) | T * nodes(void) const
method node_count (line 343) | std::size_t node_count(void) const
type runtime_sized_freelist_storage (line 351) | struct runtime_sized_freelist_storage:
method runtime_sized_freelist_storage (line 358) | runtime_sized_freelist_storage(Allocator const & alloc, std::siz...
method T (line 371) | T * nodes(void) const
method node_count (line 376) | std::size_t node_count(void) const
class fixed_size_freelist (line 386) | class fixed_size_freelist:
type freelist_node (line 389) | struct freelist_node
method initialize (line 396) | void initialize(void)
method fixed_size_freelist (line 415) | fixed_size_freelist (Allocator const & alloc, std::size_t count):
method fixed_size_freelist (line 422) | fixed_size_freelist (void):
method T (line 429) | T * construct (void)
method T (line 441) | T * construct (ArgumentType const & arg)
method T (line 453) | T * construct (ArgumentType1 const & arg1, ArgumentType2 const &...
method destruct (line 465) | void destruct (tagged_node_handle tagged_index)
method destruct (line 475) | void destruct (T * n)
method is_lock_free (line 481) | bool is_lock_free(void) const
method index_t (line 486) | index_t null_handle(void) const
method index_t (line 491) | index_t get_handle(T * pointer) const
method index_t (line 499) | index_t get_handle(tagged_node_handle const & handle) const
method T (line 504) | T * get_pointer(tagged_node_handle const & tptr) const
method T (line 509) | T * get_pointer(index_t index) const
method T (line 517) | T * get_pointer(T * ptr) const
method index_t (line 524) | index_t allocate (void)
method index_t (line 533) | index_t allocate_impl (void)
method index_t (line 552) | index_t allocate_impl_unsafe (void)
method deallocate (line 570) | void deallocate (index_t index)
method deallocate_impl (line 578) | void deallocate_impl (index_t index)
method deallocate_impl_unsafe (line 592) | void deallocate_impl_unsafe (index_t index)
type select_freelist (line 612) | struct select_freelist
type select_tagged_handle (line 626) | struct select_tagged_handle
FILE: benchmarks/boost/lockfree/detail/parameter.hpp
type boost (line 14) | namespace boost {
type lockfree (line 15) | namespace lockfree {
type detail (line 16) | namespace detail {
type has_arg (line 21) | struct has_arg
type extract_capacity (line 29) | struct extract_capacity
type extract_allocator (line 43) | struct extract_allocator
type extract_fixed_sized (line 56) | struct extract_fixed_sized
FILE: benchmarks/boost/lockfree/detail/tagged_ptr_dcas.hpp
type boost (line 16) | namespace boost {
type lockfree (line 17) | namespace lockfree {
type detail (line 18) | namespace detail {
function tagged_ptr (line 21) | class BOOST_LOCKFREE_DCAS_ALIGNMENT tagged_ptr
FILE: benchmarks/boost/lockfree/detail/tagged_ptr_ptrcompression.hpp
type boost (line 18) | namespace boost {
type lockfree (line 19) | namespace lockfree {
type detail (line 20) | namespace detail {
class tagged_ptr (line 25) | class tagged_ptr
method T (line 42) | static T* extract_ptr(volatile compressed_ptr_t const & i)
method tag_t (line 47) | static tag_t extract_tag(volatile compressed_ptr_t const & i)
method compressed_ptr_t (line 54) | static compressed_ptr_t pack_ptr(T * ptr, tag_t tag)
method tagged_ptr (line 64) | tagged_ptr(void) BOOST_NOEXCEPT//: ptr(0), tag(0)
method tagged_ptr (line 69) | tagged_ptr(tagged_ptr const & p):
method tagged_ptr (line 73) | tagged_ptr(tagged_ptr const & p) = default;
method tagged_ptr (line 76) | explicit tagged_ptr(T * p, tag_t t = 0):
method tagged_ptr (line 83) | tagged_ptr & operator= (tagged_ptr const & p)
method tagged_ptr (line 89) | tagged_ptr & operator= (tagged_ptr const & p) = default;
method set (line 92) | void set(T * p, tag_t t)
method T (line 113) | T * get_ptr() const
method set_ptr (line 118) | void set_ptr(T * p)
method tag_t (line 127) | tag_t get_tag() const
method tag_t (line 132) | tag_t get_next_tag() const
method set_tag (line 138) | void set_tag(tag_t t)
method T (line 147) | T & operator*() const
method T (line 152) | T * operator->() const
FILE: benchmarks/boost/lockfree/policies.hpp
type boost (line 17) | namespace boost {
type lockfree (line 18) | namespace lockfree {
type tag (line 21) | namespace tag { struct allocator ; }
type allocator (line 21) | struct allocator
type fixed_sized (line 22) | struct fixed_sized
type capacity (line 23) | struct capacity
type tag (line 22) | namespace tag { struct fixed_sized; }
type allocator (line 21) | struct allocator
type fixed_sized (line 22) | struct fixed_sized
type capacity (line 23) | struct capacity
type tag (line 23) | namespace tag { struct capacity; }
type allocator (line 21) | struct allocator
type fixed_sized (line 22) | struct fixed_sized
type capacity (line 23) | struct capacity
type fixed_sized (line 35) | struct fixed_sized:
type capacity (line 44) | struct capacity:
type allocator (line 51) | struct allocator:
FILE: benchmarks/boost/lockfree/queue.hpp
type boost (line 37) | namespace boost {
type lockfree (line 38) | namespace lockfree {
type detail (line 39) | namespace detail {
class queue (line 81) | class queue
type BOOST_LOCKFREE_CACHELINE_ALIGNMENT (line 102) | struct BOOST_LOCKFREE_CACHELINE_ALIGNMENT
method node (line 107) | node(T const & v, handle_type null_handle):
method node (line 116) | node (handle_type null_handle):
method node (line 120) | node(void)
method initialize (line 132) | void initialize(void)
type implementation_defined (line 140) | struct implementation_defined
method is_lock_free (line 164) | bool is_lock_free (void) const
method queue (line 171) | queue(void):
method queue (line 181) | explicit queue(typename node_allocator::template rebind<U>::other ...
method queue (line 190) | explicit queue(allocator const & alloc):
method queue (line 202) | explicit queue(size_type n):
method queue (line 212) | queue(size_type n, typename node_allocator::template rebind<U>::ot...
method reserve (line 224) | void reserve(size_type n)
method reserve_unsafe (line 231) | void reserve_unsafe(size_type n)
method empty (line 253) | bool empty(void) const
method push (line 266) | bool push(T const & t)
method bounded_push (line 279) | bool bounded_push(T const & t)
method do_push (line 288) | bool do_push(T const & t)
method unsynchronized_push (line 332) | bool unsynchronized_push(T const & t)
method pop (line 361) | bool pop (T & ret)
method pop (line 375) | bool pop (U & ret)
method unsynchronized_pop (line 422) | bool unsynchronized_pop (T & ret)
method unsynchronized_pop (line 437) | bool unsynchronized_pop (U & ret)
method consume_one (line 478) | bool consume_one(Functor & f)
method consume_one (line 490) | bool consume_one(Functor const & f)
method consume_all (line 509) | size_t consume_all(Functor & f)
method consume_all (line 520) | size_t consume_all(Functor const & f)
FILE: benchmarks/boost/memory_order.hpp
type boost (line 21) | namespace boost
type memory_order (line 45) | enum memory_order
FILE: benchmarks/boost/mpl/O1_size.hpp
type boost (line 23) | namespace boost { namespace mpl {
type mpl (line 23) | namespace mpl {
type O1_size (line 29) | struct O1_size
FILE: benchmarks/boost/mpl/O1_size_fwd.hpp
type boost (line 17) | namespace boost { namespace mpl {
type mpl (line 17) | namespace mpl {
type O1_size_impl (line 19) | struct O1_size_impl
type O1_size (line 20) | struct O1_size
FILE: benchmarks/boost/mpl/always.hpp
type boost (line 21) | namespace boost { namespace mpl {
type mpl (line 21) | namespace mpl {
type always (line 23) | struct always
type apply (line 28) | struct apply
FILE: benchmarks/boost/mpl/apply.hpp
type boost (line 57) | namespace boost { namespace mpl {
type mpl (line 57) | namespace mpl {
type aux (line 102) | namespace aux {
type apply (line 114) | struct apply
type BOOST_PP_CAT (line 148) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 173) | struct BOOST_PP_CAT
type apply (line 187) | struct apply
type apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) > (line 195) | struct apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) >
type aux (line 204) | namespace aux {
type apply_chooser<i_> (line 207) | struct apply_chooser<i_>
type result_ (line 212) | struct result_
FILE: benchmarks/boost/mpl/apply_fwd.hpp
type boost (line 51) | namespace boost { namespace mpl {
type mpl (line 51) | namespace mpl {
type apply (line 74) | struct apply
type aux (line 76) | namespace aux {
type apply_chooser (line 77) | struct apply_chooser
type BOOST_PP_CAT (line 104) | struct BOOST_PP_CAT
FILE: benchmarks/boost/mpl/apply_wrap.hpp
type boost (line 55) | namespace boost { namespace mpl {
type mpl (line 55) | namespace mpl {
type BOOST_PP_CAT (line 100) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 114) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 123) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 156) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 167) | struct BOOST_PP_CAT
type apply_wrap_impl0_bcb (line 186) | struct apply_wrap_impl0_bcb {
type apply_wrap_impl0_bcb< F, true > (line 191) | struct apply_wrap_impl0_bcb< F, true > {
type BOOST_PP_CAT (line 198) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 211) | struct BOOST_PP_CAT
FILE: benchmarks/boost/mpl/arg.hpp
type arg<i_> (line 93) | struct arg<i_>
type apply (line 103) | struct apply
type arg<-1> (line 112) | struct arg<-1>
type apply (line 121) | struct apply
FILE: benchmarks/boost/mpl/assert.hpp
type assert (line 79) | struct assert { typedef void* type; }
type assert<false> (line 80) | struct assert<false> { typedef AUX778076_ASSERT_ARG(assert) type; }
type assertion (line 86) | struct assertion
type assertion<true> (line 92) | struct assertion<true>
type assert_ (line 97) | struct assert_
type types (line 100) | struct types {}
type relations (line 103) | enum relations { equal = 1, not_equal, greater, greater_equal, less, l...
type assert_relation (line 117) | struct assert_relation {}
type assert_relation (line 121) | struct assert_relation {}
type assert_relation (line 134) | struct assert_relation {}
type extract_assert_pred (line 141) | struct extract_assert_pred
type extract_assert_pred<void(Pred)> (line 144) | struct extract_assert_pred<void(Pred)> { typedef Pred type; }
type eval_assert (line 147) | struct eval_assert {
type eval_assert_not (line 157) | struct eval_assert_not {
type assert_arg_pred_impl (line 171) | struct assert_arg_pred_impl { typedef int type; }
type assert_arg_pred_impl<true> (line 172) | struct assert_arg_pred_impl<true> { typedef void* type; }
type assert_arg_pred (line 174) | struct assert_arg_pred
type assert_arg_pred_not (line 180) | struct assert_arg_pred_not
type assert_arg_type_impl (line 208) | struct assert_arg_type_impl
type assert_arg_type_impl<true,Pred> (line 214) | struct assert_arg_type_impl<true,Pred>
type assert_arg_type (line 219) | struct assert_arg_type
FILE: benchmarks/boost/mpl/at_fwd.hpp
type boost (line 17) | namespace boost { namespace mpl {
type mpl (line 17) | namespace mpl {
type at_impl (line 19) | struct at_impl
type at (line 20) | struct at
FILE: benchmarks/boost/mpl/aux_/O1_size_impl.hpp
type aux (line 35) | namespace aux {
type O1_size_impl (line 36) | struct O1_size_impl
type O1_size_impl (line 43) | struct O1_size_impl
type apply (line 45) | struct apply
type O1_size_impl (line 75) | struct O1_size_impl
type apply (line 77) | struct apply
FILE: benchmarks/boost/mpl/aux_/adl_barrier.hpp
type BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE (line 33) | namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE { namespace aux {} }
type aux (line 33) | namespace aux {}
type boost (line 34) | namespace boost { namespace mpl { using namespace BOOST_MPL_AUX_ADL_BARR...
type mpl (line 34) | namespace mpl { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE;
type aux (line 35) | namespace aux { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE:...
FILE: benchmarks/boost/mpl/aux_/arity.hpp
type boost (line 24) | namespace boost { namespace mpl { namespace aux {
type mpl (line 24) | namespace mpl { namespace aux {
type aux (line 24) | namespace aux {
type arity (line 30) | struct arity
FILE: benchmarks/boost/mpl/aux_/begin_end_impl.hpp
type boost (line 26) | namespace boost { namespace mpl {
type mpl (line 26) | namespace mpl {
type aux (line 29) | namespace aux {
type begin_type (line 32) | struct begin_type
type end_type (line 37) | struct end_type
type begin_impl (line 49) | struct begin_impl
type apply (line 51) | struct apply
type end_impl (line 59) | struct end_impl
type apply (line 61) | struct apply
FILE: benchmarks/boost/mpl/aux_/clear_impl.hpp
type boost (line 21) | namespace boost { namespace mpl {
type mpl (line 21) | namespace mpl {
type clear_impl (line 26) | struct clear_impl
type apply (line 28) | struct apply
FILE: benchmarks/boost/mpl/aux_/count_args.hpp
type AUX778076_IS_ARG_TEMPLATE_NAME (line 71) | struct AUX778076_IS_ARG_TEMPLATE_NAME
type AUX778076_IS_ARG_TEMPLATE_NAME<AUX778076_COUNT_ARGS_DEFAULT> (line 77) | struct AUX778076_IS_ARG_TEMPLATE_NAME<AUX778076_COUNT_ARGS_DEFAULT>
type BOOST_PP_CAT (line 86) | struct BOOST_PP_CAT
FILE: benchmarks/boost/mpl/aux_/find_if_pred.hpp
type boost (line 17) | namespace boost { namespace mpl { namespace aux {
type mpl (line 17) | namespace mpl { namespace aux {
type aux (line 17) | namespace aux {
type find_if_pred (line 20) | struct find_if_pred
type apply (line 23) | struct apply
FILE: benchmarks/boost/mpl/aux_/fold_impl_body.hpp
type boost (line 49) | namespace boost { namespace mpl { namespace aux {
type mpl (line 49) | namespace mpl { namespace aux {
type aux (line 49) | namespace aux {
type AUX778076_FOLD_IMPL_NAME (line 59) | struct AUX778076_FOLD_IMPL_NAME
type AUX778076_FOLD_IMPL_NAME (line 77) | struct AUX778076_FOLD_IMPL_NAME
type AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp> (line 106) | struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp>
type AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp> (line 122) | struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp>
type AUX778076_FOLD_IMPL_NAME (line 139) | struct AUX778076_FOLD_IMPL_NAME
type AUX778076_FOLD_IMPL_NAME<N,Last,Last,State,ForwardOp > (line 160) | struct AUX778076_FOLD_IMPL_NAME<N,Last,Last,State,ForwardOp >
type AUX778076_FOLD_CHUNK_NAME (line 172) | struct AUX778076_FOLD_CHUNK_NAME
type result_ (line 188) | struct result_
type AUX778076_FOLD_CHUNK_NAME (line 180) | struct AUX778076_FOLD_CHUNK_NAME
type result_ (line 188) | struct result_
type BOOST_PP_CAT (line 218) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 224) | struct BOOST_PP_CAT
type AUX778076_FOLD_CHUNK_NAME<-1> (line 231) | struct AUX778076_FOLD_CHUNK_NAME<-1>
type result_ (line 239) | struct result_
type result_<int,int,int,int> (line 253) | struct result_<int,int,int,int>
type BOOST_PP_CAT (line 267) | struct BOOST_PP_CAT
type AUX778076_FOLD_IMPL_NAME (line 288) | struct AUX778076_FOLD_IMPL_NAME
type AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,ForwardOp> (line 319) | struct AUX778076_FOLD_IMPL_NAME<n_,First,Last,State,ForwardOp>
type AUX778076_FOLD_CHUNK_NAME<n_> (line 332) | struct AUX778076_FOLD_CHUNK_NAME<n_>
type result_ (line 340) | struct result_
type result_<int,int,int,int> (line 353) | struct result_<int,int,int,int>
FILE: benchmarks/boost/mpl/aux_/full_lambda.hpp
type boost (line 60) | namespace boost { namespace mpl {
type mpl (line 60) | namespace mpl {
type aux (line 85) | namespace aux {
type lambda_or (line 90) | struct lambda_or
type lambda_or< BOOST_MPL_PP_ENUM(n_,false) > (line 96) | struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) >
type lambda (line 109) | struct lambda
type is_lambda_expression (line 119) | struct is_lambda_expression
type lambda< arg<N>,Tag AUX778076_ARITY_PARAM(int_<-1>) > (line 126) | struct lambda< arg<N>,Tag AUX778076_ARITY_PARAM(int_<-1>) >
type lambda< mpl::protect<T>,Tag AUX778076_ARITY_PARAM(int_<1>) > (line 140) | struct lambda< mpl::protect<T>,Tag AUX778076_ARITY_PARAM(int_<1>) >
type lambda<
bind<F,AUX778076_BIND_PARAMS(T)>
, Tag
AUX778076_ARITY_PARAM(int_<BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY)>)
> (line 152) | struct lambda<
type lambda<
lambda<F,Tag1,Arity>
, Tag2
, int_<3>
> (line 172) | struct lambda<
type lambda<
lambda< F,Tag1 >
, Tag2
> (line 196) | struct lambda<
type aux (line 238) | namespace aux {
type BOOST_PP_CAT (line 255) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 269) | struct BOOST_PP_CAT
type lambda<
F<AUX778076_LAMBDA_PARAMS(i_, T)>
, Tag
AUX778076_ARITY_PARAM(int_<i_>)
> (line 305) | struct lambda<
type lambda<
BOOST_PP_CAT(bind,i_)<F AUX778076_BIND_N_PARAMS(i_, T)> (line 337) | struct lambda<
FILE: benchmarks/boost/mpl/aux_/has_apply.hpp
type boost (line 20) | namespace boost { namespace mpl { namespace aux {
type mpl (line 20) | namespace mpl { namespace aux {
type aux (line 20) | namespace aux {
type has_apply (line 25) | struct has_apply
FILE: benchmarks/boost/mpl/aux_/has_begin.hpp
type boost (line 19) | namespace boost { namespace mpl { namespace aux {
type mpl (line 19) | namespace mpl { namespace aux {
type aux (line 19) | namespace aux {
FILE: benchmarks/boost/mpl/aux_/has_key_impl.hpp
type boost (line 21) | namespace boost { namespace mpl {
type mpl (line 21) | namespace mpl {
type has_key_impl (line 25) | struct has_key_impl
type apply (line 27) | struct apply
FILE: benchmarks/boost/mpl/aux_/has_rebind.hpp
type boost (line 40) | namespace boost { namespace mpl { namespace aux {
type mpl (line 40) | namespace mpl { namespace aux {
type aux (line 40) | namespace aux {
type has_rebind (line 51) | struct has_rebind
type has_rebind_tag (line 62) | struct has_rebind_tag {}
type has_rebind (line 67) | struct has_rebind
type has_rebind_impl (line 76) | struct has_rebind_impl
type has_rebind (line 85) | struct has_rebind
FILE: benchmarks/boost/mpl/aux_/has_size.hpp
type boost (line 19) | namespace boost { namespace mpl { namespace aux {
type mpl (line 19) | namespace mpl { namespace aux {
type aux (line 19) | namespace aux {
FILE: benchmarks/boost/mpl/aux_/has_tag.hpp
type boost (line 19) | namespace boost { namespace mpl { namespace aux {
type mpl (line 19) | namespace mpl { namespace aux {
type aux (line 19) | namespace aux {
FILE: benchmarks/boost/mpl/aux_/has_type.hpp
type boost (line 19) | namespace boost { namespace mpl { namespace aux {
type mpl (line 19) | namespace mpl { namespace aux {
type aux (line 19) | namespace aux {
FILE: benchmarks/boost/mpl/aux_/insert_impl.hpp
type boost (line 25) | namespace boost { namespace mpl {
type mpl (line 25) | namespace mpl {
type insert_impl (line 31) | struct insert_impl
type apply (line 38) | struct apply
FILE: benchmarks/boost/mpl/aux_/integral_wrapper.hpp
function BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN (line 40) | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
FILE: benchmarks/boost/mpl/aux_/is_msvc_eti_arg.hpp
type boost (line 21) | namespace boost { namespace mpl { namespace aux {
type mpl (line 21) | namespace mpl { namespace aux {
type aux (line 21) | namespace aux {
type is_msvc_eti_arg (line 28) | struct is_msvc_eti_arg
type eti_int_convertible (line 35) | struct eti_int_convertible
type is_msvc_eti_arg (line 41) | struct is_msvc_eti_arg
type is_msvc_eti_arg<int> (line 55) | struct is_msvc_eti_arg<int>
FILE: benchmarks/boost/mpl/aux_/iter_apply.hpp
type boost (line 20) | namespace boost { namespace mpl { namespace aux {
type mpl (line 20) | namespace mpl { namespace aux {
type aux (line 20) | namespace aux {
type iter_apply1 (line 26) | struct iter_apply1
type iter_apply2 (line 36) | struct iter_apply2
FILE: benchmarks/boost/mpl/aux_/iter_fold_if_impl.hpp
type boost (line 43) | namespace boost { namespace mpl { namespace aux {
type mpl (line 43) | namespace mpl { namespace aux {
type aux (line 43) | namespace aux {
type iter_fold_if_null_step (line 46) | struct iter_fold_if_null_step
type iter_fold_if_step_impl (line 53) | struct iter_fold_if_step_impl
type result_ (line 61) | struct result_
type iter_fold_if_step_impl<false> (line 69) | struct iter_fold_if_step_impl<false>
type result_ (line 77) | struct result_
type iter_fold_if_forward_step (line 93) | struct iter_fold_if_forward_step
type iter_fold_if_backward_step (line 110) | struct iter_fold_if_backward_step
type iter_fold_if_impl (line 164) | struct iter_fold_if_impl
FILE: benchmarks/boost/mpl/aux_/lambda_no_ctps.hpp
type boost (line 58) | namespace boost { namespace mpl {
type mpl (line 58) | namespace mpl {
type aux (line 64) | namespace aux {
type lambda_or (line 70) | struct lambda_or
type lambda_or< BOOST_MPL_PP_ENUM(n_,false) > (line 76) | struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) >
type lambda_impl (line 82) | struct lambda_impl
type result_ (line 84) | struct result_
type lambda (line 102) | struct lambda
type is_lambda_expression (line 120) | struct is_lambda_expression
type lambda_impl< int_<i_> > (line 160) | struct lambda_impl< int_<i_> >
type result_ (line 162) | struct result_
FILE: benchmarks/boost/mpl/aux_/lambda_support.hpp
type boost (line 97) | namespace boost { namespace mpl { namespace aux {
type mpl (line 97) | namespace mpl { namespace aux {
type aux (line 97) | namespace aux {
type has_rebind_tag (line 98) | struct has_rebind_tag
FILE: benchmarks/boost/mpl/aux_/logical_op.hpp
type aux (line 59) | namespace aux {
type BOOST_PP_CAT (line 64) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 70) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 80) | struct BOOST_PP_CAT
type BOOST_PP_CAT (line 90) | struct BOOST_PP_CAT
type result_ (line 92) | struct result_
type BOOST_PP_CAT (line 98) | struct BOOST_PP_CAT
type result_ (line 100) | struct result_
type result_<AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,_))> (line 108) | struct result_<AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,...
type BOOST_PP_CAT (line 117) | struct BOOST_PP_CAT
type AUX778076_OP_NAME (line 133) | struct AUX778076_OP_NAME
FILE: benchmarks/boost/mpl/aux_/msvc_dtw.hpp
type AUX778076_MSVC_DTW_NAME (line 31) | struct AUX778076_MSVC_DTW_NAME
type f_ (line 33) | struct f_ : F {}
type f_<true> (line 34) | struct f_<true>
type AUX778076_DTW_ORIGINAL_NAME (line 37) | struct AUX778076_DTW_ORIGINAL_NAME
type result_ (line 43) | struct result_
type AUX778076_DTW_ORIGINAL_NAME (line 49) | struct AUX778076_DTW_ORIGINAL_NAME
type result_ (line 55) | struct result_
FILE: benchmarks/boost/mpl/aux_/msvc_eti_base.hpp
type boost (line 22) | namespace boost { namespace mpl { namespace aux {
type mpl (line 22) | namespace mpl { namespace aux {
type aux (line 22) | namespace aux {
type msvc_eti_base_impl (line 26) | struct msvc_eti_base_impl
type result_ (line 28) | struct result_
type msvc_eti_base_impl<true> (line 35) | struct msvc_eti_base_impl<true>
type result_ (line 37) | struct result_
type msvc_eti_base (line 47) | struct msvc_eti_base
type msvc_eti_base (line 55) | struct msvc_eti_base
type msvc_eti_base<int> (line 66) | struct msvc_eti_base<int>
FILE: benchmarks/boost/mpl/aux_/msvc_is_class.hpp
type boost (line 24) | namespace boost { namespace mpl { namespace aux {
type mpl (line 24) | namespace mpl { namespace aux {
type aux (line 24) | namespace aux {
type is_class_helper (line 26) | struct is_class_helper
type msvc_is_class_impl (line 34) | struct msvc_is_class_impl
type msvc_is_class (line 47) | struct msvc_is_class
FILE: benchmarks/boost/mpl/aux_/msvc_never_true.hpp
type boost (line 22) | namespace boost { namespace mpl { namespace aux {
type mpl (line 22) | namespace mpl { namespace aux {
type aux (line 22) | namespace aux {
type msvc_never_true (line 25) | struct msvc_never_true
FILE: benchmarks/boost/mpl/aux_/msvc_type.hpp
type boost (line 20) | namespace boost { namespace mpl { namespace aux {
type mpl (line 20) | namespace mpl { namespace aux {
type aux (line 20) | namespace aux {
type msvc_type_impl (line 24) | struct msvc_type_impl
type result_ (line 26) | struct result_
type msvc_type_impl<true> (line 32) | struct msvc_type_impl<true>
type result_ (line 34) | struct result_
type msvc_type (line 40) | struct msvc_type
type msvc_type (line 48) | struct msvc_type
type msvc_type<int> (line 53) | struct msvc_type<int>
FILE: benchmarks/boost/mpl/aux_/na.hpp
type boost (line 22) | namespace boost { namespace mpl {
type mpl (line 22) | namespace mpl {
type is_na (line 25) | struct is_na
type is_na<na> (line 34) | struct is_na<na>
type is_not_na (line 43) | struct is_not_na
type is_not_na<na> (line 52) | struct is_not_na<na>
type if_na (line 61) | struct if_na
type if_na<na,U> (line 66) | struct if_na<na,U>
type if_na_impl (line 71) | struct if_na_impl
type apply (line 73) | struct apply
type if_na_impl<na> (line 79) | struct if_na_impl<na>
type apply (line 81) | struct apply
type if_na (line 87) | struct if_na
FILE: benchmarks/boost/mpl/aux_/na_fwd.hpp
function BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN (line 19) | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
FILE: benchmarks/boost/mpl/aux_/nested_type_wknd.hpp
type boost (line 25) | namespace boost { namespace mpl { namespace aux {
type mpl (line 25) | namespace mpl { namespace aux {
type aux (line 25) | namespace aux {
type nested_type_wknd (line 26) | struct nested_type_wknd
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp
type boost (line 12) | namespace boost { namespace mpl { namespace aux {
type mpl (line 12) | namespace mpl { namespace aux {
type aux (line 12) | namespace aux {
type advance_backward (line 14) | struct advance_backward
type apply (line 78) | struct apply
type advance_backward<0> (line 16) | struct advance_backward<0>
type apply (line 18) | struct apply
type advance_backward<1> (line 26) | struct advance_backward<1>
type apply (line 28) | struct apply
type advance_backward<2> (line 37) | struct advance_backward<2>
type apply (line 39) | struct apply
type advance_backward<3> (line 49) | struct advance_backward<3>
type apply (line 51) | struct apply
type advance_backward<4> (line 62) | struct advance_backward<4>
type apply (line 64) | struct apply
type advance_backward (line 76) | struct advance_backward
type apply (line 78) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp
type boost (line 12) | namespace boost { namespace mpl { namespace aux {
type mpl (line 12) | namespace mpl { namespace aux {
type aux (line 12) | namespace aux {
type advance_forward (line 14) | struct advance_forward
type apply (line 78) | struct apply
type advance_forward<0> (line 16) | struct advance_forward<0>
type apply (line 18) | struct apply
type advance_forward<1> (line 26) | struct advance_forward<1>
type apply (line 28) | struct apply
type advance_forward<2> (line 37) | struct advance_forward<2>
type apply (line 39) | struct apply
type advance_forward<3> (line 49) | struct advance_forward<3>
type apply (line 51) | struct apply
type advance_forward<4> (line 62) | struct advance_forward<4>
type apply (line 64) | struct apply
type advance_forward (line 76) | struct advance_forward
type apply (line 78) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/and.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type aux (line 14) | namespace aux {
type and_impl (line 17) | struct and_impl
type and_impl< true,T1,T2,T3,T4 > (line 23) | struct and_impl< true,T1,T2,T3,T4 >
type and_impl<
true
, true_, true_, true_, true_
> (line 33) | struct and_impl<
type and_ (line 48) | struct and_
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/apply.hpp
type apply< F,na,na,na,na,na > (line 34) | struct apply< F,na,na,na,na,na >
type apply< F,T1,na,na,na,na > (line 59) | struct apply< F,T1,na,na,na,na >
type apply< F,T1,T2,na,na,na > (line 84) | struct apply< F,T1,T2,na,na,na >
type apply< F,T1,T2,T3,na,na > (line 109) | struct apply< F,T1,T2,T3,na,na >
type apply4 (line 117) | struct apply4
type apply< F,T1,T2,T3,T4,na > (line 134) | struct apply< F,T1,T2,T3,T4,na >
type apply5 (line 143) | struct apply5
type apply (line 163) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type apply (line 18) | struct apply
type apply0 (line 23) | struct apply0
type apply1 (line 28) | struct apply1
type apply2 (line 33) | struct apply2
type apply3 (line 38) | struct apply3
type apply4 (line 43) | struct apply4
type apply5 (line 49) | struct apply5
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type apply_wrap_impl0 (line 17) | struct apply_wrap_impl0
type apply_wrap_impl0_bcb (line 20) | struct apply_wrap_impl0_bcb {
type apply_wrap_impl0_bcb< F,true > (line 25) | struct apply_wrap_impl0_bcb< F,true > {
type apply_wrap_impl0<
0
, F
> (line 32) | struct apply_wrap_impl0<
type apply_wrap_impl0<
1
, F
> (line 44) | struct apply_wrap_impl0<
type apply_wrap_impl0<
2
, F
> (line 59) | struct apply_wrap_impl0<
type apply_wrap_impl0<
3
, F
> (line 75) | struct apply_wrap_impl0<
type apply_wrap_impl0<
4
, F
> (line 91) | struct apply_wrap_impl0<
type apply_wrap_impl0<
5
, F
> (line 107) | struct apply_wrap_impl0<
type apply_wrap0 (line 123) | struct apply_wrap0
type apply_wrap_impl1 (line 135) | struct apply_wrap_impl1
type apply_wrap_impl1<
1
, F
, T1
> (line 140) | struct apply_wrap_impl1<
type apply_wrap_impl1<
2
, F
, T1
> (line 154) | struct apply_wrap_impl1<
type apply_wrap_impl1<
3
, F
, T1
> (line 170) | struct apply_wrap_impl1<
type apply_wrap_impl1<
4
, F
, T1
> (line 186) | struct apply_wrap_impl1<
type apply_wrap_impl1<
5
, F
, T1
> (line 202) | struct apply_wrap_impl1<
type apply_wrap1 (line 218) | struct apply_wrap1
type apply_wrap_impl2 (line 230) | struct apply_wrap_impl2
type apply_wrap_impl2<
2
, F
, T1, T2
> (line 235) | struct apply_wrap_impl2<
type apply_wrap_impl2<
3
, F
, T1, T2
> (line 250) | struct apply_wrap_impl2<
type apply_wrap_impl2<
4
, F
, T1, T2
> (line 267) | struct apply_wrap_impl2<
type apply_wrap_impl2<
5
, F
, T1, T2
> (line 284) | struct apply_wrap_impl2<
type apply_wrap2 (line 301) | struct apply_wrap2
type apply_wrap_impl3 (line 313) | struct apply_wrap_impl3
type apply_wrap_impl3<
3
, F
, T1, T2, T3
> (line 318) | struct apply_wrap_impl3<
type apply_wrap_impl3<
4
, F
, T1, T2, T3
> (line 333) | struct apply_wrap_impl3<
type apply_wrap_impl3<
5
, F
, T1, T2, T3
> (line 350) | struct apply_wrap_impl3<
type apply_wrap3 (line 367) | struct apply_wrap3
type apply_wrap_impl4 (line 379) | struct apply_wrap_impl4
type apply_wrap_impl4<
4
, F
, T1, T2, T3, T4
> (line 384) | struct apply_wrap_impl4<
type apply_wrap_impl4<
5
, F
, T1, T2, T3, T4
> (line 399) | struct apply_wrap_impl4<
type apply_wrap4 (line 416) | struct apply_wrap4
type apply_wrap_impl5 (line 429) | struct apply_wrap_impl5
type apply_wrap_impl5<
5
, F
, T1, T2, T3, T4, T5
> (line 435) | struct apply_wrap_impl5<
type apply_wrap5 (line 451) | struct apply_wrap5
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/arg.hpp
type arg< -1 > (line 14) | struct arg< -1 >
type apply (line 23) | struct apply
type arg<1> (line 30) | struct arg<1>
type apply (line 40) | struct apply
type arg<2> (line 47) | struct arg<2>
type apply (line 57) | struct apply
type arg<3> (line 64) | struct arg<3>
type apply (line 74) | struct apply
type arg<4> (line 81) | struct arg<4>
type apply (line 91) | struct apply
type arg<5> (line 98) | struct arg<5>
type apply (line 108) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp
type boost (line 13) | namespace boost { namespace mpl {
type mpl (line 13) | namespace mpl {
type aux (line 15) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind0 (line 39) | struct bind0
type apply (line 44) | struct apply
type aux (line 57) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind1 (line 79) | struct bind1
type apply (line 84) | struct apply
type aux (line 99) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind2 (line 121) | struct bind2
type apply (line 126) | struct apply
type aux (line 142) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind3 (line 164) | struct bind3
type apply (line 169) | struct apply
type aux (line 186) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind4 (line 208) | struct bind4
type apply (line 213) | struct apply
type aux (line 232) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
type bind5 (line 255) | struct bind5
type apply (line 260) | struct apply
type aux (line 280) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 29) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 63) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 105) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 148) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 192) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 238) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 287) | struct resolve_bind_arg<
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/bind.hpp
type boost (line 13) | namespace boost { namespace mpl {
type mpl (line 13) | namespace mpl {
type aux (line 15) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind0 (line 58) | struct bind0
type apply (line 63) | struct apply
type aux (line 79) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind1 (line 101) | struct bind1
type apply (line 106) | struct apply
type aux (line 128) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind2 (line 150) | struct bind2
type apply (line 155) | struct apply
type aux (line 182) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind3 (line 204) | struct bind3
type apply (line 209) | struct apply
type aux (line 241) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind4 (line 263) | struct bind4
type apply (line 268) | struct apply
type aux (line 306) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
type bind5 (line 329) | struct bind5
type apply (line 334) | struct apply
type aux (line 377) | namespace aux {
type resolve_bind_arg (line 21) | struct resolve_bind_arg
type replace_unnamed_arg (line 30) | struct replace_unnamed_arg
type replace_unnamed_arg< arg< -1 >, Arg > (line 39) | struct replace_unnamed_arg< arg< -1 >, Arg >
type resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 > (line 48) | struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
type resolve_bind_arg<
bind0<F>, U1, U2, U3, U4, U5
> (line 85) | struct resolve_bind_arg<
type resolve_bind_arg<
bind1< F,T1 >, U1, U2, U3, U4, U5
> (line 134) | struct resolve_bind_arg<
type resolve_bind_arg<
bind2< F,T1,T2 >, U1, U2, U3, U4, U5
> (line 188) | struct resolve_bind_arg<
type resolve_bind_arg<
bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
> (line 247) | struct resolve_bind_arg<
type resolve_bind_arg<
bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
> (line 312) | struct resolve_bind_arg<
type resolve_bind_arg<
bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
> (line 384) | struct resolve_bind_arg<
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type bind0 (line 17) | struct bind0
type bind1 (line 22) | struct bind1
type bind2 (line 27) | struct bind2
type bind3 (line 32) | struct bind3
type bind4 (line 37) | struct bind4
type bind5 (line 43) | struct bind5
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/bitand.hpp
type bitand_impl (line 19) | struct bitand_impl
type bitand_impl< na,na > (line 32) | struct bitand_impl< na,na >
type apply (line 34) | struct apply
type bitand_impl< na,Tag > (line 41) | struct bitand_impl< na,Tag >
type apply (line 43) | struct apply
type bitand_impl< Tag,na > (line 50) | struct bitand_impl< Tag,na >
type apply (line 52) | struct apply
type bitand_tag (line 59) | struct bitand_tag
function BOOST_MPL_AUX_NA_SPEC2 (line 124) | BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_)
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/bitor.hpp
type bitor_impl (line 19) | struct bitor_impl
type bitor_impl< na,na > (line 32) | struct bitor_impl< na,na >
type apply (line 34) | struct apply
type bitor_impl< na,Tag > (line 41) | struct bitor_impl< na,Tag >
type apply (line 43) | struct apply
type bitor_impl< Tag,na > (line 50) | struct bitor_impl< Tag,na >
type apply (line 52) | struct apply
type bitor_tag (line 59) | struct bitor_tag
function BOOST_MPL_AUX_NA_SPEC2 (line 124) | BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_)
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp
type bitxor_impl (line 19) | struct bitxor_impl
type bitxor_impl< na,na > (line 32) | struct bitxor_impl< na,na >
type apply (line 34) | struct apply
type bitxor_impl< na,Tag > (line 41) | struct bitxor_impl< na,Tag >
type apply (line 43) | struct apply
type bitxor_impl< Tag,na > (line 50) | struct bitxor_impl< Tag,na >
type apply (line 52) | struct apply
type bitxor_tag (line 59) | struct bitxor_tag
function BOOST_MPL_AUX_NA_SPEC2 (line 124) | BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_)
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/deque.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type deque (line 22) | struct deque
type deque<
na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 27) | struct deque<
type deque<
T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 39) | struct deque<
type deque<
T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 51) | struct deque<
type deque<
T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 63) | struct deque<
type deque<
T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 75) | struct deque<
type deque<
T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 87) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 100) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 113) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 126) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
, na, na, na
> (line 139) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
, na, na, na
> (line 152) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
, na, na, na
> (line 166) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
, na, na, na, na
> (line 180) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
, na, na, na, na
> (line 194) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
, na, na, na, na
> (line 208) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
, na, na, na, na
> (line 222) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, na, na, na, na
> (line 239) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, na, na, na
> (line 257) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, na, na
> (line 275) | struct deque<
type deque<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, T18, na
> (line 293) | struct deque<
type deque (line 313) | struct deque
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/divides.hpp
type divides_impl (line 18) | struct divides_impl
type divides_impl< na,na > (line 31) | struct divides_impl< na,na >
type apply (line 33) | struct apply
type divides_impl< na,Tag > (line 40) | struct divides_impl< na,Tag >
type apply (line 42) | struct apply
type divides_impl< Tag,na > (line 49) | struct divides_impl< Tag,na >
type apply (line 51) | struct apply
type divides_tag (line 58) | struct divides_tag
function BOOST_MPL_AUX_NA_SPEC2 (line 123) | BOOST_MPL_AUX_NA_SPEC2(2, 5, divides)
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type equal_to_impl (line 18) | struct equal_to_impl
type equal_to_impl< na,na > (line 31) | struct equal_to_impl< na,na >
type apply (line 33) | struct apply
type equal_to_impl< na,Tag > (line 40) | struct equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type equal_to_impl< Tag,na > (line 49) | struct equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type equal_to_tag (line 58) | struct equal_to_tag
type equal_to (line 67) | struct equal_to
type equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type equal_to_impl (line 18) | struct equal_to_impl
type equal_to_impl< na,na > (line 31) | struct equal_to_impl< na,na >
type apply (line 33) | struct apply
type equal_to_impl< na,Tag > (line 40) | struct equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type equal_to_impl< Tag,na > (line 49) | struct equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type equal_to_tag (line 58) | struct equal_to_tag
type equal_to (line 67) | struct equal_to
type equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type equal_to_impl (line 18) | struct equal_to_impl
type equal_to_impl< na,na > (line 31) | struct equal_to_impl< na,na >
type apply (line 33) | struct apply
type equal_to_impl< na,Tag > (line 40) | struct equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type equal_to_impl< Tag,na > (line 49) | struct equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type equal_to_tag (line 58) | struct equal_to_tag
type equal_to (line 67) | struct equal_to
type equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type equal_to_impl (line 18) | struct equal_to_impl
type equal_to_impl< na,na > (line 31) | struct equal_to_impl< na,na >
type apply (line 33) | struct apply
type equal_to_impl< na,Tag > (line 40) | struct equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type equal_to_impl< Tag,na > (line 49) | struct equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type equal_to_tag (line 58) | struct equal_to_tag
type equal_to (line 67) | struct equal_to
type equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp
type boost (line 12) | namespace boost { namespace mpl { namespace aux {
type mpl (line 12) | namespace mpl { namespace aux {
type aux (line 12) | namespace aux {
type fold_impl (line 23) | struct fold_impl
type fold_impl< 0,First,Last,State,ForwardOp > (line 31) | struct fold_impl< 0,First,Last,State,ForwardOp >
type fold_impl< 1,First,Last,State,ForwardOp > (line 45) | struct fold_impl< 1,First,Last,State,ForwardOp >
type fold_impl< 2,First,Last,State,ForwardOp > (line 63) | struct fold_impl< 2,First,Last,State,ForwardOp >
type fold_impl< 3,First,Last,State,ForwardOp > (line 83) | struct fold_impl< 3,First,Last,State,ForwardOp >
type fold_impl< 4,First,Last,State,ForwardOp > (line 105) | struct fold_impl< 4,First,Last,State,ForwardOp >
type fold_impl (line 130) | struct fold_impl
type fold_impl< -1,First,Last,State,ForwardOp > (line 158) | struct fold_impl< -1,First,Last,State,ForwardOp >
type fold_impl< -1,Last,Last,State,ForwardOp > (line 174) | struct fold_impl< -1,Last,Last,State,ForwardOp >
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type aux (line 14) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda (line 38) | struct lambda
type is_lambda_expression (line 48) | struct is_lambda_expression
type lambda< arg<N>,Tag, int_< -1 > > (line 54) | struct lambda< arg<N>,Tag, int_< -1 > >
type lambda<
bind0<F>
, Tag
, int_<1>
> (line 65) | struct lambda<
type aux (line 79) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda<
F<T1>
, Tag
, int_<1>
> (line 117) | struct lambda<
type lambda<
bind1< F,T1 >
, Tag
, int_<2>
> (line 141) | struct lambda<
type aux (line 156) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda<
F< T1,T2 >
, Tag
, int_<2>
> (line 194) | struct lambda<
type lambda<
bind2< F,T1,T2 >
, Tag
, int_<3>
> (line 223) | struct lambda<
type aux (line 238) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda<
F< T1,T2,T3 >
, Tag
, int_<3>
> (line 276) | struct lambda<
type lambda<
bind3< F,T1,T2,T3 >
, Tag
, int_<4>
> (line 307) | struct lambda<
type aux (line 322) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda<
F< T1,T2,T3,T4 >
, Tag
, int_<4>
> (line 362) | struct lambda<
type lambda<
bind4< F,T1,T2,T3,T4 >
, Tag
, int_<5>
> (line 395) | struct lambda<
type aux (line 410) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type le_result1 (line 86) | struct le_result1
type le_result1< true_,Tag,F,L1 > (line 100) | struct le_result1< true_,Tag,F,L1 >
type le_result2 (line 163) | struct le_result2
type le_result2< true_,Tag,F,L1,L2 > (line 177) | struct le_result2< true_,Tag,F,L1,L2 >
type le_result3 (line 245) | struct le_result3
type le_result3< true_,Tag,F,L1,L2,L3 > (line 259) | struct le_result3< true_,Tag,F,L1,L2,L3 >
type le_result4 (line 329) | struct le_result4
type le_result4< true_,Tag,F,L1,L2,L3,L4 > (line 344) | struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
type le_result5 (line 417) | struct le_result5
type le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > (line 432) | struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
type lambda<
F< T1,T2,T3,T4,T5 >
, Tag
, int_<5>
> (line 454) | struct lambda<
type lambda<
bind5< F,T1,T2,T3,T4,T5 >
, Tag
, int_<6>
> (line 491) | struct lambda<
type lambda< mpl::protect<T>,Tag, int_<1> > (line 508) | struct lambda< mpl::protect<T>,Tag, int_<1> >
type lambda<
bind< F,T1,T2,T3,T4,T5 >
, Tag
, int_<6>
> (line 522) | struct lambda<
type lambda<
lambda< F,Tag1,Arity >
, Tag2
, int_<3>
> (line 539) | struct lambda<
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/greater.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type greater_impl (line 18) | struct greater_impl
type greater_impl< na,na > (line 31) | struct greater_impl< na,na >
type apply (line 33) | struct apply
type greater_impl< na,Tag > (line 40) | struct greater_impl< na,Tag >
type apply (line 42) | struct apply
type greater_impl< Tag,na > (line 49) | struct greater_impl< Tag,na >
type apply (line 51) | struct apply
type greater_tag (line 58) | struct greater_tag
type greater (line 67) | struct greater
type greater_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type greater_impl (line 18) | struct greater_impl
type greater_impl< na,na > (line 31) | struct greater_impl< na,na >
type apply (line 33) | struct apply
type greater_impl< na,Tag > (line 40) | struct greater_impl< na,Tag >
type apply (line 42) | struct apply
type greater_impl< Tag,na > (line 49) | struct greater_impl< Tag,na >
type apply (line 51) | struct apply
type greater_tag (line 58) | struct greater_tag
type greater (line 67) | struct greater
type greater_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type greater_impl (line 18) | struct greater_impl
type greater_impl< na,na > (line 31) | struct greater_impl< na,na >
type apply (line 33) | struct apply
type greater_impl< na,Tag > (line 40) | struct greater_impl< na,Tag >
type apply (line 42) | struct apply
type greater_impl< Tag,na > (line 49) | struct greater_impl< Tag,na >
type apply (line 51) | struct apply
type greater_tag (line 58) | struct greater_tag
type greater (line 67) | struct greater
type greater_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type greater_impl (line 18) | struct greater_impl
type greater_impl< na,na > (line 31) | struct greater_impl< na,na >
type apply (line 33) | struct apply
type greater_impl< na,Tag > (line 40) | struct greater_impl< na,Tag >
type apply (line 42) | struct apply
type greater_impl< Tag,na > (line 49) | struct greater_impl< Tag,na >
type apply (line 51) | struct apply
type greater_tag (line 58) | struct greater_tag
type greater (line 67) | struct greater
type greater_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type greater_equal_impl (line 18) | struct greater_equal_impl
type greater_equal_impl< na,na > (line 31) | struct greater_equal_impl< na,na >
type apply (line 33) | struct apply
type greater_equal_impl< na,Tag > (line 40) | struct greater_equal_impl< na,Tag >
type apply (line 42) | struct apply
type greater_equal_impl< Tag,na > (line 49) | struct greater_equal_impl< Tag,na >
type apply (line 51) | struct apply
type greater_equal_tag (line 58) | struct greater_equal_tag
type greater_equal (line 67) | struct greater_equal
type greater_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type greater_equal_impl (line 18) | struct greater_equal_impl
type greater_equal_impl< na,na > (line 31) | struct greater_equal_impl< na,na >
type apply (line 33) | struct apply
type greater_equal_impl< na,Tag > (line 40) | struct greater_equal_impl< na,Tag >
type apply (line 42) | struct apply
type greater_equal_impl< Tag,na > (line 49) | struct greater_equal_impl< Tag,na >
type apply (line 51) | struct apply
type greater_equal_tag (line 58) | struct greater_equal_tag
type greater_equal (line 67) | struct greater_equal
type greater_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type greater_equal_impl (line 18) | struct greater_equal_impl
type greater_equal_impl< na,na > (line 31) | struct greater_equal_impl< na,na >
type apply (line 33) | struct apply
type greater_equal_impl< na,Tag > (line 40) | struct greater_equal_impl< na,Tag >
type apply (line 42) | struct apply
type greater_equal_impl< Tag,na > (line 49) | struct greater_equal_impl< Tag,na >
type apply (line 51) | struct apply
type greater_equal_tag (line 58) | struct greater_equal_tag
type greater_equal (line 67) | struct greater_equal
type greater_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type greater_equal_impl (line 18) | struct greater_equal_impl
type greater_equal_impl< na,na > (line 31) | struct greater_equal_impl< na,na >
type apply (line 33) | struct apply
type greater_equal_impl< na,Tag > (line 40) | struct greater_equal_impl< na,Tag >
type apply (line 42) | struct apply
type greater_equal_impl< Tag,na > (line 49) | struct greater_equal_impl< Tag,na >
type apply (line 51) | struct apply
type greater_equal_tag (line 58) | struct greater_equal_tag
type greater_equal (line 67) | struct greater_equal
type greater_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct greater_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/inherit.hpp
type inherit5 (line 92) | struct inherit5
type inherit (line 116) | struct inherit
type inherit< na,na,na,na,na > (line 122) | struct inherit< na,na,na,na,na >
type apply (line 129) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp
type boost (line 13) | namespace boost { namespace mpl { namespace aux {
type mpl (line 13) | namespace mpl { namespace aux {
type aux (line 13) | namespace aux {
type iter_fold_if_null_step (line 16) | struct iter_fold_if_null_step
type iter_fold_if_step_impl (line 23) | struct iter_fold_if_step_impl
type result_ (line 31) | struct result_
type iter_fold_if_step_impl<false> (line 39) | struct iter_fold_if_step_impl<false>
type result_ (line 47) | struct result_
type iter_fold_if_forward_step (line 60) | struct iter_fold_if_forward_step
type iter_fold_if_backward_step (line 77) | struct iter_fold_if_backward_step
type iter_fold_if_impl (line 96) | struct iter_fold_if_impl
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp
type boost (line 12) | namespace boost { namespace mpl { namespace aux {
type mpl (line 12) | namespace mpl { namespace aux {
type aux (line 12) | namespace aux {
type iter_fold_impl (line 23) | struct iter_fold_impl
type iter_fold_impl< 0,First,Last,State,ForwardOp > (line 31) | struct iter_fold_impl< 0,First,Last,State,ForwardOp >
type iter_fold_impl< 1,First,Last,State,ForwardOp > (line 45) | struct iter_fold_impl< 1,First,Last,State,ForwardOp >
type iter_fold_impl< 2,First,Last,State,ForwardOp > (line 63) | struct iter_fold_impl< 2,First,Last,State,ForwardOp >
type iter_fold_impl< 3,First,Last,State,ForwardOp > (line 83) | struct iter_fold_impl< 3,First,Last,State,ForwardOp >
type iter_fold_impl< 4,First,Last,State,ForwardOp > (line 105) | struct iter_fold_impl< 4,First,Last,State,ForwardOp >
type iter_fold_impl (line 130) | struct iter_fold_impl
type iter_fold_impl< -1,First,Last,State,ForwardOp > (line 158) | struct iter_fold_impl< -1,First,Last,State,ForwardOp >
type iter_fold_impl< -1,Last,Last,State,ForwardOp > (line 174) | struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type aux (line 14) | namespace aux {
type lambda_or (line 20) | struct lambda_or
type lambda_or< false,false,false,false,false > (line 26) | struct lambda_or< false,false,false,false,false >
type lambda_impl (line 31) | struct lambda_impl
type result_ (line 33) | struct result_
type lambda_impl< int_<1> > (line 40) | struct lambda_impl< int_<1> >
type result_ (line 42) | struct result_
type lambda_impl< int_<2> > (line 65) | struct lambda_impl< int_<2> >
type result_ (line 67) | struct result_
type lambda_impl< int_<3> > (line 95) | struct lambda_impl< int_<3> >
type result_ (line 97) | struct result_
type lambda_impl< int_<4> > (line 127) | struct lambda_impl< int_<4> >
type result_ (line 129) | struct result_
type lambda_impl< int_<5> > (line 162) | struct lambda_impl< int_<5> >
type result_ (line 164) | struct result_
type lambda (line 206) | struct lambda
type is_lambda_expression (line 223) | struct is_lambda_expression
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/less.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type less_impl (line 18) | struct less_impl
type less_impl< na,na > (line 31) | struct less_impl< na,na >
type apply (line 33) | struct apply
type less_impl< na,Tag > (line 40) | struct less_impl< na,Tag >
type apply (line 42) | struct apply
type less_impl< Tag,na > (line 49) | struct less_impl< Tag,na >
type apply (line 51) | struct apply
type less_tag (line 58) | struct less_tag
type less (line 67) | struct less
type less_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type less_impl (line 18) | struct less_impl
type less_impl< na,na > (line 31) | struct less_impl< na,na >
type apply (line 33) | struct apply
type less_impl< na,Tag > (line 40) | struct less_impl< na,Tag >
type apply (line 42) | struct apply
type less_impl< Tag,na > (line 49) | struct less_impl< Tag,na >
type apply (line 51) | struct apply
type less_tag (line 58) | struct less_tag
type less (line 67) | struct less
type less_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type less_impl (line 18) | struct less_impl
type less_impl< na,na > (line 31) | struct less_impl< na,na >
type apply (line 33) | struct apply
type less_impl< na,Tag > (line 40) | struct less_impl< na,Tag >
type apply (line 42) | struct apply
type less_impl< Tag,na > (line 49) | struct less_impl< Tag,na >
type apply (line 51) | struct apply
type less_tag (line 58) | struct less_tag
type less (line 67) | struct less
type less_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type less_impl (line 18) | struct less_impl
type less_impl< na,na > (line 31) | struct less_impl< na,na >
type apply (line 33) | struct apply
type less_impl< na,Tag > (line 40) | struct less_impl< na,Tag >
type apply (line 42) | struct apply
type less_impl< Tag,na > (line 49) | struct less_impl< Tag,na >
type apply (line 51) | struct apply
type less_tag (line 58) | struct less_tag
type less (line 67) | struct less
type less_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type less_equal_impl (line 18) | struct less_equal_impl
type less_equal_impl< na,na > (line 31) | struct less_equal_impl< na,na >
type apply (line 33) | struct apply
type less_equal_impl< na,Tag > (line 40) | struct less_equal_impl< na,Tag >
type apply (line 42) | struct apply
type less_equal_impl< Tag,na > (line 49) | struct less_equal_impl< Tag,na >
type apply (line 51) | struct apply
type less_equal_tag (line 58) | struct less_equal_tag
type less_equal (line 67) | struct less_equal
type less_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type less_equal_impl (line 18) | struct less_equal_impl
type less_equal_impl< na,na > (line 31) | struct less_equal_impl< na,na >
type apply (line 33) | struct apply
type less_equal_impl< na,Tag > (line 40) | struct less_equal_impl< na,Tag >
type apply (line 42) | struct apply
type less_equal_impl< Tag,na > (line 49) | struct less_equal_impl< Tag,na >
type apply (line 51) | struct apply
type less_equal_tag (line 58) | struct less_equal_tag
type less_equal (line 67) | struct less_equal
type less_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type less_equal_impl (line 18) | struct less_equal_impl
type less_equal_impl< na,na > (line 31) | struct less_equal_impl< na,na >
type apply (line 33) | struct apply
type less_equal_impl< na,Tag > (line 40) | struct less_equal_impl< na,Tag >
type apply (line 42) | struct apply
type less_equal_impl< Tag,na > (line 49) | struct less_equal_impl< Tag,na >
type apply (line 51) | struct apply
type less_equal_tag (line 58) | struct less_equal_tag
type less_equal (line 67) | struct less_equal
type less_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type less_equal_impl (line 18) | struct less_equal_impl
type less_equal_impl< na,na > (line 31) | struct less_equal_impl< na,na >
type apply (line 33) | struct apply
type less_equal_impl< na,Tag > (line 40) | struct less_equal_impl< na,Tag >
type apply (line 42) | struct apply
type less_equal_impl< Tag,na > (line 49) | struct less_equal_impl< Tag,na >
type apply (line 51) | struct apply
type less_equal_tag (line 58) | struct less_equal_tag
type less_equal (line 67) | struct less_equal
type less_equal_impl< integral_c_tag,integral_c_tag > (line 85) | struct less_equal_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/list.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type list (line 22) | struct list
type list<
na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 27) | struct list<
type list<
T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 39) | struct list<
type list<
T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 51) | struct list<
type list<
T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 63) | struct list<
type list<
T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 75) | struct list<
type list<
T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 87) | struct list<
type list<
T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 100) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 113) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 126) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
, na, na, na
> (line 139) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
, na, na, na
> (line 152) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
, na, na, na
> (line 166) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
, na, na, na, na
> (line 180) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
, na, na, na, na
> (line 194) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
, na, na, na, na
> (line 208) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
, na, na, na, na
> (line 222) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, na, na, na, na
> (line 239) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, na, na, na
> (line 257) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, na, na
> (line 275) | struct list<
type list<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, T18, na
> (line 293) | struct list<
type list (line 313) | struct list
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/list_c.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type list_c (line 23) | struct list_c
type list_c<
T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 28) | struct list_c<
type list_c<
T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 41) | struct list_c<
type list_c<
T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 54) | struct list_c<
type list_c<
T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 67) | struct list_c<
type list_c<
T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 80) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 93) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX
> (line 106) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX
> (line 120) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX
> (line 134) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX
> (line 148) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
, LONG_MAX
> (line 162) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 176) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 189) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 202) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 216) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14
, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 232) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14
, C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
> (line 248) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14
, C15, C16, LONG_MAX, LONG_MAX, LONG_MAX
> (line 265) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14
, C15, C16, C17, LONG_MAX, LONG_MAX
> (line 282) | struct list_c<
type list_c<
T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14
, C15, C16, C17, C18, LONG_MAX
> (line 299) | struct list_c<
type list_c (line 318) | struct list_c
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/map.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type map (line 22) | struct map
type map<
na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 27) | struct map<
type map<
T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 39) | struct map<
type map<
T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 51) | struct map<
type map<
T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 63) | struct map<
type map<
T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 75) | struct map<
type map<
T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 87) | struct map<
type map<
T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 100) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 113) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
, na, na, na
> (line 126) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
, na, na, na
> (line 139) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
, na, na, na
> (line 152) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
, na, na, na
> (line 166) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
, na, na, na, na
> (line 180) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
, na, na, na, na
> (line 194) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
, na, na, na, na
> (line 208) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
, na, na, na, na
> (line 222) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, na, na, na, na
> (line 239) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, na, na, na
> (line 257) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, na, na
> (line 275) | struct map<
type map<
T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
, T15, T16, T17, T18, na
> (line 293) | struct map<
type map (line 313) | struct map
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/minus.hpp
type minus_impl (line 18) | struct minus_impl
type minus_impl< na,na > (line 31) | struct minus_impl< na,na >
type apply (line 33) | struct apply
type minus_impl< na,Tag > (line 40) | struct minus_impl< na,Tag >
type apply (line 42) | struct apply
type minus_impl< Tag,na > (line 49) | struct minus_impl< Tag,na >
type apply (line 51) | struct apply
type minus_tag (line 58) | struct minus_tag
function BOOST_MPL_AUX_NA_SPEC2 (line 123) | BOOST_MPL_AUX_NA_SPEC2(2, 5, minus)
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/modulus.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type modulus_impl (line 18) | struct modulus_impl
type modulus_impl< na,na > (line 31) | struct modulus_impl< na,na >
type apply (line 33) | struct apply
type modulus_impl< na,Tag > (line 40) | struct modulus_impl< na,Tag >
type apply (line 42) | struct apply
type modulus_impl< Tag,na > (line 49) | struct modulus_impl< Tag,na >
type apply (line 51) | struct apply
type modulus_tag (line 58) | struct modulus_tag
type modulus (line 67) | struct modulus
type modulus_impl< integral_c_tag,integral_c_tag > (line 84) | struct modulus_impl< integral_c_tag,integral_c_tag >
type apply (line 86) | struct apply
type mpl (line 82) | namespace mpl {
type modulus_impl (line 18) | struct modulus_impl
type modulus_impl< na,na > (line 31) | struct modulus_impl< na,na >
type apply (line 33) | struct apply
type modulus_impl< na,Tag > (line 40) | struct modulus_impl< na,Tag >
type apply (line 42) | struct apply
type modulus_impl< Tag,na > (line 49) | struct modulus_impl< Tag,na >
type apply (line 51) | struct apply
type modulus_tag (line 58) | struct modulus_tag
type modulus (line 67) | struct modulus
type modulus_impl< integral_c_tag,integral_c_tag > (line 84) | struct modulus_impl< integral_c_tag,integral_c_tag >
type apply (line 86) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type modulus_impl (line 18) | struct modulus_impl
type modulus_impl< na,na > (line 31) | struct modulus_impl< na,na >
type apply (line 33) | struct apply
type modulus_impl< na,Tag > (line 40) | struct modulus_impl< na,Tag >
type apply (line 42) | struct apply
type modulus_impl< Tag,na > (line 49) | struct modulus_impl< Tag,na >
type apply (line 51) | struct apply
type modulus_tag (line 58) | struct modulus_tag
type modulus (line 67) | struct modulus
type modulus_impl< integral_c_tag,integral_c_tag > (line 84) | struct modulus_impl< integral_c_tag,integral_c_tag >
type apply (line 86) | struct apply
type mpl (line 82) | namespace mpl {
type modulus_impl (line 18) | struct modulus_impl
type modulus_impl< na,na > (line 31) | struct modulus_impl< na,na >
type apply (line 33) | struct apply
type modulus_impl< na,Tag > (line 40) | struct modulus_impl< na,Tag >
type apply (line 42) | struct apply
type modulus_impl< Tag,na > (line 49) | struct modulus_impl< Tag,na >
type apply (line 51) | struct apply
type modulus_tag (line 58) | struct modulus_tag
type modulus (line 67) | struct modulus
type modulus_impl< integral_c_tag,integral_c_tag > (line 84) | struct modulus_impl< integral_c_tag,integral_c_tag >
type apply (line 86) | struct apply
FILE: benchmarks/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp
type boost (line 12) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type not_equal_to_impl (line 18) | struct not_equal_to_impl
type not_equal_to_impl< na,na > (line 31) | struct not_equal_to_impl< na,na >
type apply (line 33) | struct apply
type not_equal_to_impl< na,Tag > (line 40) | struct not_equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type not_equal_to_impl< Tag,na > (line 49) | struct not_equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type not_equal_to_tag (line 58) | struct not_equal_to_tag
type not_equal_to (line 67) | struct not_equal_to
type not_equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct not_equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type mpl (line 82) | namespace mpl {
type not_equal_to_impl (line 18) | struct not_equal_to_impl
type not_equal_to_impl< na,na > (line 31) | struct not_equal_to_impl< na,na >
type apply (line 33) | struct apply
type not_equal_to_impl< na,Tag > (line 40) | struct not_equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type not_equal_to_impl< Tag,na > (line 49) | struct not_equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type not_equal_to_tag (line 58) | struct not_equal_to_tag
type not_equal_to (line 67) | struct not_equal_to
type not_equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct not_equal_to_impl< integral_c_tag,integral_c_tag >
type apply (line 87) | struct apply
type boost (line 82) | namespace boost { namespace mpl {
type mpl (line 12) | namespace mpl {
type not_equal_to_impl (line 18) | struct not_equal_to_impl
type not_equal_to_impl< na,na > (line 31) | struct not_equal_to_impl< na,na >
type apply (line 33) | struct apply
type not_equal_to_impl< na,Tag > (line 40) | struct not_equal_to_impl< na,Tag >
type apply (line 42) | struct apply
type not_equal_to_impl< Tag,na > (line 49) | struct not_equal_to_impl< Tag,na >
type apply (line 51) | struct apply
type not_equal_to_tag (line 58) | struct not_equal_to_tag
type not_equal_to (line 67) | struct not_equal_to
type not_equal_to_impl< integral_c_tag,integral_c_tag > (line 85) | struct not_equal_to_i
Copy disabled (too large)
Download .json
Condensed preview — 1830 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (13,033K chars).
[
{
"path": ".gitignore",
"chars": 557,
"preview": "*.ipch\r\n*.suo\r\n*.user\r\n*.sdf\r\n*.opensdf\r\n*.exe\r\n*.pdb\r\n*.vs\r\n*.VC.db\r\nbuild/bin/\r\nbuild/*.o\r\nbuild/*.log\r\nbuild/msvc16/*"
},
{
"path": "CMakeLists.txt",
"chars": 2281,
"preview": "cmake_minimum_required(VERSION 3.9)\nproject(concurrentqueue VERSION 1.0.0)\n\ninclude(GNUInstallDirs)\ninclude(CMakePackage"
},
{
"path": "LICENSE.md",
"chars": 3266,
"preview": "This license file applies to everything in this repository except that which\nis explicitly annotated as being written by"
},
{
"path": "README.md",
"chars": 28071,
"preview": "# moodycamel::ConcurrentQueue<T>\r\n\r\nAn industrial-strength lock-free queue for C++.\r\n\r\nNote: If all you need is a single"
},
{
"path": "benchmarks/benchmarks.cpp",
"chars": 60521,
"preview": "// ©2013-2014 Cameron Desrochers.\n// Distributed under the simplified BSD license (see the LICENSE file that\n// should h"
},
{
"path": "benchmarks/boost/LICENSE_1_0.txt",
"chars": 1361,
"preview": "Boost Software License - Version 1.0 - August 17th, 2003\r\n\r\nPermission is hereby granted, free of charge, to any person "
},
{
"path": "benchmarks/boost/README.txt",
"chars": 130,
"preview": "This is a partial copy of Boost 1.60, specifically only the parts that\r\nboost/lockfree/queue.hpp depends on (extracted u"
},
{
"path": "benchmarks/boost/array.hpp",
"chars": 15780,
"preview": "/* The following code declares class array,\n * an STL container (as wrapper) for arrays of constant size.\n *\n * See\n * "
},
{
"path": "benchmarks/boost/assert.hpp",
"chars": 2625,
"preview": "//\n// boost/assert.hpp - BOOST_ASSERT(expr)\n// BOOST_ASSERT_MSG(expr, msg)\n// B"
},
{
"path": "benchmarks/boost/atomic/atomic.hpp",
"chars": 2520,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/atomic_flag.hpp",
"chars": 775,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/capabilities.hpp",
"chars": 4996,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/atomic_flag.hpp",
"chars": 2025,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/atomic_template.hpp",
"chars": 31249,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/bitwise_cast.hpp",
"chars": 1277,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_alpha.hpp",
"chars": 920,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_arm.hpp",
"chars": 2087,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_atomic.hpp",
"chars": 4322,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_ppc.hpp",
"chars": 968,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_sparc.hpp",
"chars": 920,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_sync.hpp",
"chars": 1969,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_gcc_x86.hpp",
"chars": 1793,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_linux_arm.hpp",
"chars": 963,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_msvc_arm.hpp",
"chars": 923,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_msvc_x86.hpp",
"chars": 1401,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/caps_windows.hpp",
"chars": 880,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/config.hpp",
"chars": 2419,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/int_sizes.hpp",
"chars": 4947,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/interlocked.hpp",
"chars": 30272,
"preview": "#ifndef BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP\n#define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP\n\n// Copyright (c) 2009 Helge Ba"
},
{
"path": "benchmarks/boost/atomic/detail/link.hpp",
"chars": 1534,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/lockpool.hpp",
"chars": 1299,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/operations.hpp",
"chars": 646,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/operations_fwd.hpp",
"chars": 808,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/operations_lockfree.hpp",
"chars": 804,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_cas_based.hpp",
"chars": 3647,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_emulated.hpp",
"chars": 5338,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_extending_cas_based.hpp",
"chars": 2337,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_alpha.hpp",
"chars": 26511,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_arm.hpp",
"chars": 42896,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_atomic.hpp",
"chars": 15889,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_ppc.hpp",
"chars": 24990,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_sparc.hpp",
"chars": 7497,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_sync.hpp",
"chars": 10125,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_x86.hpp",
"chars": 16729,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_gcc_x86_dcas.hpp",
"chars": 23319,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_linux_arm.hpp",
"chars": 6029,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_msvc_arm.hpp",
"chars": 33055,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_msvc_common.hpp",
"chars": 1120,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_msvc_x86.hpp",
"chars": 31950,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/ops_windows.hpp",
"chars": 7720,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/pause.hpp",
"chars": 1030,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at"
},
{
"path": "benchmarks/boost/atomic/detail/platform.hpp",
"chars": 3716,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/detail/storage_type.hpp",
"chars": 6583,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic/fences.hpp",
"chars": 1618,
"preview": "/*\n * Distributed under the Boost Software License, Version 1.0.\n * (See accompanying file LICENSE_1_0.txt or copy at\n *"
},
{
"path": "benchmarks/boost/atomic.hpp",
"chars": 400,
"preview": "#ifndef BOOST_ATOMIC_HPP\n#define BOOST_ATOMIC_HPP\n\n// Copyright (c) 2011 Helge Bahmann\n//\n// Distributed under the Boo"
},
{
"path": "benchmarks/boost/config/abi/borland_prefix.hpp",
"chars": 1002,
"preview": "// (C) Copyright John Maddock 2003. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/abi/borland_suffix.hpp",
"chars": 280,
"preview": "// (C) Copyright John Maddock 2003. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/abi/msvc_prefix.hpp",
"chars": 819,
"preview": "// (C) Copyright John Maddock 2003. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/abi/msvc_suffix.hpp",
"chars": 252,
"preview": "// (C) Copyright John Maddock 2003. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/abi_prefix.hpp",
"chars": 698,
"preview": "// abi_prefix header -------------------------------------------------------//\n\n// (c) Copyright John Maddock 2003\n "
},
{
"path": "benchmarks/boost/config/abi_suffix.hpp",
"chars": 781,
"preview": "// abi_sufffix header -------------------------------------------------------//\n\n// (c) Copyright John Maddock 2003\n "
},
{
"path": "benchmarks/boost/config/auto_link.hpp",
"chars": 14971,
"preview": "// (C) Copyright John Maddock 2003.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/compiler/borland.hpp",
"chars": 9988,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright David Abrahams 2002 - 2003.\n// (C) Copyright Aleksey Gurt"
},
{
"path": "benchmarks/boost/config/compiler/clang.hpp",
"chars": 7824,
"preview": "// (C) Copyright Douglas Gregor 2010\n//\n// Use, modification and distribution are subject to the\n// Boost Software Lic"
},
{
"path": "benchmarks/boost/config/compiler/codegear.hpp",
"chars": 7215,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright David Abrahams 2002 - 2003.\n// (C) Copyright Aleksey Gurt"
},
{
"path": "benchmarks/boost/config/compiler/comeau.hpp",
"chars": 1631,
"preview": "// (C) Copyright John Maddock 2001. \n// (C) Copyright Douglas Gregor 2001. \n// (C) Copyright Peter Dimov 2001. \n// ("
},
{
"path": "benchmarks/boost/config/compiler/common_edg.hpp",
"chars": 4676,
"preview": "// (C) Copyright John Maddock 2001 - 2002.\n// (C) Copyright Jens Maurer 2001.\n// (C) Copyright David Abrahams 2002.\n/"
},
{
"path": "benchmarks/boost/config/compiler/compaq_cxx.hpp",
"chars": 501,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/compiler/cray.hpp",
"chars": 2880,
"preview": "// (C) Copyright John Maddock 2011.\n// (C) Copyright Cray, Inc. 2013\n// Use, modification and distribution are subjec"
},
{
"path": "benchmarks/boost/config/compiler/digitalmars.hpp",
"chars": 3944,
"preview": "// Copyright (C) Christof Meerwald 2003\n// Copyright (C) Dan Watkins 2003\n//\n// Use, modification and distribution ar"
},
{
"path": "benchmarks/boost/config/compiler/gcc.hpp",
"chars": 10008,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright Darin Adler 2001 - 2002.\n// (C) Copyright Jens Maurer 200"
},
{
"path": "benchmarks/boost/config/compiler/gcc_xml.hpp",
"chars": 3391,
"preview": "// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/compiler/greenhills.hpp",
"chars": 815,
"preview": "// (C) Copyright John Maddock 2001. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/compiler/hp_acc.hpp",
"chars": 4849,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright Jens Maurer 2001 - 2003.\n// (C) Copyright Aleksey Gurtovo"
},
{
"path": "benchmarks/boost/config/compiler/intel.hpp",
"chars": 20966,
"preview": "// (C) Copyright John Maddock 2001-8.\n// (C) Copyright Peter Dimov 2001.\n// (C) Copyright Jens Maurer 2001.\n// (C) C"
},
{
"path": "benchmarks/boost/config/compiler/kai.hpp",
"chars": 1023,
"preview": "// (C) Copyright John Maddock 2001. \n// (C) Copyright David Abrahams 2002. \n// (C) Copyright Aleksey Gurtovoy 2002. \n"
},
{
"path": "benchmarks/boost/config/compiler/metrowerks.hpp",
"chars": 5726,
"preview": "// (C) Copyright John Maddock 2001.\n// (C) Copyright Darin Adler 2001.\n// (C) Copyright Peter Dimov 2001.\n// (C) Cop"
},
{
"path": "benchmarks/boost/config/compiler/mpw.hpp",
"chars": 4129,
"preview": "// (C) Copyright John Maddock 2001 - 2002.\n// (C) Copyright Aleksey Gurtovoy 2002.\n// Use, modification and distribut"
},
{
"path": "benchmarks/boost/config/compiler/nvcc.hpp",
"chars": 585,
"preview": "// (C) Copyright Eric Jourdanneau, Joel Falcou 2010\n// Use, modification and distribution are subject to the \n// Boos"
},
{
"path": "benchmarks/boost/config/compiler/pathscale.hpp",
"chars": 4191,
"preview": "// (C) Copyright Bryce Lelbach 2011\n\n// Use, modification and distribution are subject to the\n// Boost Software Licen"
},
{
"path": "benchmarks/boost/config/compiler/pgi.hpp",
"chars": 4993,
"preview": "// (C) Copyright Noel Belcourt 2007.\n// Use, modification and distribution are subject to the\n// Boost Software Licen"
},
{
"path": "benchmarks/boost/config/compiler/sgi_mipspro.hpp",
"chars": 774,
"preview": "// (C) Copyright John Maddock 2001 - 2002. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/compiler/sunpro_cc.hpp",
"chars": 6574,
"preview": "// (C) Copyright John Maddock 2001.\n// (C) Copyright Jens Maurer 2001 - 2003.\n// (C) Copyright Peter Dimov 2002.\n// "
},
{
"path": "benchmarks/boost/config/compiler/vacpp.hpp",
"chars": 5326,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright Toon Knapen 2001 - 2003.\n// (C) Copyright Lie-Quan Lee 20"
},
{
"path": "benchmarks/boost/config/compiler/visualc.hpp",
"chars": 9745,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright Darin Adler 2001 - 2002.\n// (C) Copyright Peter Dimov 200"
},
{
"path": "benchmarks/boost/config/compiler/xlcpp.hpp",
"chars": 7070,
"preview": "// (C) Copyright Douglas Gregor 2010\n//\n// Use, modification and distribution are subject to the\n// Boost Software Lic"
},
{
"path": "benchmarks/boost/config/no_tr1/cmath.hpp",
"chars": 838,
"preview": "// (C) Copyright John Maddock 2008.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/no_tr1/complex.hpp",
"chars": 854,
"preview": "// (C) Copyright John Maddock 2005.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/no_tr1/functional.hpp",
"chars": 878,
"preview": "// (C) Copyright John Maddock 2005.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/no_tr1/memory.hpp",
"chars": 846,
"preview": "// (C) Copyright John Maddock 2005.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/no_tr1/utility.hpp",
"chars": 854,
"preview": "// (C) Copyright John Maddock 2005.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/platform/aix.hpp",
"chars": 881,
"preview": "// (C) Copyright John Maddock 2001 - 2002. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/platform/amigaos.hpp",
"chars": 442,
"preview": "// (C) Copyright John Maddock 2002. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/platform/beos.hpp",
"chars": 593,
"preview": "// (C) Copyright John Maddock 2001. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/platform/bsd.hpp",
"chars": 2498,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Darin Adler 2001. \n// (C) Copyright Douglas Gregor 2002."
},
{
"path": "benchmarks/boost/config/platform/cloudabi.hpp",
"chars": 530,
"preview": "// Copyright Nuxi, https://nuxi.nl/ 2015.\n// Distributed under the Boost Software License, Version 1.0.\n// (See"
},
{
"path": "benchmarks/boost/config/platform/cray.hpp",
"chars": 449,
"preview": "// (C) Copyright John Maddock 2011.\n// Use, modification and distribution are subject to the\n// Boost Software Licens"
},
{
"path": "benchmarks/boost/config/platform/cygwin.hpp",
"chars": 1392,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/platform/haiku.hpp",
"chars": 800,
"preview": "// (C) Copyright Jessica Hamilton 2014.\n// Use, modification and distribution are subject to the\n// Boost Software Li"
},
{
"path": "benchmarks/boost/config/platform/hpux.hpp",
"chars": 2477,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 2001 - 2003. \n// (C) Copyright David Abraham"
},
{
"path": "benchmarks/boost/config/platform/irix.hpp",
"chars": 789,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 2003. \n// Use, modification and distribution"
},
{
"path": "benchmarks/boost/config/platform/linux.hpp",
"chars": 2580,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 2001 - 2003. \n// Use, modification and distr"
},
{
"path": "benchmarks/boost/config/platform/macos.hpp",
"chars": 2343,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Darin Adler 2001 - 2002. \n// (C) Copyright Bill Kempf 20"
},
{
"path": "benchmarks/boost/config/platform/qnxnto.hpp",
"chars": 766,
"preview": "// (C) Copyright Jim Douglas 2005. \n// Use, modification and distribution are subject to the \n// Boost Software Licen"
},
{
"path": "benchmarks/boost/config/platform/solaris.hpp",
"chars": 834,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 2003. \n// Use, modification and distribution"
},
{
"path": "benchmarks/boost/config/platform/symbian.hpp",
"chars": 2614,
"preview": "// (C) Copyright Yuriy Krasnoschek 2009. \n// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 20"
},
{
"path": "benchmarks/boost/config/platform/vms.hpp",
"chars": 749,
"preview": "// (C) Copyright Artyom Beilis 2010. \n// Use, modification and distribution are subject to the \n// Boost Software L"
},
{
"path": "benchmarks/boost/config/platform/vxworks.hpp",
"chars": 15168,
"preview": "// (C) Copyright Dustin Spicuzza 2009.\n// Adapted to vxWorks 6.9 by Peter Brockamp 2012.\n// Use, modification and"
},
{
"path": "benchmarks/boost/config/platform/win32.hpp",
"chars": 2718,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Bill Kempf 2001. \n// (C) Copyright Aleksey Gurtovoy 2003"
},
{
"path": "benchmarks/boost/config/posix_features.hpp",
"chars": 3736,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/requires_threads.hpp",
"chars": 3507,
"preview": "// (C) Copyright John Maddock 2003. \n// Use, modification and distribution are subject to the \n// Boost Software Lice"
},
{
"path": "benchmarks/boost/config/select_compiler_config.hpp",
"chars": 5049,
"preview": "// Boost compiler configuration selection header file\n\n// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright M"
},
{
"path": "benchmarks/boost/config/select_platform_config.hpp",
"chars": 4314,
"preview": "// Boost compiler configuration selection header file\n\n// (C) Copyright John Maddock 2001 - 2002. \n// (C) Copyright J"
},
{
"path": "benchmarks/boost/config/select_stdlib_config.hpp",
"chars": 3880,
"preview": "// Boost compiler configuration selection header file\n\n// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright J"
},
{
"path": "benchmarks/boost/config/stdlib/dinkumware.hpp",
"chars": 7451,
"preview": "// (C) Copyright John Maddock 2001 - 2003.\n// (C) Copyright Jens Maurer 2001.\n// (C) Copyright Peter Dimov 2001.\n// "
},
{
"path": "benchmarks/boost/config/stdlib/libcomo.hpp",
"chars": 2563,
"preview": "// (C) Copyright John Maddock 2002 - 2003. \n// (C) Copyright Jens Maurer 2002 - 2003. \n// (C) Copyright Beman Dawes 2"
},
{
"path": "benchmarks/boost/config/stdlib/libcpp.hpp",
"chars": 2460,
"preview": "// (C) Copyright Christopher Jefferson 2011.\n// Use, modification and distribution are subject to the\n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/stdlib/libstdcpp3.hpp",
"chars": 10181,
"preview": "// (C) Copyright John Maddock 2001.\n// (C) Copyright Jens Maurer 2001.\n// Use, modification and distribution are subj"
},
{
"path": "benchmarks/boost/config/stdlib/modena.hpp",
"chars": 1968,
"preview": "// (C) Copyright Jens Maurer 2001. \n// Use, modification and distribution are subject to the \n// Boost Software Licen"
},
{
"path": "benchmarks/boost/config/stdlib/msl.hpp",
"chars": 2562,
"preview": "// (C) Copyright John Maddock 2001. \n// (C) Copyright Darin Adler 2001. \n// Use, modification and distribution are su"
},
{
"path": "benchmarks/boost/config/stdlib/roguewave.hpp",
"chars": 5991,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Jens Maurer 2001. \n// (C) Copyright David Abrahams 2003."
},
{
"path": "benchmarks/boost/config/stdlib/sgi.hpp",
"chars": 4793,
"preview": "// (C) Copyright John Maddock 2001 - 2003. \n// (C) Copyright Darin Adler 2001. \n// (C) Copyright Jens Maurer 2001 - 2"
},
{
"path": "benchmarks/boost/config/stdlib/stlport.hpp",
"chars": 8304,
"preview": "// (C) Copyright John Maddock 2001 - 2002. \n// (C) Copyright Darin Adler 2001. \n// (C) Copyright Jens Maurer 2001. \n/"
},
{
"path": "benchmarks/boost/config/stdlib/vacpp.hpp",
"chars": 2127,
"preview": "// (C) Copyright John Maddock 2001 - 2002. \n// Use, modification and distribution are subject to the \n// Boost Softwa"
},
{
"path": "benchmarks/boost/config/suffix.hpp",
"chars": 35903,
"preview": "// Boost config.hpp configuration header file ------------------------------//\n// boostinspect:ndprecated_macros -- t"
},
{
"path": "benchmarks/boost/config/user.hpp",
"chars": 5367,
"preview": "// boost/config/user.hpp ---------------------------------------------------//\n\n// (C) Copyright John Maddock 2001. \n"
},
{
"path": "benchmarks/boost/config/warning_disable.hpp",
"chars": 1820,
"preview": "// Copyright John Maddock 2008\n// Use, modification, and distribution is subject to the Boost Software\n// License, Ve"
},
{
"path": "benchmarks/boost/config.hpp",
"chars": 2188,
"preview": "// Boost config.hpp configuration header file ------------------------------//\n\n// (C) Copyright John Maddock 2002.\n/"
},
{
"path": "benchmarks/boost/core/enable_if.hpp",
"chars": 3315,
"preview": "// Boost enable_if library\n\n// Copyright 2003 (c) The Trustees of Indiana University.\n\n// Use, modification, and distrib"
},
{
"path": "benchmarks/boost/core/noncopyable.hpp",
"chars": 1394,
"preview": "// Boost noncopyable.hpp header file --------------------------------------//\n\n// (C) Copyright Beman Dawes 1999-2003"
},
{
"path": "benchmarks/boost/core/swap.hpp",
"chars": 1726,
"preview": "// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker\n//\n// Distributed under the Boost Software Li"
},
{
"path": "benchmarks/boost/cstdint.hpp",
"chars": 18210,
"preview": "// boost cstdint.hpp header file ------------------------------------------//\n\n// (C) Copyright Beman Dawes 1999.\n// "
},
{
"path": "benchmarks/boost/current_function.hpp",
"chars": 1607,
"preview": "#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED\n#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED\n\n// MS compatible compilers supp"
},
{
"path": "benchmarks/boost/detail/is_xxx.hpp",
"chars": 1229,
"preview": "// Copyright David Abrahams 2005. Distributed under the Boost\n// Software License, Version 1.0. (See accompanying\n// fil"
},
{
"path": "benchmarks/boost/detail/iterator.hpp",
"chars": 501,
"preview": "// (C) Copyright David Abrahams 2002.\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying"
},
{
"path": "benchmarks/boost/detail/workaround.hpp",
"chars": 7285,
"preview": "// Copyright David Abrahams 2002.\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompanying fil"
},
{
"path": "benchmarks/boost/exception/exception.hpp",
"chars": 12590,
"preview": "//Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc.\n\n//Distributed under the Boost Software License, Ver"
},
{
"path": "benchmarks/boost/functional/hash/hash_fwd.hpp",
"chars": 998,
"preview": "\n// Copyright 2005-2009 Daniel James.\n// Distributed under the Boost Software License, Version 1.0. (See accompanying\n//"
},
{
"path": "benchmarks/boost/functional/hash_fwd.hpp",
"chars": 322,
"preview": "\n// Copyright 2005-2009 Daniel James.\n// Distributed under the Boost Software License, Version 1.0. (See accompanying\n//"
},
{
"path": "benchmarks/boost/limits.hpp",
"chars": 6146,
"preview": "\n// (C) Copyright John maddock 1999. \n// (C) David Abrahams 2002. Distributed under the Boost\n// Software License, V"
},
{
"path": "benchmarks/boost/lockfree/detail/atomic.hpp",
"chars": 2049,
"preview": "// Copyright (C) 2011-2013 Tim Blechmann\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// acc"
},
{
"path": "benchmarks/boost/lockfree/detail/copy_payload.hpp",
"chars": 1708,
"preview": "// boost lockfree: copy_payload helper\n//\n// Copyright (C) 2011 Tim Blechmann\n//\n// Distributed under the Boost Softw"
},
{
"path": "benchmarks/boost/lockfree/detail/freelist.hpp",
"chars": 16286,
"preview": "// lock-free freelist\n//\n// Copyright (C) 2008-2013 Tim Blechmann\n//\n// Distributed under the Boost Software License,"
},
{
"path": "benchmarks/boost/lockfree/detail/parameter.hpp",
"chars": 2119,
"preview": "// boost lockfree\n//\n// Copyright (C) 2011 Tim Blechmann\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "benchmarks/boost/lockfree/detail/prefix.hpp",
"chars": 1934,
"preview": "// Copyright (C) 2009 Tim Blechmann\n//\n// Distributed under the Boost Software License, Version 1.0. (See\n// accompan"
},
{
"path": "benchmarks/boost/lockfree/detail/tagged_ptr.hpp",
"chars": 631,
"preview": "// tagged pointer, for aba prevention\n//\n// Copyright (C) 2008 Tim Blechmann\n//\n// Distributed under the Boost Softwa"
},
{
"path": "benchmarks/boost/lockfree/detail/tagged_ptr_dcas.hpp",
"chars": 2480,
"preview": "// tagged pointer, for aba prevention\n//\n// Copyright (C) 2008 Tim Blechmann\n//\n// Distributed under the Boost Softwa"
},
{
"path": "benchmarks/boost/lockfree/detail/tagged_ptr_ptrcompression.hpp",
"chars": 3488,
"preview": "// tagged pointer, for aba prevention\n//\n// Copyright (C) 2008, 2009 Tim Blechmann, based on code by Cory Nelson\n//\n//"
},
{
"path": "benchmarks/boost/lockfree/policies.hpp",
"chars": 1714,
"preview": "// boost lockfree\n//\n// Copyright (C) 2011 Tim Blechmann\n//\n// Distributed under the Boost Software License, Version 1.0"
},
{
"path": "benchmarks/boost/lockfree/queue.hpp",
"chars": 18858,
"preview": "// lock-free queue from\n// Michael, M. M. and Scott, M. L.,\n// \"simple, fast and practical non-blocking and blocking "
},
{
"path": "benchmarks/boost/memory_order.hpp",
"chars": 1445,
"preview": "#ifndef BOOST_MEMORY_ORDER_HPP_INCLUDED\n#define BOOST_MEMORY_ORDER_HPP_INCLUDED\n\n// MS compatible compilers support #pra"
},
{
"path": "benchmarks/boost/mpl/O1_size.hpp",
"chars": 1003,
"preview": "\n#ifndef BOOST_MPL_O1_SIZE_HPP_INCLUDED\n#define BOOST_MPL_O1_SIZE_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2000-2004\n"
},
{
"path": "benchmarks/boost/mpl/O1_size_fwd.hpp",
"chars": 559,
"preview": "\n#ifndef BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED\n#define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 20"
},
{
"path": "benchmarks/boost/mpl/always.hpp",
"chars": 838,
"preview": "\n#ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED\n#define BOOST_MPL_ALWAYS_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2001-2004\n//"
},
{
"path": "benchmarks/boost/mpl/and.hpp",
"chars": 1593,
"preview": "\n#ifndef BOOST_MPL_AND_HPP_INCLUDED\n#define BOOST_MPL_AND_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2000-2004\n//\n// Di"
},
{
"path": "benchmarks/boost/mpl/apply.hpp",
"chars": 6087,
"preview": "\n#if !defined(BOOST_PP_IS_ITERATING)\n\n///// header body\n\n#ifndef BOOST_MPL_APPLY_HPP_INCLUDED\n#define BOOST_MPL_APPLY_HP"
},
{
"path": "benchmarks/boost/mpl/apply_fwd.hpp",
"chars": 2663,
"preview": "\n#if !defined(BOOST_PP_IS_ITERATING)\n\n///// header body\n\n#ifndef BOOST_MPL_APPLY_FWD_HPP_INCLUDED\n#define BOOST_MPL_APPL"
},
{
"path": "benchmarks/boost/mpl/apply_wrap.hpp",
"chars": 6177,
"preview": "\n#if !defined(BOOST_PP_IS_ITERATING)\n\n///// header body\n\n#ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED\n#define BOOST_MPL_APP"
},
{
"path": "benchmarks/boost/mpl/arg.hpp",
"chars": 3216,
"preview": "\n#if !defined(BOOST_PP_IS_ITERATING)\n\n///// header body\n\n#ifndef BOOST_MPL_ARG_HPP_INCLUDED\n#define BOOST_MPL_ARG_HPP_IN"
},
{
"path": "benchmarks/boost/mpl/arg_fwd.hpp",
"chars": 711,
"preview": "\n#ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED\n#define BOOST_MPL_ARG_FWD_HPP_INCLUDED\n\n// Copyright Peter Dimov 2001-2002\n// Co"
},
{
"path": "benchmarks/boost/mpl/assert.hpp",
"chars": 14129,
"preview": "\n#ifndef BOOST_MPL_ASSERT_HPP_INCLUDED\n#define BOOST_MPL_ASSERT_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2000-2006\n//"
},
{
"path": "benchmarks/boost/mpl/at_fwd.hpp",
"chars": 546,
"preview": "\n#ifndef BOOST_MPL_AT_FWD_HPP_INCLUDED\n#define BOOST_MPL_AT_FWD_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2000-2004\n//"
},
{
"path": "benchmarks/boost/mpl/aux_/O1_size_impl.hpp",
"chars": 2104,
"preview": "\n#ifndef BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED\n#define BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy "
},
{
"path": "benchmarks/boost/mpl/aux_/adl_barrier.hpp",
"chars": 1559,
"preview": "\n#ifndef BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED\n#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED\n\n// Copyright Aleksey Gur"
},
{
"path": "benchmarks/boost/mpl/aux_/arg_typedef.hpp",
"chars": 776,
"preview": "\n#ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED\n#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED\n\n// Copyright Aleksey Gur"
},
{
"path": "benchmarks/boost/mpl/aux_/arity.hpp",
"chars": 1095,
"preview": "\n#ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED\n#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED\n\n// Copyright Aleksey Gurtovoy 2001-2"
},
{
"path": "benchmarks/boost/mpl/aux_/arity_spec.hpp",
"chars": 1832,
"preview": "\n#ifndef BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED\n#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/begin_end_impl.hpp",
"chars": 2643,
"preview": "\n#ifndef BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED\n#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED\n\n// Copyright Aleks"
},
{
"path": "benchmarks/boost/mpl/aux_/clear_impl.hpp",
"chars": 827,
"preview": "\n#ifndef BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED\n#define BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/common_name_wknd.hpp",
"chars": 873,
"preview": "\n#ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED\n#define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED\n\n// Copyright A"
},
{
"path": "benchmarks/boost/mpl/aux_/config/adl.hpp",
"chars": 1416,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/arrays.hpp",
"chars": 829,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED\n\n// Copyright Aleksey"
},
{
"path": "benchmarks/boost/mpl/aux_/config/bcc.hpp",
"chars": 801,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/bind.hpp",
"chars": 898,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED\n\n// Copyright David Abrah"
},
{
"path": "benchmarks/boost/mpl/aux_/config/compiler.hpp",
"chars": 2134,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED\n\n// Copyright Ale"
},
{
"path": "benchmarks/boost/mpl/aux_/config/ctps.hpp",
"chars": 823,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED\n\n// Copyright Aleksey Gur"
},
{
"path": "benchmarks/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp",
"chars": 736,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUD"
},
{
"path": "benchmarks/boost/mpl/aux_/config/dtp.hpp",
"chars": 1571,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/eti.hpp",
"chars": 1235,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/forwarding.hpp",
"chars": 721,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED\n\n// Copyright"
},
{
"path": "benchmarks/boost/mpl/aux_/config/gcc.hpp",
"chars": 591,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/gpu.hpp",
"chars": 666,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED\n\n// Copyright Eric Niebler "
},
{
"path": "benchmarks/boost/mpl/aux_/config/has_apply.hpp",
"chars": 905,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED\n\n// Copyright A"
},
{
"path": "benchmarks/boost/mpl/aux_/config/has_xxx.hpp",
"chars": 973,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED\n\n// Copyright Aleks"
},
{
"path": "benchmarks/boost/mpl/aux_/config/integral.hpp",
"chars": 1045,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED\n\n// Copyright Ale"
},
{
"path": "benchmarks/boost/mpl/aux_/config/intel.hpp",
"chars": 511,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED\n\n// Copyright Aleksey G"
},
{
"path": "benchmarks/boost/mpl/aux_/config/lambda.hpp",
"chars": 910,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED\n\n// Copyright Aleksey"
},
{
"path": "benchmarks/boost/mpl/aux_/config/msvc.hpp",
"chars": 500,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED\n\n// Copyright Aleksey Gur"
},
{
"path": "benchmarks/boost/mpl/aux_/config/msvc_typename.hpp",
"chars": 684,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED\n\n// Cop"
},
{
"path": "benchmarks/boost/mpl/aux_/config/nttp.hpp",
"chars": 1009,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED\n\n// Copyright Aleksey Gur"
},
{
"path": "benchmarks/boost/mpl/aux_/config/operators.hpp",
"chars": 1069,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED\n\n// Copyright A"
},
{
"path": "benchmarks/boost/mpl/aux_/config/overload_resolution.hpp",
"chars": 818,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCL"
},
{
"path": "benchmarks/boost/mpl/aux_/config/pp_counter.hpp",
"chars": 713,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED\n\n// Copyright"
},
{
"path": "benchmarks/boost/mpl/aux_/config/preprocessor.hpp",
"chars": 1109,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED\n\n// Copyr"
},
{
"path": "benchmarks/boost/mpl/aux_/config/static_constant.hpp",
"chars": 680,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED\n\n//"
},
{
"path": "benchmarks/boost/mpl/aux_/config/ttp.hpp",
"chars": 1168,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED\n\n// Copyright Aleksey Gurto"
},
{
"path": "benchmarks/boost/mpl/aux_/config/use_preprocessed.hpp",
"chars": 525,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED\n\n"
},
{
"path": "benchmarks/boost/mpl/aux_/config/workaround.hpp",
"chars": 497,
"preview": "\n#ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED\n#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED\n\n// Copyright"
},
{
"path": "benchmarks/boost/mpl/aux_/count_args.hpp",
"chars": 2937,
"preview": "\n// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION\n\n// Copyright Aleksey Gurtovoy 2000-2004\n//\n// Dist"
},
{
"path": "benchmarks/boost/mpl/aux_/find_if_pred.hpp",
"chars": 756,
"preview": "\n#ifndef BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED\n#define BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED\n\n// Copyright Aleksey G"
}
]
// ... and 1630 more files (download for full content)
About this extraction
This page contains the full source code of the cameron314/concurrentqueue GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1830 files (11.8 MB), approximately 3.2M tokens, and a symbol index with 17099 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.