Showing preview only (7,359K chars total). Download the full file or copy to clipboard to get everything.
Repository: electronicarts/EASTL
Branch: master
Commit: e323f67e5d93
Files: 416
Total size: 6.9 MB
Directory structure:
gitextract_oaro068o/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ └── c-cpp.yml
├── .gitignore
├── .p4ignore
├── 3RDPARTYLICENSES.TXT
├── CMakeLists.txt
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── _config.yml
├── benchmark/
│ ├── CMakeLists.txt
│ └── source/
│ ├── BenchmarkAlgorithm.cpp
│ ├── BenchmarkBitset.cpp
│ ├── BenchmarkDeque.cpp
│ ├── BenchmarkHash.cpp
│ ├── BenchmarkHeap.cpp
│ ├── BenchmarkList.cpp
│ ├── BenchmarkMap.cpp
│ ├── BenchmarkSet.cpp
│ ├── BenchmarkSort.cpp
│ ├── BenchmarkString.cpp
│ ├── BenchmarkTupleVector.cpp
│ ├── BenchmarkVector.cpp
│ ├── EASTLBenchmark.cpp
│ ├── EASTLBenchmark.h
│ └── main.cpp
├── doc/
│ ├── Benchmarks.md
│ ├── BestPractices.md
│ ├── Bonus/
│ │ └── tuple_vector_readme.md
│ ├── CMake/
│ │ └── EASTL_Project_Integration.md
│ ├── Design.md
│ ├── EASTL.natvis
│ ├── FAQ.md
│ ├── Glossary.md
│ ├── Gotchas.md
│ ├── Introduction.md
│ ├── Maintenance.md
│ ├── Modules.md
│ └── html/
│ ├── EASTL Benchmarks.html
│ ├── EASTL Best Practices.html
│ ├── EASTL Design.html
│ ├── EASTL FAQ.html
│ ├── EASTL Glossary.html
│ ├── EASTL Gotchas.html
│ ├── EASTL Introduction.html
│ ├── EASTL Maintenance.html
│ ├── EASTL Modules.html
│ └── EASTLDoc.css
├── include/
│ └── EASTL/
│ ├── algorithm.h
│ ├── allocator.h
│ ├── allocator_malloc.h
│ ├── any.h
│ ├── array.h
│ ├── atomic.h
│ ├── atomic_raw.h
│ ├── bit.h
│ ├── bitset.h
│ ├── bitvector.h
│ ├── bonus/
│ │ ├── adaptors.h
│ │ ├── call_traits.h
│ │ ├── compressed_pair.h
│ │ ├── fixed_ring_buffer.h
│ │ ├── fixed_tuple_vector.h
│ │ ├── flags.h
│ │ ├── intrusive_sdlist.h
│ │ ├── intrusive_slist.h
│ │ ├── list_map.h
│ │ ├── lru_cache.h
│ │ ├── overloaded.h
│ │ ├── ring_buffer.h
│ │ ├── sort_extra.h
│ │ └── tuple_vector.h
│ ├── chrono.h
│ ├── compare.h
│ ├── core_allocator.h
│ ├── core_allocator_adapter.h
│ ├── deque.h
│ ├── expected.h
│ ├── finally.h
│ ├── fixed_allocator.h
│ ├── fixed_function.h
│ ├── fixed_hash_map.h
│ ├── fixed_hash_set.h
│ ├── fixed_list.h
│ ├── fixed_map.h
│ ├── fixed_set.h
│ ├── fixed_slist.h
│ ├── fixed_string.h
│ ├── fixed_substring.h
│ ├── fixed_vector.h
│ ├── functional.h
│ ├── hash_map.h
│ ├── hash_set.h
│ ├── heap.h
│ ├── initializer_list.h
│ ├── internal/
│ │ ├── atomic/
│ │ │ ├── arch/
│ │ │ │ ├── arch.h
│ │ │ │ ├── arch_acquire_fence.h
│ │ │ │ ├── arch_add_fetch.h
│ │ │ │ ├── arch_and_fetch.h
│ │ │ │ ├── arch_cmpxchg_strong.h
│ │ │ │ ├── arch_cmpxchg_weak.h
│ │ │ │ ├── arch_compiler_barrier.h
│ │ │ │ ├── arch_cpu_pause.h
│ │ │ │ ├── arch_exchange.h
│ │ │ │ ├── arch_fetch_add.h
│ │ │ │ ├── arch_fetch_and.h
│ │ │ │ ├── arch_fetch_or.h
│ │ │ │ ├── arch_fetch_sub.h
│ │ │ │ ├── arch_fetch_xor.h
│ │ │ │ ├── arch_load.h
│ │ │ │ ├── arch_memory_barrier.h
│ │ │ │ ├── arch_or_fetch.h
│ │ │ │ ├── arch_signal_fence.h
│ │ │ │ ├── arch_store.h
│ │ │ │ ├── arch_sub_fetch.h
│ │ │ │ ├── arch_thread_fence.h
│ │ │ │ ├── arch_xor_fetch.h
│ │ │ │ ├── arm/
│ │ │ │ │ ├── arch_arm.h
│ │ │ │ │ ├── arch_arm_acquire_fence.h
│ │ │ │ │ ├── arch_arm_load.h
│ │ │ │ │ ├── arch_arm_memory_barrier.h
│ │ │ │ │ ├── arch_arm_store.h
│ │ │ │ │ └── arch_arm_thread_fence.h
│ │ │ │ └── x86/
│ │ │ │ ├── arch_x86.h
│ │ │ │ ├── arch_x86_acquire_fence.h
│ │ │ │ ├── arch_x86_add_fetch.h
│ │ │ │ ├── arch_x86_and_fetch.h
│ │ │ │ ├── arch_x86_cmpxchg_strong.h
│ │ │ │ ├── arch_x86_cmpxchg_weak.h
│ │ │ │ ├── arch_x86_exchange.h
│ │ │ │ ├── arch_x86_fetch_add.h
│ │ │ │ ├── arch_x86_fetch_and.h
│ │ │ │ ├── arch_x86_fetch_or.h
│ │ │ │ ├── arch_x86_fetch_sub.h
│ │ │ │ ├── arch_x86_fetch_xor.h
│ │ │ │ ├── arch_x86_load.h
│ │ │ │ ├── arch_x86_memory_barrier.h
│ │ │ │ ├── arch_x86_or_fetch.h
│ │ │ │ ├── arch_x86_store.h
│ │ │ │ ├── arch_x86_sub_fetch.h
│ │ │ │ ├── arch_x86_thread_fence.h
│ │ │ │ └── arch_x86_xor_fetch.h
│ │ │ ├── atomic.h
│ │ │ ├── atomic_asserts.h
│ │ │ ├── atomic_base_width.h
│ │ │ ├── atomic_casts.h
│ │ │ ├── atomic_flag.h
│ │ │ ├── atomic_flag_standalone.h
│ │ │ ├── atomic_integral.h
│ │ │ ├── atomic_macros/
│ │ │ │ ├── atomic_macros.h
│ │ │ │ ├── atomic_macros_acquire_fence.h
│ │ │ │ ├── atomic_macros_add_fetch.h
│ │ │ │ ├── atomic_macros_and_fetch.h
│ │ │ │ ├── atomic_macros_base.h
│ │ │ │ ├── atomic_macros_cmpxchg_strong.h
│ │ │ │ ├── atomic_macros_cmpxchg_weak.h
│ │ │ │ ├── atomic_macros_compiler_barrier.h
│ │ │ │ ├── atomic_macros_cpu_pause.h
│ │ │ │ ├── atomic_macros_exchange.h
│ │ │ │ ├── atomic_macros_fetch_add.h
│ │ │ │ ├── atomic_macros_fetch_and.h
│ │ │ │ ├── atomic_macros_fetch_or.h
│ │ │ │ ├── atomic_macros_fetch_sub.h
│ │ │ │ ├── atomic_macros_fetch_xor.h
│ │ │ │ ├── atomic_macros_load.h
│ │ │ │ ├── atomic_macros_memory_barrier.h
│ │ │ │ ├── atomic_macros_or_fetch.h
│ │ │ │ ├── atomic_macros_signal_fence.h
│ │ │ │ ├── atomic_macros_store.h
│ │ │ │ ├── atomic_macros_sub_fetch.h
│ │ │ │ ├── atomic_macros_thread_fence.h
│ │ │ │ └── atomic_macros_xor_fetch.h
│ │ │ ├── atomic_macros.h
│ │ │ ├── atomic_memory_order.h
│ │ │ ├── atomic_pointer.h
│ │ │ ├── atomic_size_aligned.h
│ │ │ ├── atomic_standalone.h
│ │ │ └── compiler/
│ │ │ ├── compiler.h
│ │ │ ├── compiler_acquire_fence.h
│ │ │ ├── compiler_add_fetch.h
│ │ │ ├── compiler_and_fetch.h
│ │ │ ├── compiler_barrier.h
│ │ │ ├── compiler_cmpxchg_strong.h
│ │ │ ├── compiler_cmpxchg_weak.h
│ │ │ ├── compiler_cpu_pause.h
│ │ │ ├── compiler_exchange.h
│ │ │ ├── compiler_fetch_add.h
│ │ │ ├── compiler_fetch_and.h
│ │ │ ├── compiler_fetch_or.h
│ │ │ ├── compiler_fetch_sub.h
│ │ │ ├── compiler_fetch_xor.h
│ │ │ ├── compiler_load.h
│ │ │ ├── compiler_memory_barrier.h
│ │ │ ├── compiler_or_fetch.h
│ │ │ ├── compiler_signal_fence.h
│ │ │ ├── compiler_store.h
│ │ │ ├── compiler_sub_fetch.h
│ │ │ ├── compiler_thread_fence.h
│ │ │ ├── compiler_xor_fetch.h
│ │ │ ├── gcc/
│ │ │ │ ├── compiler_gcc.h
│ │ │ │ ├── compiler_gcc_add_fetch.h
│ │ │ │ ├── compiler_gcc_and_fetch.h
│ │ │ │ ├── compiler_gcc_barrier.h
│ │ │ │ ├── compiler_gcc_cmpxchg_strong.h
│ │ │ │ ├── compiler_gcc_cmpxchg_weak.h
│ │ │ │ ├── compiler_gcc_cpu_pause.h
│ │ │ │ ├── compiler_gcc_exchange.h
│ │ │ │ ├── compiler_gcc_fetch_add.h
│ │ │ │ ├── compiler_gcc_fetch_and.h
│ │ │ │ ├── compiler_gcc_fetch_or.h
│ │ │ │ ├── compiler_gcc_fetch_sub.h
│ │ │ │ ├── compiler_gcc_fetch_xor.h
│ │ │ │ ├── compiler_gcc_load.h
│ │ │ │ ├── compiler_gcc_or_fetch.h
│ │ │ │ ├── compiler_gcc_signal_fence.h
│ │ │ │ ├── compiler_gcc_store.h
│ │ │ │ ├── compiler_gcc_sub_fetch.h
│ │ │ │ ├── compiler_gcc_thread_fence.h
│ │ │ │ └── compiler_gcc_xor_fetch.h
│ │ │ └── msvc/
│ │ │ ├── compiler_msvc.h
│ │ │ ├── compiler_msvc_add_fetch.h
│ │ │ ├── compiler_msvc_and_fetch.h
│ │ │ ├── compiler_msvc_barrier.h
│ │ │ ├── compiler_msvc_cmpxchg_strong.h
│ │ │ ├── compiler_msvc_cmpxchg_weak.h
│ │ │ ├── compiler_msvc_cpu_pause.h
│ │ │ ├── compiler_msvc_exchange.h
│ │ │ ├── compiler_msvc_fetch_add.h
│ │ │ ├── compiler_msvc_fetch_and.h
│ │ │ ├── compiler_msvc_fetch_or.h
│ │ │ ├── compiler_msvc_fetch_sub.h
│ │ │ ├── compiler_msvc_fetch_xor.h
│ │ │ ├── compiler_msvc_or_fetch.h
│ │ │ ├── compiler_msvc_signal_fence.h
│ │ │ ├── compiler_msvc_sub_fetch.h
│ │ │ └── compiler_msvc_xor_fetch.h
│ │ ├── char_traits.h
│ │ ├── concepts.h
│ │ ├── config.h
│ │ ├── copy_help.h
│ │ ├── enable_shared.h
│ │ ├── fill_help.h
│ │ ├── fixed_pool.h
│ │ ├── function.h
│ │ ├── function_detail.h
│ │ ├── function_help.h
│ │ ├── functional_base.h
│ │ ├── generic_iterator.h
│ │ ├── hashtable.h
│ │ ├── in_place_t.h
│ │ ├── integer_sequence.h
│ │ ├── intrusive_hashtable.h
│ │ ├── mem_fn.h
│ │ ├── memory_base.h
│ │ ├── memory_uses_allocator.h
│ │ ├── move_help.h
│ │ ├── pair_fwd_decls.h
│ │ ├── piecewise_construct_t.h
│ │ ├── red_black_tree.h
│ │ ├── smart_ptr.h
│ │ ├── special_member_functions.h
│ │ ├── special_member_functions_expected.h
│ │ ├── special_member_functions_variant_optional.h
│ │ ├── thread_support.h
│ │ ├── tuple_fwd_decls.h
│ │ ├── type_compound.h
│ │ ├── type_detected.h
│ │ ├── type_fundamental.h
│ │ ├── type_pod.h
│ │ ├── type_properties.h
│ │ ├── type_transformations.h
│ │ └── type_void_t.h
│ ├── intrusive_hash_map.h
│ ├── intrusive_hash_set.h
│ ├── intrusive_list.h
│ ├── intrusive_ptr.h
│ ├── iterator.h
│ ├── linked_array.h
│ ├── linked_ptr.h
│ ├── list.h
│ ├── map.h
│ ├── memory.h
│ ├── meta.h
│ ├── numeric.h
│ ├── numeric_limits.h
│ ├── optional.h
│ ├── priority_queue.h
│ ├── queue.h
│ ├── random.h
│ ├── ratio.h
│ ├── safe_ptr.h
│ ├── scoped_array.h
│ ├── scoped_ptr.h
│ ├── segmented_vector.h
│ ├── set.h
│ ├── shared_array.h
│ ├── shared_ptr.h
│ ├── slist.h
│ ├── sort.h
│ ├── span.h
│ ├── stack.h
│ ├── string.h
│ ├── string_hash_map.h
│ ├── string_map.h
│ ├── string_view.h
│ ├── tuple.h
│ ├── type_traits.h
│ ├── unique_ptr.h
│ ├── unordered_map.h
│ ├── unordered_set.h
│ ├── utility.h
│ ├── variant.h
│ ├── vector.h
│ ├── vector_map.h
│ ├── vector_multimap.h
│ ├── vector_multiset.h
│ ├── vector_set.h
│ ├── version.h
│ └── weak_ptr.h
├── scripts/
│ ├── CMake/
│ │ └── CommonCppFlags.cmake
│ └── build.sh
├── source/
│ ├── allocator_eastl.cpp
│ ├── assert.cpp
│ ├── atomic.cpp
│ ├── fixed_pool.cpp
│ ├── hashtable.cpp
│ ├── intrusive_list.cpp
│ ├── numeric_limits.cpp
│ ├── red_black_tree.cpp
│ ├── string.cpp
│ └── thread_support.cpp
└── test/
├── CMakeLists.txt
└── source/
├── ConceptImpls.h
├── EASTLTest.cpp
├── EASTLTest.h
├── EASTLTestAllocator.cpp
├── EASTLTestAllocator.h
├── EASTLTestIterators.h
├── GetTypeName.h
├── TestAlgorithm.cpp
├── TestAllocator.cpp
├── TestAllocatorPropagate.cpp
├── TestAny.cpp
├── TestArray.cpp
├── TestAssociativeContainers.h
├── TestAtomicAsm.cpp
├── TestAtomicBasic.cpp
├── TestAtomicMultiThreaded.cpp
├── TestAtomicRaw.cpp
├── TestBit.cpp
├── TestBitVector.cpp
├── TestBitcast.cpp
├── TestBitset.cpp
├── TestCharTraits.cpp
├── TestChrono.cpp
├── TestConcepts.cpp
├── TestContainerBehaviour.cpp
├── TestCppCXTypeTraits.cpp
├── TestDeque.cpp
├── TestExpected.cpp
├── TestExtra.cpp
├── TestFinally.cpp
├── TestFixedFunction.cpp
├── TestFixedHash.cpp
├── TestFixedList.cpp
├── TestFixedMap.cpp
├── TestFixedSList.cpp
├── TestFixedSet.cpp
├── TestFixedString.cpp
├── TestFixedTupleVector.cpp
├── TestFixedVector.cpp
├── TestFlags.cpp
├── TestFunctional.cpp
├── TestHash.cpp
├── TestHeap.cpp
├── TestIntrusiveHash.cpp
├── TestIntrusiveList.cpp
├── TestIntrusiveSDList.cpp
├── TestIntrusiveSList.cpp
├── TestIterator.cpp
├── TestList.cpp
├── TestListMap.cpp
├── TestLruCache.cpp
├── TestMap.cpp
├── TestMap.h
├── TestMemory.cpp
├── TestMeta.cpp
├── TestNumericLimits.cpp
├── TestOptional.cpp
├── TestRandom.cpp
├── TestRatio.cpp
├── TestRingBuffer.cpp
├── TestSList.cpp
├── TestSegmentedVector.cpp
├── TestSet.cpp
├── TestSet.h
├── TestSmartPtr.cpp
├── TestSort.cpp
├── TestSpan.cpp
├── TestString.cpp
├── TestString.inl
├── TestStringHashMap.cpp
├── TestStringMap.cpp
├── TestStringView.cpp
├── TestStringView.inl
├── TestTuple.cpp
├── TestTupleVector.cpp
├── TestTypeTraits.cpp
├── TestUtility.cpp
├── TestVariant.cpp
├── TestVariant2.cpp
├── TestVector.cpp
├── TestVectorMap.cpp
├── TestVectorSet.cpp
└── main.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
Language : Cpp
BasedOnStyle : Google
Standard : Auto
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
AccessModifierOffset : -4
AlignTrailingComments : true
AllowAllParametersOfDeclarationOnNextLine : false
AllowShortBlocksOnASingleLine : true
AllowShortFunctionsOnASingleLine : true
AllowShortIfStatementsOnASingleLine : false
AllowShortLoopsOnASingleLine : false
BinPackParameters : false
BreakBeforeBraces : Allman
BreakBeforeTernaryOperators : false
BreakConstructorInitializersBeforeComma : true
ColumnLimit : 120
Cpp11BracedListStyle : true
DerivePointerAlignment : true
DerivePointerBinding : false
IndentWidth : 4
KeepEmptyLinesAtTheStartOfBlocks : true
MaxEmptyLinesToKeep : 2
NamespaceIndentation : All
PointerBindsToType : true
SpacesBeforeTrailingComments : 1
SpacesInAngles : false
SpacesInSquareBrackets : false
TabWidth : 4
UseTab : ForIndentation
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-
================================================
FILE: .gitattributes
================================================
# Auto detect text files and perform LF normalization
# http://git-scm.com/docs/gitattributes
* text=auto
.appveyor.yml -text eol=crlf
.appveyor-mingw.yml -text eol=crlf
ci-*.cmd -text eol=crlf
================================================
FILE: .github/workflows/c-cpp.yml
================================================
name: EASTL Build & Test Pipeline
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
checkout:
name: Checkout EASTL
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
with:
path: EASTL/
- name: Upload checked out code
uses: actions/upload-artifact@v4
with:
name: Code
path: EASTL/
build:
needs: checkout
strategy:
fail-fast: false
matrix:
os: [ windows-latest, ubuntu-latest ]
compiler: [ clang, gcc, msvc ]
configuration: [ Debug, Release ]
std_iter_compatibility: [ std_iter_category_disabled, std_iter_category_enabled ]
exclude:
- os: windows-latest
compiler: gcc
- os: windows-latest
compiler: clang
- os: ubuntu-latest
compiler: msvc
include:
- os: windows-latest
compiler: msvc
cxxflags: '/std:c++20 /Zc:char8_t'
- os: ubuntu-latest
compiler: clang
cc: 'clang-18'
cxx: 'clang++-18'
cxxflags: '-std=c++20'
- os: ubuntu-latest
compiler: gcc
cc: 'gcc-14'
cxx: 'g++-14'
cxxflags: '-std=c++2a'
name: Build EASTL
runs-on: ${{ matrix.os }}
steps:
- name: Download a Build Artifact
uses: actions/download-artifact@v4
with:
name: Code
path: Code/
- run: mkdir build
- run: cd build && cmake ../Code -DEASTL_BUILD_BENCHMARK:BOOL=ON -DEASTL_BUILD_TESTS:BOOL=ON -DEASTL_STD_ITERATOR_CATEGORY_ENABLED:BOOL=${{ contains(matrix.std_iter_compatibility, 'enabled') && 'ON' || 'OFF' }}
env:
CXXFLAGS: ${{ matrix.cxxflags }}
CXX: ${{ matrix.cxx }}
CC: ${{ matrix.cc }}
- run: cd build && cmake --build . --config ${{ matrix.configuration }}
- name: Upload binaries
uses: actions/upload-artifact@v4
with:
name: Binaries-${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.configuration }}-${{ matrix.std_iter_compatibility }}
path: build/
test:
needs: build
name: Run EASTL tests
strategy:
fail-fast: false
matrix:
os: [ windows-latest, ubuntu-latest ]
compiler: [ clang, msvc, gcc ]
configuration: [ Debug, Release ]
std_iter_compatibility: [ std_iter_category_disabled, std_iter_category_enabled ]
exclude:
- os: windows-latest
compiler: gcc
- os: windows-latest
compiler: clang
- os: ubuntu-latest
compiler: msvc
runs-on: ${{ matrix.os }}
steps:
- name: Download a Build Artifact
uses: actions/download-artifact@v4
with:
name: Binaries-${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.configuration }}-${{ matrix.std_iter_compatibility }}
path: Binaries/
- if: matrix.os == 'ubuntu-latest'
run: chmod 755 ./Binaries/test/EASTLTest
- run: cd Binaries/test && ctest -C ${{ matrix.configuration }} -V
benchmark:
needs: build
name: Run EASTL benchmarks
strategy:
fail-fast: false
matrix:
os: [ windows-latest, ubuntu-latest ]
compiler: [ clang, msvc, gcc ]
configuration: [ Release ]
exclude:
- os: windows-latest
compiler: gcc
- os: windows-latest
compiler: clang
- os: ubuntu-latest
compiler: msvc
runs-on: ${{ matrix.os }}
steps:
- name: Download a Build Artifact
uses: actions/download-artifact@v4
with:
name: Binaries-${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.configuration }}-std_iter_category_disabled
path: Binaries/
- if: matrix.os == 'ubuntu-latest'
run: chmod 755 ./Binaries/benchmark/EASTLBenchmarks
- run: cd Binaries/benchmark && ctest -C ${{ matrix.configuration }} -V
================================================
FILE: .gitignore
================================================
tags
cscope.out
**/*.swp
**/*.swo
.swp
*.swp
.swo
.TMP
-.d
eastl_build_out
build_bench
bench.bat
build.bat
.p4config
## CMake generated files
CMakeCache.txt
cmake_install.cmake
## Patch files
*.patch
## For Visual Studio Generated projects
*.sln
**/*.vcxproj
**/*.vcxproj.filters
*.VC.opendb
*.sdf
**/*.suo
**/*.user
.vs/*
**/Debug/*
CMakeFiles/*
EASTL.dir/**
RelWithDebInfo/*
Release/*
Win32/*
x64/*
MinSizeRel/*
build*/*
Testing/*
%ALLUSERSPROFILE%/*
# Buck
/buck-out/
/.buckd/
/buckaroo/
.buckconfig.local
BUCKAROO_DEPS
.vscode/settings.json
================================================
FILE: .p4ignore
================================================
/.git/
tags
.gitignore
cscope.out
================================================
FILE: 3RDPARTYLICENSES.TXT
================================================
Additional licenses also apply to this software package as detailed below.
HP STL comes with the following license:
///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 1994
// Hewlett-Packard Company
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation. Hewlett-Packard Company makes no
// representations about the suitability of this software for any
// purpose. It is provided "as is" without express or implied warranty.
///////////////////////////////////////////////////////////////////////////////
libc++ comes with the following license:
==============================================================================
libc++ License
==============================================================================
The libc++ library is dual licensed under both the University of Illinois
"BSD-Like" license and the MIT license. As a user of this code you may choose
to use it under either license. As a contributor, you agree to allow your code
to be used under both.
Full text of the relevant licenses is included below.
==============================================================================
University of Illinois/NCSA
Open Source License
Copyright (c) 2009-2015 by the contributors listed at
http://llvm.org/svn/llvm-project/libcxx/trunk/CREDITS.TXT
All rights reserved.
Developed by:
LLVM Team
University of Illinois at Urbana-Champaign
http://llvm.org
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal with
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimers.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimers in the
documentation and/or other materials provided with the distribution.
* Neither the names of the LLVM Team, University of Illinois at
Urbana-Champaign, nor the names of its contributors may be used to
endorse or promote products derived from this Software without specific
prior written permission.
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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
SOFTWARE.
==============================================================================
Copyright (c) 2009-2014 by the contributors listed at
http://llvm.org/svn/llvm-project/libcxx/trunk/CREDITS.TXT
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
==============================================================================
*No express or implied license to use PlayStation®4 libraries included.
PlayStation®4 development tools and libraries are subject to separate license
with Sony Interactive Entertainment LLC.
==============================================================================
================================================
FILE: CMakeLists.txt
================================================
#-------------------------------------------------------------------------------------------
# Copyright (C) Electronic Arts Inc. All rights reserved.
#-------------------------------------------------------------------------------------------
cmake_minimum_required(VERSION 3.11)
include(FetchContent)
project(EASTL CXX)
#-------------------------------------------------------------------------------------------
# Options
#-------------------------------------------------------------------------------------------
option(EASTL_BUILD_BENCHMARK "Enable generation of build files for benchmark" OFF)
option(EASTL_BUILD_TESTS "Enable generation of build files for tests" OFF)
option(EASTL_STD_ITERATOR_CATEGORY_ENABLED "Enable compatibility with std:: iterator categories" OFF)
option(EASTL_DISABLE_APRIL_2024_DEPRECATIONS "Enable use of API marked for removal in April 2024." OFF)
option(EASTL_DISABLE_SEPT_2024_DEPRECATIONS "Enable use of API marked for removal in September 2024." OFF)
option(EASTL_DISABLE_APRIL_2025_DEPRECATIONS "Enable use of API marked for removal in April 2025." OFF)
#-------------------------------------------------------------------------------------------
# Compiler Flags
#-------------------------------------------------------------------------------------------
set (CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/scripts/CMake")
include(CommonCppFlags)
#-------------------------------------------------------------------------------------------
# Library definition
#-------------------------------------------------------------------------------------------
file(GLOB EASTL_SOURCES "source/*.cpp")
file(GLOB_RECURSE EASTL_HEADERS "include/EASTL/**.h")
add_library(EASTL ${EASTL_SOURCES} ${EASTL_HEADERS})
target_compile_features(EASTL PUBLIC cxx_std_14)
# include both source and headers in the files tab in Visual Studio
source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Header Files" FILES ${EASTL_HEADERS})
if (MSVC)
set(EASTL_NATVIS_DIR "doc")
set(EASTL_NATVIS_FILE "${EASTL_NATVIS_DIR}/EASTL.natvis")
target_sources(EASTL INTERFACE
$<INSTALL_INTERFACE:${EASTL_NATVIS_FILE}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${EASTL_NATVIS_FILE}>
)
endif()
if(EASTL_BUILD_BENCHMARK)
add_subdirectory(benchmark)
endif()
if(EASTL_BUILD_TESTS)
add_subdirectory(test)
endif()
#-------------------------------------------------------------------------------------------
# Defines
#-------------------------------------------------------------------------------------------
add_definitions(-D_CHAR16T)
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
add_definitions(-D_SCL_SECURE_NO_WARNINGS)
add_definitions(-DEASTL_OPENSOURCE=1)
if (EASTL_STD_ITERATOR_CATEGORY_ENABLED)
add_definitions(-DEASTL_STD_ITERATOR_CATEGORY_ENABLED=1)
endif()
#-------------------------------------------------------------------------------------------
# Include dirs
#-------------------------------------------------------------------------------------------
target_include_directories(EASTL PUBLIC include)
#-------------------------------------------------------------------------------------------
# Dependencies
#-------------------------------------------------------------------------------------------
FetchContent_Declare(
EABase
GIT_REPOSITORY https://github.com/electronicarts/EABase.git
GIT_TAG 0699a15efdfd20b6cecf02153bfa5663decb653c
GIT_SUBMODULES "" # This should be temporary until we update the cyclic submodule dependencies in EABase.
)
FetchContent_MakeAvailable(EABase)
target_link_libraries(EASTL EABase)
#-------------------------------------------------------------------------------------------
# Deprecations
#-------------------------------------------------------------------------------------------
if(EASTL_DISABLE_APRIL_2024_DEPRECATIONS)
target_compile_definitions(EASTL PUBLIC EA_DEPRECATIONS_FOR_2024_APRIL=EA_DISABLED)
endif()
if(EASTL_DISABLE_SEPT_2024_DEPRECATIONS)
target_compile_definitions(EASTL PUBLIC EA_DEPRECATIONS_FOR_2024_SEPT=EA_DISABLED)
endif()
if(EASTL_DISABLE_APRIL_2025_DEPRECATIONS)
target_compile_definitions(EASTL PUBLIC EA_DEPRECATIONS_FOR_2025_APRIL=EA_DISABLED)
endif()
#-------------------------------------------------------------------------------------------
# Installation
#-------------------------------------------------------------------------------------------
install(TARGETS EASTL DESTINATION lib)
install(DIRECTORY include/EASTL DESTINATION include)
if (MSVC)
install(FILES ${EASTL_NATVIS_FILE} DESTINATION ${EASTL_NATVIS_DIR})
endif()
================================================
FILE: CONTRIBUTING.md
================================================
## Contributing
Before you can contribute, EA must have a Contributor License Agreement (CLA) on file that has been signed by each contributor.
You can sign here: [Go to CLA](https://electronicarts.na1.echosign.com/public/esignWidget?wid=CBFCIBAA3AAABLblqZhByHRvZqmltGtliuExmuV-WNzlaJGPhbSRg2ufuPsM3P0QmILZjLpkGslg24-UJtek*)
If you want to be recognized for your contributions to EASTL or have a project using EASTL be recognized; you can submit a pull request to the appropriate sections in [README.md](README.md).
Some examples of what the format and information will look like is as follows.
* John Smith - jsmith@domain.com
* John Smith
* Frostbite - Electronic Arts
* My Project - [link to said project]
### Pull Request Policy
All code contributions to EASTL are submitted as [Github pull requests](https://help.github.com/articles/using-pull-requests/). All pull requests will be reviewed by an EASTL maintainer according to the guidelines found in the next section.
Your pull request should:
* merge cleanly
* come with tests
* tests should be minimal and stable
* fail before your fix is applied
* pass the test suite
* code formatting is encoded in clang format
* limit using clang format on new code
* do not deviate from style already established in the files
### Getting the Repository
```bash
git clone https://github.com/electronicarts/EASTL
```
### Running the Unit Tests
EASTL uses CMake as its build system.
* Create and navigate to "your_build_folder":
* mkdir your_build_folder && cd your_build_folder
* Generate build scripts:
* cmake eastl_source_folder -DEASTL_BUILD_TESTS:BOOL=ON
* Build unit tests for "your_config":
* cmake --build . --config your_config
* Run the unit tests for "your_config" from the test folder:
* cd test && ctest -C your_config
Here is an example batch file.
```batch
set build_folder=out
mkdir %build_folder%
pushd %build_folder%
call cmake .. -DEASTL_BUILD_TESTS:BOOL=ON -DEASTL_BUILD_BENCHMARK:BOOL=OFF
call cmake --build . --config Release
call cmake --build . --config Debug
call cmake --build . --config RelWithDebInfo
call cmake --build . --config MinSizeRel
pushd test
call ctest -C Release
call ctest -C Debug
call ctest -C RelWithDebInfo
call ctest -C MinSizeRel
popd
popd
```
Here is an example bash file
```bash
build_folder=out
mkdir $build_folder
pushd $build_folder
cmake .. -DEASTL_BUILD_TESTS:BOOL=ON -DEASTL_BUILD_BENCHMARK:BOOL=OFF
cmake --build . --config Release
cmake --build . --config Debug
cmake --build . --config RelWithDebInfo
cmake --build . --config MinSizeRel
pushd test
ctest -C Release
ctest -C Debug
ctest -C RelWithDebInfo
ctest -C MinSizeRel
popd
popd
```
The value of EASTL_BUILD_BENCHMARK can be toggled to `ON` in order to build projects that include the benchmark program.
================================================
FILE: LICENSE
================================================
BSD 3-Clause License
Copyright (c) 2019, Electronic Arts
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. 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.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
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.
================================================
FILE: README.md
================================================
# EA Standard Template Library
[](https://travis-ci.org/electronicarts/EASTL)
EASTL stands for Electronic Arts Standard Template Library. It is a C++ template library of containers, algorithms, and iterators useful for runtime and tool development across multiple platforms. It is a fairly extensive and robust implementation of such a library and has an emphasis on high performance above all other considerations.
## Usage
If you are familiar with the C++ STL or have worked with other templated container/algorithm libraries, you probably don't need to read this. If you have no familiarity with C++ templates at all, then you probably will need more than this document to get you up to speed. In this case, you need to understand that templates, when used properly, are powerful vehicles for the ease of creation of optimized C++ code. A description of C++ templates is outside the scope of this documentation, but there is plenty of such documentation on the Internet.
EASTL is suitable for any tools and shipping applications where the functionality of EASTL is useful. Modern compilers are capable of producing good code with templates and many people are using them in both current generation and future generation applications on multiple platforms from embedded systems to servers and mainframes.
## Package Managers
You can download and install EASTL using the [Conan](https://github.com/conan-io/conan) package manager:
conan install eastl/3.15.00@
The EASTL package in conan is kept up to date by Conan team members and community contributors. If the version is out-of-date, please [create an issue or pull request](https://github.com/conan-io/conan-center-index) on the Conan Center Index repository.
You can download and install EASTL using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install eastl
The EASTL 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.
## Documentation
Please see [EASTL Introduction](doc/Introduction.md).
## Compiling sources
Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on compiling and testing the source.
## Credits And Maintainers
EASTL was created by Paul Pedriana and he maintained the project for roughly 10 years.
EASTL was subsequently maintained by Roberto Parolin for more than 8 years.
He was the driver and proponent for getting EASTL opensourced.
Rob was a mentor to all members of the team and taught us everything we ever wanted to know about C++ spookyness.
After Rob, maintenance of EASTL passed to Max Winkler for roughly a year, then to Liam Mitchell for about another year.
The current maintainers (since circa 2022) are Galo Rojo and Jonathan Hopkins.
Significant EASTL contributions were made by (in alphabetical order):
* Avery Lee
* Claire Andrews
* Galo Rojo
* Jonathan Hopkins
* JP Flouret
* Liam Mitchell
* Matt Newport
* Max Winkler
* Paul Pedriana
* Roberto Parolin
* Simon Everett
## Contributors
## Projects And Products Using EASTL
* Frostbite - Electronic Arts - [https://www.ea.com/frostbite]
## License
Modified BSD License (3-Clause BSD license) see the file LICENSE in the project root.
================================================
FILE: _config.yml
================================================
theme: jekyll-theme-minimal
================================================
FILE: benchmark/CMakeLists.txt
================================================
#-------------------------------------------------------------------------------------------
# Copyright (C) Electronic Arts Inc. All rights reserved.
#-------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------
# CMake info
#-------------------------------------------------------------------------------------------
cmake_minimum_required(VERSION 3.1)
project(EASTLBenchmarks CXX)
include(CTest)
#-------------------------------------------------------------------------------------------
# Defines
#-------------------------------------------------------------------------------------------
add_definitions(-D_CHAR16T)
#-------------------------------------------------------------------------------------------
# Include directories
#-------------------------------------------------------------------------------------------
include_directories(source)
include_directories(../test/source)
#-------------------------------------------------------------------------------------------
# Compiler Flags
#-------------------------------------------------------------------------------------------
set (CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH};${CMAKE_CURRENT_SOURCE_DIR}/../scripts/CMake")
include(CommonCppFlags)
# Libstdc++ calls new internally, since DLLs have no weak symbols, runtime symbol resolution fails and EASTL's new is not called.
# Linking against static libstdc++ fixes this.
# See https://github.com/electronicarts/EASTL/issues/40 for more info.
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND MINGW)
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -static-libstdc++")
set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} -static-libstdc++")
set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} -static-libstdc++")
endif()
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_BUILD_TYPE MATCHES "MinSizeRel" AND MINGW)
message(FATAL_ERROR "FIXME: MinSizeRel on MingW-w64's Clang fails to link.")
endif()
# The benchmark suite fails to compile if char8_t is enabled, so disable it.
if (EASTL_NO_CHAR8T_FLAG)
add_compile_options(${EASTL_NO_CHAR8T_FLAG})
endif()
#-------------------------------------------------------------------------------------------
# Source files
#-------------------------------------------------------------------------------------------
file(GLOB EASTLBENCHMARK_SOURCES "source/*.cpp")
file(GLOB EASTLTEST_SOURCES "../test/source/EASTLTestAllocator.cpp" "../test/source/EASTLTest.cpp")
file(GLOB EASTLBENCHMARK_HEADERS "source/*.h")
set(SOURCES ${EASTLBENCHMARK_SOURCES} ${EASTLTEST_SOURCES} ${EASTLBENCHMARK_HEADERS})
# include both source and headers in the files view in Visual Studio
source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "Header Files" FILES ${EASTLBENCHMARK_HEADERS})
#-------------------------------------------------------------------------------------------
# Defines
#-------------------------------------------------------------------------------------------
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
add_definitions(-D_SCL_SECURE_NO_WARNINGS)
add_definitions(-DEASTL_THREAD_SUPPORT_AVAILABLE=0)
add_definitions(-DEASTL_OPENSOURCE=1)
add_definitions(-D_SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS) # silence std::hash_map deprecation warnings
if (EASTL_STD_ITERATOR_CATEGORY_ENABLED)
add_definitions(-DEASTL_STD_ITERATOR_CATEGORY_ENABLED=1)
endif()
if(NOT EASTL_BUILD_TESTS)
add_subdirectory(../test/packages/EAStdC ../test/EAStdC)
add_subdirectory(../test/packages/EAAssert ../test/EAAssert)
add_subdirectory(../test/packages/EAThread ../test/EAThread)
add_subdirectory(../test/packages/EATest ../test/EATest)
add_subdirectory(../test/packages/EAMain ../test/EAMain)
endif()
#-------------------------------------------------------------------------------------------
# Executable definition
#-------------------------------------------------------------------------------------------
add_executable(EASTLBenchmarks ${SOURCES})
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
set(EASTLBenchmark_Libraries
EABase
EAAssert
EAMain
EAThread
EAStdC
EASTL
EATest)
target_link_libraries(EASTLBenchmarks ${EASTLBenchmark_Libraries} Threads::Threads)
#-------------------------------------------------------------------------------------------
# Run Unit tests and verify the results.
#-------------------------------------------------------------------------------------------
add_test(EASTLBenchmarkRuns EASTLBenchmarks)
set_tests_properties (EASTLBenchmarkRuns PROPERTIES PASS_REGULAR_EXPRESSION "RETURNCODE=0")
================================================
FILE: benchmark/source/BenchmarkAlgorithm.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// BenchmarkAlgorithm.cpp
//
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EAStdC/EAMemory.h>
#include <EASTL/algorithm.h>
#include <EASTL/sort.h>
#include <EASTL/vector.h>
#include <EASTL/slist.h>
#include <EASTL/list.h>
#include <EASTL/string.h>
#include <EASTL/random.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include <list>
#include <algorithm>
EA_RESTORE_ALL_VC_WARNINGS()
#ifdef _MSC_VER
#pragma warning(disable: 4996) // Function call with parameters that may be unsafe
#endif
using namespace EA;
typedef std::vector<unsigned char> StdVectorUChar;
typedef eastl::vector<unsigned char> EaVectorUChar;
typedef std::vector<signed char> StdVectorSChar;
typedef eastl::vector<signed char> EaVectorSChar;
typedef std::vector<uint32_t> StdVectorUint32;
typedef eastl::vector<uint32_t> EaVectorUint32;
typedef std::vector<uint64_t> StdVectorUint64;
typedef eastl::vector<uint64_t> EaVectorUint64;
typedef std::vector<TestObject> StdVectorTO;
typedef eastl::vector<TestObject> EaVectorTO;
// We make a fake version of C++11 std::next, as some C++ compilers don't currently
// provide the C++11 next algorithm in their standard libraries.
namespace std__
{
template<typename InputIterator>
inline InputIterator
next(InputIterator it, typename std::iterator_traits<InputIterator>::difference_type n = 1)
{
std::advance(it, n);
return it;
}
}
namespace
{
// Exists for the purpose testing PODs that are larger than built-in types.
template <size_t kSize>
struct SizedPOD
{
char memory[kSize];
};
void TestFindEndStd(EA::StdC::Stopwatch& stopwatch, const std::string& sTest, const char* pSearchStringBegin, const char* pSearchStringEnd)
{
stopwatch.Restart();
std::string::const_iterator it = std::find_end(sTest.begin(), sTest.end(), pSearchStringBegin, pSearchStringEnd);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
void TestFindEndEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& sTest, const char* pSearchStringBegin, const char* pSearchStringEnd)
{
stopwatch.Restart();
eastl::string::const_iterator it = eastl::find_end(sTest.begin(), sTest.end(), pSearchStringBegin, pSearchStringEnd);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
void TestSearchStd(EA::StdC::Stopwatch& stopwatch, const std::string& sTest, const char* pSearchStringBegin, const char* pSearchStringEnd)
{
stopwatch.Restart();
std::string::const_iterator it = std::search(sTest.begin(), sTest.end(), pSearchStringBegin, pSearchStringEnd);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
void TestSearchEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& sTest, const char* pSearchStringBegin, const char* pSearchStringEnd)
{
stopwatch.Restart();
eastl::string::const_iterator it = eastl::search(sTest.begin(), sTest.end(), pSearchStringBegin, pSearchStringEnd);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
void TestSearchNStd(EA::StdC::Stopwatch& stopwatch, const std::string& sTest, int n, char c)
{
stopwatch.Restart();
std::string::const_iterator it = std::search_n(sTest.begin(), sTest.end(), n, c);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
void TestSearchNEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& sTest, int n, char c)
{
stopwatch.Restart();
eastl::string::const_iterator it = eastl::search_n(sTest.begin(), sTest.end(), n, c);
stopwatch.Stop();
if(it != sTest.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%c", *it);
}
template <typename Container>
void TestUniqueStd(EA::StdC::Stopwatch& stopwatch, Container& c)
{
stopwatch.Restart();
typename Container::iterator it = std::unique(c.begin(), c.end());
stopwatch.Stop();
c.erase(it, c.end());
}
template <typename Container>
void TestUniqueEa(EA::StdC::Stopwatch& stopwatch, Container& c)
{
stopwatch.Restart();
typename Container::iterator it = eastl::unique(c.begin(), c.end());
stopwatch.Stop();
c.erase(it, c.end());
}
template <typename Container>
void TestMinElementStd(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::const_iterator it = std::min_element(c.begin(), c.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &it);
}
template <typename Container>
void TestMinElementEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::const_iterator it = eastl::min_element(c.begin(), c.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &it);
}
template <typename Container>
void TestCountStd(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::difference_type n = std::count(c.begin(), c.end(), (typename Container::value_type)999999);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)n);
}
template <typename Container>
void TestCountEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::difference_type n = eastl::count(c.begin(), c.end(), (typename Container::value_type)999999);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)n);
}
template <typename Container>
void TestAdjacentFindStd(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::const_iterator it = std::adjacent_find(c.begin(), c.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &it);
}
template <typename Container>
void TestAdjacentFindEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
const typename Container::const_iterator it = eastl::adjacent_find(c.begin(), c.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &it);
}
template <typename Container>
void TestLowerBoundStd(EA::StdC::Stopwatch& stopwatch, const Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
typename Container::const_iterator it = std::lower_bound(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&it);
}
stopwatch.Stop();
}
template <typename Container>
void TestLowerBoundEa(EA::StdC::Stopwatch& stopwatch, Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
typename Container::const_iterator it = eastl::lower_bound(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&it);
}
stopwatch.Stop();
}
template <typename Container>
void TestUpperBoundStd(EA::StdC::Stopwatch& stopwatch, const Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
typename Container::const_iterator it = std::upper_bound(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&it);
}
stopwatch.Stop();
}
template <typename Container>
void TestUpperBoundEa(EA::StdC::Stopwatch& stopwatch, Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
typename Container::const_iterator it = eastl::upper_bound(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&it);
}
stopwatch.Stop();
}
template <typename Container>
void TestEqualRangeStd(EA::StdC::Stopwatch& stopwatch, const Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
std::pair<const typename Container::const_iterator,
const typename Container::const_iterator> itPair = std::equal_range(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&itPair);
}
stopwatch.Stop();
}
template <typename Container>
void TestEqualRangeEa(EA::StdC::Stopwatch& stopwatch, Container& c, const typename Container::value_type* pBegin, const typename Container::value_type* pEnd)
{
stopwatch.Restart();
while(pBegin != pEnd)
{
eastl::pair<const typename Container::const_iterator,
const typename Container::const_iterator> itPair = eastl::equal_range(c.begin(), c.end(), *pBegin++);
Benchmark::DoNothing(&itPair);
}
stopwatch.Stop();
}
template <typename Iterator1, typename Iterator2>
void TestLexicographicalCompareStd(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
{
stopwatch.Restart();
const bool bResult = std::lexicographical_compare(first1, last1, first2, last2);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", bResult ? (int)1 : (int)0);
}
template <typename Iterator1, typename Iterator2>
void TestLexicographicalCompareEa(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
{
stopwatch.Restart();
const bool bResult = eastl::lexicographical_compare(first1, last1, first2, last2);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", bResult ? (int)1 : (int)0);
}
template <typename Iterator, typename OutputIterator>
void TestCopyStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, OutputIterator result)
{
stopwatch.Restart();
std::copy(first, last, result);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)*first);
}
template <typename Iterator, typename OutputIterator>
void TestCopyEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, OutputIterator result)
{
stopwatch.Restart();
eastl::copy(first, last, result);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)*first);
}
template <typename Iterator, typename OutputIterator>
void TestCopyBackwardStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, OutputIterator result)
{
stopwatch.Restart();
std::copy_backward(first, last, result);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)*first);
}
template <typename Iterator, typename OutputIterator>
void TestCopyBackwardEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, OutputIterator result)
{
stopwatch.Restart();
eastl::copy_backward(first, last, result);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (int)*first);
}
template <typename Iterator, typename Value>
void TestFillStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, const Value& v)
{
stopwatch.Restart();
std::fill(first, last, v);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator, typename Value>
void TestFillEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, const Value& v)
{
stopwatch.Restart();
eastl::fill(first, last, v);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator, typename Value>
void TestFillNStd(EA::StdC::Stopwatch& stopwatch, Iterator first, int n, const Value& v)
{
stopwatch.Restart();
std::fill_n(first, n, v);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator, typename Value>
void TestFillNEa(EA::StdC::Stopwatch& stopwatch, Iterator first, int n, const Value& v)
{
stopwatch.Restart();
eastl::fill_n(first, n, v);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator>
void TestReverseStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
std::reverse(first, last);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator>
void TestReverseEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
eastl::reverse(first, last);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator>
void TestRotateStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator middle, Iterator last)
{
stopwatch.Restart();
std::rotate(first, middle, last); // C++11 specifies that rotate has a return value, but not all std implementations return it.
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator>
void TestRotateEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator middle, Iterator last)
{
stopwatch.Restart();
eastl::rotate(first, middle, last);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*first);
}
template <typename Iterator>
void TestMergeStd(EA::StdC::Stopwatch& stopwatch, Iterator firstIn1, Iterator lastIn1, Iterator firstIn2, Iterator lastIn2, Iterator out)
{
stopwatch.Restart();
std::merge(firstIn1, lastIn1, firstIn2, lastIn2, out);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*out);
}
template <typename Iterator>
void TestMergeEa(EA::StdC::Stopwatch& stopwatch, Iterator firstIn1, Iterator lastIn1, Iterator firstIn2, Iterator lastIn2, Iterator out)
{
stopwatch.Restart();
eastl::merge(firstIn1, lastIn1, firstIn2, lastIn2, out);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*out);
}
} // namespace
void BenchmarkAlgorithm1(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
std::string sTestStd;
eastl::string sTestEa;
const char* pSearchString1Begin = "AAA";
const char* pSearchString1End = pSearchString1Begin + strlen(pSearchString1Begin);
const char* pSearchString2Begin = "BBB"; // This is something that doesn't exist searched string.
const char* pSearchString2End = pSearchString2Begin + strlen(pSearchString2Begin);
const char* pSearchString3Begin = "CCC";
const char* pSearchString3End = pSearchString3Begin + strlen(pSearchString3Begin);
for(int i = 0; i < 10000; i++)
sTestStd += "This is a test of the find_end algorithm. ";
sTestEa.assign(sTestStd.data(), (eastl_size_t)sTestStd.length());
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test find_end
///////////////////////////////
sTestStd.insert(sTestStd.size() * 15 / 16, pSearchString1Begin);
sTestEa.insert (sTestEa.size() * 15 / 16, pSearchString1Begin);
TestFindEndStd(stopwatch1, sTestStd, pSearchString1Begin, pSearchString1End);
TestFindEndEa (stopwatch2, sTestEa, pSearchString1Begin, pSearchString1End);
if(i == 1)
Benchmark::AddResult("algorithm/find_end/string/end", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
sTestStd.insert(sTestStd.size() / 2, pSearchString2Begin);
sTestEa.insert (sTestEa.size() / 2, pSearchString2Begin);
TestFindEndStd(stopwatch1, sTestStd, pSearchString2Begin, pSearchString2End);
TestFindEndEa (stopwatch2, sTestEa, pSearchString2Begin, pSearchString2End);
if(i == 1)
Benchmark::AddResult("algorithm/find_end/string/middle", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFindEndStd(stopwatch1, sTestStd, pSearchString3Begin, pSearchString3End);
TestFindEndEa (stopwatch2, sTestEa, pSearchString3Begin, pSearchString3End);
if(i == 1)
Benchmark::AddResult("algorithm/find_end/string/none", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test search
///////////////////////////////
TestSearchStd(stopwatch1, sTestStd, pSearchString1Begin, pSearchString1End);
TestSearchEa (stopwatch2, sTestEa, pSearchString1Begin, pSearchString1End);
if(i == 1)
Benchmark::AddResult("algorithm/search/string<char>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test search_n
///////////////////////////////
TestSearchNStd(stopwatch1, sTestStd, 3, 'A');
TestSearchNEa (stopwatch2, sTestEa, 3, 'A');
if(i == 1)
Benchmark::AddResult("algorithm/search_n/string<char>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test adjacent_find
///////////////////////////////
}
}
}
void BenchmarkAlgorithm2(EASTLTest_Rand& rng, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
StdVectorUint32 stdVectorUint32;
EaVectorUint32 eaVectorUint32;
StdVectorUint64 stdVectorUint64;
EaVectorUint64 eaVectorUint64;
StdVectorTO stdVectorTO;
EaVectorTO eaVectorTO;
for(int i = 0; i < 2; i++)
{
stdVectorUint32.clear();
eaVectorUint32.clear();
for(int j = 0; j < 100000; j++)
{
stdVectorUint32.push_back(j);
eaVectorUint32.push_back(j);
stdVectorUint64.push_back(j);
eaVectorUint64.push_back(j);
stdVectorTO.push_back(TestObject(j));
eaVectorTO.push_back(TestObject(j));
if((rng() % 16) == 0)
{
stdVectorUint32.push_back(i);
eaVectorUint32.push_back(i);
stdVectorUint64.push_back(j);
eaVectorUint64.push_back(j);
stdVectorTO.push_back(TestObject(j));
eaVectorTO.push_back(TestObject(j));
if((rng() % 16) == 0)
{
stdVectorUint32.push_back(i);
eaVectorUint32.push_back(i);
stdVectorUint64.push_back(j);
eaVectorUint64.push_back(j);
stdVectorTO.push_back(TestObject(j));
eaVectorTO.push_back(TestObject(j));
}
}
}
///////////////////////////////
// Test unique
///////////////////////////////
TestUniqueStd(stopwatch1, stdVectorUint32);
TestUniqueEa (stopwatch2, eaVectorUint32);
if(i == 1)
Benchmark::AddResult("algorithm/unique/vector<uint32_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestUniqueStd(stopwatch1, stdVectorUint64);
TestUniqueEa (stopwatch2, eaVectorUint64);
if(i == 1)
Benchmark::AddResult("algorithm/unique/vector<uint64_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestUniqueStd(stopwatch1, stdVectorTO);
TestUniqueEa (stopwatch2, eaVectorTO);
if(i == 1)
Benchmark::AddResult("algorithm/unique/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test min_element
///////////////////////////////
TestMinElementStd(stopwatch1, stdVectorTO);
TestMinElementEa (stopwatch2, eaVectorTO);
if(i == 1)
Benchmark::AddResult("algorithm/min_element/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test count
///////////////////////////////
TestCountStd(stopwatch1, stdVectorUint64);
TestCountEa (stopwatch2, eaVectorUint64);
if(i == 1)
Benchmark::AddResult("algorithm/count/vector<uint64_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test adjacent_find
///////////////////////////////
// Due to the above unique testing, the container should container unique elements. Let's change that.
stdVectorTO[stdVectorTO.size() - 2] = stdVectorTO[stdVectorTO.size() - 1];
eaVectorTO[eaVectorTO.size() - 2] = eaVectorTO[eaVectorTO.size() - 1];
TestAdjacentFindStd(stopwatch1, stdVectorTO);
TestAdjacentFindEa (stopwatch2, eaVectorTO);
if(i == 1)
Benchmark::AddResult("algorithm/adj_find/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test lower_bound
///////////////////////////////
// Sort the containers for the following tests.
std::sort(stdVectorTO.begin(), stdVectorTO.end());
eaVectorTO.assign(&stdVectorTO[0], &stdVectorTO[0] + stdVectorTO.size());
TestLowerBoundStd(stopwatch1, stdVectorTO, &stdVectorTO[0], &stdVectorTO[0] + stdVectorTO.size());
TestLowerBoundEa (stopwatch2, eaVectorTO, &eaVectorTO[0], &eaVectorTO[0] + eaVectorTO.size());
if(i == 1)
Benchmark::AddResult("algorithm/lower_bound/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test upper_bound
///////////////////////////////
std::sort(stdVectorUint32.begin(), stdVectorUint32.end());
eaVectorUint32.assign(&stdVectorUint32[0], &stdVectorUint32[0] + stdVectorUint32.size());
TestUpperBoundStd(stopwatch1, stdVectorUint32, &stdVectorUint32[0], &stdVectorUint32[0] + stdVectorUint32.size());
TestUpperBoundEa (stopwatch2, eaVectorUint32, &eaVectorUint32[0], &eaVectorUint32[0] + eaVectorUint32.size());
if(i == 1)
Benchmark::AddResult("algorithm/upper_bound/vector<uint32_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test equal_range
///////////////////////////////
// VS2010 (and later versions?) is extremely slow executing this in debug builds. It can take minutes for a
// single TestEqualRangeStd call to complete. It's so slow that it's nearly pointless to execute.
#if !defined(_MSC_VER) || (_MSC_VER < 1600) || !defined(_ITERATOR_DEBUG_LEVEL) || (_ITERATOR_DEBUG_LEVEL < 2)
std::sort(stdVectorUint64.begin(), stdVectorUint64.end());
eaVectorUint64.assign(&stdVectorUint64[0], &stdVectorUint64[0] + stdVectorUint64.size());
TestEqualRangeStd(stopwatch1, stdVectorUint64, &stdVectorUint64[0], &stdVectorUint64[0] + stdVectorUint64.size());
TestEqualRangeEa (stopwatch2, eaVectorUint64, &eaVectorUint64[0], &eaVectorUint64[0] + eaVectorUint64.size());
if(i == 1)
Benchmark::AddResult("algorithm/equal_range/vector<uint64_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
#endif
}
}
}
void BenchmarkAlgorithm3(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
StdVectorUChar stdVectorUChar1(100000);
StdVectorUChar stdVectorUChar2(100000);
EaVectorUChar eaVectorUChar1(100000);
EaVectorUChar eaVectorUChar2(100000);
StdVectorSChar stdVectorSChar1(100000);
StdVectorSChar stdVectorSChar2(100000);
EaVectorSChar eaVectorSChar1(100000);
EaVectorSChar eaVectorSChar2(100000);
StdVectorTO stdVectorTO1(100000);
StdVectorTO stdVectorTO2(100000);
EaVectorTO eaVectorTO1(100000);
EaVectorTO eaVectorTO2(100000);
// All these containers should have values of zero in them.
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test lexicographical_compare
///////////////////////////////
TestLexicographicalCompareStd(stopwatch1, stdVectorUChar1.begin(), stdVectorUChar1.end(), stdVectorUChar2.begin(), stdVectorUChar2.end());
TestLexicographicalCompareEa (stopwatch2, eaVectorUChar1.begin(), eaVectorUChar2.end(), eaVectorUChar2.begin(), eaVectorUChar2.end());
if(i == 1)
Benchmark::AddResult("algorithm/lex_cmp/vector<uchar>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestLexicographicalCompareStd(stopwatch1, &stdVectorSChar1[0], &stdVectorSChar1[0] + stdVectorSChar1.size(), &stdVectorSChar2[0], &stdVectorSChar2[0] + stdVectorSChar2.size());
TestLexicographicalCompareEa (stopwatch2, &eaVectorSChar1[0], &eaVectorSChar1[0] + eaVectorSChar1.size(), &eaVectorSChar2[0], &eaVectorSChar2[0] + eaVectorSChar2.size());
if(i == 1)
Benchmark::AddResult("algorithm/lex_cmp/schar[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestLexicographicalCompareStd(stopwatch1, stdVectorTO1.begin(), stdVectorTO1.end(), stdVectorTO2.begin(), stdVectorTO2.end());
TestLexicographicalCompareEa (stopwatch2, eaVectorTO1.begin(), eaVectorTO1.end(), eaVectorTO2.begin(), eaVectorTO2.end());
if(i == 1)
Benchmark::AddResult("algorithm/lex_cmp/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
void BenchmarkAlgorithm4(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
std::vector<uint32_t> stdVectorUint321(10000);
std::vector<uint32_t> stdVectorUint322(10000);
eastl::vector<uint32_t> eaVectorUint321(10000);
eastl::vector<uint32_t> eaVectorUint322(10000);
std::vector<uint64_t> stdVectorUint64(100000);
eastl::vector<uint64_t> eaVectorUint64(100000);
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test copy
///////////////////////////////
TestCopyStd(stopwatch1, stdVectorUint321.begin(), stdVectorUint321.end(), stdVectorUint322.begin());
TestCopyEa (stopwatch2, eaVectorUint321.begin(), eaVectorUint321.end(), eaVectorUint322.begin());
if(i == 1)
Benchmark::AddResult("algorithm/copy/vector<uint32_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test copy_backward
///////////////////////////////
TestCopyBackwardStd(stopwatch1, stdVectorUint321.begin(), stdVectorUint321.end(), stdVectorUint322.end());
TestCopyBackwardEa (stopwatch2, eaVectorUint321.begin(), eaVectorUint321.end(), eaVectorUint322.end());
if(i == 1)
Benchmark::AddResult("algorithm/copy_backward/vector<uint32_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test fill
///////////////////////////////
TestFillStd(stopwatch1, stdVectorUint64.begin(), stdVectorUint64.end(), UINT64_C(37));
TestFillEa (stopwatch2, eaVectorUint64.begin(), eaVectorUint64.end(), UINT64_C(37));
TestFillStd(stopwatch1, stdVectorUint64.begin(), stdVectorUint64.end(), UINT64_C(37)); // Intentionally do this a second time, as we are finding
TestFillEa (stopwatch2, eaVectorUint64.begin(), eaVectorUint64.end(), UINT64_C(37)); // the results are inconsistent otherwise.
if(EA::StdC::Memcheck64(&eaVectorUint64[0], UINT64_C(37), eaVectorUint64.size()))
EA::UnitTest::Report("eastl algorithm 64 bit fill failure.");
if(i == 1)
Benchmark::AddResult("algorithm/fill/vector<uint64_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test fill_n
///////////////////////////////
TestFillNStd(stopwatch1, stdVectorUint64.begin(), (int)stdVectorUint64.size(), UINT64_C(37));
TestFillNEa (stopwatch2, eaVectorUint64.begin(), (int) eaVectorUint64.size(), UINT64_C(37));
TestFillNStd(stopwatch1, stdVectorUint64.begin(), (int)stdVectorUint64.size(), UINT64_C(37)); // Intentionally do this a second time, as we are finding
TestFillNEa (stopwatch2, eaVectorUint64.begin(), (int) eaVectorUint64.size(), UINT64_C(37)); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill_n/vector<uint64_t>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
void BenchmarkAlgorithm5(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
std::vector<void*> stdVectorVoid(100000);
eastl::vector<void*> eaVectorVoid(100000);
std::vector<char> stdVectorChar(100000);
eastl::vector<char> eaVectorChar(100000);
std::vector<bool> stdVectorBool(100000);
eastl::vector<bool> eaVectorBool(100000);
for(int i = 0; i < 2; i++)
{
TestFillStd(stopwatch1, stdVectorVoid.begin(), stdVectorVoid.end(), (void*)NULL);
TestFillEa (stopwatch2, eaVectorVoid.begin(), eaVectorVoid.end(), (void*)NULL);
if(i == 1)
Benchmark::AddResult("algorithm/fill/vector<void*>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFillStd(stopwatch1, &stdVectorChar[0], &stdVectorChar[0] + stdVectorChar.size(), 'd'); // Intentionally use ' ' and not casted to any type.
TestFillEa (stopwatch2, eaVectorChar.data(), eaVectorChar.data() + eaVectorChar.size(), 'd');
TestFillStd(stopwatch1, &stdVectorChar[0], &stdVectorChar[0] + stdVectorChar.size(), 'd'); // Intentionally do this a second time, as we are finding
TestFillEa (stopwatch2, eaVectorChar.data(), eaVectorChar.data() + eaVectorChar.size(), 'd'); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill/char[]/'d'", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFillStd(stopwatch1, stdVectorChar.begin(), stdVectorChar.end(), (char)'d');
TestFillEa (stopwatch2, eaVectorChar.begin(), eaVectorChar.end(), (char)'d');
TestFillStd(stopwatch1, stdVectorChar.begin(), stdVectorChar.end(), (char)'d'); // Intentionally do this a second time, as we are finding
TestFillEa (stopwatch2, eaVectorChar.begin(), eaVectorChar.end(), (char)'d'); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill/vector<char>/'d'", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFillStd(stopwatch1, stdVectorChar.begin(), stdVectorChar.end(), (char)0);
TestFillEa (stopwatch2, eaVectorChar.begin(), eaVectorChar.end(), (char)0);
TestFillStd(stopwatch1, stdVectorChar.begin(), stdVectorChar.end(), (char)0); // Intentionally do this a second time, as we are finding
TestFillEa (stopwatch2, eaVectorChar.begin(), eaVectorChar.end(), (char)0); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill/vector<char>/0", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFillStd(stopwatch1, eaVectorBool.data(), eaVectorBool.data() + eaVectorBool.size(), false); // Intentionally use eaVectorBool for the array.
TestFillEa (stopwatch2, eaVectorBool.data(), eaVectorBool.data() + eaVectorBool.size(), false);
TestFillStd(stopwatch1, eaVectorBool.data(), eaVectorBool.data() + eaVectorBool.size(), false);
TestFillEa (stopwatch2, eaVectorBool.data(), eaVectorBool.data() + eaVectorBool.size(), false);
if(i == 1)
Benchmark::AddResult("algorithm/fill/bool[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test fill_n
///////////////////////////////
TestFillNStd(stopwatch1, eaVectorChar.data(), (int) eaVectorChar.size(), 'd'); // Intentionally use eaVectorBool for the array.
TestFillNEa (stopwatch2, eaVectorChar.data(), (int) eaVectorChar.size(), 'd');
TestFillNStd(stopwatch1, eaVectorChar.data(), (int) eaVectorChar.size(), 'd'); // Intentionally do this a second time, as we are finding
TestFillNEa (stopwatch2, eaVectorChar.data(), (int) eaVectorChar.size(), 'd'); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill_n/char[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFillNStd(stopwatch1, eaVectorBool.data(), (int) eaVectorBool.size(), false); // Intentionally use eaVectorBool for the array.
TestFillNEa (stopwatch2, eaVectorBool.data(), (int) eaVectorBool.size(), false);
TestFillNStd(stopwatch1, eaVectorBool.data(), (int) eaVectorBool.size(), false); // Intentionally do this a second time, as we are finding
TestFillNEa (stopwatch2, eaVectorBool.data(), (int) eaVectorBool.size(), false); // the results are inconsistent otherwise.
if(i == 1)
Benchmark::AddResult("algorithm/fill_n/bool[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
void BenchmarkAlgorithm6(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
// We allocate this on the heap because some platforms don't always have enough stack space for this.
std::vector<LargePOD>* pstdVectorLP1 = new std::vector<LargePOD>(100);
std::vector<LargePOD>* pstdVectorLP2 = new std::vector<LargePOD>(100);
eastl::vector<LargePOD>* peaVectorLP1 = new eastl::vector<LargePOD>(100);
eastl::vector<LargePOD>* peaVectorLP2 = new eastl::vector<LargePOD>(100);
// Aliases.
std::vector<LargePOD>& stdVectorLP1 = *pstdVectorLP1;
std::vector<LargePOD>& stdVectorLP2 = *pstdVectorLP2;
eastl::vector<LargePOD>& eaVectorLP1 = *peaVectorLP1;
eastl::vector<LargePOD>& eaVectorLP2 = *peaVectorLP2;
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test copy
///////////////////////////////
TestCopyStd(stopwatch1, stdVectorLP1.begin(), stdVectorLP1.end(), stdVectorLP2.begin());
TestCopyEa (stopwatch2, eaVectorLP1.begin(), eaVectorLP1.end(), eaVectorLP2.begin());
if(i == 1)
Benchmark::AddResult("algorithm/copy/vector<LargePOD>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test copy_backward
///////////////////////////////
TestCopyBackwardStd(stopwatch1, stdVectorLP1.begin(), stdVectorLP1.end(), stdVectorLP2.end());
TestCopyBackwardEa (stopwatch2, eaVectorLP1.begin(), eaVectorLP1.end(), eaVectorLP2.end());
if(i == 1)
Benchmark::AddResult("algorithm/copy_backward/vector<LargePOD>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
delete pstdVectorLP1;
delete pstdVectorLP2;
delete peaVectorLP1;
delete peaVectorLP2;
}
void BenchmarkAlgorithm7(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
{
std::list<TestObject> stdListTO(10000);
eastl::list<TestObject> eaListTO(10000);
std::vector<TestObject> stdVectorTO(10000);
eastl::vector<TestObject> eaVectorTO(10000);
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test reverse
///////////////////////////////
TestReverseStd(stopwatch1, stdListTO.begin(), stdListTO.end());
TestReverseEa (stopwatch2, eaListTO.begin(), eaListTO.end());
if(i == 1)
Benchmark::AddResult("algorithm/reverse/list<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestReverseStd(stopwatch1, stdVectorTO.begin(), stdVectorTO.end());
TestReverseEa (stopwatch2, eaVectorTO.begin(), eaVectorTO.end());
if(i == 1)
Benchmark::AddResult("algorithm/reverse/vector<TestObject>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
{
// Create some containers and seed them with incremental values (i.e. 0, 1, 2, 3...).
eastl::slist<int32_t> eaSlistIntLarge(10000);
eastl::generate(eaSlistIntLarge.begin(), eaSlistIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
std::vector< SizedPOD<32> > stdVectorLargePod32(10000);
for(std::vector< SizedPOD<32> >::iterator it = stdVectorLargePod32.begin(); it != stdVectorLargePod32.end(); ++it)
memset(&*it, 0, sizeof(SizedPOD<32>));
eastl::vector< SizedPOD<32> > eaVectorLargePod32(10000);
for(eastl::vector< SizedPOD<32> >::iterator it = eaVectorLargePod32.begin(); it != eaVectorLargePod32.end(); ++it)
memset(&*it, 0, sizeof(SizedPOD<32>));
std::list<int32_t> stdListIntLarge(10000);
eastl::generate(stdListIntLarge.begin(), stdListIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
eastl::list<int32_t> eaListIntLarge(10000);
eastl::generate(eaListIntLarge.begin(), eaListIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
std::vector<int32_t> stdVectorIntLarge(10000);
eastl::generate(stdVectorIntLarge.begin(), stdVectorIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
eastl::vector<int32_t> eaVectorIntLarge(10000);
eastl::generate(eaVectorIntLarge.begin(), eaVectorIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
std::list<int32_t> stdListIntSmall(10);
eastl::generate(stdListIntLarge.begin(), stdListIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
eastl::list<int32_t> eaListIntSmall(10);
eastl::generate(eaListIntLarge.begin(), eaListIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
std::vector<int32_t> stdVectorIntSmall(10);
eastl::generate(stdVectorIntLarge.begin(), stdVectorIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
eastl::vector<int32_t> eaVectorIntSmall(10);
eastl::generate(eaVectorIntLarge.begin(), eaVectorIntLarge.end(), GenerateIncrementalIntegers<int32_t>());
std::list<TestObject> stdListTOLarge(10000);
eastl::generate(stdListTOLarge.begin(), stdListTOLarge.end(), GenerateIncrementalIntegers<TestObject>());
eastl::list<TestObject> eaListTOLarge(10000);
eastl::generate(eaListTOLarge.begin(), eaListTOLarge.end(), GenerateIncrementalIntegers<TestObject>());
std::vector<TestObject> stdVectorTOLarge(10000);
eastl::generate(stdVectorTOLarge.begin(), stdVectorTOLarge.end(), GenerateIncrementalIntegers<TestObject>());
eastl::vector<TestObject> eaVectorTOLarge(10000);
eastl::generate(eaVectorTOLarge.begin(), eaVectorTOLarge.end(), GenerateIncrementalIntegers<TestObject>());
std::list<TestObject> stdListTOSmall(10);
eastl::generate(stdListTOSmall.begin(), stdListTOSmall.end(), GenerateIncrementalIntegers<TestObject>());
eastl::list<TestObject> eaListTOSmall(10);
eastl::generate(eaListTOSmall.begin(), eaListTOSmall.end(), GenerateIncrementalIntegers<TestObject>());
std::vector<TestObject> stdVectorTOSmall(10);
eastl::generate(stdVectorTOSmall.begin(), stdVectorTOSmall.end(), GenerateIncrementalIntegers<TestObject>());
eastl::vector<TestObject> eaVectorTOSmall(10);
eastl::generate(eaVectorTOSmall.begin(), eaVectorTOSmall.end(), GenerateIncrementalIntegers<TestObject>());
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test reverse
///////////////////////////////
// There is no guaranteed Standard Library forward_list or slist.
TestRotateEa (stopwatch2, eaSlistIntLarge.begin(), eastl::next( eaSlistIntLarge.begin(), (eaSlistIntLarge.size() / 2) - 1), eaSlistIntLarge.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/slist<int32_t> large", stopwatch1.GetUnits(), 0 /* untested */, stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdVectorLargePod32.begin(), std__::next(stdVectorLargePod32.begin(), (stdVectorLargePod32.size() / 2) - 1), stdVectorLargePod32.end());
TestRotateEa (stopwatch2, eaVectorLargePod32.begin(), eastl::next( eaVectorLargePod32.begin(), (eaVectorLargePod32.size() / 2) - 1), eaVectorLargePod32.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/vector<SizedPOD<32>> large", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdListIntLarge.begin(), std__::next(stdListIntLarge.begin(), (stdListIntLarge.size() / 2) - 1), stdListIntLarge.end());
TestRotateEa (stopwatch2, eaListIntLarge.begin(), eastl::next( eaListIntLarge.begin(), (eaListIntLarge.size() / 2) - 1), eaListIntLarge.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/list<int32_t> large", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdVectorIntLarge.begin(), std__::next(stdVectorIntLarge.begin(), (stdVectorIntLarge.size() / 2) - 1), stdVectorIntLarge.end());
TestRotateEa (stopwatch2, eaVectorIntLarge.begin(), eastl::next( eaVectorIntLarge.begin(), (eaVectorIntLarge.size() / 2) - 1), eaVectorIntLarge.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/vector<int32_t large>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdListIntSmall.begin(), std__::next(stdListIntSmall.begin(), (stdListIntSmall.size() / 2) - 1), stdListIntSmall.end());
TestRotateEa (stopwatch2, eaListIntSmall.begin(), eastl::next( eaListIntSmall.begin(), (eaListIntSmall.size() / 2) - 1), eaListIntSmall.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/list<int32_t> small", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdVectorIntSmall.begin(), std__::next(stdVectorIntSmall.begin(), (stdVectorIntSmall.size() / 2) - 1), stdVectorIntSmall.end());
TestRotateEa (stopwatch2, eaVectorIntSmall.begin(), eastl::next( eaVectorIntSmall.begin(), (eaVectorIntSmall.size() / 2) - 1), eaVectorIntSmall.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/vector<int32_t small>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdListTOLarge.begin(), std__::next(stdListTOLarge.begin(), (stdListTOLarge.size() / 2) - 1), stdListTOLarge.end());
TestRotateEa (stopwatch2, eaListTOLarge.begin(), eastl::next( eaListTOLarge.begin(), (eaListTOLarge.size() / 2) - 1), eaListTOLarge.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/list<TestObject large>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdVectorTOLarge.begin(), std__::next(stdVectorTOLarge.begin(), (stdVectorTOLarge.size() / 2) - 1), stdVectorTOLarge.end());
TestRotateEa (stopwatch2, eaVectorTOLarge.begin(), eastl::next( eaVectorTOLarge.begin(), (eaVectorTOLarge.size() / 2) - 1), eaVectorTOLarge.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/vector<TestObject large>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdListTOSmall.begin(), std__::next(stdListTOSmall.begin(), (stdListTOSmall.size() / 2) - 1), stdListTOSmall.end());
TestRotateEa (stopwatch2, eaListTOSmall.begin(), eastl::next( eaListTOSmall.begin(), (eaListTOSmall.size() / 2) - 1), eaListTOSmall.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/list<TestObject small>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestRotateStd(stopwatch1, stdVectorTOSmall.begin(), std__::next(stdVectorTOSmall.begin(), (stdVectorTOSmall.size() / 2) - 1), stdVectorTOSmall.end());
TestRotateEa (stopwatch2, eaVectorTOSmall.begin(), eastl::next( eaVectorTOSmall.begin(), (eaVectorTOSmall.size() / 2) - 1), eaVectorTOSmall.end());
if(i == 1)
Benchmark::AddResult("algorithm/rotate/vector<TestObject small>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
void BenchmarkAlgorithm8(EASTLTest_Rand& rng, EA::StdC::Stopwatch& stopwatch1, EA::StdC::Stopwatch& stopwatch2)
{
const uint32_t ElementCount = 10000;
eastl::vector<int> srcVecA(ElementCount);
eastl::vector<int> srcVecB(ElementCount);
std::vector<int> stdVecAInt(ElementCount);
std::vector<int> stdVecBInt(ElementCount);
std::vector<int> stdVecOutInt(2 * ElementCount);
std::vector<TestObject> stdVecATestObject(ElementCount);
std::vector<TestObject> stdVecBTestObject(ElementCount);
std::vector<TestObject> stdVecOutTestObject(2 * ElementCount);
eastl::vector<int> eaVecAInt(ElementCount);
eastl::vector<int> eaVecBInt(ElementCount);
eastl::vector<int> eaVecOutInt(2 * ElementCount);
eastl::vector<TestObject> eaVecATestObject(ElementCount);
eastl::vector<TestObject> eaVecBTestObject(ElementCount);
eastl::vector<TestObject> eaVecOutTestObject(2 * ElementCount);
// Note:
// In some cases the compiler may generate branch free code for the loop body of merge.
// In this situation the performance of merging data that has a random merge selection (i.e. the chance that the smallest
// element is taken from the first or second list is essentially random) is the same as merging data where the choice of
// which list has the smallest element is predictable.
// However, if the compiler doesn't generate branch free code, then the performance of merge will suffer from branch
// misprediction when merging random data and will benefit greatly when misprediction is rare.
// This benchmark is aimed at highlighting what sort of code is being generated, and also showing the impact of
// predictability of the comparisons performed during merge. The branch predictablity /can/ have a large impact
// on merge sort performance.
// 'unpred' is the case where the comparison is unpredictable
// 'pred' is the case where the comparison is mostly predictable
const char* patternDescriptions[][2] =
{
{
"algorithm/merge/vector<int> (unpred)",
"algorithm/merge/vector<int> (pred)",
},
{
"algorithm/merge/vector<TestObject> (unpred)",
"algorithm/merge/vector<TestObject> (pred)",
},
};
enum Pattern
{
P_Random,
P_Predictable,
P_Count
};
for (int pattern = 0; pattern < P_Count; pattern++)
{
if (pattern == P_Random)
{
eastl::generate(srcVecA.begin(), srcVecA.end(), [&]{ return int(rng()); });
eastl::sort(srcVecA.begin(), srcVecA.end());
eastl::generate(srcVecB.begin(), srcVecB.end(), [&] { return int(rng()); });
eastl::sort(srcVecB.begin(), srcVecB.end());
}
else if (pattern == P_Predictable)
{
// The data pattern means that a simple/naive algorithm will select 'runLen' values
// from one list, and then 'runLen' values from the other list (alternating back and forth).
// Of course, a merge algorithm that is more complicated might have a different order of
// comparison.
const int runLen = 32;
for (int i = 0; i < ElementCount; i++)
{
int baseValue = ((i / runLen) * 2 * runLen) + (i % (runLen));
srcVecA[i] = baseValue;
srcVecB[i] = baseValue + runLen;
}
}
///////////////////////////////
// Test merge
///////////////////////////////
for (int i = 0; i < 2; i++)
{
eastl::copy(srcVecA.begin(), srcVecA.end(), stdVecAInt.begin());
eastl::copy(srcVecB.begin(), srcVecB.end(), stdVecBInt.begin());
eastl::copy(srcVecA.begin(), srcVecA.end(), eaVecAInt.begin());
eastl::copy(srcVecB.begin(), srcVecB.end(), eaVecBInt.begin());
TestMergeStd(stopwatch1, stdVecAInt.begin(), stdVecAInt.end(), stdVecBInt.begin(), stdVecBInt.end(), stdVecOutInt.begin());
TestMergeEa(stopwatch2, eaVecAInt.begin(), eaVecAInt.end(), eaVecBInt.begin(), eaVecBInt.end(), eaVecOutInt.begin());
if (i == 1)
{
Benchmark::AddResult(patternDescriptions[0][pattern], stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
for (int j = 0; j < ElementCount; j++)
{
stdVecATestObject[j] = TestObject(srcVecA[j]);
stdVecBTestObject[j] = TestObject(srcVecB[j]);
eaVecATestObject[j] = TestObject(srcVecA[j]);
eaVecBTestObject[j] = TestObject(srcVecB[j]);
}
TestMergeStd(stopwatch1, stdVecATestObject.begin(), stdVecATestObject.end(), stdVecBTestObject.begin(), stdVecBTestObject.end(), stdVecOutTestObject.begin());
TestMergeEa(stopwatch2, eaVecATestObject.begin(), eaVecATestObject.end(), eaVecBTestObject.begin(), eaVecBTestObject.end(), eaVecOutTestObject.begin());
if (i == 1)
{
Benchmark::AddResult(patternDescriptions[1][pattern], stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
}
void BenchmarkAlgorithm()
{
EASTLTest_Printf("Algorithm\n");
EASTLTest_Rand rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
BenchmarkAlgorithm1(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm2(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm3(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm4(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm5(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm6(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm7(rng, stopwatch1, stopwatch2);
BenchmarkAlgorithm8(rng, stopwatch1, stopwatch2);
}
================================================
FILE: benchmark/source/BenchmarkBitset.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#ifdef _MSC_VER
// Microsoft STL generates warnings.
#pragma warning(disable: 4267) // 'initializing' : conversion from 'size_t' to 'const int', possible loss of data
#endif
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/bitset.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <bitset>
EA_RESTORE_ALL_VC_WARNINGS()
using namespace EA;
namespace
{
template <typename Bitset>
void TestSet(EA::StdC::Stopwatch& stopwatch, Bitset& b)
{
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
b.set();
Benchmark::DoNothing(&b);
}
stopwatch.Stop();
}
template <typename Bitset>
void TestSetIndex(EA::StdC::Stopwatch& stopwatch, Bitset& b, size_t index)
{
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
b.set(index);
Benchmark::DoNothing(&b);
}
stopwatch.Stop();
}
template <typename Bitset>
void TestReset(EA::StdC::Stopwatch& stopwatch, Bitset& b)
{
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
b.reset();
Benchmark::DoNothing(&b);
}
stopwatch.Stop();
}
template <typename Bitset>
void TestFlip(EA::StdC::Stopwatch& stopwatch, Bitset& b)
{
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
b.flip();
Benchmark::DoNothing(&b);
}
stopwatch.Stop();
}
template <typename Bitset>
void TestTest(EA::StdC::Stopwatch& stopwatch, Bitset& b, unsigned nANDValue)
{
stopwatch.Restart();
for(unsigned i = 0; i < 100000; i++)
Benchmark::DoNothing(b.test(i & nANDValue)); // We use & instead of % because the former is always fast due to forced power of 2.
stopwatch.Stop();
}
template <typename Bitset>
void TestCount(EA::StdC::Stopwatch& stopwatch, Bitset& b)
{
size_t temp = 0;
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
temp += b.count();
Benchmark::DoNothing(&temp);
}
stopwatch.Stop();
}
template <typename Bitset>
void TestRightShift(EA::StdC::Stopwatch& stopwatch, Bitset& b, size_t n)
{
size_t temp = 0;
stopwatch.Restart();
for(int i = 0; i < 100000; i++)
{
b >>= n;
Benchmark::DoNothing(&temp);
}
stopwatch.Stop();
}
} // namespace
void BenchmarkBitset()
{
EASTLTest_Printf("Bitset\n");
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{
std::bitset<15> stdBitset15;
eastl::bitset<15> eaBitset15;
std::bitset<35> stdBitset35;
eastl::bitset<35> eaBitset35;
std::bitset<75> stdBitset75;
eastl::bitset<75> eaBitset75;
std::bitset<1500> stdBitset1500;
eastl::bitset<1500> eaBitset1500;
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test set()
///////////////////////////////
TestSet(stopwatch1, stdBitset15);
TestSet(stopwatch2, eaBitset15);
if(i == 1)
Benchmark::AddResult("bitset<15>/set()", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSet(stopwatch1, stdBitset35);
TestSet(stopwatch2, eaBitset35);
if(i == 1)
Benchmark::AddResult("bitset<35>/set()", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSet(stopwatch1, stdBitset75);
TestSet(stopwatch2, eaBitset75);
if(i == 1)
Benchmark::AddResult("bitset<75>/set()", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSet(stopwatch1, stdBitset1500);
TestSet(stopwatch2, eaBitset1500);
if(i == 1)
Benchmark::AddResult("bitset<1500>/set()", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test set(index)
///////////////////////////////
TestSetIndex(stopwatch1, stdBitset15, 13);
TestSetIndex(stopwatch2, eaBitset15, 13);
if(i == 1)
Benchmark::AddResult("bitset<15>/set(i)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSetIndex(stopwatch1, stdBitset35, 33);
TestSetIndex(stopwatch2, eaBitset35, 33);
if(i == 1)
Benchmark::AddResult("bitset<35>/set(i)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSetIndex(stopwatch1, stdBitset75, 73);
TestSetIndex(stopwatch2, eaBitset75, 73);
if(i == 1)
Benchmark::AddResult("bitset<75>/set(i)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSetIndex(stopwatch1, stdBitset1500, 730);
TestSetIndex(stopwatch2, eaBitset1500, 730);
if(i == 1)
Benchmark::AddResult("bitset<1500>/set(i)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test reset()
///////////////////////////////
TestReset(stopwatch1, stdBitset15);
TestReset(stopwatch2, eaBitset15);
if(i == 1)
Benchmark::AddResult("bitset<15>/reset", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestReset(stopwatch1, stdBitset35);
TestReset(stopwatch2, eaBitset35);
if(i == 1)
Benchmark::AddResult("bitset<35>/reset", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestReset(stopwatch1, stdBitset75);
TestReset(stopwatch2, eaBitset75);
if(i == 1)
Benchmark::AddResult("bitset<75>/reset", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestReset(stopwatch1, stdBitset1500);
TestReset(stopwatch2, eaBitset1500);
if(i == 1)
Benchmark::AddResult("bitset<1500>/reset", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test flip
///////////////////////////////
TestFlip(stopwatch1, stdBitset15);
TestFlip(stopwatch2, eaBitset15);
if(i == 1)
Benchmark::AddResult("bitset<15>/flip", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFlip(stopwatch1, stdBitset35);
TestFlip(stopwatch2, eaBitset35);
if(i == 1)
Benchmark::AddResult("bitset<35>/flip", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFlip(stopwatch1, stdBitset75);
TestFlip(stopwatch2, eaBitset75);
if(i == 1)
Benchmark::AddResult("bitset<75>/flip", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFlip(stopwatch1, stdBitset1500);
TestFlip(stopwatch2, eaBitset1500);
if(i == 1)
Benchmark::AddResult("bitset<1500>/flip", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test test
///////////////////////////////
TestTest(stopwatch1, stdBitset15, 7);
TestTest(stopwatch2, eaBitset15, 7);
if(i == 1)
Benchmark::AddResult("bitset<15>/test", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestTest(stopwatch1, stdBitset35, 31);
TestTest(stopwatch2, eaBitset35, 31);
if(i == 1)
Benchmark::AddResult("bitset<35>/test", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestTest(stopwatch1, stdBitset75, 63);
TestTest(stopwatch2, eaBitset75, 63);
if(i == 1)
Benchmark::AddResult("bitset<75>/test", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestTest(stopwatch1, stdBitset1500, 1023);
TestTest(stopwatch2, eaBitset1500, 1023);
if(i == 1)
Benchmark::AddResult("bitset<1500>/test", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test count
///////////////////////////////
TestCount(stopwatch1, stdBitset15);
TestCount(stopwatch2, eaBitset15);
if(i == 1)
Benchmark::AddResult("bitset<15>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestCount(stopwatch1, stdBitset35);
TestCount(stopwatch2, eaBitset35);
if(i == 1)
Benchmark::AddResult("bitset<35>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestCount(stopwatch1, stdBitset75);
TestCount(stopwatch2, eaBitset75);
if(i == 1)
Benchmark::AddResult("bitset<75>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestCount(stopwatch1, stdBitset1500);
TestCount(stopwatch2, eaBitset1500);
if(i == 1)
Benchmark::AddResult("bitset<1500>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test >>=
///////////////////////////////
TestRightShift(stopwatch1, stdBitset15, 1);
TestRightShift(stopwatch2, eaBitset15, 1);
if(i == 1)
Benchmark::AddResult("bitset<15>/>>=/1", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLPort ? "STLPort is broken, neglects wraparound check." : NULL);
TestRightShift(stopwatch1, stdBitset35, 1);
TestRightShift(stopwatch2, eaBitset35, 1);
if(i == 1)
Benchmark::AddResult("bitset<35>/>>=/1", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLPort ? "STLPort is broken, neglects wraparound check." : NULL);
TestRightShift(stopwatch1, stdBitset75, 1);
TestRightShift(stopwatch2, eaBitset75, 1);
if(i == 1)
Benchmark::AddResult("bitset<75>/>>=/1", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLPort ? "STLPort is broken, neglects wraparound check." : NULL);
TestRightShift(stopwatch1, stdBitset1500, 1);
TestRightShift(stopwatch2, eaBitset1500, 1);
if(i == 1)
Benchmark::AddResult("bitset<1500>/>>=/1", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLPort ? "STLPort is broken, neglects wraparound check." : NULL);
}
}
}
================================================
FILE: benchmark/source/BenchmarkDeque.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/algorithm.h>
#include <EASTL/deque.h>
#include <EASTL/vector.h>
#include <EASTL/sort.h>
#ifdef _MSC_VER
#pragma warning(push, 0)
#pragma warning(disable: 4350) // behavior change: X called instead of Y
#endif
#include <algorithm>
#include <vector>
#include <deque>
#include <stdio.h>
#include <stdlib.h>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
using namespace EA;
namespace
{
struct ValuePair
{
uint32_t key;
uint32_t v;
};
struct VPCompare
{
bool operator()(const ValuePair& vp1, const ValuePair& vp2) const
{
return (vp1.key == vp2.key) ? (vp1.v < vp2.v) : (vp1.key < vp2.key);
}
};
bool operator<(const ValuePair& vp1, const ValuePair& vp2)
{
return (vp1.key == vp2.key) ? (vp1.v < vp2.v) : (vp1.key < vp2.key);
}
bool operator==(const ValuePair& vp1, const ValuePair& vp2)
{
return (vp1.key == vp2.key) && (vp1.v == vp2.v);
}
}
typedef std::deque<ValuePair> StdDeque;
typedef eastl::deque<ValuePair, EASTLAllocatorType, 128> EaDeque; // What value do we pick for the subarray size to make the comparison fair? Using the default isn't ideal because it results in this test measuring speed efficiency and ignoring memory efficiency.
namespace
{
template <typename Container>
void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::vector<uint32_t>& intVector)
{
stopwatch.Restart();
for(eastl_size_t j = 0, jEnd = intVector.size(); j < jEnd; j++)
{
const ValuePair vp = { intVector[j], intVector[j] };
c.push_back(vp);
}
stopwatch.Stop();
}
template <typename Container>
void TestPushFront(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::vector<uint32_t>& intVector)
{
stopwatch.Restart();
for(eastl_size_t j = 0, jEnd = intVector.size(); j < jEnd; j++)
{
const ValuePair vp = { intVector[j], intVector[j] };
c.push_front(vp);
}
stopwatch.Stop();
}
template <typename Container>
void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
{
uint64_t temp = 0;
stopwatch.Restart();
for(typename Container::size_type j = 0, jEnd = c.size(); j < jEnd; j++)
temp += c[j].key;
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)(temp & 0xffffffff));
}
template <typename Container>
void TestIteration(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::iterator it = c.begin(), itEnd = c.end();
stopwatch.Restart();
while(it != itEnd)
++it;
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)(*it).key);
/* Alternative way to measure:
const eastl_size_t n = c.size();
stopwatch.Restart();
for(eastl_size_t i = 0; i < n; ++i)
++it;
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)(*it).key);
*/
}
template <typename Container>
void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c)
{
// Intentionally use eastl find in order to measure just
// vector access speed and not be polluted by sort speed.
const ValuePair vp = { 0xffffffff, 0 };
stopwatch.Restart();
typename Container::iterator it = eastl::find(c.begin(), c.end(), vp);
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)(*it).key);
}
template <typename Container>
void TestSort(EA::StdC::Stopwatch& stopwatch, Container& c)
{
// Intentionally use eastl sort in order to measure just
// vector access speed and not be polluted by sort speed.
VPCompare vpCompare;
stopwatch.Restart();
eastl::quick_sort(c.begin(), c.end(), vpCompare);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c[0].key);
}
template <typename Container>
void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c)
{
const ValuePair vp = { 0xffffffff, 0 };
typename Container::size_type j, jEnd;
typename Container::iterator it;
stopwatch.Restart();
for(j = 0, jEnd = 2000, it = c.begin(); j < jEnd; ++j)
{
it = c.insert(it, vp);
if(it == c.end()) // Try to safely increment the iterator three times.
it = c.begin();
if(++it == c.end())
it = c.begin();
if(++it == c.end())
it = c.begin();
}
stopwatch.Stop();
}
template <typename Container>
void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it;
stopwatch.Restart();
for(j = 0, jEnd = 2000, it = c.begin(); j < jEnd; ++j)
{
it = c.erase(it);
if(it == c.end()) // Try to safely increment the iterator three times.
it = c.begin();
if(++it == c.end())
it = c.begin();
if(++it == c.end())
it = c.begin();
}
stopwatch.Stop();
}
} // namespace
void BenchmarkDeque()
{
EASTLTest_Printf("Deque\n");
EA::UnitTest::RandGenT<uint32_t> rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{ // Exercise some declarations
int nErrorCount = 0;
ValuePair vp1 = { 0, 0 }, vp2 = { 0, 0 };
VPCompare c1, c2;
VERIFY(c1.operator()(vp1, vp2) == c2.operator()(vp1, vp2));
VERIFY((vp1 < vp2) || (vp1 == vp2) || !(vp1 == vp2));
}
{
eastl::vector<uint32_t> intVector(100000);
eastl::generate(intVector.begin(), intVector.end(), rng);
for(int i = 0; i < 2; i++)
{
StdDeque stdDeque;
EaDeque eaDeque;
///////////////////////////////
// Test push_back
///////////////////////////////
TestPushBack(stopwatch1, stdDeque, intVector);
TestPushBack(stopwatch2, eaDeque, intVector);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/push_back", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test push_front
///////////////////////////////
TestPushFront(stopwatch1, stdDeque, intVector);
TestPushFront(stopwatch2, eaDeque, intVector);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/push_front", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test operator[]
///////////////////////////////
TestBracket(stopwatch1, stdDeque);
TestBracket(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/operator[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test iteration
///////////////////////////////
TestIteration(stopwatch1, stdDeque);
TestIteration(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/iteration", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test find()
///////////////////////////////
TestFind(stopwatch1, stdDeque);
TestFind(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test sort
///////////////////////////////
// Currently VC++ complains about our sort function decrementing std::iterator that is already at begin(). In the strictest sense,
// that's a valid complaint, but we aren't testing std STL here. We will want to revise our sort function eventually.
#if !defined(_MSC_VER) || !defined(_ITERATOR_DEBUG_LEVEL) || (_ITERATOR_DEBUG_LEVEL < 2)
TestSort(stopwatch1, stdDeque);
TestSort(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/sort", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
#endif
///////////////////////////////
// Test insert
///////////////////////////////
TestInsert(stopwatch1, stdDeque);
TestInsert(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase
///////////////////////////////
TestErase(stopwatch1, stdDeque);
TestErase(stopwatch2, eaDeque);
if(i == 1)
Benchmark::AddResult("deque<ValuePair>/erase", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
================================================
FILE: benchmark/source/BenchmarkHash.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/vector.h>
#include <EASTL/hash_map.h>
#include <EASTL/string.h>
#include <EASTL/algorithm.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <unordered_map>
#include <string>
#include <algorithm>
#include <stdio.h>
EA_RESTORE_ALL_VC_WARNINGS()
using namespace EA;
// HashString8
//
// We define a string
//
template <typename String>
struct HashString8
{
// Defined for EASTL, STLPort, SGI, etc. and Metrowerks-related hash tables:
size_t operator()(const String& s) const
{
const uint8_t* p = (const uint8_t*) s.c_str();
uint32_t c, stringHash = UINT32_C(2166136261);
while((c = *p++) != 0)
stringHash = (stringHash * 16777619) ^ c;
return stringHash;
}
// Defined for Dinkumware-related (e.g. MS STL) hash tables:
bool operator()(const String& s1, const String& s2) const
{
return s1 < s2;
}
// Defined for Dinkumware-related (e.g. MS STL) hash tables:
enum {
bucket_size = 7,
min_buckets = 8
};
};
using StdMapUint32TO = std::unordered_map<uint32_t, TestObject>;
using StdMapStrUint32 = std::unordered_map<std::string, uint32_t, HashString8<std::string>>;
using EaMapUint32TO = eastl::hash_map<uint32_t, TestObject>;
using EaMapStrUint32 = eastl::hash_map<eastl::string, uint32_t, HashString8<eastl::string>>;
namespace
{
template <typename Container, typename Value>
void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
c.insert(pArrayBegin, pArrayEnd);
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c, const Value& findValue)
{
stopwatch.Restart();
typename Container::const_iterator it = eastl::find(c.begin(), c.end(), findValue); // It shouldn't matter what find implementation we use here, as it merely iterates values.
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*it);
}
template <typename Container, typename Value>
void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(&c[pArrayBegin->first]);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
typename Container::iterator it = c.find(pArrayBegin->first);
Benchmark::DoNothing(&it);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestFindAsStd(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
typename Container::iterator it = c.find(pArrayBegin->first.c_str());
Benchmark::DoNothing(&it);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestFindAsEa(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
typename Container::iterator it = c.find_as(pArrayBegin->first.c_str());
Benchmark::DoNothing(&it);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
typename Container::size_type temp = 0;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
temp += c.count(pArrayBegin->first);
++pArrayBegin;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container, typename Value>
void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
c.erase(pArrayBegin->first);
++pArrayBegin;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
template <typename Container>
void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it;
stopwatch.Restart();
for(j = 0, jEnd = c.size() / 3, it = c.begin(); j < jEnd; ++j)
{
// The erase fucntion is supposed to return an iterator, but the C++ standard was
// not initially clear about it and some STL implementations don't do it correctly.
#if (defined(_MSC_VER) || defined(_CPPLIB_VER)) // _CPPLIB_VER is something defined by Dinkumware STL.
it = c.erase(it);
#else
// This pathway may execute at a slightly different speed than the
// standard behaviour, but that's fine for the benchmark because the
// benchmark is measuring the speed of erasing while iterating, and
// however it needs to get done by the given STL is how it is measured.
const typename Container::iterator itErase(it++);
c.erase(itErase);
#endif
++it;
++it;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p %p", &c, &it);
}
template <typename Container>
void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it1 = c.begin();
typename Container::iterator it2 = c.begin();
for(j = 0, jEnd = c.size() / 3; j < jEnd; ++j)
++it2;
stopwatch.Restart();
c.erase(it1, it2);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p %p %p", &c, &it1, &it2);
}
template <typename Container>
void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
{
stopwatch.Restart();
c.clear();
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
} // namespace
void BenchmarkHash()
{
EASTLTest_Printf("HashMap\n");
EA::UnitTest::Rand rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{
eastl::vector< std::pair<uint32_t, TestObject> > stdVectorUT(10000);
eastl::vector< eastl::pair<uint32_t, TestObject> > eaVectorUT(10000);
eastl::vector< std::pair< std::string, uint32_t> > stdVectorSU(10000);
eastl::vector< eastl::pair<eastl::string, uint32_t> > eaVectorSU(10000);
for(eastl_size_t i = 0, iEnd = stdVectorUT.size(); i < iEnd; i++)
{
const uint32_t n1 = rng.RandLimit((uint32_t)(iEnd / 2));
const uint32_t n2 = rng.RandValue();
stdVectorUT[i] = std::pair<uint32_t, TestObject>(n1, TestObject(n2));
eaVectorUT[i] = eastl::pair<uint32_t, TestObject>(n1, TestObject(n2));
char str_n1[32];
sprintf(str_n1, "%u", (unsigned)n1);
stdVectorSU[i] = std::pair< std::string, uint32_t>( std::string(str_n1), n2);
eaVectorSU[i] = eastl::pair<eastl::string, uint32_t>(eastl::string(str_n1), n2);
}
for(int i = 0; i < 2; i++)
{
StdMapUint32TO stdMapUint32TO;
EaMapUint32TO eaMapUint32TO;
StdMapStrUint32 stdMapStrUint32;
EaMapStrUint32 eaMapStrUint32;
///////////////////////////////
// Test insert(const value_type&)
///////////////////////////////
TestInsert(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + stdVectorUT.size());
TestInsert(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + eaVectorUT.size());
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestInsert(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestInsert(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test iteration
///////////////////////////////
TestIteration(stopwatch1, stdMapUint32TO, StdMapUint32TO::value_type(9999999, TestObject(9999999)));
TestIteration(stopwatch2, eaMapUint32TO, EaMapUint32TO::value_type(9999999, TestObject(9999999)));
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/iteration", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestIteration(stopwatch1, stdMapStrUint32, StdMapStrUint32::value_type( std::string("9999999"), 9999999));
TestIteration(stopwatch2, eaMapStrUint32, EaMapStrUint32::value_type(eastl::string("9999999"), 9999999));
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/iteration", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test operator[]
///////////////////////////////
TestBracket(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + stdVectorUT.size());
TestBracket(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + eaVectorUT.size());
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/operator[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestBracket(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestBracket(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/operator[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test find
///////////////////////////////
TestFind(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + stdVectorUT.size());
TestFind(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + eaVectorUT.size());
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestFind(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestFind(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test find_as
///////////////////////////////
TestFindAsStd(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestFindAsEa(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/find_as/char*", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test count
///////////////////////////////
TestCount(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + stdVectorUT.size());
TestCount(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + eaVectorUT.size());
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestCount(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestCount(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(const key_type& key)
///////////////////////////////
TestEraseValue(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + (stdVectorUT.size() / 2));
TestEraseValue(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + (eaVectorUT.size() / 2));
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/erase val", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestEraseValue(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + (stdVectorSU.size() / 2));
TestEraseValue(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + (eaVectorSU.size() / 2));
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/erase val", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(iterator position)
///////////////////////////////
TestErasePosition(stopwatch1, stdMapUint32TO);
TestErasePosition(stopwatch2, eaMapUint32TO);
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/erase pos", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestErasePosition(stopwatch1, stdMapStrUint32);
TestErasePosition(stopwatch2, eaMapStrUint32);
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/erase pos", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(iterator first, iterator last)
///////////////////////////////
TestEraseRange(stopwatch1, stdMapUint32TO);
TestEraseRange(stopwatch2, eaMapUint32TO);
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/erase range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestEraseRange(stopwatch1, stdMapStrUint32);
TestEraseRange(stopwatch2, eaMapStrUint32);
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/erase range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test clear()
///////////////////////////////
// Clear the containers of whatever they happen to have. We want the containers to have full data.
TestClear(stopwatch1, stdMapUint32TO);
TestClear(stopwatch2, eaMapUint32TO);
TestClear(stopwatch1, stdMapStrUint32);
TestClear(stopwatch2, eaMapStrUint32);
// Re-set the containers with full data.
TestInsert(stopwatch1, stdMapUint32TO, stdVectorUT.data(), stdVectorUT.data() + stdVectorUT.size());
TestInsert(stopwatch2, eaMapUint32TO, eaVectorUT.data(), eaVectorUT.data() + eaVectorUT.size());
TestInsert(stopwatch1, stdMapStrUint32, stdVectorSU.data(), stdVectorSU.data() + stdVectorSU.size());
TestInsert(stopwatch2, eaMapStrUint32, eaVectorSU.data(), eaVectorSU.data() + eaVectorSU.size());
// Now clear the data again, this time measuring it.
TestClear(stopwatch1, stdMapUint32TO);
TestClear(stopwatch2, eaMapUint32TO);
if(i == 1)
Benchmark::AddResult("hash_map<uint32_t, TestObject>/clear", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestClear(stopwatch1, stdMapStrUint32);
TestClear(stopwatch2, eaMapStrUint32);
if(i == 1)
Benchmark::AddResult("hash_map<string, uint32_t>/clear", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
================================================
FILE: benchmark/source/BenchmarkHeap.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/heap.h>
#include <EASTL/vector.h>
#include <EASTL/algorithm.h>
#ifdef _MSC_VER
#pragma warning(push, 0)
#pragma warning(disable: 4350) // behavior change: X called instead of Y
#endif
#include <algorithm>
#include <vector>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
using namespace EA;
namespace
{
template <typename Iterator>
void TestMakeHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
std::make_heap(first, last);
stopwatch.Stop();
}
template <typename Iterator>
void TestMakeHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
eastl::make_heap(first, last);
stopwatch.Stop();
}
template <typename Iterator1, typename Iterator2>
void TestPushHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
{
stopwatch.Restart();
while(first2 != last2)
{
*last1++ = *first2++;
std::push_heap(first1, last1);
}
stopwatch.Stop();
}
template <typename Iterator1, typename Iterator2>
void TestPushHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
{
stopwatch.Restart();
while(first2 != last2)
{
*last1++ = *first2++;
eastl::push_heap(first1, last1);
}
stopwatch.Stop();
}
template <typename Iterator>
void TestPopHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, Iterator popEnd)
{
stopwatch.Restart();
while(last != popEnd)
std::pop_heap(first, last--);
stopwatch.Stop();
}
template <typename Iterator>
void TestPopHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last, Iterator popEnd)
{
stopwatch.Restart();
while(last != popEnd)
eastl::pop_heap(first, last--);
stopwatch.Stop();
}
template <typename Iterator>
void TestSortHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
std::sort_heap(first, last);
stopwatch.Stop();
}
template <typename Iterator>
void TestSortHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator last)
{
stopwatch.Restart();
eastl::sort_heap(first, last);
stopwatch.Stop();
}
} // namespace
void BenchmarkHeap()
{
EASTLTest_Printf("Heap (Priority Queue)\n");
EA::UnitTest::RandGenT<uint32_t> rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{
const int kArraySize = 100000;
// uint32[]
uint32_t* const pIntArrayS = new uint32_t[kArraySize * 2]; // * 2 because we will be adding more items via push_heap.
uint32_t* const pIntArrayE = new uint32_t[kArraySize * 2]; // S means Std; E means EA.
uint32_t* const pIntArray2 = new uint32_t[kArraySize]; // This will be used for pop_heap.
eastl::generate(pIntArrayS, pIntArrayS + kArraySize, rng);
eastl::copy(pIntArrayS, pIntArrayS + kArraySize, pIntArrayE);
eastl::copy(pIntArrayS, pIntArrayS + kArraySize, pIntArray2);
// vector<TestObject>
std::vector<TestObject> stdVectorTO(kArraySize * 2);
std::vector<TestObject> stdVectorTO2(kArraySize);
eastl::vector<TestObject> eaVectorTO(kArraySize * 2);
eastl::vector<TestObject> eaVectorTO2(kArraySize);
for(int k = 0; k < kArraySize; k++)
{
stdVectorTO[k] = TestObject(pIntArrayS[k]);
stdVectorTO2[k] = TestObject(pIntArrayS[k]);
eaVectorTO[k] = TestObject(pIntArrayS[k]);
eaVectorTO2[k] = TestObject(pIntArrayS[k]);
}
for(int i = 0; i < 2; i++)
{
///////////////////////////////
// Test make_heap
///////////////////////////////
TestMakeHeapStd(stopwatch1, pIntArrayS, pIntArrayS + kArraySize);
TestMakeHeapEa (stopwatch2, pIntArrayE, pIntArrayE + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (uint32_t[])/make_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestMakeHeapStd(stopwatch1, stdVectorTO.begin(), stdVectorTO.begin() + kArraySize);
TestMakeHeapEa (stopwatch2, eaVectorTO.begin(), eaVectorTO.begin() + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (vector<TestObject>)/make_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test push_heap
///////////////////////////////
TestPushHeapStd(stopwatch1, pIntArrayS, pIntArrayS + kArraySize, pIntArray2, pIntArray2 + kArraySize);
TestPushHeapEa (stopwatch2, pIntArrayE, pIntArrayE + kArraySize, pIntArray2, pIntArray2 + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (uint32_t[])/push_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestPushHeapStd(stopwatch1, stdVectorTO.begin(), stdVectorTO.begin() + kArraySize, stdVectorTO2.begin(), stdVectorTO2.begin() + kArraySize);
TestPushHeapEa (stopwatch2, eaVectorTO.begin(), eaVectorTO.begin() + kArraySize, eaVectorTO2.begin(), eaVectorTO2.begin() + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (vector<TestObject>)/push_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test pop_heap
///////////////////////////////
TestPopHeapStd(stopwatch1, pIntArrayS, pIntArrayS + (kArraySize * 2), pIntArrayS + kArraySize); // * 2 because we used push_heap above to add more items.
TestPopHeapEa (stopwatch2, pIntArrayE, pIntArrayE + (kArraySize * 2), pIntArrayE + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (uint32_t[])/pop_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestPopHeapStd(stopwatch1, stdVectorTO.begin(), stdVectorTO.begin() + (kArraySize * 2), stdVectorTO.begin() + kArraySize); // * 2 because we used push_heap above to add more items.
TestPopHeapEa (stopwatch2, eaVectorTO.begin(), eaVectorTO.begin() + (kArraySize * 2), eaVectorTO.begin() + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (vector<TestObject>)/pop_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test sort_heap
///////////////////////////////
TestSortHeapStd(stopwatch1, pIntArrayS, pIntArrayS + kArraySize);
TestSortHeapEa (stopwatch2, pIntArrayE, pIntArrayE + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (uint32_t[])/sort_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSortHeapStd(stopwatch1, stdVectorTO.begin(), stdVectorTO.begin() + kArraySize);
TestSortHeapEa (stopwatch2, eaVectorTO.begin(), eaVectorTO.begin() + kArraySize);
if(i == 1)
Benchmark::AddResult("heap (vector<TestObject>)/sort_heap", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
delete[] pIntArrayS;
delete[] pIntArrayE;
delete[] pIntArray2;
}
}
================================================
FILE: benchmark/source/BenchmarkList.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/list.h>
#include <EASTL/vector.h>
#include <EASTL/algorithm.h>
#include <EASTL/random.h>
#ifdef _MSC_VER
#pragma warning(push, 0)
#pragma warning(disable: 4555) // expression has no effect; expected expression with side-effect
#pragma warning(disable: 4350) // behavior change: X called instead of Y
#endif
#include <list>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
using namespace EA;
using namespace eastl;
typedef std::list<TestObject> StdListTO;
typedef eastl::list<TestObject> EaListTO;
namespace
{
void DoNothing(void*)
{
// Empty
}
template <typename ContainerSource, typename Container>
void TestCtorIterator(EA::StdC::Stopwatch& stopwatch, const ContainerSource& cs, Container*) // Dummy Container argument because of GCC 2.X limitations.
{
stopwatch.Restart();
Container c(cs.begin(), cs.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestCtorN(EA::StdC::Stopwatch& stopwatch, Container*) // Dummy Container argument because of GCC 2.X limitations.
{
stopwatch.Restart();
Container c(10000);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, const TestObject* pTOBegin, const TestObject* const pTOEnd)
{
stopwatch.Restart();
while(pTOBegin != pTOEnd)
c.push_back(*pTOBegin++);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const TestObject* pTOBegin, const TestObject* const pTOEnd)
{
typename Container::iterator it = c.begin();
stopwatch.Restart();
while(pTOBegin != pTOEnd)
{
it = c.insert(it, *pTOBegin++);
if(++it == c.end()) // Try to safely increment the iterator a couple times
it = c.begin();
if(++it == c.end())
it = c.begin();
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestSize(EA::StdC::Stopwatch& stopwatch, Container& c, void (*pFunction)(...))
{
stopwatch.Restart();
for(int i = 0; (i < 10000) && c.size(); i++)
(*pFunction)(&c);
stopwatch.Stop();
}
template <typename Container>
void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const TestObject& to)
{
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
stopwatch.Restart();
typename Container::iterator it = eastl::find(c.begin(), c.end(), to);
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%d", (*it).mX);
}
template <typename Container>
void TestReverse(EA::StdC::Stopwatch& stopwatch, Container& c)
{
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
stopwatch.Restart();
c.reverse();
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestRemove(EA::StdC::Stopwatch& stopwatch, Container& c, const TestObject* pTOBegin, const TestObject* const pTOEnd)
{
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
stopwatch.Restart();
while(pTOBegin != pTOEnd)
c.remove(*pTOBegin++);
stopwatch.Stop();
if(!c.empty())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestSplice(EA::StdC::Stopwatch& stopwatch, Container& c, Container& cSource)
{
typename Container::iterator it = c.begin();
int i = 0, iEnd = (int)cSource.size() - 5;
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
stopwatch.Restart();
while(i++ != iEnd)
c.splice(it, cSource, cSource.begin());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
template <typename Container>
void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::iterator it = c.begin();
int i = 0, iEnd = (int)c.size() - 5;
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
stopwatch.Restart();
while(i++ != iEnd)
{
it = c.erase(it);
if(it == c.end()) // Try to safely increment the iterator a couple times
it = c.begin();
if(++it == c.end())
it = c.begin();
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.back().mX);
}
} // namespace
void BenchmarkList()
{
EASTLTest_Printf("List\n");
EASTLTest_Rand rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
EaListTO eaListTO_1(1);
EaListTO eaListTO_10(10);
EaListTO eaListTO_100(100);
StdListTO stdListTO_1(1);
StdListTO stdListTO_10(10);
StdListTO stdListTO_100(100);
{
char buffer[32];
sprintf(buffer, "%p", &DoNothing);
}
{
eastl::vector<TestObject> toVector(100000);
for(eastl_size_t i = 0, iEnd = toVector.size(); i < iEnd; ++i)
toVector[i] = TestObject((int)i);
random_shuffle(toVector.begin(), toVector.end(), rng);
for(int i = 0; i < 2; i++)
{
StdListTO stdListTO;
EaListTO eaListTO;
///////////////////////////////
// Test list(InputIterator first, InputIterator last)
///////////////////////////////
TestCtorIterator(stopwatch1, toVector, &stdListTO);
TestCtorIterator(stopwatch2, toVector, &eaListTO);
if(i == 1)
Benchmark::AddResult("list<TestObject>/ctor(it)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test list(size_type n)
///////////////////////////////
TestCtorN(stopwatch1, &stdListTO);
TestCtorN(stopwatch2, &eaListTO);
if(i == 1)
Benchmark::AddResult("list<TestObject>/ctor(n)", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test push_back()
///////////////////////////////
TestPushBack(stopwatch1, stdListTO, toVector.data(), toVector.data() + toVector.size());
TestPushBack(stopwatch2, eaListTO, toVector.data(), toVector.data() + toVector.size());
if(i == 1)
Benchmark::AddResult("list<TestObject>/push_back", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test insert()
///////////////////////////////
TestInsert(stopwatch1, stdListTO, toVector.data(), toVector.data() + toVector.size());
TestInsert(stopwatch2, eaListTO, toVector.data(), toVector.data() + toVector.size());
if(i == 1)
Benchmark::AddResult("list<TestObject>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test size()
///////////////////////////////
TestSize(stopwatch1, stdListTO_1, Benchmark::DoNothing);
TestSize(stopwatch2, eaListTO_1, Benchmark::DoNothing);
if(i == 1)
Benchmark::AddResult("list<TestObject>/size/1", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
TestSize(stopwatch1, stdListTO_10, Benchmark::DoNothing);
TestSize(stopwatch2, eaListTO_10, Benchmark::DoNothing);
if(i == 1)
Benchmark::AddResult("list<TestObject>/size/10", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime()
#if !EASTL_LIST_SIZE_CACHE
, "EASTL is configured to not cache the list size."
#endif
);
TestSize(stopwatch1, stdListTO_100, Benchmark::DoNothing);
TestSize(stopwatch2, eaListTO_100, Benchmark::DoNothing);
if(i == 1)
Benchmark::AddResult("list<TestObject>/size/100", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime()
#if !EASTL_LIST_SIZE_CACHE
, "EASTL is configured to not cache the list size."
#endif
);
///////////////////////////////
// Test find()
///////////////////////////////
TestFind(stopwatch1, stdListTO, TestObject(99999999));
TestFind(stopwatch2, eaListTO, TestObject(99999999));
if(i == 1)
Benchmark::AddResult("list<TestObject>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test reverse()
///////////////////////////////
TestReverse(stopwatch1, stdListTO);
TestReverse(stopwatch2, eaListTO);
if(i == 1)
Benchmark::AddResult("list<TestObject>/reverse", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test remove()
///////////////////////////////
random_shuffle(toVector.begin(), toVector.end(), rng);
TestRemove(stopwatch1, stdListTO, &toVector[0], &toVector[20]);
TestRemove(stopwatch2, eaListTO, &toVector[0], &toVector[20]);
if(i == 1)
Benchmark::AddResult("list<TestObject>/remove", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test splice()
///////////////////////////////
StdListTO listCopyStd(stdListTO);
EaListTO listCopyEa(eaListTO);
TestSplice(stopwatch1, stdListTO, listCopyStd);
TestSplice(stopwatch2, eaListTO, listCopyEa);
if(i == 1)
Benchmark::AddResult("list<TestObject>/splice", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase()
///////////////////////////////
TestErase(stopwatch1, stdListTO);
TestErase(stopwatch2, eaListTO);
if(i == 1)
Benchmark::AddResult("list<TestObject>/erase", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
================================================
FILE: benchmark/source/BenchmarkMap.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/map.h>
#include <EASTL/vector.h>
#include <EASTL/algorithm.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <map>
#include <algorithm>
EA_RESTORE_ALL_VC_WARNINGS()
using namespace EA;
typedef std::map<TestObject, uint32_t> StdMapTOUint32;
typedef eastl::map<TestObject, uint32_t> EaMapTOUint32;
namespace
{
template <typename Container, typename Value>
void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd, const Value& highValue)
{
stopwatch.Restart();
c.insert(pArrayBegin, pArrayEnd);
stopwatch.Stop();
c.insert(highValue);
}
template <typename Container, typename Value>
void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c, const Value& findValue)
{
stopwatch.Restart();
typename Container::const_iterator it = eastl::find(c.begin(), c.end(), findValue); // It shouldn't matter what find implementation we use here, as it merely iterates values.
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p", &*it);
}
template <typename Container, typename Value>
void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(c[pArrayBegin->first]);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(c.find(pArrayBegin->first)->second);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
typename Container::size_type temp = 0;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
temp += c.count(pArrayBegin->first);
++pArrayBegin;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container, typename Value>
void TestLowerBound(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(c.lower_bound(pArrayBegin->first)->second);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestUpperBound(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(c.upper_bound(pArrayBegin->first)->second);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestEqualRange(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
Benchmark::DoNothing(c.equal_range(pArrayBegin->first).second->second);
++pArrayBegin;
}
stopwatch.Stop();
}
template <typename Container, typename Value>
void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const Value* pArrayBegin, const Value* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
c.erase(pArrayBegin->first);
++pArrayBegin;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
template <typename Container>
void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it;
stopwatch.Restart();
for(j = 0, jEnd = c.size() / 3, it = c.begin(); j < jEnd; ++j)
{
// The erase fucntion is supposed to return an iterator, but the C++ standard was
// not initially clear about it and some STL implementations don't do it correctly.
#if (((defined(_MSC_VER) || defined(_CPPLIB_VER)) && !defined(_HAS_STRICT_CONFORMANCE))) // _CPPLIB_VER is something defined by Dinkumware STL.
it = c.erase(it); // Standard behavior.
#else
// This pathway may execute at a slightly different speed than the
// standard behaviour, but that's fine for the benchmark because the
// benchmark is measuring the speed of erasing while iterating, and
// however it needs to get done by the given STL is how it is measured.
const typename Container::iterator itErase(it++);
c.erase(itErase);
#endif
++it;
++it;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p %p", &c, &it);
}
template <typename Container>
void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it1 = c.begin();
typename Container::iterator it2 = c.begin();
for(j = 0, jEnd = c.size() / 3; j < jEnd; ++j)
++it2;
stopwatch.Restart();
c.erase(it1, it2);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%p %p %p", &c, &it1, &it2);
}
template <typename Container>
void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
{
stopwatch.Restart();
c.clear();
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
} // namespace
void BenchmarkMap()
{
EASTLTest_Printf("Map\n");
EA::UnitTest::Rand rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{
eastl::vector< std::pair<TestObject, uint32_t> > stdVector(10000);
eastl::vector< eastl::pair<TestObject, uint32_t> > eaVector(10000);
for(eastl_size_t i = 0, iEnd = stdVector.size(); i < iEnd; i++)
{
const uint32_t n1 = rng.RandLimit(((uint32_t)iEnd / 2));
const uint32_t n2 = rng.RandValue();
stdVector[i] = std::pair<TestObject, uint32_t>(TestObject(n1), n2);
eaVector[i] = eastl::pair<TestObject, uint32_t>(TestObject(n1), n2);
}
for(int i = 0; i < 2; i++)
{
StdMapTOUint32 stdMapTOUint32;
EaMapTOUint32 eaMapTOUint32;
///////////////////////////////
// Test insert(const value_type&)
///////////////////////////////
const std::pair<TestObject, uint32_t> stdHighValue(TestObject(0x7fffffff), 0x7fffffff);
const eastl::pair<TestObject, uint32_t> eaHighValue(TestObject(0x7fffffff), 0x7fffffff);
TestInsert(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size(), stdHighValue);
TestInsert(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size(), eaHighValue);
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test iteration
///////////////////////////////
TestIteration(stopwatch1, stdMapTOUint32, StdMapTOUint32::value_type(TestObject(9999999), 9999999));
TestIteration(stopwatch2, eaMapTOUint32, EaMapTOUint32::value_type(TestObject(9999999), 9999999));
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/iteration", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test operator[]
///////////////////////////////
TestBracket(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestBracket(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/operator[]", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test find
///////////////////////////////
TestFind(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestFind(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test count
///////////////////////////////
TestCount(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestCount(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test lower_bound
///////////////////////////////
TestLowerBound(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestLowerBound(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/lower_bound", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test upper_bound
///////////////////////////////
TestUpperBound(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestUpperBound(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/upper_bound", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test equal_range
///////////////////////////////
TestEqualRange(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + stdVector.size());
TestEqualRange(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + eaVector.size());
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/equal_range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(const key_type& key)
///////////////////////////////
TestEraseValue(stopwatch1, stdMapTOUint32, stdVector.data(), stdVector.data() + (stdVector.size() / 2));
TestEraseValue(stopwatch2, eaMapTOUint32, eaVector.data(), eaVector.data() + (eaVector.size() / 2));
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/erase/key", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(iterator position)
///////////////////////////////
TestErasePosition(stopwatch1, stdMapTOUint32);
TestErasePosition(stopwatch2, eaMapTOUint32);
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/erase/pos", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLMS ? "MS uses a code bloating implementation of erase." : NULL);
///////////////////////////////
// Test erase(iterator first, iterator last)
///////////////////////////////
TestEraseRange(stopwatch1, stdMapTOUint32);
TestEraseRange(stopwatch2, eaMapTOUint32);
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/erase/range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test clear()
///////////////////////////////
TestClear(stopwatch1, stdMapTOUint32);
TestClear(stopwatch2, eaMapTOUint32);
if(i == 1)
Benchmark::AddResult("map<TestObject, uint32_t>/clear", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
================================================
FILE: benchmark/source/BenchmarkSet.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
#include <EAStdC/EAStopwatch.h>
#include <EASTL/set.h>
#include <EASTL/vector.h>
#include <EASTL/algorithm.h>
EA_DISABLE_ALL_VC_WARNINGS()
#include <set>
#include <algorithm>
EA_RESTORE_ALL_VC_WARNINGS()
using namespace EA;
typedef std::set<uint32_t> StdSetUint32;
typedef eastl::set<uint32_t> EaSetUint32;
namespace
{
template <typename Container>
void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
stopwatch.Restart();
c.insert(pArrayBegin, pArrayEnd);
stopwatch.Stop();
// Intentionally push back a high uint32_t value. We do this so that
// later upper_bound, lower_bound and equal_range never return end().
c.insert(0xffffffff);
}
template <typename Container>
void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c)
{
stopwatch.Restart();
typename Container::const_iterator it = eastl::find(c.begin(), c.end(), uint32_t(9999999));
stopwatch.Stop();
if(it != c.end())
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)*it);
}
template <typename Container>
void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
uint32_t temp = 0;
typename Container::iterator it;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
it = c.find(*pArrayBegin++);
temp += *it;
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container>
void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
typename Container::size_type temp = 0;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
temp += c.count(*pArrayBegin++);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container>
void TestLowerBound(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
uint32_t temp = 0;
typename Container::iterator it;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
it = c.lower_bound(*pArrayBegin++);
temp += *it; // We know that it != end because earlier we inserted 0xffffffff.
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container>
void TestUpperBound(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
uint32_t temp = 0;
typename Container::iterator it;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
it = c.upper_bound(*pArrayBegin++);
temp += *it; // We know that it != end because earlier we inserted 0xffffffff.
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container>
void TestEqualRange(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
uint32_t temp = 0;
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
{
temp += *(c.equal_range(*pArrayBegin++).first); // We know that it != end because earlier we inserted 0xffffffff.
}
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)temp);
}
template <typename Container>
void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32_t* pArrayBegin, const uint32_t* pArrayEnd)
{
stopwatch.Restart();
while(pArrayBegin != pArrayEnd)
c.erase(*pArrayBegin++);
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
template <typename Container>
void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it;
stopwatch.Restart();
for(j = 0, jEnd = c.size() / 3, it = c.begin(); j < jEnd; ++j)
{
// The erase fucntion is supposed to return an iterator, but the C++ standard was
// not initially clear about it and some STL implementations don't do it correctly.
#if (((defined(_MSC_VER) || defined(_CPPLIB_VER)) && !defined(_HAS_STRICT_CONFORMANCE))) // _CPPLIB_VER is something defined by Dinkumware STL.
it = c.erase(it);
#else
// This pathway may execute at a slightly different speed than the
// standard behaviour, but that's fine for the benchmark because the
// benchmark is measuring the speed of erasing while iterating, and
// however it needs to get done by the given STL is how it is measured.
const typename Container::iterator itErase(it++);
c.erase(itErase);
#endif
++it;
++it;
}
stopwatch.Stop();
}
template <typename Container>
void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
{
typename Container::size_type j, jEnd;
typename Container::iterator it1 = c.begin();
typename Container::iterator it2 = c.begin();
for(j = 0, jEnd = c.size() / 3; j < jEnd; ++j)
++it2;
stopwatch.Restart();
c.erase(it1, it2);
stopwatch.Stop();
}
template <typename Container>
void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
{
stopwatch.Restart();
c.clear();
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)c.size());
}
} // namespace
void BenchmarkSet()
{
EASTLTest_Printf("Set\n");
EA::UnitTest::Rand rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
{
eastl::vector<uint32_t> intVector(10000);
for(eastl_size_t i = 0, iEnd = intVector.size(); i < iEnd; i++)
intVector[i] = (uint32_t)rng.RandLimit(((uint32_t)iEnd / 2)); // This will result in duplicates and even a few triplicates.
for(int i = 0; i < 2; i++)
{
StdSetUint32 stdSetUint32;
EaSetUint32 eaSetUint32;
///////////////////////////////
// Test insert(const value_type&)
///////////////////////////////
TestInsert(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestInsert(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/insert", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test iteration
///////////////////////////////
TestIteration(stopwatch1, stdSetUint32);
TestIteration(stopwatch2, eaSetUint32);
if(i == 1)
Benchmark::AddResult("set<uint32_t>/iteration", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test find
///////////////////////////////
TestFind(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestFind(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/find", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test count
///////////////////////////////
TestCount(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestCount(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/count", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test lower_bound
///////////////////////////////
TestLowerBound(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestLowerBound(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/lower_bound", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test upper_bound
///////////////////////////////
TestUpperBound(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestUpperBound(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/upper_bound", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test equal_range
///////////////////////////////
TestEqualRange(stopwatch1, stdSetUint32, intVector.data(), intVector.data() + intVector.size());
TestEqualRange(stopwatch2, eaSetUint32, intVector.data(), intVector.data() + intVector.size());
if(i == 1)
Benchmark::AddResult("set<uint32_t>/equal_range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(const key_type& key)
///////////////////////////////
TestEraseValue(stopwatch1, stdSetUint32, &intVector[0], &intVector[intVector.size() / 2]);
TestEraseValue(stopwatch2, eaSetUint32, &intVector[0], &intVector[intVector.size() / 2]);
if(i == 1)
Benchmark::AddResult("set<uint32_t>/erase/val", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test erase(iterator position)
///////////////////////////////
TestErasePosition(stopwatch1, stdSetUint32);
TestErasePosition(stopwatch2, eaSetUint32);
if(i == 1)
Benchmark::AddResult("set<uint32_t>/erase/pos", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime(),
GetStdSTLType() == kSTLMS ? "MS uses a code bloating implementation of erase." : NULL);
///////////////////////////////
// Test erase(iterator first, iterator last)
///////////////////////////////
TestEraseRange(stopwatch1, stdSetUint32);
TestEraseRange(stopwatch2, eaSetUint32);
if(i == 1)
Benchmark::AddResult("set<uint32_t>/erase range", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test clear()
///////////////////////////////
TestClear(stopwatch1, stdSetUint32);
TestClear(stopwatch2, eaSetUint32);
if(i == 1)
Benchmark::AddResult("set<uint32_t>/clear", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
}
}
}
================================================
FILE: benchmark/source/BenchmarkSort.cpp
================================================
/////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
/////////////////////////////////////////////////////////////////////////////
#include <EASTL/bonus/sort_extra.h>
#include <EASTL/sort.h>
#include <EASTL/vector.h>
#include <EAStdC/EAStopwatch.h>
#include "EASTLBenchmark.h"
#include "EASTLTest.h"
EA_DISABLE_ALL_VC_WARNINGS()
#include <stdlib.h>
#include <algorithm>
#include <functional>
#include <vector>
EA_RESTORE_ALL_VC_WARNINGS()
using namespace EA;
namespace
{
struct ValuePair
{
uint32_t key;
uint32_t v;
};
struct VPCompare
{
bool operator()(const ValuePair& vp1, const ValuePair& vp2) const
{
// return *(const uint64_t*)&vp1 < *(const uint64_t*)&vp2;
return (vp1.key == vp2.key) ? (vp1.v < vp2.v) : (vp1.key < vp2.key);
}
};
bool operator<(const ValuePair& vp1, const ValuePair& vp2)
{
// return *(const uint64_t*)&vp1 < *(const uint64_t*)&vp2;
return (vp1.key == vp2.key) ? (vp1.v < vp2.v) : (vp1.key < vp2.key);
}
bool operator==(const ValuePair& vp1, const ValuePair& vp2)
{
// return *(const uint64_t*)&vp1 == *(const uint64_t*)&vp2;
return (vp1.key == vp2.key) && (vp1.v == vp2.v);
}
}
// VPCompareC
// Useful for testing the the C qsort function.
int VPCompareC(const void* elem1, const void* elem2)
{
return (int)(*(const uint64_t*)elem1 - *(const uint64_t*)elem2);
}
typedef std::vector<ValuePair> StdVectorVP;
typedef eastl::vector<ValuePair> EaVectorVP;
typedef std::vector<uint32_t> StdVectorInt;
typedef eastl::vector<uint32_t> EaVectorInt;
typedef std::vector<TestObject> StdVectorTO;
typedef eastl::vector<TestObject> EaVectorTO;
namespace
{
#ifndef EA_PREFIX_NO_INLINE
#ifdef _MSC_VER
#define EA_PREFIX_NO_INLINE EA_NO_INLINE
#define EA_POSTFIX_NO_INLINE
#else
#define EA_PREFIX_NO_INLINE
#define EA_POSTFIX_NO_INLINE EA_NO_INLINE
#endif
#endif
EA_PREFIX_NO_INLINE void TestQuickSortStdVP (EA::StdC::Stopwatch& stopwatch, StdVectorVP& stdVectorVP) EA_POSTFIX_NO_INLINE;
EA_PREFIX_NO_INLINE void TestQuickSortEaVP (EA::StdC::Stopwatch& stopwatch, EaVectorVP& eaVectorVP) EA_POSTFIX_NO_INLINE;
EA_PREFIX_NO_INLINE void TestQuickSortStdInt(EA::StdC::Stopwatch& stopwatch, StdVectorInt& stdVectorInt) EA_POSTFIX_NO_INLINE;
EA_PREFIX_NO_INLINE void TestQuickSortEaInt (EA::StdC::Stopwatch& stopwatch, EaVectorInt& eaVectorInt) EA_POSTFIX_NO_INLINE;
EA_PREFIX_NO_INLINE void TestQuickSortStdTO (EA::StdC::Stopwatch& stopwatch, StdVectorTO& stdVectorTO) EA_POSTFIX_NO_INLINE;
EA_PREFIX_NO_INLINE void TestQuickSortEaTO (EA::StdC::Stopwatch& stopwatch, EaVectorTO& eaVectorTO) EA_POSTFIX_NO_INLINE;
void TestQuickSortStdVP(EA::StdC::Stopwatch& stopwatch, StdVectorVP& stdVectorVP)
{
stopwatch.Restart();
std::sort(stdVectorVP.begin(), stdVectorVP.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)stdVectorVP[0].key);
}
void TestQuickSortEaVP(EA::StdC::Stopwatch& stopwatch, EaVectorVP& eaVectorVP)
{
stopwatch.Restart();
eastl::quick_sort(eaVectorVP.begin(), eaVectorVP.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)eaVectorVP[0].key);
}
void TestQuickSortStdInt(EA::StdC::Stopwatch& stopwatch, StdVectorInt& stdVectorInt)
{
stopwatch.Restart();
std::sort(stdVectorInt.begin(), stdVectorInt.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)stdVectorInt[0]);
}
void TestQuickSortEaInt(EA::StdC::Stopwatch& stopwatch, EaVectorInt& eaVectorInt)
{
stopwatch.Restart();
eastl::quick_sort(eaVectorInt.begin(), eaVectorInt.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)eaVectorInt[0]);
}
void TestQuickSortStdTO(EA::StdC::Stopwatch& stopwatch, StdVectorTO& stdVectorTO)
{
stopwatch.Restart();
std::sort(stdVectorTO.begin(), stdVectorTO.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)stdVectorTO[0].mX);
}
void TestQuickSortEaTO(EA::StdC::Stopwatch& stopwatch, EaVectorTO& eaVectorTO)
{
stopwatch.Restart();
eastl::quick_sort(eaVectorTO.begin(), eaVectorTO.end());
stopwatch.Stop();
EA::StdC::Snprintf(Benchmark::gScratchBuffer, Benchmark::kScratchBufferSize, "%u", (unsigned)eaVectorTO[0].mX);
}
} // namespace
namespace
{
enum SortFunctionType
{
sf_qsort, // C qsort
sf_shell_sort, // eastl::shell_sort.
sf_heap_sort, // eastl::heap_sort
sf_merge_sort, // eastl::merge_sort
sf_merge_sort_buffer, // eastl::merge_sort_buffer
sf_comb_sort, // eastl::comb_sort
sf_bubble_sort, // eastl::bubble_sort
sf_selection_sort, // eastl::selection_sort
sf_shaker_sort, // eastl::shaker_sort
sf_quick_sort, // eastl::quick_sort
sf_tim_sort, // eastl::tim_sort
sf_insertion_sort, // eastl::insertion_sort
sf_std_sort, // std::sort
sf_std_stable_sort, // std::stable_sort
sf_radix_sort, // eastl::radix_sort (unconventional sort)
sf_count //
};
const char* GetSortFunctionName(int sortFunctionType)
{
switch (sortFunctionType)
{
case sf_quick_sort:
return "eastl::sort";
case sf_tim_sort:
return "eastl::tim_sort";
case sf_insertion_sort:
return "eastl::insertion_sort";
case sf_shell_sort:
return "eastl::shell_sort";
case sf_heap_sort:
return "eastl::heap_sort";
case sf_merge_sort:
return "eastl::merge_sort";
case sf_merge_sort_buffer:
return "eastl::merge_sort_buffer";
case sf_comb_sort:
return "eastl::comb_sort";
case sf_bubble_sort:
return "eastl::bubble_sort";
case sf_selection_sort:
return "eastl::selection_sort";
case sf_shaker_sort:
return "eastl::shaker_sort";
case sf_radix_sort:
return "eastl::radix_sort";
case sf_qsort:
return "qsort";
case sf_std_sort:
return "std::sort";
case sf_std_stable_sort:
return "std::stable_sort";
default:
return "unknown";
}
}
enum RandomizationType
{
kRandom, // Completely random data.
kRandomSorted, // Random values already sorted.
kOrdered, // Already sorted.
kMostlyOrdered, // Partly sorted already.
kRandomizationTypeCount
};
const char* GetRandomizationTypeName(int randomizationType)
{
switch (randomizationType)
{
case kRandom:
return "random";
case kRandomSorted:
return "random sorted";
case kOrdered:
return "ordered";
case kMostlyOrdered:
return "mostly ordered";
default:
return "unknown";
}
}
template <typename ElementType, typename RandomType>
void Randomize(eastl::vector<ElementType>& v, EA::UnitTest::RandGenT<RandomType>& rng, RandomizationType type)
{
typedef RandomType value_type;
switch (type)
{
default:
case kRandomizationTypeCount: // We specify this only to avoid a compiler warning about not testing for it.
case kRandom:
{
eastl::generate(v.begin(), v.end(), rng);
break;
}
case kRandomSorted:
{
// This randomization type differs from kOrdered because the set of values is random (but sorted), in the kOrdered
// case the set of values is contiguous (i.e. 0, 1, ..., n) which can have different performance characteristics.
// For example, radix_sort performs poorly for kOrdered.
eastl::generate(v.begin(), v.end(), rng);
eastl::sort(v.begin(), v.end());
break;
}
case kOrdered:
{
for(eastl_size_t i = 0; i < v.size(); ++i)
v[i] = value_type((value_type)i); // Note that value_type may be a struct and not an integer. Thus the casting and construction here.
break;
}
case kMostlyOrdered:
{
for(eastl_size_t i = 0; i < v.size(); ++i)
v[i] = value_type((value_type)i); // Note that value_type may be a struct and not an integer. Thus the casting and construction here.
// We order random segments.
// The algorithm below in practice will make slightly more than kPercentOrdered be ordered.
const eastl_size_t kPercentOrdered = 80; // In actuality, due to statistics, the actual ordered percent will be about 82-85%.
for(eastl_size_t n = 0, s = v.size(), nEnd = ((s < (100 - kPercentOrdered)) ? 1 : (s / (100 - kPercentOrdered))); n < nEnd; n++)
{
eastl_size_t i = rng.mRand.RandLimit((uint32_t)s);
eastl_size_t j = rng.mRand.RandLimit((uint32_t)s);
eastl::swap(v[i], v[j]);
}
break;
}
}
}
char gSlowAssignBuffer1[256] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* ... */};
char gSlowAssignBuffer2[256] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* ... */};
// SlowAssign
// Implements an object which has slow assign performance.
template <typename T>
struct SlowAssign
{
typedef T key_type;
T x;
static int nAssignCount;
SlowAssign()
{ x = 0; memcpy(gSlowAssignBuffer1, gSlowAssignBuffer2, sizeof(gSlowAssignBuffer1)); }
SlowAssign(const SlowAssign& sa)
{ ++nAssignCount; x = sa.x; memcpy(gSlowAssignBuffer1, gSlowAssignBuffer2, sizeof(gSlowAssignBuffer1)); }
SlowAssign& operator=(const SlowAssign& sa)
{ ++nAssignCount; x = sa.x; memcpy(gSlowAssignBuffer1, gSlowAssignBuffer2, sizeof(gSlowAssignBuffer1)); return *this; }
SlowAssign& operator=(int a)
{ x = (T)a; return *this; }
static void Reset()
{ nAssignCount = 0; }
};
template<> int SlowAssign<uint32_t>::nAssignCount = 0;
template <typename T>
bool operator <(const SlowAssign<T>& a, const SlowAssign<T>& b)
{ return a.x < b.x; }
// SlowCompare
// Implements a compare which is N time slower than a simple integer compare.
template <typename T>
struct SlowCompare
{
static int nCompareCount;
bool operator()(T a, T b)
{
++nCompareCount;
return (a < b) && // It happens that gSlowAssignBuffer1 is always zeroed.
(gSlowAssignBuffer1[0] == 0) && (gSlowAssignBuffer1[1] == 0) && (gSlowAssignBuffer1[1] == 0) &&
(gSlowAssignBuffer1[2] == 0) && (gSlowAssignBuffer1[4] == 0) && (gSlowAssignBuffer1[5] == 0);
}
static void Reset() { nCompareCount = 0; }
};
template <>
int SlowCompare<int32_t>::nCompareCount = 0;
// qsort callback functions
// qsort compare function returns negative if b > a and positive if a > b.
template <typename T>
int CompareInteger(const void* a, const void* b)
{
// Even though you see the following in Internet example code, it doesn't work!
// The reason is that it works only if a and b are both >= 0, otherwise large
// values can cause integer register wraparound. A similar kind of problem happens
// if you try to do the same thing with floating point value compares.
// See http://www.akalin.cx/2006/06/23/on-the-qsort-comparison-function/
// Internet exmaple code:
// return *(const int32_t*)a - *(const int32_t*)b;
// This double comparison might seem like it's crippling qsort against the
// STL-based sorts which do a single compare. But consider that the returning
// of -1, 0, +1 gives qsort more information, and its logic takes advantage
// of that.
if (*(const T*)a < *(const T*)b)
return -1;
if (*(const T*)a > *(const T*)b)
return +1;
return 0;
}
int SlowCompareInt32(const void* a, const void* b)
{
++SlowCompare<int32_t>::nCompareCount;
// This code is similar in performance to the C++ SlowCompare template functor above.
if((gSlowAssignBuffer1[0] == 0) && (gSlowAssignBuffer1[1] == 0) &&
(gSlowAssignBuffer1[1] == 0) && (gSlowAssignBuffer1[2] == 0) &&
(gSlowAssignBuffer1[4] == 0) && (gSlowAssignBuffer1[5] == 0))
{
if (*(const int32_t*)a < *(const int32_t*)b)
return -1;
if (*(const int32_t*)a > *(const int32_t*)b)
return +1;
}
return 0;
}
template <typename slow_assign_type>
struct slow_assign_extract_radix_key
{
typedef typename slow_assign_type::key_type radix_type;
const radix_type operator()(const slow_assign_type& obj) const
{
return obj.x;
}
};
template <typename integer_type>
struct identity_extract_radix_key
{
typedef integer_type radix_type;
const radix_type operator()(const integer_type& x) const
{
return x;
}
};
} // namespace
struct BenchmarkResult
{
uint64_t mTime;
uint64_t mCompareCount;
uint64_t mAssignCount;
BenchmarkResult() : mTime(0), mCompareCount(0), mAssignCount(0) {}
};
int CompareSortPerformance()
{
// Sizes of arrays to be sorted.
const eastl_size_t kSizes[] = { 10, 100, 1000, 10000 };
const eastl_size_t kSizesCount = EAArrayCount(kSizes);
static BenchmarkResult sResults[kRandomizationTypeCount][kSizesCount][sf_count];
int nErrorCount = 0;
EA::UnitTest::ReportVerbosity(2, "Sort comparison\n");
EA::UnitTest::ReportVerbosity(2, "Random seed = %u\n", (unsigned)EA::UnitTest::GetRandSeed());
EA::UnitTest::RandGenT<int32_t> rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatchGlobal(EA::StdC::Stopwatch::kUnitsSeconds);
const eastl_size_t kArraySizeMax = *eastl::max_element(eastl::begin(kSizes), eastl::end(kSizes));
const int kRunCount = 4;
#if !defined(EA_DEBUG)
EA::UnitTest::SetHighThreadPriority();
#endif
eastl::vector<SortFunctionType> allSortFunctions;
for (int i = 0; i < sf_count; i++)
{
allSortFunctions.push_back(SortFunctionType(i));
}
{
auto& sortFunctions = allSortFunctions;
// Regular speed test.
// In this case we test the sorting of integral values.
// This is probably the most common type of comparison.
EA::UnitTest::ReportVerbosity(2, "Sort comparison: Regular speed test\n");
typedef uint32_t ElementType;
typedef eastl::less<ElementType> CompareFunction;
eastl::string sOutput;
sOutput.set_capacity(100000);
ElementType* pBuffer = new ElementType[kArraySizeMax];
memset(sResults, 0, sizeof(sResults));
stopwatchGlobal.Restart();
for (int c = 0; c < kRunCount; c++)
{
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
eastl::vector<ElementType> v(size);
rng.SetSeed(EA::UnitTest::GetRandSeed());
Randomize(v, rng, (RandomizationType)i);
switch (sortFunction)
{
case sf_quick_sort:
stopwatch.Restart();
eastl::quick_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_tim_sort:
stopwatch.Restart();
eastl::tim_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_insertion_sort:
stopwatch.Restart();
eastl::insertion_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shell_sort:
stopwatch.Restart();
eastl::shell_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_heap_sort:
stopwatch.Restart();
eastl::heap_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort:
stopwatch.Restart();
eastl::merge_sort(v.begin(), v.end(), *get_default_allocator((EASTLAllocatorType*)NULL), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort_buffer:
stopwatch.Restart();
eastl::merge_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_comb_sort:
stopwatch.Restart();
eastl::comb_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_bubble_sort:
stopwatch.Restart();
eastl::bubble_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_selection_sort:
stopwatch.Restart();
eastl::selection_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shaker_sort:
stopwatch.Restart();
eastl::shaker_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_radix_sort:
stopwatch.Restart();
eastl::radix_sort<ElementType*, identity_extract_radix_key<ElementType>>(v.begin(), v.end(), pBuffer);
stopwatch.Stop();
break;
case sf_qsort:
stopwatch.Restart();
qsort(&v[0], (size_t)v.size(), sizeof(ElementType), CompareInteger<ElementType>);
stopwatch.Stop();
break;
case sf_std_sort:
stopwatch.Restart();
std::sort(v.data(), v.data() + v.size(), std::less<ElementType>());
stopwatch.Stop();
break;
case sf_std_stable_sort:
stopwatch.Restart();
std::stable_sort(v.data(), v.data() + v.size(), std::less<ElementType>());
stopwatch.Stop();
break;
case sf_count:
default:
// unsupported
break;
}
const uint64_t elapsedTime = (uint64_t)stopwatch.GetElapsedTime();
// If this result was faster than a previously fastest result, record this one instead.
if ((c == 0) || (elapsedTime < sResults[i][sizeType][sortFunction].mTime))
sResults[i][sizeType][sortFunction].mTime = elapsedTime;
VERIFY(eastl::is_sorted(v.begin(), v.end()));
} // for each sort function...
} // for each size type...
} // for each randomization type...
} // for each run
EA::UnitTest::ReportVerbosity(2, "Total time: %.2f s\n", stopwatchGlobal.GetElapsedTimeFloat());
delete[] pBuffer;
// Now print the results.
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
sOutput.append_sprintf("%25s, %14s, Size: %8u, Time: %14" PRIu64 " ticks %0.2f ticks/elem\n",
GetSortFunctionName(sortFunction), GetRandomizationTypeName(i),
(unsigned)size, sResults[i][sizeType][sortFunction].mTime,
float(sResults[i][sizeType][sortFunction].mTime)/float(size));
}
sOutput.append("\n");
}
}
EA::UnitTest::ReportVerbosity(2, "%s\n\n", sOutput.c_str());
}
{
// Do a speed test for the case of slow compares.
// By this we mean to compare sorting speeds when the comparison of elements is slow.
// Sort functions use element comparison to tell where elements go and use element
// movement to get them there. But some sorting functions accomplish sorting performance by
// minimizing the amount of movement, some minimize the amount of comparisons, and the
// best do a good job of minimizing both.
auto sortFunctions = allSortFunctions;
// We can't test this radix_sort because what we need isn't exposed.
sortFunctions.erase(eastl::remove(sortFunctions.begin(), sortFunctions.end(), sf_radix_sort), sortFunctions.end());
EA::UnitTest::ReportVerbosity(2, "Sort comparison: Slow compare speed test\n");
typedef int32_t ElementType;
typedef SlowCompare<ElementType> CompareFunction;
eastl::string sOutput;
sOutput.set_capacity(100000);
ElementType* pBuffer = new ElementType[kArraySizeMax];
memset(sResults, 0, sizeof(sResults));
stopwatchGlobal.Restart();
for (int c = 0; c < kRunCount; c++)
{
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
eastl::vector<ElementType> v(size);
rng.SetSeed(EA::UnitTest::GetRandSeed());
Randomize(v, rng, (RandomizationType)i);
CompareFunction::Reset();
switch (sortFunction)
{
case sf_quick_sort:
stopwatch.Restart();
eastl::quick_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_tim_sort:
stopwatch.Restart();
eastl::tim_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_insertion_sort:
stopwatch.Restart();
eastl::insertion_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shell_sort:
stopwatch.Restart();
eastl::shell_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_heap_sort:
stopwatch.Restart();
eastl::heap_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort:
stopwatch.Restart();
eastl::merge_sort(v.begin(), v.end(), *get_default_allocator((EASTLAllocatorType*)NULL), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort_buffer:
stopwatch.Restart();
eastl::merge_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_comb_sort:
stopwatch.Restart();
eastl::comb_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_bubble_sort:
stopwatch.Restart();
eastl::bubble_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_selection_sort:
stopwatch.Restart();
eastl::selection_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shaker_sort:
stopwatch.Restart();
eastl::shaker_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_qsort:
stopwatch.Restart();
qsort(&v[0], (size_t)v.size(), sizeof(ElementType), SlowCompareInt32);
stopwatch.Stop();
break;
case sf_std_sort:
stopwatch.Restart();
std::sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_std_stable_sort:
stopwatch.Restart();
std::stable_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_radix_sort:
case sf_count:
default:
// unsupported
break;
}
const uint64_t elapsedTime = (uint64_t)stopwatch.GetElapsedTime();
// If this result was faster than a previously fastest result, record this one instead.
if ((c == 0) || (elapsedTime < sResults[i][sizeType][sortFunction].mTime))
{
sResults[i][sizeType][sortFunction].mTime = elapsedTime;
sResults[i][sizeType][sortFunction].mCompareCount = (uint64_t)CompareFunction::nCompareCount;
}
VERIFY(eastl::is_sorted(v.begin(), v.end()));
} // for each sort function...
} // for each size type...
} // for each randomization type...
} // for each run
EA::UnitTest::ReportVerbosity(2, "Total time: %.2f s\n", stopwatchGlobal.GetElapsedTimeFloat());
delete[] pBuffer;
// Now print the results.
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
sOutput.append_sprintf("%25s, %14s, Size: %6u, Time: %11" PRIu64 " ticks, Compares: %11" PRIu64 "\n",
GetSortFunctionName(sortFunction), GetRandomizationTypeName(i),
(unsigned)size, sResults[i][sizeType][sortFunction].mTime,
sResults[i][sizeType][sortFunction].mCompareCount);
}
sOutput.append("\n");
}
}
EA::UnitTest::ReportVerbosity(2, "%s\n\n", sOutput.c_str());
}
{
// Do a speed test for the case of slow assignment.
// By this we mean to compare sorting speeds when the movement of elements is slow.
// Sort functions use element comparison to tell where elements go and use element
// movement to get them there. But some sorting functions accomplish sorting performance by
// minimizing the amount of movement, some minimize the amount of comparisons, and the
// best do a good job of minimizing both.
auto sortFunctions = allSortFunctions;
// Can't implement this for qsort because the C standard library doesn't expose it.
// We could implement it by copying and modifying the source code.
sortFunctions.erase(eastl::remove(sortFunctions.begin(), sortFunctions.end(), sf_qsort), sortFunctions.end());
EA::UnitTest::ReportVerbosity(2, "Sort comparison: Slow assignment speed test\n");
typedef SlowAssign<uint32_t> ElementType;
typedef eastl::less<ElementType> CompareFunction;
eastl::string sOutput;
sOutput.set_capacity(100000);
ElementType* pBuffer = new ElementType[kArraySizeMax];
memset(sResults, 0, sizeof(sResults));
stopwatchGlobal.Restart();
for (int c = 0; c < kRunCount; c++)
{
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
eastl::vector<ElementType> v(size);
Randomize<ElementType>(v, rng, (RandomizationType)i);
ElementType::Reset();
switch (sortFunction)
{
case sf_quick_sort:
stopwatch.Restart();
eastl::quick_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_tim_sort:
stopwatch.Restart();
eastl::tim_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_insertion_sort:
stopwatch.Restart();
eastl::insertion_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shell_sort:
stopwatch.Restart();
eastl::shell_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_heap_sort:
stopwatch.Restart();
eastl::heap_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort:
stopwatch.Restart();
eastl::merge_sort(v.begin(), v.end(), *get_default_allocator((EASTLAllocatorType*)NULL), CompareFunction());
stopwatch.Stop();
break;
case sf_merge_sort_buffer:
stopwatch.Restart();
eastl::merge_sort_buffer(v.begin(), v.end(), pBuffer, CompareFunction());
stopwatch.Stop();
break;
case sf_comb_sort:
stopwatch.Restart();
eastl::comb_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_bubble_sort:
stopwatch.Restart();
eastl::bubble_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_selection_sort:
stopwatch.Restart();
eastl::selection_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_shaker_sort:
stopwatch.Restart();
eastl::shaker_sort(v.begin(), v.end(), CompareFunction());
stopwatch.Stop();
break;
case sf_radix_sort:
stopwatch.Restart();
eastl::radix_sort<ElementType*, slow_assign_extract_radix_key<ElementType>>(v.begin(), v.end(), pBuffer);
stopwatch.Stop();
break;
case sf_std_sort:
stopwatch.Restart();
std::sort(v.begin(), v.end(), std::less<ElementType>());
stopwatch.Stop();
break;
case sf_std_stable_sort:
stopwatch.Restart();
std::stable_sort(v.begin(), v.end(), std::less<ElementType>());
stopwatch.Stop();
break;
case sf_qsort:
case sf_count:
default:
// unsupported
break;
}
const uint64_t elapsedTime = (uint64_t)stopwatch.GetElapsedTime();
// If this result was faster than a previously fastest result, record this one instead.
if ((c == 0) || (elapsedTime < sResults[i][sizeType][sortFunction].mTime))
{
sResults[i][sizeType][sortFunction].mTime = elapsedTime;
sResults[i][sizeType][sortFunction].mAssignCount = (uint64_t)ElementType::nAssignCount;
}
VERIFY(eastl::is_sorted(v.begin(), v.end()));
} // for each sort function...
} // for each size type...
} // for each randomization type...
} // for each run
EA::UnitTest::ReportVerbosity(2, "Total time: %.2f s\n", stopwatchGlobal.GetElapsedTimeFloat());
delete[] pBuffer;
// Now print the results.
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t sizeType = 0; sizeType < EAArrayCount(kSizes); sizeType++)
{
const eastl_size_t size = kSizes[sizeType];
for (SortFunctionType sortFunction : sortFunctions)
{
sOutput.append_sprintf("%25s, %14s, Size: %6u, Time: %11" PRIu64 " ticks, Assignments: %11" PRIu64 "\n",
GetSortFunctionName(sortFunction), GetRandomizationTypeName(i),
(unsigned)size, sResults[i][sizeType][sortFunction].mTime,
sResults[i][sizeType][sortFunction].mAssignCount);
}
sOutput.append("\n");
}
}
EA::UnitTest::ReportVerbosity(2, "%s\n", sOutput.c_str());
}
#if !defined(EA_DEBUG)
EA::UnitTest::SetNormalThreadPriority();
#endif
return nErrorCount;
}
typedef eastl::function<void(eastl::string &output, const char* sortFunction, const char* randomizationType, size_t size, size_t numSubArrays, const BenchmarkResult &result)> OutputResultCallback;
typedef eastl::function<void(BenchmarkResult &result)> PostExecuteCallback;
typedef eastl::function<void()> PreExecuteCallback;
template<class ElementType, class CompareFunction>
static int CompareSmallInputSortPerformanceHelper(eastl::vector<eastl_size_t> &arraySizes, eastl::vector<SortFunctionType> &sortFunctions, const PreExecuteCallback &preExecuteCallback, const PostExecuteCallback &postExecuteCallback, const OutputResultCallback &outputResultCallback)
{
int nErrorCount = 0;
EA::UnitTest::RandGenT<int32_t> rng(EA::UnitTest::GetRandSeed());
EA::StdC::Stopwatch stopwatch(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatchGlobal(EA::StdC::Stopwatch::kUnitsSeconds);
const eastl_size_t kArraySizeMax = *eastl::max_element(eastl::begin(arraySizes), eastl::end(arraySizes));
const int kRunCount = 4;
const int numSubArrays = 128;
eastl::string sOutput;
sOutput.set_capacity(100000);
ElementType* pBuffer = new ElementType[kArraySizeMax];
stopwatchGlobal.Restart();
for (int i = 0; i < kRandomizationTypeCount; i++)
{
for (size_t size : arraySizes)
{
for (SortFunctionType sortFunction : sortFunctions)
{
BenchmarkResult bestResult{};
for (int c = 0; c < kRunCount; c++)
{
eastl::vector<ElementType> v(size * numSubArrays);
rng.SetSeed(EA::UnitTest::GetRandSeed());
Randomize(v, rng, (RandomizationType)i);
preExecuteCallback();
switch (sortFunction)
{
case sf_quick_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::quick_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_tim_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::tim_sort_buffer(begin, begin + size, pBuffer, CompareFunction());
}
stopwatch.Stop();
break;
case sf_insertion_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::insertion_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_shell_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::shell_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_heap_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::heap_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_merge_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::merge_sort(begin, begin + size, *get_default_allocator((EASTLAllocatorType*)NULL), CompareFunction());
}
stopwatch.Stop();
break;
case sf_merge_sort_buffer:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::merge_sort_buffer(begin, begin + size, pBuffer, CompareFunction());
}
stopwatch.Stop();
break;
case sf_comb_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::comb_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_bubble_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::bubble_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_selection_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::selection_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_shaker_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
eastl::shaker_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_std_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
std::sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_std_stable_sort:
stopwatch.Restart();
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
std::stable_sort(begin, begin + size, CompareFunction());
}
stopwatch.Stop();
break;
case sf_qsort:
case sf_radix_sort:
case sf_count:
default:
EATEST_VERIFY_F(false, "Missing case statement for sort function %s.", GetSortFunctionName(sortFunction));
break;
}
BenchmarkResult result {};
result.mTime = (uint64_t)stopwatch.GetElapsedTime();
postExecuteCallback(result);
// If this result was faster than a previously fastest result, record this one instead.
if ((c == 0) || (result.mTime < bestResult.mTime))
bestResult = result;
for (auto begin = v.begin(); begin != v.end(); begin += size)
{
VERIFY(eastl::is_sorted(begin, begin + size));
}
} // for each run
outputResultCallback(sOutput, GetSortFunctionName(sortFunction), GetRandomizationTypeName(i), size, numSubArrays, bestResult);
} // for each sort function...
sOutput.append("\n");
} // for each size type...
} // for each randomization type...
EA::UnitTest::ReportVerbosity(2, "Total time: %.2f s\n", stopwatchGlobal.GetElapsedTimeFloat());
EA::UnitTest::ReportVerbosity(2, "%s\n", sOutput.c_str());
delete[] pBuffer;
return nErrorCount;
}
static int CompareSmallInputSortPerformance()
{
int nErrorCount = 0;
eastl::vector<eastl_size_t> arraySizes{1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 64, 128, 256};
// Test quick sort and merge sort to provide a "base line" for performance. The other sort algorithms are mostly
// O(n^2) and they are benchmarked to determine what sorts are ideal for sorting small arrays or sub-arrays. (i.e.
// this is useful to determine good algorithms to choose as a base case for some of the recursive sorts).
eastl::vector<SortFunctionType> sortFunctions{sf_quick_sort, sf_merge_sort_buffer, sf_bubble_sort, sf_comb_sort,
sf_insertion_sort, sf_selection_sort, sf_shell_sort, sf_shaker_sort};
EA::UnitTest::ReportVerbosity(2, "Small Sub-array Sort comparison: Regular speed test\n");
nErrorCount += CompareSmallInputSortPerformanceHelper<uint32_t, eastl::less<uint32_t>>(
arraySizes, sortFunctions, PreExecuteCallback([]() {}), PostExecuteCallback([](BenchmarkResult&) {}),
OutputResultCallback([](eastl::string& output, const char* sortFunction, const char* randomizationType,
size_t size, size_t numSubArrays, const BenchmarkResult& result) {
output.append_sprintf("%25s, %14s, Size: %8u, Time: %0.1f ticks %0.2f ticks/elem\n", sortFunction,
randomizationType, (unsigned)size, float(result.mTime) / float(numSubArrays),
float(result.mTime) / float(size * numSubArrays));
}));
EA::UnitTest::ReportVerbosity(2, "Small Sub-array Sort comparison: Slow compare speed test\n");
nErrorCount += CompareSmallInputSortPerformanceHelper<int32_t, SlowCompare<int32_t>>(
arraySizes, sortFunctions, PreExecuteCallback([]() { SlowCompare<int32_t>::Reset(); }),
PostExecuteCallback(
[](BenchmarkResult& result) { result.mCompareCount = (uint64_t)SlowCompare<int32_t>::nCompareCount; }),
OutputResultCallback([](eastl::string& output, const char* sortFunction, const char* randomizationType,
size_t size, size_t numSubArrays, const BenchmarkResult& result) {
output.append_sprintf("%25s, %14s, Size: %6u, Time: %0.2f ticks, Compares: %0.2f\n", sortFunction,
randomizationType, (unsigned)size, float(result.mTime) / float(numSubArrays),
float(result.mCompareCount) / float(numSubArrays));
}));
EA::UnitTest::ReportVerbosity(2, "Small Sub-array Sort comparison: Slow assignment speed test\n");
nErrorCount += CompareSmallInputSortPerformanceHelper<SlowAssign<uint32_t>, eastl::less<SlowAssign<uint32_t>>>(
arraySizes, sortFunctions, PreExecuteCallback([]() { SlowAssign<uint32_t>::Reset(); }),
PostExecuteCallback([](BenchmarkResult& result) {
result.mCompareCount = (uint64_t)SlowCompare<int32_t>::nCompareCount;
result.mAssignCount = (uint64_t)SlowAssign<uint32_t>::nAssignCount;
}),
OutputResultCallback([](eastl::string& output, const char* sortFunction, const char* randomizationType,
size_t size, size_t numSubArrays, const BenchmarkResult& result) {
output.append_sprintf("%25s, %14s, Size: %6u, Time: %0.2f ticks, Assignments: %0.2f\n", sortFunction,
randomizationType, (unsigned)size, float(result.mTime) / float(numSubArrays),
float(result.mAssignCount) / float(numSubArrays));
}));
return nErrorCount;
}
void BenchmarkSort()
{
EASTLTest_Printf("Sort\n");
EA::UnitTest::RandGenT<uint32_t> rng(12345678); // For debugging sort code we should use 12345678, for normal testing use EA::UnitTest::GetRandSeed().
EA::StdC::Stopwatch stopwatch1(EA::StdC::Stopwatch::kUnitsCPUCycles);
EA::StdC::Stopwatch stopwatch2(EA::StdC::Stopwatch::kUnitsCPUCycles);
if (EA::UnitTest::GetVerbosity() >= 3)
{
CompareSortPerformance();
CompareSmallInputSortPerformance();
}
{ // Exercise some declarations
int nErrorCount = 0;
ValuePair vp1 = {0, 0}, vp2 = {0, 0};
VPCompare c1, c2;
VERIFY(c1.operator()(vp1, vp2) == c2.operator()(vp1, vp2));
VERIFY((vp1 < vp2) || (vp1 == vp2) || !(vp1 == vp2));
}
{
eastl::vector<uint32_t> intVector(10000);
eastl::generate(intVector.begin(), intVector.end(), rng);
for (int i = 0; i < 2; i++)
{
///////////////////////////////
// Test quick_sort/vector/ValuePair
///////////////////////////////
StdVectorVP stdVectorVP(intVector.size());
EaVectorVP eaVectorVP(intVector.size());
for (eastl_size_t j = 0, jEnd = intVector.size(); j < jEnd; j++)
{
const ValuePair vp = {intVector[j], intVector[j]};
stdVectorVP[j] = vp;
eaVectorVP[j] = vp;
}
TestQuickSortStdVP(stopwatch1, stdVectorVP);
TestQuickSortEaVP (stopwatch2, eaVectorVP);
if(i == 1)
Benchmark::AddResult("sort/q_sort/vector<ValuePair>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
// Benchmark the sorting of something that is already sorted.
TestQuickSortStdVP(stopwatch1, stdVectorVP);
TestQuickSortEaVP (stopwatch2, eaVectorVP);
if(i == 1)
Benchmark::AddResult("sort/q_sort/vector<ValuePair>/sorted", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test quick_sort/vector/Int
///////////////////////////////
StdVectorInt stdVectorInt(intVector.size());
EaVectorInt eaVectorInt (intVector.size());
for(eastl_size_t j = 0, jEnd = intVector.size(); j < jEnd; j++)
{
stdVectorInt[j] = intVector[j];
eaVectorInt[j] = intVector[j];
}
TestQuickSortStdInt(stopwatch1, stdVectorInt);
TestQuickSortEaInt (stopwatch2, eaVectorInt);
if(i == 1)
Benchmark::AddResult("sort/q_sort/vector<uint32>", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
// Benchmark the sorting of something that is already sorted.
TestQuickSortStdInt(stopwatch1, stdVectorInt);
TestQuickSortEaInt (stopwatch2, eaVectorInt);
if(i == 1)
Benchmark::AddResult("sort/q_sort/vector<uint32>/sorted", stopwatch1.GetUnits(), stopwatch1.GetElapsedTime(), stopwatch2.GetElapsedTime());
///////////////////////////////
// Test quick_sort/vector/TestObject
//////////
gitextract_oaro068o/
├── .clang-format
├── .gitattributes
├── .github/
│ └── workflows/
│ └── c-cpp.yml
├── .gitignore
├── .p4ignore
├── 3RDPARTYLICENSES.TXT
├── CMakeLists.txt
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── _config.yml
├── benchmark/
│ ├── CMakeLists.txt
│ └── source/
│ ├── BenchmarkAlgorithm.cpp
│ ├── BenchmarkBitset.cpp
│ ├── BenchmarkDeque.cpp
│ ├── BenchmarkHash.cpp
│ ├── BenchmarkHeap.cpp
│ ├── BenchmarkList.cpp
│ ├── BenchmarkMap.cpp
│ ├── BenchmarkSet.cpp
│ ├── BenchmarkSort.cpp
│ ├── BenchmarkString.cpp
│ ├── BenchmarkTupleVector.cpp
│ ├── BenchmarkVector.cpp
│ ├── EASTLBenchmark.cpp
│ ├── EASTLBenchmark.h
│ └── main.cpp
├── doc/
│ ├── Benchmarks.md
│ ├── BestPractices.md
│ ├── Bonus/
│ │ └── tuple_vector_readme.md
│ ├── CMake/
│ │ └── EASTL_Project_Integration.md
│ ├── Design.md
│ ├── EASTL.natvis
│ ├── FAQ.md
│ ├── Glossary.md
│ ├── Gotchas.md
│ ├── Introduction.md
│ ├── Maintenance.md
│ ├── Modules.md
│ └── html/
│ ├── EASTL Benchmarks.html
│ ├── EASTL Best Practices.html
│ ├── EASTL Design.html
│ ├── EASTL FAQ.html
│ ├── EASTL Glossary.html
│ ├── EASTL Gotchas.html
│ ├── EASTL Introduction.html
│ ├── EASTL Maintenance.html
│ ├── EASTL Modules.html
│ └── EASTLDoc.css
├── include/
│ └── EASTL/
│ ├── algorithm.h
│ ├── allocator.h
│ ├── allocator_malloc.h
│ ├── any.h
│ ├── array.h
│ ├── atomic.h
│ ├── atomic_raw.h
│ ├── bit.h
│ ├── bitset.h
│ ├── bitvector.h
│ ├── bonus/
│ │ ├── adaptors.h
│ │ ├── call_traits.h
│ │ ├── compressed_pair.h
│ │ ├── fixed_ring_buffer.h
│ │ ├── fixed_tuple_vector.h
│ │ ├── flags.h
│ │ ├── intrusive_sdlist.h
│ │ ├── intrusive_slist.h
│ │ ├── list_map.h
│ │ ├── lru_cache.h
│ │ ├── overloaded.h
│ │ ├── ring_buffer.h
│ │ ├── sort_extra.h
│ │ └── tuple_vector.h
│ ├── chrono.h
│ ├── compare.h
│ ├── core_allocator.h
│ ├── core_allocator_adapter.h
│ ├── deque.h
│ ├── expected.h
│ ├── finally.h
│ ├── fixed_allocator.h
│ ├── fixed_function.h
│ ├── fixed_hash_map.h
│ ├── fixed_hash_set.h
│ ├── fixed_list.h
│ ├── fixed_map.h
│ ├── fixed_set.h
│ ├── fixed_slist.h
│ ├── fixed_string.h
│ ├── fixed_substring.h
│ ├── fixed_vector.h
│ ├── functional.h
│ ├── hash_map.h
│ ├── hash_set.h
│ ├── heap.h
│ ├── initializer_list.h
│ ├── internal/
│ │ ├── atomic/
│ │ │ ├── arch/
│ │ │ │ ├── arch.h
│ │ │ │ ├── arch_acquire_fence.h
│ │ │ │ ├── arch_add_fetch.h
│ │ │ │ ├── arch_and_fetch.h
│ │ │ │ ├── arch_cmpxchg_strong.h
│ │ │ │ ├── arch_cmpxchg_weak.h
│ │ │ │ ├── arch_compiler_barrier.h
│ │ │ │ ├── arch_cpu_pause.h
│ │ │ │ ├── arch_exchange.h
│ │ │ │ ├── arch_fetch_add.h
│ │ │ │ ├── arch_fetch_and.h
│ │ │ │ ├── arch_fetch_or.h
│ │ │ │ ├── arch_fetch_sub.h
│ │ │ │ ├── arch_fetch_xor.h
│ │ │ │ ├── arch_load.h
│ │ │ │ ├── arch_memory_barrier.h
│ │ │ │ ├── arch_or_fetch.h
│ │ │ │ ├── arch_signal_fence.h
│ │ │ │ ├── arch_store.h
│ │ │ │ ├── arch_sub_fetch.h
│ │ │ │ ├── arch_thread_fence.h
│ │ │ │ ├── arch_xor_fetch.h
│ │ │ │ ├── arm/
│ │ │ │ │ ├── arch_arm.h
│ │ │ │ │ ├── arch_arm_acquire_fence.h
│ │ │ │ │ ├── arch_arm_load.h
│ │ │ │ │ ├── arch_arm_memory_barrier.h
│ │ │ │ │ ├── arch_arm_store.h
│ │ │ │ │ └── arch_arm_thread_fence.h
│ │ │ │ └── x86/
│ │ │ │ ├── arch_x86.h
│ │ │ │ ├── arch_x86_acquire_fence.h
│ │ │ │ ├── arch_x86_add_fetch.h
│ │ │ │ ├── arch_x86_and_fetch.h
│ │ │ │ ├── arch_x86_cmpxchg_strong.h
│ │ │ │ ├── arch_x86_cmpxchg_weak.h
│ │ │ │ ├── arch_x86_exchange.h
│ │ │ │ ├── arch_x86_fetch_add.h
│ │ │ │ ├── arch_x86_fetch_and.h
│ │ │ │ ├── arch_x86_fetch_or.h
│ │ │ │ ├── arch_x86_fetch_sub.h
│ │ │ │ ├── arch_x86_fetch_xor.h
│ │ │ │ ├── arch_x86_load.h
│ │ │ │ ├── arch_x86_memory_barrier.h
│ │ │ │ ├── arch_x86_or_fetch.h
│ │ │ │ ├── arch_x86_store.h
│ │ │ │ ├── arch_x86_sub_fetch.h
│ │ │ │ ├── arch_x86_thread_fence.h
│ │ │ │ └── arch_x86_xor_fetch.h
│ │ │ ├── atomic.h
│ │ │ ├── atomic_asserts.h
│ │ │ ├── atomic_base_width.h
│ │ │ ├── atomic_casts.h
│ │ │ ├── atomic_flag.h
│ │ │ ├── atomic_flag_standalone.h
│ │ │ ├── atomic_integral.h
│ │ │ ├── atomic_macros/
│ │ │ │ ├── atomic_macros.h
│ │ │ │ ├── atomic_macros_acquire_fence.h
│ │ │ │ ├── atomic_macros_add_fetch.h
│ │ │ │ ├── atomic_macros_and_fetch.h
│ │ │ │ ├── atomic_macros_base.h
│ │ │ │ ├── atomic_macros_cmpxchg_strong.h
│ │ │ │ ├── atomic_macros_cmpxchg_weak.h
│ │ │ │ ├── atomic_macros_compiler_barrier.h
│ │ │ │ ├── atomic_macros_cpu_pause.h
│ │ │ │ ├── atomic_macros_exchange.h
│ │ │ │ ├── atomic_macros_fetch_add.h
│ │ │ │ ├── atomic_macros_fetch_and.h
│ │ │ │ ├── atomic_macros_fetch_or.h
│ │ │ │ ├── atomic_macros_fetch_sub.h
│ │ │ │ ├── atomic_macros_fetch_xor.h
│ │ │ │ ├── atomic_macros_load.h
│ │ │ │ ├── atomic_macros_memory_barrier.h
│ │ │ │ ├── atomic_macros_or_fetch.h
│ │ │ │ ├── atomic_macros_signal_fence.h
│ │ │ │ ├── atomic_macros_store.h
│ │ │ │ ├── atomic_macros_sub_fetch.h
│ │ │ │ ├── atomic_macros_thread_fence.h
│ │ │ │ └── atomic_macros_xor_fetch.h
│ │ │ ├── atomic_macros.h
│ │ │ ├── atomic_memory_order.h
│ │ │ ├── atomic_pointer.h
│ │ │ ├── atomic_size_aligned.h
│ │ │ ├── atomic_standalone.h
│ │ │ └── compiler/
│ │ │ ├── compiler.h
│ │ │ ├── compiler_acquire_fence.h
│ │ │ ├── compiler_add_fetch.h
│ │ │ ├── compiler_and_fetch.h
│ │ │ ├── compiler_barrier.h
│ │ │ ├── compiler_cmpxchg_strong.h
│ │ │ ├── compiler_cmpxchg_weak.h
│ │ │ ├── compiler_cpu_pause.h
│ │ │ ├── compiler_exchange.h
│ │ │ ├── compiler_fetch_add.h
│ │ │ ├── compiler_fetch_and.h
│ │ │ ├── compiler_fetch_or.h
│ │ │ ├── compiler_fetch_sub.h
│ │ │ ├── compiler_fetch_xor.h
│ │ │ ├── compiler_load.h
│ │ │ ├── compiler_memory_barrier.h
│ │ │ ├── compiler_or_fetch.h
│ │ │ ├── compiler_signal_fence.h
│ │ │ ├── compiler_store.h
│ │ │ ├── compiler_sub_fetch.h
│ │ │ ├── compiler_thread_fence.h
│ │ │ ├── compiler_xor_fetch.h
│ │ │ ├── gcc/
│ │ │ │ ├── compiler_gcc.h
│ │ │ │ ├── compiler_gcc_add_fetch.h
│ │ │ │ ├── compiler_gcc_and_fetch.h
│ │ │ │ ├── compiler_gcc_barrier.h
│ │ │ │ ├── compiler_gcc_cmpxchg_strong.h
│ │ │ │ ├── compiler_gcc_cmpxchg_weak.h
│ │ │ │ ├── compiler_gcc_cpu_pause.h
│ │ │ │ ├── compiler_gcc_exchange.h
│ │ │ │ ├── compiler_gcc_fetch_add.h
│ │ │ │ ├── compiler_gcc_fetch_and.h
│ │ │ │ ├── compiler_gcc_fetch_or.h
│ │ │ │ ├── compiler_gcc_fetch_sub.h
│ │ │ │ ├── compiler_gcc_fetch_xor.h
│ │ │ │ ├── compiler_gcc_load.h
│ │ │ │ ├── compiler_gcc_or_fetch.h
│ │ │ │ ├── compiler_gcc_signal_fence.h
│ │ │ │ ├── compiler_gcc_store.h
│ │ │ │ ├── compiler_gcc_sub_fetch.h
│ │ │ │ ├── compiler_gcc_thread_fence.h
│ │ │ │ └── compiler_gcc_xor_fetch.h
│ │ │ └── msvc/
│ │ │ ├── compiler_msvc.h
│ │ │ ├── compiler_msvc_add_fetch.h
│ │ │ ├── compiler_msvc_and_fetch.h
│ │ │ ├── compiler_msvc_barrier.h
│ │ │ ├── compiler_msvc_cmpxchg_strong.h
│ │ │ ├── compiler_msvc_cmpxchg_weak.h
│ │ │ ├── compiler_msvc_cpu_pause.h
│ │ │ ├── compiler_msvc_exchange.h
│ │ │ ├── compiler_msvc_fetch_add.h
│ │ │ ├── compiler_msvc_fetch_and.h
│ │ │ ├── compiler_msvc_fetch_or.h
│ │ │ ├── compiler_msvc_fetch_sub.h
│ │ │ ├── compiler_msvc_fetch_xor.h
│ │ │ ├── compiler_msvc_or_fetch.h
│ │ │ ├── compiler_msvc_signal_fence.h
│ │ │ ├── compiler_msvc_sub_fetch.h
│ │ │ └── compiler_msvc_xor_fetch.h
│ │ ├── char_traits.h
│ │ ├── concepts.h
│ │ ├── config.h
│ │ ├── copy_help.h
│ │ ├── enable_shared.h
│ │ ├── fill_help.h
│ │ ├── fixed_pool.h
│ │ ├── function.h
│ │ ├── function_detail.h
│ │ ├── function_help.h
│ │ ├── functional_base.h
│ │ ├── generic_iterator.h
│ │ ├── hashtable.h
│ │ ├── in_place_t.h
│ │ ├── integer_sequence.h
│ │ ├── intrusive_hashtable.h
│ │ ├── mem_fn.h
│ │ ├── memory_base.h
│ │ ├── memory_uses_allocator.h
│ │ ├── move_help.h
│ │ ├── pair_fwd_decls.h
│ │ ├── piecewise_construct_t.h
│ │ ├── red_black_tree.h
│ │ ├── smart_ptr.h
│ │ ├── special_member_functions.h
│ │ ├── special_member_functions_expected.h
│ │ ├── special_member_functions_variant_optional.h
│ │ ├── thread_support.h
│ │ ├── tuple_fwd_decls.h
│ │ ├── type_compound.h
│ │ ├── type_detected.h
│ │ ├── type_fundamental.h
│ │ ├── type_pod.h
│ │ ├── type_properties.h
│ │ ├── type_transformations.h
│ │ └── type_void_t.h
│ ├── intrusive_hash_map.h
│ ├── intrusive_hash_set.h
│ ├── intrusive_list.h
│ ├── intrusive_ptr.h
│ ├── iterator.h
│ ├── linked_array.h
│ ├── linked_ptr.h
│ ├── list.h
│ ├── map.h
│ ├── memory.h
│ ├── meta.h
│ ├── numeric.h
│ ├── numeric_limits.h
│ ├── optional.h
│ ├── priority_queue.h
│ ├── queue.h
│ ├── random.h
│ ├── ratio.h
│ ├── safe_ptr.h
│ ├── scoped_array.h
│ ├── scoped_ptr.h
│ ├── segmented_vector.h
│ ├── set.h
│ ├── shared_array.h
│ ├── shared_ptr.h
│ ├── slist.h
│ ├── sort.h
│ ├── span.h
│ ├── stack.h
│ ├── string.h
│ ├── string_hash_map.h
│ ├── string_map.h
│ ├── string_view.h
│ ├── tuple.h
│ ├── type_traits.h
│ ├── unique_ptr.h
│ ├── unordered_map.h
│ ├── unordered_set.h
│ ├── utility.h
│ ├── variant.h
│ ├── vector.h
│ ├── vector_map.h
│ ├── vector_multimap.h
│ ├── vector_multiset.h
│ ├── vector_set.h
│ ├── version.h
│ └── weak_ptr.h
├── scripts/
│ ├── CMake/
│ │ └── CommonCppFlags.cmake
│ └── build.sh
├── source/
│ ├── allocator_eastl.cpp
│ ├── assert.cpp
│ ├── atomic.cpp
│ ├── fixed_pool.cpp
│ ├── hashtable.cpp
│ ├── intrusive_list.cpp
│ ├── numeric_limits.cpp
│ ├── red_black_tree.cpp
│ ├── string.cpp
│ └── thread_support.cpp
└── test/
├── CMakeLists.txt
└── source/
├── ConceptImpls.h
├── EASTLTest.cpp
├── EASTLTest.h
├── EASTLTestAllocator.cpp
├── EASTLTestAllocator.h
├── EASTLTestIterators.h
├── GetTypeName.h
├── TestAlgorithm.cpp
├── TestAllocator.cpp
├── TestAllocatorPropagate.cpp
├── TestAny.cpp
├── TestArray.cpp
├── TestAssociativeContainers.h
├── TestAtomicAsm.cpp
├── TestAtomicBasic.cpp
├── TestAtomicMultiThreaded.cpp
├── TestAtomicRaw.cpp
├── TestBit.cpp
├── TestBitVector.cpp
├── TestBitcast.cpp
├── TestBitset.cpp
├── TestCharTraits.cpp
├── TestChrono.cpp
├── TestConcepts.cpp
├── TestContainerBehaviour.cpp
├── TestCppCXTypeTraits.cpp
├── TestDeque.cpp
├── TestExpected.cpp
├── TestExtra.cpp
├── TestFinally.cpp
├── TestFixedFunction.cpp
├── TestFixedHash.cpp
├── TestFixedList.cpp
├── TestFixedMap.cpp
├── TestFixedSList.cpp
├── TestFixedSet.cpp
├── TestFixedString.cpp
├── TestFixedTupleVector.cpp
├── TestFixedVector.cpp
├── TestFlags.cpp
├── TestFunctional.cpp
├── TestHash.cpp
├── TestHeap.cpp
├── TestIntrusiveHash.cpp
├── TestIntrusiveList.cpp
├── TestIntrusiveSDList.cpp
├── TestIntrusiveSList.cpp
├── TestIterator.cpp
├── TestList.cpp
├── TestListMap.cpp
├── TestLruCache.cpp
├── TestMap.cpp
├── TestMap.h
├── TestMemory.cpp
├── TestMeta.cpp
├── TestNumericLimits.cpp
├── TestOptional.cpp
├── TestRandom.cpp
├── TestRatio.cpp
├── TestRingBuffer.cpp
├── TestSList.cpp
├── TestSegmentedVector.cpp
├── TestSet.cpp
├── TestSet.h
├── TestSmartPtr.cpp
├── TestSort.cpp
├── TestSpan.cpp
├── TestString.cpp
├── TestString.inl
├── TestStringHashMap.cpp
├── TestStringMap.cpp
├── TestStringView.cpp
├── TestStringView.inl
├── TestTuple.cpp
├── TestTupleVector.cpp
├── TestTypeTraits.cpp
├── TestUtility.cpp
├── TestVariant.cpp
├── TestVariant2.cpp
├── TestVector.cpp
├── TestVectorMap.cpp
├── TestVectorSet.cpp
└── main.cpp
Showing preview only (318K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3620 symbols across 242 files)
FILE: benchmark/source/BenchmarkAlgorithm.cpp
type std__ (line 55) | namespace std__
function InputIterator (line 58) | inline InputIterator
type SizedPOD (line 71) | struct SizedPOD
function TestFindEndStd (line 76) | void TestFindEndStd(EA::StdC::Stopwatch& stopwatch, const std::string& s...
function TestFindEndEa (line 85) | void TestFindEndEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& ...
function TestSearchStd (line 96) | void TestSearchStd(EA::StdC::Stopwatch& stopwatch, const std::string& sT...
function TestSearchEa (line 105) | void TestSearchEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& s...
function TestSearchNStd (line 116) | void TestSearchNStd(EA::StdC::Stopwatch& stopwatch, const std::string& s...
function TestSearchNEa (line 125) | void TestSearchNEa(EA::StdC::Stopwatch& stopwatch, const eastl::string& ...
function TestUniqueStd (line 137) | void TestUniqueStd(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestUniqueEa (line 146) | void TestUniqueEa(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestMinElementStd (line 157) | void TestMinElementStd(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestMinElementEa (line 166) | void TestMinElementEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestCountStd (line 177) | void TestCountStd(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestCountEa (line 186) | void TestCountEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestAdjacentFindStd (line 197) | void TestAdjacentFindStd(EA::StdC::Stopwatch& stopwatch, const Container...
function TestAdjacentFindEa (line 206) | void TestAdjacentFindEa(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestLowerBoundStd (line 217) | void TestLowerBoundStd(EA::StdC::Stopwatch& stopwatch, const Container& ...
function TestLowerBoundEa (line 230) | void TestLowerBoundEa(EA::StdC::Stopwatch& stopwatch, Container& c, cons...
function TestUpperBoundStd (line 244) | void TestUpperBoundStd(EA::StdC::Stopwatch& stopwatch, const Container& ...
function TestUpperBoundEa (line 256) | void TestUpperBoundEa(EA::StdC::Stopwatch& stopwatch, Container& c, cons...
function TestEqualRangeStd (line 270) | void TestEqualRangeStd(EA::StdC::Stopwatch& stopwatch, const Container& ...
function TestEqualRangeEa (line 284) | void TestEqualRangeEa(EA::StdC::Stopwatch& stopwatch, Container& c, cons...
function TestLexicographicalCompareStd (line 299) | void TestLexicographicalCompareStd(EA::StdC::Stopwatch& stopwatch, Itera...
function TestLexicographicalCompareEa (line 308) | void TestLexicographicalCompareEa(EA::StdC::Stopwatch& stopwatch, Iterat...
function TestCopyStd (line 319) | void TestCopyStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterato...
function TestCopyEa (line 328) | void TestCopyEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator...
function TestCopyBackwardStd (line 339) | void TestCopyBackwardStd(EA::StdC::Stopwatch& stopwatch, Iterator first,...
function TestCopyBackwardEa (line 348) | void TestCopyBackwardEa(EA::StdC::Stopwatch& stopwatch, Iterator first, ...
function TestFillStd (line 359) | void TestFillStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterato...
function TestFillEa (line 368) | void TestFillEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterator...
function TestFillNStd (line 379) | void TestFillNStd(EA::StdC::Stopwatch& stopwatch, Iterator first, int n,...
function TestFillNEa (line 388) | void TestFillNEa(EA::StdC::Stopwatch& stopwatch, Iterator first, int n, ...
function TestReverseStd (line 399) | void TestReverseStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iter...
function TestReverseEa (line 408) | void TestReverseEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Itera...
function TestRotateStd (line 419) | void TestRotateStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Itera...
function TestRotateEa (line 428) | void TestRotateEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iterat...
function TestMergeStd (line 437) | void TestMergeStd(EA::StdC::Stopwatch& stopwatch, Iterator firstIn1, Ite...
function TestMergeEa (line 446) | void TestMergeEa(EA::StdC::Stopwatch& stopwatch, Iterator firstIn1, Iter...
function BenchmarkAlgorithm1 (line 458) | void BenchmarkAlgorithm1(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm2 (line 533) | void BenchmarkAlgorithm2(EASTLTest_Rand& rng, EA::StdC::Stopwatch& stopw...
function BenchmarkAlgorithm3 (line 694) | void BenchmarkAlgorithm3(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm4 (line 743) | void BenchmarkAlgorithm4(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm5 (line 810) | void BenchmarkAlgorithm5(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm6 (line 887) | void BenchmarkAlgorithm6(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm7 (line 932) | void BenchmarkAlgorithm7(EASTLTest_Rand& /*rng*/, EA::StdC::Stopwatch& s...
function BenchmarkAlgorithm8 (line 1101) | void BenchmarkAlgorithm8(EASTLTest_Rand& rng, EA::StdC::Stopwatch& stopw...
function BenchmarkAlgorithm (line 1216) | void BenchmarkAlgorithm()
FILE: benchmark/source/BenchmarkBitset.cpp
function TestSet (line 28) | void TestSet(EA::StdC::Stopwatch& stopwatch, Bitset& b)
function TestSetIndex (line 41) | void TestSetIndex(EA::StdC::Stopwatch& stopwatch, Bitset& b, size_t index)
function TestReset (line 54) | void TestReset(EA::StdC::Stopwatch& stopwatch, Bitset& b)
function TestFlip (line 67) | void TestFlip(EA::StdC::Stopwatch& stopwatch, Bitset& b)
function TestTest (line 80) | void TestTest(EA::StdC::Stopwatch& stopwatch, Bitset& b, unsigned nANDVa...
function TestCount (line 90) | void TestCount(EA::StdC::Stopwatch& stopwatch, Bitset& b)
function TestRightShift (line 104) | void TestRightShift(EA::StdC::Stopwatch& stopwatch, Bitset& b, size_t n)
function BenchmarkBitset (line 120) | void BenchmarkBitset()
FILE: benchmark/source/BenchmarkDeque.cpp
type ValuePair (line 33) | struct ValuePair
type VPCompare (line 39) | struct VPCompare
function TestPushBack (line 67) | void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::v...
function TestPushFront (line 80) | void TestPushFront(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::...
function TestBracket (line 93) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestIteration (line 105) | void TestIteration(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestFind (line 128) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestSort (line 142) | void TestSort(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestInsert (line 155) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestErase (line 178) | void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkDeque (line 202) | void BenchmarkDeque()
FILE: benchmark/source/BenchmarkHash.cpp
type HashString8 (line 33) | struct HashString8
function TestInsert (line 69) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const Valu...
function TestIteration (line 78) | void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c, c...
function TestBracket (line 89) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c, const Val...
function TestFind (line 102) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const Value*...
function TestFindAsStd (line 116) | void TestFindAsStd(EA::StdC::Stopwatch& stopwatch, Container& c, const V...
function TestFindAsEa (line 130) | void TestFindAsEa(EA::StdC::Stopwatch& stopwatch, Container& c, const Va...
function TestCount (line 144) | void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const Value...
function TestEraseValue (line 159) | void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestErasePosition (line 173) | void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestEraseRange (line 204) | void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestClear (line 221) | void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkHash (line 234) | void BenchmarkHash()
FILE: benchmark/source/BenchmarkHeap.cpp
function TestMakeHeapStd (line 30) | void TestMakeHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Ite...
function TestMakeHeapEa (line 38) | void TestMakeHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iter...
function TestPushHeapStd (line 48) | void TestPushHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, I...
function TestPushHeapEa (line 60) | void TestPushHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator1 first1, It...
function TestPopHeapStd (line 74) | void TestPopHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Iter...
function TestPopHeapEa (line 83) | void TestPopHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Itera...
function TestSortHeapStd (line 94) | void TestSortHeapStd(EA::StdC::Stopwatch& stopwatch, Iterator first, Ite...
function TestSortHeapEa (line 102) | void TestSortHeapEa(EA::StdC::Stopwatch& stopwatch, Iterator first, Iter...
function BenchmarkHeap (line 113) | void BenchmarkHeap()
FILE: benchmark/source/BenchmarkList.cpp
function DoNothing (line 37) | void DoNothing(void*)
function TestCtorIterator (line 44) | void TestCtorIterator(EA::StdC::Stopwatch& stopwatch, const ContainerSou...
function TestCtorN (line 54) | void TestCtorN(EA::StdC::Stopwatch& stopwatch, Container*) // Dummy Cont...
function TestPushBack (line 64) | void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, const Te...
function TestInsert (line 75) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const Test...
function TestSize (line 94) | void TestSize(EA::StdC::Stopwatch& stopwatch, Container& c, void (*pFunc...
function TestFind (line 104) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const TestOb...
function TestReverse (line 116) | void TestReverse(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestRemove (line 127) | void TestRemove(EA::StdC::Stopwatch& stopwatch, Container& c, const Test...
function TestSplice (line 140) | void TestSplice(EA::StdC::Stopwatch& stopwatch, Container& c, Container&...
function TestErase (line 154) | void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkList (line 178) | void BenchmarkList()
FILE: benchmark/source/BenchmarkMap.cpp
function TestInsert (line 29) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const Valu...
function TestIteration (line 39) | void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c, c...
function TestBracket (line 50) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c, const Val...
function TestFind (line 63) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const Value*...
function TestCount (line 76) | void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const Value...
function TestLowerBound (line 91) | void TestLowerBound(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestUpperBound (line 104) | void TestUpperBound(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestEqualRange (line 117) | void TestEqualRange(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestEraseValue (line 130) | void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestErasePosition (line 144) | void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestEraseRange (line 174) | void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestClear (line 191) | void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkMap (line 204) | void BenchmarkMap()
FILE: benchmark/source/BenchmarkSet.cpp
function TestInsert (line 29) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c, const uint...
function TestIteration (line 42) | void TestIteration(EA::StdC::Stopwatch& stopwatch, const Container& c)
function TestFind (line 53) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c, const uint32...
function TestCount (line 69) | void TestCount(EA::StdC::Stopwatch& stopwatch, Container& c, const uint3...
function TestLowerBound (line 81) | void TestLowerBound(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestUpperBound (line 97) | void TestUpperBound(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestEqualRange (line 113) | void TestEqualRange(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestEraseValue (line 127) | void TestEraseValue(EA::StdC::Stopwatch& stopwatch, Container& c, const ...
function TestErasePosition (line 138) | void TestErasePosition(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestEraseRange (line 167) | void TestEraseRange(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestClear (line 183) | void TestClear(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkSet (line 196) | void BenchmarkSet()
FILE: benchmark/source/BenchmarkSort.cpp
type ValuePair (line 26) | struct ValuePair
type VPCompare (line 32) | struct VPCompare
function VPCompareC (line 56) | int VPCompareC(const void* elem1, const void* elem2)
function TestQuickSortStdVP (line 93) | void TestQuickSortStdVP(EA::StdC::Stopwatch& stopwatch, StdVectorVP& std...
function TestQuickSortEaVP (line 102) | void TestQuickSortEaVP(EA::StdC::Stopwatch& stopwatch, EaVectorVP& eaVec...
function TestQuickSortStdInt (line 111) | void TestQuickSortStdInt(EA::StdC::Stopwatch& stopwatch, StdVectorInt& s...
function TestQuickSortEaInt (line 120) | void TestQuickSortEaInt(EA::StdC::Stopwatch& stopwatch, EaVectorInt& eaV...
function TestQuickSortStdTO (line 129) | void TestQuickSortStdTO(EA::StdC::Stopwatch& stopwatch, StdVectorTO& std...
function TestQuickSortEaTO (line 138) | void TestQuickSortEaTO(EA::StdC::Stopwatch& stopwatch, EaVectorTO& eaVec...
type SortFunctionType (line 151) | enum SortFunctionType
type RandomizationType (line 226) | enum RandomizationType
function Randomize (line 257) | void Randomize(eastl::vector<ElementType>& v, EA::UnitTest::RandGenT<Ran...
type SlowAssign (line 318) | struct SlowAssign
method SlowAssign (line 325) | SlowAssign()
method SlowAssign (line 328) | SlowAssign(const SlowAssign& sa)
method SlowAssign (line 331) | SlowAssign& operator=(const SlowAssign& sa)
method SlowAssign (line 334) | SlowAssign& operator=(int a)
method Reset (line 337) | static void Reset()
type SlowCompare (line 351) | struct SlowCompare
method Reset (line 364) | static void Reset() { nCompareCount = 0; }
function CompareInteger (line 374) | int CompareInteger(const void* a, const void* b)
function SlowCompareInt32 (line 396) | int SlowCompareInt32(const void* a, const void* b)
type slow_assign_extract_radix_key (line 415) | struct slow_assign_extract_radix_key
method radix_type (line 419) | const radix_type operator()(const slow_assign_type& obj) const
type identity_extract_radix_key (line 426) | struct identity_extract_radix_key
method radix_type (line 430) | const radix_type operator()(const integer_type& x) const
type BenchmarkResult (line 438) | struct BenchmarkResult
method BenchmarkResult (line 444) | BenchmarkResult() : mTime(0), mCompareCount(0), mAssignCount(0) {}
function CompareSortPerformance (line 448) | int CompareSortPerformance()
function CompareSmallInputSortPerformanceHelper (line 1014) | static int CompareSmallInputSortPerformanceHelper(eastl::vector<eastl_si...
function CompareSmallInputSortPerformance (line 1204) | static int CompareSmallInputSortPerformance()
function BenchmarkSort (line 1254) | void BenchmarkSort()
FILE: benchmark/source/BenchmarkString.cpp
function TestPushBack (line 27) | void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestInsert1 (line 37) | void TestInsert1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p)
function TestErase1 (line 48) | void TestErase1(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestReplace1 (line 59) | void TestReplace1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, in...
function TestReserve (line 70) | void TestReserve(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestSize (line 81) | void TestSize(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestBracket (line 91) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestFind (line 103) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestFind1 (line 113) | void TestFind1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, int p...
function TestRfind1 (line 123) | void TestRfind1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, int ...
function TestFirstOf1 (line 132) | void TestFirstOf1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, in...
function TestLastOf1 (line 141) | void TestLastOf1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, int...
function TestFirstNotOf1 (line 150) | void TestFirstNotOf1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p,...
function TestLastNotOf1 (line 159) | void TestLastNotOf1(EA::StdC::Stopwatch& stopwatch, Container& c, T* p, ...
function TestCompare (line 169) | void TestCompare(EA::StdC::Stopwatch& stopwatch, Container& c1, Containe...
function TestSwap (line 179) | void TestSwap(EA::StdC::Stopwatch& stopwatch, Container& c1, Container& ...
function BenchmarkString (line 195) | void BenchmarkString()
FILE: benchmark/source/BenchmarkTupleVector.cpp
type PaddingStruct (line 32) | struct PaddingStruct
type MovableType (line 48) | struct MovableType
method MovableType (line 53) | MovableType() : mpData(new int8_t[kDataSize])
method MovableType (line 56) | MovableType(const MovableType& x) : mpData(new int8_t[kDataSize])
method MovableType (line 59) | MovableType& operator=(const MovableType& x)
method MovableType (line 68) | MovableType(MovableType&& x) EA_NOEXCEPT : mpData(x.mpData)
method MovableType (line 71) | MovableType& operator=(MovableType&& x)
class AutoRefCount (line 89) | class AutoRefCount
method AutoRefCount (line 95) | AutoRefCount() EA_NOEXCEPT : mpObject(NULL)
method AutoRefCount (line 98) | AutoRefCount(T* pObject) EA_NOEXCEPT : mpObject(pObject)
method AutoRefCount (line 104) | AutoRefCount(T* pObject, int) EA_NOEXCEPT : mpObject(pObject)
method AutoRefCount (line 109) | AutoRefCount(const AutoRefCount& x) EA_NOEXCEPT : mpObject(x.mpObject)
method AutoRefCount (line 115) | AutoRefCount& operator=(const AutoRefCount& x)
method AutoRefCount (line 120) | AutoRefCount& operator=(T* pObject)
method AutoRefCount (line 135) | AutoRefCount(AutoRefCount&& x) EA_NOEXCEPT : mpObject(x.mpObject)
method AutoRefCount (line 140) | AutoRefCount& operator=(AutoRefCount&& x)
method T (line 156) | T& operator *() const EA_NOEXCEPT
method T (line 159) | T* operator ->() const EA_NOEXCEPT
type RefCounted (line 168) | struct RefCounted
method RefCounted (line 174) | RefCounted() : mRefCount(1) {}
method AddRef (line 176) | int AddRef()
method Release (line 179) | int Release()
function TestPushBack (line 198) | void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::v...
function TestBracket (line 208) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestBracket (line 218) | void TestBracket(EA::StdC::Stopwatch& stopwatch, EaTupleVectorUint64& c)
function TestFind (line 229) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestFind (line 239) | void TestFind(EA::StdC::Stopwatch& stopwatch, EaTupleVectorUint64& c)
function TestSort (line 250) | void TestSort(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestSort (line 260) | void TestSort(EA::StdC::Stopwatch& stopwatch, EaTupleVectorUint64& c)
function TestInsert (line 272) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestErase (line 294) | void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestMoveReallocate (line 316) | void TestMoveReallocate(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestMoveErase (line 326) | void TestMoveErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestTuplePushBack (line 337) | void TestTuplePushBack(EA::StdC::Stopwatch& stopwatch, Container& c, eas...
function TestTupleBracket (line 350) | void TestTupleBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestTupleFind (line 362) | void TestTupleFind(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestTupleSort (line 373) | void TestTupleSort(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestTupleInsert (line 384) | void TestTupleInsert(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestTupleErase (line 406) | void TestTupleErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkTupleVector (line 432) | void BenchmarkTupleVector()
FILE: benchmark/source/BenchmarkVector.cpp
type MovableType (line 40) | struct MovableType
method MovableType (line 45) | MovableType() : mpData(new int8_t[kDataSize])
method MovableType (line 48) | MovableType(const MovableType& x) : mpData(new int8_t[kDataSize])
method MovableType (line 51) | MovableType& operator=(const MovableType& x)
method MovableType (line 59) | MovableType(MovableType&& x) EA_NOEXCEPT : mpData(x.mpData)
method MovableType (line 62) | MovableType& operator=(MovableType&& x)
class AutoRefCount (line 79) | class AutoRefCount
method AutoRefCount (line 85) | AutoRefCount() EA_NOEXCEPT : mpObject(NULL)
method AutoRefCount (line 88) | AutoRefCount(T* pObject) EA_NOEXCEPT : mpObject(pObject)
method AutoRefCount (line 94) | AutoRefCount(T* pObject, int) EA_NOEXCEPT : mpObject(pObject)
method AutoRefCount (line 99) | AutoRefCount(const AutoRefCount& x) EA_NOEXCEPT : mpObject(x.mpObject)
method AutoRefCount (line 105) | AutoRefCount& operator=(const AutoRefCount& x)
method AutoRefCount (line 110) | AutoRefCount& operator=(T* pObject)
method AutoRefCount (line 124) | AutoRefCount(AutoRefCount&& x) EA_NOEXCEPT : mpObject(x.mpObject)
method AutoRefCount (line 129) | AutoRefCount& operator=(AutoRefCount&& x)
method T (line 144) | T& operator *() const EA_NOEXCEPT
method T (line 147) | T* operator ->() const EA_NOEXCEPT
type RefCounted (line 156) | struct RefCounted
method RefCounted (line 162) | RefCounted() : mRefCount(1) {}
method AddRef (line 164) | int AddRef()
method Release (line 167) | int Release()
function TestPushBack (line 186) | void TestPushBack(EA::StdC::Stopwatch& stopwatch, Container& c, eastl::v...
function TestBracket (line 196) | void TestBracket(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestFind (line 208) | void TestFind(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestSort (line 220) | void TestSort(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestInsert (line 232) | void TestInsert(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestErase (line 254) | void TestErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestMoveReallocate (line 276) | void TestMoveReallocate(EA::StdC::Stopwatch& stopwatch, Container& c)
function TestMoveErase (line 286) | void TestMoveErase(EA::StdC::Stopwatch& stopwatch, Container& c)
function BenchmarkVector (line 301) | void BenchmarkVector()
FILE: benchmark/source/EASTLBenchmark.cpp
type Benchmark (line 23) | namespace Benchmark
function ConvertStopwatchUnits (line 25) | static int64_t ConvertStopwatchUnits(EA::StdC::Stopwatch::Units unitsS...
function WriteTime (line 61) | void WriteTime(int64_t timeNS, eastl::string& sTime)
function Environment (line 77) | Environment& GetEnvironment()
function ResultSet (line 86) | ResultSet& GetResultSet()
function DoNothing (line 97) | void DoNothing(...)
function AddResult (line 103) | void AddResult(const char* pName, int units, int64_t nTime1, int64_t n...
function PrintResultLine (line 121) | void PrintResultLine(const Result& result)
type FileWriter (line 148) | struct FileWriter
method StaticPrintfReportFunction (line 154) | static void StaticPrintfReportFunction(const char8_t* pText)
method PrintfReportFunction (line 160) | void PrintfReportFunction(const char8_t* pText)
method FileWriter (line 167) | FileWriter() : mpReportFile(NULL), mpSavedReportFunction(NULL)
function PrintResults (line 194) | void PrintResults()
FILE: benchmark/source/EASTLBenchmark.h
function namespace (line 50) | namespace Benchmark
function virtual (line 166) | virtual void DoSomething() // Note that by declaring this virtual, this ...
function operator (line 171) | operator int()
FILE: benchmark/source/main.cpp
type EA (line 26) | namespace EA
type Allocator (line 28) | namespace Allocator
function Vsnprintf8 (line 46) | int Vsnprintf8(char8_t* pDestination, size_t n, const char8_t* pFormat,...
function Vsnprintf16 (line 51) | int Vsnprintf16(char16_t* pDestination, size_t n, const char16_t* pForma...
function Vsnprintf32 (line 57) | int Vsnprintf32(char32_t* pDestination, size_t n, const char32_t* pForma...
function EAMain (line 68) | int EAMain(int argc, char* argv[])
FILE: include/EASTL/algorithm.h
function namespace (line 293) | namespace eastl
function EA_CONSTEXPR (line 490) | inline EA_CONSTEXPR float min_alt(float a, float b) {...
function EA_CONSTEXPR (line 491) | inline EA_CONSTEXPR double min_alt(double a, double b) {...
function min_alt (line 492) | inline EA_CONSTEXPR long double min_alt(long double a, long double b) {...
function EA_CONSTEXPR (line 576) | inline EA_CONSTEXPR float max(float a, float b) { retu...
function EA_CONSTEXPR (line 577) | inline EA_CONSTEXPR double max(double a, double b) { retu...
function max (line 578) | inline EA_CONSTEXPR long double max(long double a, long double b) { retu...
function EA_CONSTEXPR (line 602) | inline EA_CONSTEXPR float max_alt(float a, float b) { ...
function EA_CONSTEXPR (line 603) | inline EA_CONSTEXPR double max_alt(double a, double b) { ...
function max_alt (line 604) | inline EA_CONSTEXPR long double max_alt(long double a, long double b) { ...
type typename (line 740) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function T (line 785) | const T&>
type typename (line 797) | typedef typename std::initializer_list<T>::iterator iterator_type;
type typename (line 806) | typedef typename std::initializer_list<T>::iterator iterator_type;
function all_of (line 915) | bool all_of(InputIterator first, InputIterator last, Predicate p)
function any_of (line 931) | bool any_of(InputIterator first, InputIterator last, Predicate p)
function none_of (line 947) | bool none_of(InputIterator first, InputIterator last, Predicate p)
function ForwardIterator (line 967) | ForwardIterator
function ForwardIterator (line 995) | ForwardIterator
type typename (line 1038) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
type typename (line 1039) | typedef typename eastl::make_unsigned<difference_type>::type ...
type typename (line 1040) | typedef typename eastl::uniform_int_distribution<unsigned_difference_typ...
type typename (line 1041) | typedef typename uniform_int_distribution::param_type ...
function random_shuffle (line 1069) | void random_shuffle(RandomAccessIterator first, RandomAccessIterator las...
function OutputIterator (line 1118) | OutputIterator
function OutputIterator (line 1127) | OutputIterator
function OutputIterator (line 1135) | OutputIterator
function OutputIterator (line 1152) | OutputIterator
function OutputIterator (line 1161) | OutputIterator
function OutputIterator (line 1169) | OutputIterator
function OutputIterator (line 1182) | OutputIterator
function BidirectionalIterator2 (line 1203) | BidirectionalIterator2 move_or_copy_backward(BidirectionalIterator1 firs...
function BidirectionalIterator2 (line 1216) | BidirectionalIterator2 move_or_copy_backward(BidirectionalIterator1 firs...
type move_and_copy_backward_helper (line 1226) | struct move_and_copy_backward_helper
function BidirectionalIterator2 (line 1229) | BidirectionalIterator2 move_or_copy_backward(BidirectionalIterator1 firs...
type move_and_copy_backward_helper (line 1243) | struct move_and_copy_backward_helper
function BidirectionalIterator2 (line 1246) | BidirectionalIterator2 move_or_copy_backward(BidirectionalIterator1 firs...
function T (line 1261) | T* move_or_copy_backward(const T* first, const T* last, T* resultEnd)
function BidirectionalIterator2 (line 1273) | BidirectionalIterator2 move_and_copy_backward_chooser(BidirectionalItera...
function BidirectionalIterator2 (line 1284) | inline BidirectionalIterator2 move_and_copy_backward_unwrapper(Bidirecti...
function BidirectionalIterator2 (line 1314) | BidirectionalIterator2 move_backward(BidirectionalIterator1 first, Bidir...
function BidirectionalIterator2 (line 1335) | BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, Bidir...
function typename (line 1354) | typename eastl::iterator_traits<InputIterator>::difference_type
function typename (line 1371) | typename eastl::iterator_traits<InputIterator>::difference_type
function typename (line 1399) | typename eastl::iterator_traits<InputIterator>::difference_type
function InputIterator (line 1428) | InputIterator
function InputIterator (line 1440) | InputIterator
function InputIterator (line 1466) | InputIterator
function InputIterator (line 1482) | InputIterator
function ForwardIterator1 (line 1610) | ForwardIterator1
function BidirectionalIterator1 (line 1628) | BidirectionalIterator1
function BidirectionalIterator1 (line 1671) | BidirectionalIterator1
function BidirectionalIterator1 (line 1691) | BidirectionalIterator1
function Function (line 1730) | Function
function InputIterator (line 1755) | inline InputIterator
function generate (line 1773) | void
function OutputIterator (line 1790) | OutputIterator
function OutputIterator (line 1816) | OutputIterator
function OutputIterator (line 1842) | OutputIterator
function equal (line 1864) | inline bool equal(InputIterator1 first1, InputIterator1 last1, InputIter...
function equal (line 1924) | bool
function lexicographical_compare (line 2003) | bool
function lexicographical_compare (line 2016) | inline bool // Specialization for const char*.
function lexicographical_compare (line 2027) | inline bool // Specialization for char*.
function lexicographical_compare (line 2038) | inline bool // Specialization for const unsigned char*.
function lexicographical_compare (line 2049) | inline bool // Specialization for unsigned char*.
function lexicographical_compare (line 2060) | inline bool // Specialization for const signed char*.
function lexicographical_compare (line 2071) | inline bool // Specialization for signed char*.
function lexicographical_compare (line 2127) | bool
type typename (line 2451) | typedef typename eastl::iterator_traits<ForwardIterator>::difference_typ...
function replace (line 2497) | void
function replace_if (line 2519) | void
function OutputIterator (line 2542) | OutputIterator
function OutputIterator (line 2569) | OutputIterator
function ForwardIterator (line 2608) | ForwardIterator
function ForwardIterator (line 2649) | ForwardIterator
function ForwardIterator (line 2686) | ForwardIterator apply_and_remove_if(ForwardIterator first,
function ForwardIterator (line 2730) | ForwardIterator apply_and_remove(ForwardIterator first,
function OutputIterator (line 2770) | OutputIterator
function OutputIterator (line 2795) | OutputIterator
function reverse_impl (line 2812) | void reverse_impl(BidirectionalIterator first, BidirectionalIterator las...
function reverse_impl (line 2819) | void reverse_impl(RandomAccessIterator first, RandomAccessIterator last,...
function reverse (line 2838) | void reverse(BidirectionalIterator first, BidirectionalIterator last)
function OutputIterator (line 2863) | OutputIterator
type typename (line 2989) | typedef typename eastl::iterator_traits<ForwardIterator2>::difference_ty...
function RandomAccessIterator (line 3047) | RandomAccessIterator // Random access iterator implementation. Much f...
function binary_search (line 3141) | bool
function binary_search (line 3161) | bool
function ForwardIterator (line 3179) | ForwardIterator
function ForwardIterator (line 3199) | ForwardIterator
type eastl (line 3328) | typedef eastl::reverse_iterator<BidirectionalIterator2> reverse_iterator2;
function ForwardIterator1 (line 3354) | ForwardIterator1
type eastl (line 3402) | typedef eastl::reverse_iterator<BidirectionalIterator2> reverse_iterator2;
function ForwardIterator1 (line 3431) | ForwardIterator1
type typename (line 3909) | typedef typename eastl::iterator_traits<ForwardIterator1>::difference_ty...
type typename (line 3944) | typedef typename eastl::iterator_traits<ForwardIterator1>::difference_ty...
type typename (line 4039) | typedef typename eastl::iterator_traits<BidirectionalIterator>::value_ty...
function namespace (line 4082) | namespace Internal
type typename (line 4118) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 4131) | typedef typename eastl::iterator_traits<BidirectionalIterator>::value_ty...
function ForwardIterator (line 4145) | ForwardIterator rotate_impl(ForwardIterator first, ForwardIterator middl...
type rotate_helper (line 4150) | struct rotate_helper
function ForwardIterator (line 4153) | ForwardIterator rotate_impl(ForwardIterator first, ForwardIterator middl...
type rotate_helper (line 4162) | struct rotate_helper
function BidirectionalIterator (line 4165) | BidirectionalIterator rotate_impl(BidirectionalIterator first, Bidirecti...
type rotate_helper (line 4209) | struct rotate_helper
function BidirectionalIterator (line 4212) | BidirectionalIterator rotate_impl(BidirectionalIterator first, Bidirecti...
function Integer (line 4223) | Integer greatest_common_divisor(Integer x, Integer y)
type rotate_helper (line 4235) | struct rotate_helper
function RandomAccessIterator (line 4241) | RandomAccessIterator rotate_impl(RandomAccessIterator first, RandomAcces...
type rotate_helper (line 4276) | struct rotate_helper
function RandomAccessIterator (line 4285) | RandomAccessIterator rotate_impl(RandomAccessIterator first, RandomAcces...
type typename (line 4307) | typedef typename eastl::iterator_traits<ForwardIterator>::iterator_categ...
type typename (line 4308) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type ...
function is_partitioned (line 4366) | bool is_partitioned(InputIterator first, InputIterator last, UnaryPredic...
function ForwardIterator (line 4399) | ForwardIterator partition_point(ForwardIterator first, ForwardIterator l...
FILE: include/EASTL/allocator.h
function namespace (line 21) | namespace eastl
function namespace (line 179) | namespace eastl
function namespace (line 318) | namespace eastl
FILE: include/EASTL/allocator_malloc.h
function namespace (line 58) | namespace eastl
function deallocate (line 106) | void deallocate(void* p, size_t /*n*/)
function set_name (line 112) | void set_name(const char*)
FILE: include/EASTL/any.h
function namespace (line 41) | namespace eastl
function class (line 103) | class any
function destroy (line 187) | static inline void destroy(any& refAny)
function construct (line 264) | inline void construct(storage& s, V&& v)
function construct_inplace (line 270) | inline void construct_inplace(storage& s, Args... args)
function construct_inplace (line 276) | inline void construct_inplace(storage& s, std::initializer_list<U> il, A...
function destroy (line 281) | static inline void destroy(any& refAny)
function m_handler (line 385) | any(const any& other) : m_handler(nullptr)
type decay_t (line 416) | typedef decay_t<ValueType> DecayedValueType;
type storage_handler (line 425) | typedef storage_handler<decay_t<T>> StorageHandlerT;
type storage_handler (line 439) | typedef storage_handler<decay_t<T>> StorageHandlerT;
type storage_handler (line 472) | typedef storage_handler<decay_t<T>> StorageHandlerT;
type storage_handler (line 484) | typedef storage_handler<decay_t<NT>> StorageHandlerT;
function reset (line 493) | void reset() EA_NOEXCEPT
function swap (line 499) | void swap(any& other) EA_NOEXCEPT
function std (line 536) | inline const std::type_info& type() const EA_NOEXCEPT
function swap (line 556) | inline void swap(any& rhs, any& lhs) EA_NOEXCEPT { rhs.swap(lhs); }
function ValueType (line 563) | ValueType any_cast(const any& operand)
function ValueType (line 609) | const ValueType* any_cast(const any* pAny) EA_NOEXCEPT
FILE: include/EASTL/array.h
function namespace (line 41) | namespace eastl
function namespace (line 636) | namespace internal {
FILE: include/EASTL/atomic_raw.h
function namespace (line 208) | namespace eastl
FILE: include/EASTL/bit.h
function namespace (line 23) | namespace eastl
FILE: include/EASTL/bitset.h
function namespace (line 54) | namespace eastl
type WordType (line 214) | typedef WordType word_type;
type BitsetBase (line 215) | typedef BitsetBase<NW, WordType> this_type;
type size_type (line 217) | typedef size_t size_type;
type eastl_size_t (line 219) | typedef eastl_size_t size_type;
type BitsetBase (line 399) | typedef BitsetBase<BITSET_WORD_COUNT(N, WordType), WordType> base_type;
type bitset (line 400) | typedef bitset<N, WordType> this_type;
type WordType (line 401) | typedef WordType word_type;
type typename (line 402) | typedef typename base_type::size_type size_type;
function to_ulong (line 509) | unsigned long to_ulong() const;
function to_ulong_assert_convertible (line 519) | unsigned long to_ulong_assert_convertible() const { return detail::to_...
function to_uint32_no_assert_convertible (line 529) | uint32_t to_uint32_no_assert_convertible() const { return detail::to_u...
function to_ulong_no_assert_convertible (line 531) | unsigned long to_ulong_no_assert_convertible() const { return detail::...
function noexcept (line 540) | const noexcept { return detail::to_unsigned_integral<UInt, true>(*this); }
function noexcept (line 543) | const noexcept { return to_uint32_assert_convertible(); }
function noexcept (line 545) | const noexcept { return to_uint64_assert_convertible(); }
function noexcept (line 547) | const noexcept { return to_ulong_assert_convertible(); }
function as_ullong (line 549) | long long> as_ullong() const noexcept { return to_ullong_assert_converti...
function GetFirstBit (line 732) | inline uint32_t GetFirstBit(eastl_uint128_t x)
function GetLastBit (line 851) | inline uint32_t GetLastBit(eastl_uint128_t x)
FILE: include/EASTL/bitvector.h
function namespace (line 37) | namespace eastl
type value_type (line 212) | typedef bool value_type;
type bitvector_reference (line 213) | typedef bitvector_reference<Element> reference;
type const_reference (line 214) | typedef bool const_reference;
type bitvector_iterator (line 215) | typedef bitvector_iterator<Element> iterator;
type bitvector_const_iterator (line 216) | typedef bitvector_const_iterator<Element> const_iterator;
type eastl (line 217) | typedef eastl::reverse_iterator<iterator> reverse_iterator;
type eastl (line 218) | typedef eastl::reverse_iterator<const_iterator> const_reverse_iterator;
type Allocator (line 219) | typedef Allocator allocator_type;
type Element (line 220) | typedef Element element_type;
type Container (line 221) | typedef Container container_type;
type eastl_size_t (line 222) | typedef eastl_size_t size_type;
type difference_type (line 223) | typedef ptrdiff_t difference_type;
type size_type (line 226) | enum : size_type { // Use Microsoft enum language e...
function const_reverse_iterator (line 271) | const_reverse_iterator rend() const EA_NOEXCEPT;
function mReference (line 418) | mReference(reference)
FILE: include/EASTL/bonus/adaptors.h
function namespace (line 28) | namespace eastl
FILE: include/EASTL/bonus/call_traits.h
function namespace (line 30) | namespace eastl
type T (line 56) | typedef T& reference;
type T (line 57) | typedef const T& const_reference;
type typename (line 58) | typedef typename ct_imp<T, is_pointer<T>::value, is_arithmetic<T>::value...
type T (line 66) | typedef T& reference;
type T (line 67) | typedef const T& const_reference;
type T (line 68) | typedef T& param_type;
type array_type (line 80) | typedef array_type& reference;
type array_type (line 81) | typedef const array_type& const_reference;
type T (line 82) | typedef const T* const param_type;
type array_type (line 94) | typedef array_type& reference;
type array_type (line 95) | typedef const array_type& const_reference;
type T (line 96) | typedef const T* const param_type;
FILE: include/EASTL/bonus/compressed_pair.h
function namespace (line 75) | namespace eastl
type T1 (line 122) | typedef T1 first_type;
type T2 (line 123) | typedef T2 second_type;
type typename (line 124) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 125) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 126) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 127) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 128) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 129) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 145) | second_reference second() { return mSecond; }
function swap (line 148) | void swap(compressed_pair<T1, T2>& y)
type T2 (line 166) | typedef T2 second_type;
type typename (line 167) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 168) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 169) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 170) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 171) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 172) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 188) | second_reference second() { return mSecond; }
function swap (line 191) | void swap(compressed_pair<T1,T2>& y)
type T2 (line 209) | typedef T2 second_type;
type typename (line 210) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 211) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 212) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 213) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 214) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 215) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 231) | second_reference second() { return *this; }
function swap (line 234) | void swap(compressed_pair<T1,T2>& y)
type T2 (line 252) | typedef T2 second_type;
type typename (line 253) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 254) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 255) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 256) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 257) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 258) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 274) | second_reference second() { return *this; }
function swap (line 278) | void swap(compressed_pair<T1, T2>&)
type T2 (line 291) | typedef T2 second_type;
type typename (line 292) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 293) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 294) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 295) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 296) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 297) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 310) | second_reference second() { return *this; }
function swap (line 313) | void swap(compressed_pair<T1, T2>&) { }
type T1 (line 322) | typedef T1 first_type;
type T2 (line 323) | typedef T2 second_type;
type typename (line 324) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 325) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 326) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 327) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 328) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 329) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 342) | second_reference second() { return mSecond; }
function swap (line 345) | void swap(compressed_pair<T1, T2>& y)
type T2 (line 378) | typedef T2 second_type;
type typename (line 379) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 380) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 381) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 382) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 383) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 384) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 394) | second_reference second() { return base::second(); }
function second_const_reference (line 395) | second_const_reference second() const { return base::second(); }
type T (line 422) | typedef T second_type;
type typename (line 423) | typedef typename call_traits<first_type>::param_type first_param_t...
type typename (line 424) | typedef typename call_traits<second_type>::param_type second_param_...
type typename (line 425) | typedef typename call_traits<first_type>::reference first_reference;
type typename (line 426) | typedef typename call_traits<second_type>::reference second_refere...
type typename (line 427) | typedef typename call_traits<first_type>::const_reference first_const_r...
type typename (line 428) | typedef typename call_traits<second_type>::const_reference second_const_...
function second_reference (line 437) | second_reference second() { return base::second(); }
function second_const_reference (line 438) | second_const_reference second() const { return base::second(); }
FILE: include/EASTL/bonus/fixed_ring_buffer.h
function namespace (line 16) | namespace eastl
FILE: include/EASTL/bonus/fixed_tuple_vector.h
function namespace (line 15) | namespace eastl
function base_type (line 81) | fixed_tuple_vector(const this_type& x)
function swap (line 169) | void swap(this_type& x)
function full (line 189) | bool full() const { return (base_type::mNumElements >= nodeCount) || ((v...
FILE: include/EASTL/bonus/flags.h
function namespace (line 202) | namespace eastl
function namespace (line 224) | namespace eastl::detail
function namespace (line 239) | namespace eastl
function namespace (line 644) | namespace eastl
FILE: include/EASTL/bonus/intrusive_sdlist.h
function namespace (line 65) | namespace eastl
function intrusive_sdlist_base (line 304) | inline intrusive_sdlist_base::intrusive_sdlist_base()
function clear (line 321) | inline void intrusive_sdlist_base::clear()
function pop_front (line 325) | inline void intrusive_sdlist_base::pop_front()
FILE: include/EASTL/bonus/intrusive_slist.h
function namespace (line 26) | namespace eastl
FILE: include/EASTL/bonus/list_map.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/bonus/lru_cache.h
function namespace (line 37) | namespace eastl
FILE: include/EASTL/bonus/overloaded.h
function namespace (line 20) | namespace eastl
FILE: include/EASTL/bonus/ring_buffer.h
function namespace (line 33) | namespace eastl
function c (line 598) | c(allocator)
function c (line 613) | c(x) // This copies elements from x, but unless the user is doing some t...
function c (line 627) | c(allocator)
function c (line 666) | c(allocator)
function c (line 682) | c(allocator)
function namespace (line 944) | namespace Internal
FILE: include/EASTL/bonus/sort_extra.h
function namespace (line 33) | namespace eastl
FILE: include/EASTL/bonus/tuple_vector.h
function namespace (line 45) | namespace eastl
type TupleRecurser (line 148) | struct TupleRecurser<>
function size_type (line 161) | size_type GetTotalAllocationSize(size_type capacity, size_type offset)
function EA_CONSTEXPR (line 202) | static EA_CONSTEXPR size_type GetTotalAlignment()
function EA_CONSTEXPR (line 207) | static EA_CONSTEXPR size_type GetTotalAllocationSize(size_type capacity,...
function EA_CONSTEXPR (line 238) | static EA_CONSTEXPR size_type CalculatAllocationOffset(size_type offset)...
type eastl_size_t (line 244) | typedef eastl_size_t size_type;
function DoUninitializedMoveAndDestruct (line 246) | void DoUninitializedMoveAndDestruct(const size_type begin, const size_ty...
function DoInsertAndFill (line 254) | void DoInsertAndFill(size_type pos, size_type n, size_type numElements, ...
function DoInsertRange (line 274) | void DoInsertRange(T* pSrcBegin, T* pSrcEnd, T* pDestBegin, size_type nu...
function DoInsertValue (line 294) | void DoInsertValue(size_type pos, size_type numElements, T&& arg)
type TupleVecIterCompatibleImpl (line 324) | struct TupleVecIterCompatibleImpl
type eastl_size_t (line 349) | typedef eastl_size_t size_type;
type TupleVecIter (line 352) | struct TupleVecIter
type tuple (line 361) | typedef tuple<Ts...> value_type;
type eastl_size_t (line 362) | typedef eastl_size_t difference_type;
type tuple (line 363) | typedef tuple<Ts*...> pointer;
type tuple (line 364) | typedef tuple<Ts&... > reference;
function reference (line 384) | reference operator*() const { return MakeReference(); }
function reference (line 432) | reference operator[](const size_type n) const
type index_sequence (line 463) | typedef index_sequence<Indices...> index_sequence_type;
type TupleVecImpl (line 464) | typedef TupleVecImpl<Allocator, index_sequence_type, Ts...> this_type;
type TupleVecImpl (line 465) | typedef TupleVecImpl<Allocator, index_sequence_type, const Ts...> const_...
type TupleVecInternal (line 469) | typedef TupleVecInternal::TupleVecIter<index_sequence_type, const Ts...>...
type eastl (line 470) | typedef eastl::reverse_iterator<iterator> reverse_iterator;
type eastl (line 471) | typedef eastl::reverse_iterator<const_iterator> const_reverse_iterator;
type eastl_size_t (line 472) | typedef eastl_size_t size_type;
type eastl (line 473) | typedef eastl::tuple<Ts...> value_tuple;
type eastl (line 474) | typedef eastl::tuple<Ts&...> reference_tuple;
type eastl (line 475) | typedef eastl::tuple<const Ts&...> const_reference_tuple;
type eastl (line 476) | typedef eastl::tuple<Ts*...> ptr_tuple;
type eastl (line 477) | typedef eastl::tuple<const Ts*...> const_ptr_tuple;
type eastl (line 478) | typedef eastl::tuple<Ts&&...> rvalue_tuple;
function mDataSizeAndAllocator (line 484) | TupleVecImpl(const allocator_type& allocator)
function assign (line 586) | void assign(size_type n, const Ts&... args)
function assign (line 608) | void assign(const_iterator first, const_iterator last)
function assign (line 645) | void assign(const value_tuple* first, const value_tuple* last)
function reference_tuple (line 675) | reference_tuple push_back()
function push_back (line 686) | void push_back(const Ts&... args)
function push_back_uninitialized (line 696) | void push_back_uninitialized()
function reference_tuple (line 705) | reference_tuple emplace_back(Ts&&... args)
function iterator (line 716) | iterator emplace(const_iterator pos, Ts&&... args)
function iterator (line 761) | iterator insert(const_iterator pos, size_type n, const Ts&... args)
function iterator (line 808) | iterator insert(const_iterator pos, const_iterator first, const_iterator...
function iterator (line 865) | iterator insert(const_iterator pos, const value_tuple* first, const valu...
function iterator (line 937) | iterator erase(const_iterator first, const_iterator last)
function iterator (line 961) | iterator erase_unsorted(const_iterator pos)
function resize (line 978) | void resize(size_type n)
function resize (line 998) | void resize(size_type n, const Ts&... args)
function reserve (line 1019) | void reserve(size_type n)
function shrink_to_fit (line 1024) | void shrink_to_fit()
function clear (line 1030) | void clear() EA_NOEXCEPT
function pop_back (line 1037) | void pop_back()
function swap (line 1048) | void swap(this_type& x)
function assign (line 1058) | void assign(size_type n, const_reference_tuple tup) { assign(n, eastl::g...
function assign (line 1059) | void assign(std::initializer_list<value_tuple> iList) { assign(iList.beg...
function push_back (line 1061) | void push_back(Ts&&... args) { emplace_back(eastl::forward<Ts>(args)...); }
function push_back (line 1062) | void push_back(const_reference_tuple tup) { push_back(eastl::get<Indices...
function push_back (line 1063) | void push_back(rvalue_tuple tup) { emplace_back(eastl::forward<Ts>(eastl...
function emplace_back (line 1065) | void emplace_back(rvalue_tuple tup) { emplace_back(eastl::forward<Ts>(ea...
function emplace (line 1066) | void emplace(const_iterator pos, rvalue_tuple tup) { emplace(pos, eastl:...
function iterator (line 1068) | iterator insert(const_iterator pos, const Ts&... args) { return insert(p...
function iterator (line 1069) | iterator insert(const_iterator pos, Ts&&... args) { return emplace(pos, ...
function iterator (line 1070) | iterator insert(const_iterator pos, rvalue_tuple tup) { return emplace(p...
function iterator (line 1071) | iterator insert(const_iterator pos, const_reference_tuple tup) { return ...
function iterator (line 1072) | iterator insert(const_iterator pos, size_type n, const_reference_tuple t...
function iterator (line 1073) | iterator insert(const_iterator pos, std::initializer_list<value_tuple> i...
function iterator (line 1075) | iterator erase(const_iterator pos) { return erase(pos, pos + 1); }
function reverse_iterator (line 1076) | reverse_iterator erase(const_reverse_iterator pos) { return reverse_iter...
function reverse_iterator (line 1077) | reverse_iterator erase(const_reverse_iterator first, const_reverse_itera...
function reverse_iterator (line 1078) | reverse_iterator erase_unsorted(const_reverse_iterator pos) { return rev...
function resize (line 1080) | void resize(size_type n, const_reference_tuple tup) { resize(n, eastl::g...
function iterator (line 1086) | iterator begin() EA_NOEXCEPT { return iterator(this, 0); }
function iterator (line 1090) | iterator end() EA_NOEXCEPT { return iterator(this, size()); }
function reverse_iterator (line 1094) | reverse_iterator rbegin() EA_NOEXCEPT { return reverse_iterator(end()); }
function const_reverse_iterator (line 1095) | const_reverse_iterator rbegin() const EA_NOEXCEPT { return const_revers...
function reverse_iterator (line 1098) | reverse_iterator rend() EA_NOEXCEPT { return reverse_iterator(begin()); }
function const_reverse_iterator (line 1099) | const_reverse_iterator rend() const EA_NOEXCEPT { return const_reverse_i...
function ptr_tuple (line 1102) | ptr_tuple data() EA_NOEXCEPT { return ptr_tuple(TupleVecLeaf<Indices, Ts...
function reference_tuple (line 1105) | reference_tuple at(size_type n)
function const_reference_tuple (line 1117) | const_reference_tuple at(size_type n) const
function reference_tuple (line 1129) | reference_tuple operator[](size_type n) { return at(n); }
function const_reference_tuple (line 1130) | const_reference_tuple operator[](size_type n) const { return at(n); }
function reference_tuple (line 1132) | reference_tuple front()
function reference_tuple (line 1156) | reference_tuple back()
type tuplevec_element_t (line 1179) | typedef tuplevec_element_t<I, Ts...> Element;
type tuplevec_element_t (line 1185) | typedef tuplevec_element_t<I, Ts...> Element;
type tuplevec_index (line 1192) | typedef tuplevec_index<T, TupleTypes<Ts...>> Index;
function T (line 1196) | T* get() const
function validate_iterator (line 1239) | int validate_iterator(const_iterator iter) const EA_NOEXCEPT
function validate_iterator_pair (line 1250) | static bool validate_iterator_pair(const_iterator first, const_iterator ...
function validate_iterator (line 1258) | int validate_iterator(Iterator iter) const EA_NOEXCEPT { return validate...
function validate_iterator_pair (line 1261) | static bool validate_iterator_pair(Iterator first, Iterator last) EA_NOE...
function set_allocator (line 1268) | void set_allocator(const allocator_type& alloc)
type TupleRecurser (line 1288) | struct TupleRecurser
function DoInitFromIterator (line 1308) | void DoInitFromIterator(const_iterator begin, const_iterator end)
function DoInitFillTuple (line 1325) | void DoInitFillTuple(size_type n, const_reference_tuple tup) { DoInitFil...
function DoInitFillArgs (line 1327) | void DoInitFillArgs(size_type n, const Ts&... args)
function DoInitDefaultFill (line 1334) | void DoInitDefaultFill(size_type n)
function DoInitFromTupleArray (line 1341) | void DoInitFromTupleArray(const value_tuple* first, const value_tuple* l...
function DoCopyFromTupleArray (line 1353) | void DoCopyFromTupleArray(iterator destPos, iterator destEnd, const valu...
function DoUninitializedCopyFromTupleArray (line 1364) | void DoUninitializedCopyFromTupleArray(iterator destPos, iterator destEn...
function DoGrow (line 1376) | void DoGrow(size_type oldNumElements, size_type oldNumCapacity, size_typ...
function DoConditionalReallocate (line 1383) | void DoConditionalReallocate(size_type oldNumElements, size_type oldNumC...
function DoReallocate (line 1389) | void DoReallocate(size_type oldNumElements, size_type requiredCapacity)
function size_type (line 1403) | size_type GetNewCapacity(size_type oldNumCapacity)
type iterator_traits (line 1419) | typedef iterator_traits<iterator_type> traits_type;
type typename (line 1420) | typedef typename traits_type::iterator_category iterator_category;
type typename (line 1421) | typedef typename traits_type::value_type value_type;
type typename (line 1422) | typedef typename traits_type::difference_type difference_type;
type typename (line 1423) | typedef typename traits_type::pointer pointer;
type tuple (line 1424) | typedef tuple<Ts&&...> reference;
type move_iterator (line 1425) | typedef move_iterator<iterator_type> this_type;
function explicit (line 1432) | explicit move_iterator(iterator_type mi) : mIterator(mi) {}
function reference (line 1438) | reference operator*() const { return eastl::move(MakeReference()); }
function pointer (line 1439) | pointer operator->() const { return mIterator; }
function reference (line 1476) | reference operator[](difference_type n) const { return *(*this + n); }
function swap (line 1537) | void swap(TupleVecInternal::TupleVecImpl<AllocatorA, Indices, Ts...>& a,
type TupleVecInternal (line 1568) | typedef TupleVecInternal::TupleVecImpl<EASTLAllocatorType, make_index_se...
type TupleVecInternal (line 1585) | typedef TupleVecInternal::TupleVecImpl<AllocatorType, make_index_sequenc...
FILE: include/EASTL/chrono.h
function namespace (line 73) | namespace eastl
type Period (line 221) | typedef Period period;
type duration (line 222) | typedef duration<Rep, Period> this_type;
function EA_CONSTEXPR (line 225) | EA_CONSTEXPR duration()
function EA_CONSTEXPR (line 268) | EA_CONSTEXPR inline static duration zero() { return duration(duration_va...
function EA_CONSTEXPR (line 269) | EA_CONSTEXPR inline static duration min() { return duration(duration_va...
function EA_CONSTEXPR (line 270) | EA_CONSTEXPR inline static duration max() { return duration(duration_va...
type typename (line 309) | typedef typename eastl::common_type<duration<Rep1, Period1>, duration<Re...
type duration (line 317) | typedef duration<typename
type duration (line 325) | typedef duration<typename
type duration (line 333) | typedef duration<typename
type typename (line 341) | typedef typename eastl::common_type<duration<Rep1, Period1>, duration<Re...
type duration (line 349) | typedef duration<typename
type typename (line 357) | typedef typename eastl::common_type<duration<Rep1, Period1>, duration<Re...
type typename (line 369) | typedef typename eastl::common_type<duration<Rep1, Period1>, duration<Re...
type typename (line 377) | typedef typename eastl::common_type<duration<Rep1, Period1>, duration<Re...
type nanoseconds (line 413) | typedef duration<long long, nano> nanoseconds;
type microseconds (line 414) | typedef duration<long long, micro> microseconds;
type milliseconds (line 415) | typedef duration<long long, milli> milliseconds;
type seconds (line 416) | typedef duration<long long> seconds;
type duration (line 417) | typedef duration<int, ratio<60>> minutes;
type duration (line 418) | typedef duration<int, ratio<3600>> hours;
type Duration (line 431) | typedef Duration duration;
type typename (line 432) | typedef typename Duration::rep rep;
type typename (line 433) | typedef typename Duration::period period;
function EA_CONSTEXPR (line 436) | EA_CONSTEXPR explicit time_point(const Duration& other) : mDuration(othe...
function EA_CONSTEXPR (line 449) | static EA_CONSTEXPR time_point min() { return time_point(Duration::min()...
function EA_CONSTEXPR (line 450) | static EA_CONSTEXPR time_point max() { return time_point(Duration::max()...
type time_point (line 461) | typedef time_point<Clock, typename
type time_point (line 469) | typedef time_point<Clock, typename
type time_point (line 477) | typedef time_point<Clock, typename
function namespace (line 546) | namespace Internal
function class (line 646) | class system_clock
function class (line 668) | class steady_clock
type system_clock (line 690) | typedef system_clock high_resolution_clock;
type chrono (line 702) | typedef chrono::duration<typename
type chrono (line 713) | typedef chrono::time_point<Clock, typename
function namespace (line 727) | inline namespace literals
FILE: include/EASTL/compare.h
type synth_three_way (line 16) | struct synth_three_way
FILE: include/EASTL/core_allocator.h
function namespace (line 12) | namespace EA
function virtual (line 47) | virtual void* AllocDebug(size_t size, const DebugParams debugParams, uns...
function EASTLCoreAllocatorImpl (line 60) | inline EASTLCoreAllocatorImpl* EASTLCoreAllocatorImpl::GetDefaultAllocat...
FILE: include/EASTL/core_allocator_adapter.h
function namespace (line 35) | namespace EA
type CoreDeleterAdapter (line 201) | typedef CoreDeleterAdapter<ICoreAllocator> EASTLICoreDeleterAdapter;
type CoreDeleterAdapter (line 202) | typedef CoreDeleterAdapter<EASTLCoreAllocatorImpl> EASTLCoreDeleterAdapter;
function namespace (line 216) | namespace EA
FILE: include/EASTL/deque.h
function namespace (line 113) | namespace eastl
function try (line 854) | try
type typename (line 1204) | typedef typename DequeIterator<T, PointerA, ReferenceA, kDequeSubarraySi...
function base_type (line 1274) | base_type(allocator)
function base_type (line 1283) | base_type(EASTL_DEQUE_DEFAULT_ALLOCATOR) // Call the empty base construc...
function Allocator (line 1568) | Allocator, kDequeSubarraySize>::operator[](size_type n) const
function Allocator (line 1591) | Allocator, kDequeSubarraySize>::at(size_type n)
function Allocator (line 1606) | Allocator, kDequeSubarraySize>::at(size_type n) const
function Allocator (line 1621) | Allocator, kDequeSubarraySize>::front()
function Allocator (line 1651) | Allocator, kDequeSubarraySize>::back()
function Allocator (line 1680) | Allocator, kDequeSubarraySize>::push_front(const value_type& value)
function Allocator (line 1687) | Allocator, kDequeSubarraySize>::push_front(value_type&& value)
function Allocator (line 1695) | Allocator, kDequeSubarraySize>::push_front()
function Allocator (line 1703) | Allocator, kDequeSubarraySize>::push_back(const value_type& value)
function Allocator (line 1710) | Allocator, kDequeSubarraySize>::push_back(value_type&& value)
function Allocator (line 1718) | Allocator, kDequeSubarraySize>::push_back()
function Allocator (line 1726) | Allocator, kDequeSubarraySize>::pop_front()
function Allocator (line 1756) | Allocator, kDequeSubarraySize>::pop_back()
function Allocator (line 1788) | Allocator, kDequeSubarraySize>::emplace(const_iterator position, Args&&....
type typename (line 2162) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type typename (line 2199) | typedef typename eastl::remove_const<ForwardIterator>::type non_const_it...
type typename (line 2200) | typedef typename eastl::remove_const<value_type>::type non_const_va...
FILE: include/EASTL/expected.h
function namespace (line 28) | namespace eastl
function E (line 169) | const E&& error() const&& noexcept { return eastl::move(mError); };
function namespace (line 183) | namespace internal
function ConstructFrom (line 241) | void ConstructFrom(const ExpectedConstructLayer& other)
function ConstructFrom (line 254) | void ConstructFrom(ExpectedConstructLayer&& other)
function AssignFrom (line 267) | void AssignFrom(const ExpectedConstructLayer& other)
function AssignFrom (line 289) | void AssignFrom(ExpectedConstructLayer&& other)
function explicit (line 470) | explicit expected(const unexpected<G>& unex)
function T (line 726) | constexpr const T* operator->() const noexcept
function T (line 732) | constexpr T* operator->() noexcept
function T (line 802) | constexpr T&& value() &&
function E (line 833) | constexpr E&& error() &&
function namespace (line 1156) | namespace internal
function noexcept (line 1187) | constexpr expected() noexcept { this->mHasValue = true; }
function noexcept (line 1188) | constexpr expected(in_place_t) noexcept { this->mHasValue = true; }
function explicit (line 1233) | explicit expected(const unexpected<G>& unex)
function noexcept (line 1323) | noexcept(NoExcept)
function value (line 1375) | constexpr void value() &&
function E (line 1388) | constexpr const E& error() const& noexcept { return this->mError; };
function E (line 1390) | constexpr const E&& error() const&& noexcept { return eastl::move(this->...
FILE: include/EASTL/finally.h
function namespace (line 38) | namespace eastl
FILE: include/EASTL/fixed_allocator.h
function namespace (line 37) | namespace eastl
function deallocate (line 190) | void deallocate(void* p, size_t)
function set_name (line 210) | void set_name(const char*)
function deallocate (line 379) | void deallocate(void* p, size_t)
function set_name (line 404) | void set_name(const char* pName)
FILE: include/EASTL/fixed_function.h
function namespace (line 14) | namespace eastl
function swap (line 153) | void swap(fixed_function& other) EA_NOEXCEPT
function explicit (line 158) | explicit operator bool() const EA_NOEXCEPT
function std (line 169) | const std::type_info& target_type() const EA_NOEXCEPT
function Functor (line 181) | Functor* target() const EA_NOEXCEPT
FILE: include/EASTL/fixed_hash_map.h
function namespace (line 25) | namespace eastl
type typename (line 183) | typedef typename fixed_allocator_type::overflow_allocator_type ...
type hash_multimap (line 184) | typedef hash_multimap<Key, T, Hash, Predicate, fixed_allocator_type, bCa...
type fixed_hash_multimap (line 185) | typedef fixed_hash_multimap<Key, T, nodeCount, bucketCount, bEnableOverf...
type typename (line 186) | typedef typename base_type::value_type ...
type typename (line 187) | typedef typename base_type::node_type ...
type typename (line 188) | typedef typename base_type::size_type ...
function size_type (line 228) | size_type max_size() const;
FILE: include/EASTL/fixed_hash_set.h
function namespace (line 26) | namespace eastl
type typename (line 179) | typedef typename fixed_allocator_type::overflow_allocator_type ...
type hash_multiset (line 180) | typedef hash_multiset<Value, Hash, Predicate, fixed_allocator_type, bCac...
type fixed_hash_multiset (line 181) | typedef fixed_hash_multiset<Value, nodeCount, bucketCount, bEnableOverfl...
type typename (line 182) | typedef typename base_type::value_type ...
type typename (line 183) | typedef typename base_type::node_type ...
type typename (line 184) | typedef typename base_type::size_type ...
function size_type (line 222) | size_type max_size() const;
FILE: include/EASTL/fixed_list.h
function namespace (line 23) | namespace eastl
FILE: include/EASTL/fixed_map.h
function namespace (line 24) | namespace eastl
type typename (line 140) | typedef typename fixed_allocator_type::overflow_allocator_type ...
type multimap (line 141) | typedef multimap<Key, T, Compare, fixed_allocator_type> ...
type fixed_multimap (line 142) | typedef fixed_multimap<Key, T, nodeCount, bEnableOverflow, Compare, Over...
type typename (line 143) | typedef typename base_type::value_type ...
type typename (line 144) | typedef typename base_type::node_type ...
type typename (line 145) | typedef typename base_type::size_type ...
function size_type (line 177) | size_type max_size() const;
function base_type (line 196) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 206) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 265) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 274) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 380) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 390) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 445) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 455) | base_type(fixed_allocator_type(mBuffer))
FILE: include/EASTL/fixed_set.h
function namespace (line 24) | namespace eastl
type typename (line 142) | typedef typename fixed_allocator_type::overflow_allocator_type ...
type multiset (line 143) | typedef multiset<Key, Compare, fixed_allocator_type> ...
type fixed_multiset (line 144) | typedef fixed_multiset<Key, nodeCount, bEnableOverflow, Compare, Overflo...
type typename (line 145) | typedef typename base_type::value_type ...
type typename (line 146) | typedef typename base_type::node_type ...
type typename (line 147) | typedef typename base_type::size_type ...
function size_type (line 178) | size_type max_size() const;
function base_type (line 196) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 206) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 265) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 274) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 379) | base_type(fixed_allocator_type(mBuffer))
function base_type (line 389) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 448) | base_type(fixed_allocator_type(mBuffer, overflowAllocator))
function base_type (line 457) | base_type(fixed_allocator_type(mBuffer))
FILE: include/EASTL/fixed_slist.h
function namespace (line 23) | namespace eastl
FILE: include/EASTL/fixed_string.h
function namespace (line 24) | namespace eastl
function swap (line 799) | inline void swap(fixed_string<T, nodeCount, bEnableOverflow, OverflowAll...
FILE: include/EASTL/fixed_substring.h
function namespace (line 18) | namespace eastl
function base_type (line 144) | fixed_substring(const value_type* p)
FILE: include/EASTL/fixed_vector.h
function namespace (line 25) | namespace eastl
type typename (line 294) | typedef typename std::initializer_list<value_type>::iterator InputIterator;
type typename (line 295) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type typename (line 341) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
FILE: include/EASTL/functional.h
function namespace (line 26) | namespace eastl
function const (line 576) | size_t operator()(T* p) const { return size_t(uintptr_t(p)); }
function bool (line 578) | struct hash<bool>
function char (line 581) | struct hash<char>
function signed (line 584) | struct hash<signed char>
function unsigned (line 587) | struct hash<unsigned char>
type hash (line 591) | struct hash
function const (line 592) | size_t operator()(char8_t val) const { return static_cast<size_t>(val); }
type hash (line 596) | struct hash
function const (line 597) | size_t operator()(char16_t val) const { return static_cast<size_t>(val); }
type hash (line 601) | struct hash
function const (line 602) | size_t operator()(char32_t val) const { return static_cast<size_t>(val); }
type hash (line 607) | struct hash
function const (line 608) | size_t operator()(wchar_t val) const { return static_cast<size_t>(val); }
function signed (line 611) | struct hash<signed short>
function unsigned (line 614) | struct hash<unsigned short>
function signed (line 617) | struct hash<signed int>
function unsigned (line 620) | struct hash<unsigned int>
function signed (line 623) | struct hash<signed long>
function unsigned (line 626) | struct hash<unsigned long>
type hash (line 629) | struct hash
function const (line 630) | size_t operator()(signed long long val) const { return static_cast<size_...
type hash (line 632) | struct hash
function const (line 633) | size_t operator()(unsigned long long val) const { return static_cast<siz...
function namespace (line 635) | namespace internal
function float (line 651) | struct hash<float>
function double (line 654) | struct hash<double>
type hash (line 657) | struct hash
function const (line 658) | size_t operator()(long double val) const { return internal::floating_poi...
type hash (line 661) | struct hash
function const (line 662) | size_t operator()(uint128_t val) const { return static_cast<size_t>(val); }
function char (line 678) | struct hash<char*>
function char (line 689) | struct hash<const char*>
type hash (line 701) | struct hash
function char8_t (line 712) | struct hash<const char8_t*>
function char16_t (line 725) | struct hash<char16_t*>
function char16_t (line 736) | struct hash<const char16_t*>
function char32_t (line 747) | struct hash<char32_t*>
function char32_t (line 758) | struct hash<const char32_t*>
type hash (line 770) | struct hash
function wchar_t (line 781) | struct hash<const wchar_t*>
type String (line 803) | typedef String string_type;
type typename (line 804) | typedef typename String::value_type value_type;
type typename (line 805) | typedef typename eastl::make_unsigned<value_type>::type unsigned_value_t...
function const (line 807) | size_t operator()(const string_type& s) const
FILE: include/EASTL/hash_map.h
function namespace (line 32) | namespace eastl
function insert_return_type (line 282) | insert_return_type insert(const key_type& key)
function insert_return_type (line 287) | insert_return_type insert(key_type&& key)
function T (line 300) | const T& at(const key_type& k) const { return DoAt(k); }
function insert_return_type (line 337) | insert_return_type try_emplace(const key_type& k, Args&&... args)
function iterator (line 355) | iterator try_emplace(const_iterator, const key_type& k, Args&&... args) {
type hash_multimap (line 476) | typedef hash_multimap<Key, T, Hash, Predicate, Allocator, bCacheHashCode...
type typename (line 477) | typedef typename base_type::size_type ...
type typename (line 478) | typedef typename base_type::key_type ...
type T (line 479) | typedef T ...
type typename (line 480) | typedef typename base_type::value_type ...
type typename (line 481) | typedef typename base_type::allocator_type ...
type typename (line 482) | typedef typename base_type::node_type ...
type typename (line 483) | typedef typename base_type::insert_return_type ...
type typename (line 484) | typedef typename base_type::iterator ...
function base_type (line 526) | hash_multimap(const this_type& x)
function insert_return_type (line 615) | insert_return_type insert(const key_type& key)
function insert_return_type (line 621) | insert_return_type insert(key_type&& key)
type typename (line 666) | typedef typename hash_map<Key, T, Hash, Predicate, Allocator, bCacheHash...
type typename (line 698) | typedef typename hash_multimap<Key, T, Hash, Predicate, Allocator, bCach...
type typename (line 699) | typedef typename eastl::iterator_traits<const_iterator>::difference_type...
FILE: include/EASTL/hash_set.h
function namespace (line 29) | namespace eastl
function insert_return_type (line 296) | insert_return_type insert(P&& otherValue)
type hash_multiset (line 343) | typedef hash_multiset<Value, Hash, Predicate, Allocator, bCacheHashCode>...
type typename (line 344) | typedef typename base_type::size_type ...
type typename (line 345) | typedef typename base_type::value_type ...
type typename (line 346) | typedef typename base_type::allocator_type ...
type typename (line 347) | typedef typename base_type::node_type ...
type typename (line 348) | typedef typename base_type::insert_return_type insert_return_type;
function base_type (line 385) | hash_multiset(const this_type& x)
function insert_return_type (line 470) | insert_return_type insert(P&& otherValue)
type typename (line 509) | typedef typename hash_set<Value, Hash, Predicate, Allocator, bCacheHashC...
type typename (line 541) | typedef typename hash_multiset<Value, Hash, Predicate, Allocator, bCache...
type typename (line 542) | typedef typename eastl::iterator_traits<const_iterator>::difference_type...
FILE: include/EASTL/heap.h
function namespace (line 47) | namespace eastl
type typename (line 259) | typedef typename iterator_traits<RandomAccessIterator>::value_type value...
type typename (line 275) | typedef typename iterator_traits<RandomAccessIterator>::value_type value...
function push_heap (line 297) | void push_heap(RandomAccessIterator first, RandomAccessIterator last)
function push_heap (line 320) | void push_heap(RandomAccessIterator first, RandomAccessIterator last, Co...
function pop_heap (line 354) | void pop_heap(RandomAccessIterator first, RandomAccessIterator last)
function pop_heap (line 378) | void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Com...
type typename (line 405) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
type typename (line 406) | typedef typename eastl::iterator_traits<RandomAccessIterator>::value_typ...
type typename (line 427) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
type typename (line 428) | typedef typename eastl::iterator_traits<RandomAccessIterator>::value_typ...
function sort_heap (line 463) | void sort_heap(RandomAccessIterator first, RandomAccessIterator last)
function sort_heap (line 476) | void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Co...
function remove_heap (line 501) | void remove_heap(RandomAccessIterator first, Distance heapSize, Distance...
function remove_heap (line 524) | void remove_heap(RandomAccessIterator first, Distance heapSize, Distance...
function change_heap (line 548) | void change_heap(RandomAccessIterator first, Distance heapSize, Distance...
function change_heap (line 568) | void change_heap(RandomAccessIterator first, Distance heapSize, Distance...
function RandomAccessIterator (line 590) | RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAcc...
function RandomAccessIterator (line 611) | RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAcc...
function is_heap (line 637) | bool is_heap(RandomAccessIterator first, RandomAccessIterator last)
function is_heap (line 649) | bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Comp...
FILE: include/EASTL/initializer_list.h
function namespace (line 33) | namespace std
FILE: include/EASTL/internal/atomic/atomic.h
function namespace (line 55) | namespace internal
function EA_CONSTEXPR (line 143) | EA_CONSTEXPR atomic() EA_NOEXCEPT_IF(eastl::is_nothrow_default_construct...
function is_lock_free (line 152) | bool is_lock_free() const volatile EA_NOEXCEPT \
FILE: include/EASTL/internal/atomic/atomic_asserts.h
function namespace (line 43) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_base_width.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_flag.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_flag_standalone.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_integral.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_memory_order.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_pointer.h
function namespace (line 41) | namespace eastl
FILE: include/EASTL/internal/atomic/atomic_size_aligned.h
function namespace (line 14) | namespace eastl
function T (line 150) | T exchange(T /*desired*/) volatile EA_NOEXCEPT
FILE: include/EASTL/internal/atomic/atomic_standalone.h
function namespace (line 14) | namespace eastl
FILE: include/EASTL/internal/atomic/compiler/compiler.h
function namespace (line 32) | namespace eastl
FILE: include/EASTL/internal/atomic/compiler/msvc/compiler_msvc.h
function namespace (line 40) | namespace eastl
FILE: include/EASTL/internal/char_traits.h
function namespace (line 30) | namespace eastl
function Compare (line 252) | constexpr int Compare(const char* p1, const char* p2, size_t n) { return...
function Compare (line 256) | constexpr int Compare(const wchar_t* p1, const wchar_t* p2, size_t n)
function Compare (line 265) | inline int Compare(const char* p1, const char* p2, size_t n)
function CompareI (line 275) | int CompareI(const T* p1, const T* p2, size_t n)
function T (line 291) | const T* Find(const T* p, T c, size_t n)
function CharStrlen (line 317) | size_t CharStrlen(const T* p)
function CharStrlen (line 328) | constexpr size_t CharStrlen(const char* p) { return __builtin_strlen(p); }
function CharStrlen (line 330) | constexpr size_t CharStrlen(const wchar_t* p)
function T (line 341) | T* CharStringUninitializedCopy(const T* pSource, const T* pSourceEnd, T*...
function T (line 352) | T* CharTypeStringFindEnd(const T* pBegin, const T* pEnd, T c)
function T (line 369) | T* CharTypeStringSearch(const T* p1Begin, const T* p1End,
function T (line 416) | T* CharTypeStringRSearch(const T* p1Begin, const T* p1End,
function T (line 459) | const T* CharTypeStringFindFirstOf(const T* p1Begin, const T* p1End, con...
function T (line 476) | const T* CharTypeStringRFindFirstNotOf(const T* p1RBegin, const T* p1REn...
function T (line 496) | const T* CharTypeStringFindFirstNotOf(const T* p1Begin, const T* p1End, ...
function T (line 517) | const T* CharTypeStringRFindFirstOf(const T* p1RBegin, const T* p1REnd, ...
function T (line 534) | const T* CharTypeStringRFind(const T* pRBegin, const T* pREnd, const T c)
function T (line 554) | T* CharStringUninitializedFillN(T* pDestination, size_t n, const T c)
function T (line 572) | T* CharTypeAssignN(T* pDestination, size_t n, T c)
FILE: include/EASTL/internal/concepts.h
function namespace (line 17) | namespace eastl
FILE: include/EASTL/internal/config.h
function namespace (line 168) | namespace eastl
function namespace (line 480) | namespace eastl
type __int128_t (line 898) | typedef __int128_t eastl_int128_t;
type __uint128_t (line 899) | typedef __uint128_t eastl_uint128_t;
type int128_t (line 901) | typedef int128_t eastl_int128_t;
type uint128_t (line 902) | typedef uint128_t eastl_uint128_t;
type EASTL_SIZE_T (line 1504) | typedef EASTL_SIZE_T eastl_size_t;
type EASTL_SSIZE_T (line 1505) | typedef EASTL_SSIZE_T eastl_ssize_t;
FILE: include/EASTL/internal/copy_help.h
function namespace (line 20) | namespace eastl
type move_and_copy_helper (line 93) | struct move_and_copy_helper
function OutputIterator (line 96) | OutputIterator move_or_copy(InputIterator first, InputIterator last, Out...
function T (line 112) | T* move_or_copy(const T* first, const T* last, T* result)
function namespace (line 123) | namespace internal {
function OutputIterator (line 152) | OutputIterator move_and_copy_chooser(InputIterator first, InputIterator ...
function OutputIterator (line 165) | inline OutputIterator move_and_copy_unwrapper(InputIterator first, Input...
function OutputIterator (line 194) | OutputIterator move(InputIterator first, InputIterator last, OutputItera...
function OutputIterator (line 215) | OutputIterator copy(InputIterator first, InputIterator last, OutputItera...
FILE: include/EASTL/internal/enable_shared.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/internal/fill_help.h
function namespace (line 20) | namespace eastl
FILE: include/EASTL/internal/fixed_pool.h
function namespace (line 42) | namespace eastl
type fixed_pool_base (line 133) | struct fixed_pool_base
type Link (line 208) | struct Link
function deallocate (line 340) | void deallocate(void* p)
function set_name (line 360) | void set_name(const char*)
function mOverflowAllocator (line 402) | mOverflowAllocator(EASTL_FIXED_POOL_DEFAULT_NAME)
function mOverflowAllocator (line 413) | mOverflowAllocator(allocator)
function deallocate (line 522) | void deallocate(void* p)
function set_name (line 547) | void set_name(const char* pName)
function set_overflow_allocator (line 565) | void set_overflow_allocator(const overflow_allocator_type& overflowAlloc...
type fixed_node_allocator (line 610) | typedef fixed_node_allocator<nodeSize, nodeCount, nodeAlignment, nodeAli...
type OverflowAllocator (line 611) | typedef OverflowAllocator overflow_allocator_type;
function mPool (line 659) | fixed_node_allocator(const this_type& x)
function deallocate (line 688) | void deallocate(void* p, size_t)
function reset (line 709) | void reset(void* pNodeBuffer)
function set_name (line 721) | void set_name(const char* pName)
function set_overflow_allocator (line 739) | void set_overflow_allocator(const overflow_allocator_type& allocator)
function copy_overflow_allocator (line 745) | void copy_overflow_allocator(const this_type& x) // This function exist...
type fixed_node_allocator (line 761) | typedef fixed_node_allocator<nodeSize, nodeCount, nodeAlignment, nodeAli...
type OverflowAllocator (line 762) | typedef OverflowAllocator overflow_allocator_type;
function deallocate (line 833) | void deallocate(void* p, size_t)
function reset (line 845) | void reset(void* pNodeBuffer)
function set_name (line 857) | void set_name(const char* pName)
function overflow_allocator_type (line 863) | const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT
function copy_overflow_allocator (line 886) | void copy_overflow_allocator(const this_type&) // This function exists ...
type fixed_hashtable_allocator (line 942) | typedef fixed_hashtable_allocator<bucketCount, nodeSize, nodeCount, node...
type OverflowAllocator (line 943) | typedef OverflowAllocator overflow_allocator_type;
function deallocate (line 1056) | void deallocate(void* p, size_t)
function reset (line 1069) | void reset(void* pNodeBuffer)
function set_name (line 1082) | void set_name(const char* pName)
function set_overflow_allocator (line 1100) | void set_overflow_allocator(const overflow_allocator_type& allocator)
function copy_overflow_allocator (line 1106) | void copy_overflow_allocator(const this_type& x) // This function exist...
type fixed_hashtable_allocator (line 1122) | typedef fixed_hashtable_allocator<bucketCount, nodeSize, nodeCount, node...
type OverflowAllocator (line 1123) | typedef OverflowAllocator overflow_allocator_type;
function mpBucketBuffer (line 1166) | mpBucketBuffer(pBucketBuffer)
function deallocate (line 1228) | void deallocate(void* p, size_t)
function reset (line 1241) | void reset(void* pNodeBuffer)
function set_name (line 1254) | void set_name(const char* pName)
function overflow_allocator_type (line 1260) | const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT
function copy_overflow_allocator (line 1281) | void copy_overflow_allocator(const this_type&) // This function exists ...
type OverflowAllocator (line 1332) | typedef OverflowAllocator overflow_allocator_type;
function deallocate (line 1393) | void deallocate(void* p, size_t n)
function set_name (line 1404) | void set_name(const char* pName)
function overflow_allocator_type (line 1409) | const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT
function set_overflow_allocator (line 1419) | void set_overflow_allocator(const overflow_allocator_type& allocator)
function copy_overflow_allocator (line 1424) | void copy_overflow_allocator(const this_type& x) // This function exist...
type OverflowAllocator (line 1437) | typedef OverflowAllocator overflow_allocator_type;
function deallocate (line 1493) | void deallocate(void* /*p*/, size_t /*n*/)
function set_name (line 1502) | void set_name(const char* /*pName*/)
function overflow_allocator_type (line 1506) | const overflow_allocator_type& get_overflow_allocator() const EA_NOEXCEPT
function set_overflow_allocator (line 1520) | void set_overflow_allocator(const overflow_allocator_type& /*allocator*/)
function copy_overflow_allocator (line 1526) | void copy_overflow_allocator(const this_type&) // This function exists ...
FILE: include/EASTL/internal/function.h
function namespace (line 16) | namespace eastl
function swap (line 96) | void swap(function& other) EA_NOEXCEPT
function explicit (line 101) | explicit operator bool() const EA_NOEXCEPT
function std (line 112) | const std::type_info& target_type() const EA_NOEXCEPT
function Functor (line 124) | Functor* target() const EA_NOEXCEPT
FILE: include/EASTL/internal/function_detail.h
function namespace (line 66) | namespace eastl
function swap (line 566) | void swap(function_detail& other) EA_NOEXCEPT
function explicit (line 594) | explicit operator bool() const EA_NOEXCEPT
function std (line 605) | const std::type_info& target_type() const EA_NOEXCEPT
function Functor (line 627) | Functor* target() const EA_NOEXCEPT
function Destroy (line 648) | void Destroy() EA_NOEXCEPT
function Copy (line 657) | void Copy(const function_detail& other)
function Move (line 684) | void Move(function_detail&& other)
type R (line 737) | typedef R (*InvokeFuncPtr)(Args..., void*);
function R (line 746) | static R DefaultInvoker(Args... /*args*/, void* /*storage*/)
FILE: include/EASTL/internal/function_help.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/internal/functional_base.h
function namespace (line 20) | namespace eastl
function invoke (line 84) | decltype(auto) invoke(F&& func, Args&&... args) EA_NOEXCEPT_IF(EA_NOEXCE...
type allocator_arg_t (line 169) | struct allocator_arg_t
function EA_CPP14_CONSTEXPR (line 187) | EA_CPP14_CONSTEXPR bool operator()(const T& a, const T& b) const
type less (line 193) | struct less<void>
FILE: include/EASTL/internal/generic_iterator.h
function namespace (line 31) | namespace eastl
function reference (line 94) | reference operator[](const difference_type& n) const
function EASTL_REMOVE_AT_2024_SEPT (line 191) | EASTL_REMOVE_AT_2024_SEPT is_generic_iterator : public false_type { }
FILE: include/EASTL/internal/hashtable.h
function namespace (line 61) | namespace eastl
function namespace (line 155) | namespace Internal
type hash_node (line 189) | typedef hash_node<Value, bCacheHashCode> node_type;
function mpNode (line 194) | mpNode(pNode) { }
function increment (line 196) | void increment()
type node_iterator (line 214) | typedef node_iterator<Value, bConst, bCacheHashCode> this_type;
type typename (line 215) | typedef typename base_type::node_type node_type;
type Value (line 216) | typedef Value value_t...
type typename (line 217) | typedef typename conditional<bConst, const
type typename (line 218) | typedef typename conditional<bConst, const
type difference_type (line 219) | typedef ptrdiff_t differe...
type eastl (line 220) | typedef eastl::forward_iterator_tag iterator_categ...
function reference (line 229) | reference operator*() const
function pointer (line 232) | pointer operator->() const
type hash_node (line 260) | typedef hash_node<Value, bCacheHashCode> node_type;
type hashtable_iterator (line 267) | struct hashtable_iterator
function increment_bucket (line 282) | void increment_bucket()
function increment (line 290) | void increment()
type hashtable_iterator (line 318) | typedef hashtable_iterator<Value, bConst, bCacheHashCode> this_type;
type hashtable_iterator (line 319) | typedef hashtable_iterator<Value, false, bCacheHashCode> this_ty...
type typename (line 320) | typedef typename base_type::node_type node_type;
type Value (line 321) | typedef Value value_t...
type typename (line 322) | typedef typename conditional<bConst, const
type typename (line 323) | typedef typename conditional<bConst, const
type difference_type (line 324) | typedef ptrdiff_t differe...
type eastl (line 325) | typedef eastl::forward_iterator_tag iterator_categ...
function reference (line 343) | reference operator*() const
function pointer (line 346) | pointer operator->() const
function node_type (line 355) | const node_type* get_node() const
function typename (line 381) | typename eastl::iterator_traits<Iterator>::difference_type
function typename (line 386) | typename eastl::iterator_traits<Iterator>::difference_type
type mod_range_hashing (line 401) | struct mod_range_hashing
type default_ranged_hash (line 418) | struct default_ranged_hash{ }
function prime_rehash_policy (line 426) | struct EASTL_API prime_rehash_policy
function get_max_load_factor (line 493) | float get_max_load_factor() const
type bucket_index_t (line 560) | typedef uint32_t bucket_index_t;
function bucket_index_t (line 571) | bucket_index_t bucket_index(hash_code_t, uint32_t) const
function bucket_index_t (line 578) | bucket_index_t bucket_index(const hash_node<Value, false>* pNode, uint32...
function copy_code (line 585) | void copy_code(hash_node<Value, false>*, const hash_node<Value, false>*)...
function set_code (line 588) | void set_code(hash_node<Value, false>* pDest, hash_code_t c) const
function base_swap (line 594) | void base_swap(hash_code_base& x)
type bucket_index_t (line 651) | typedef uint32_t bucket_index_t;
type hash_node (line 652) | typedef hash_node<Value, false> node_type;
function bucket_index_t (line 661) | bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const
function bucket_index_t (line 668) | bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCoun...
function copy_code (line 675) | void copy_code(node_type*, const node_type*) const
function set_code (line 678) | void set_code(node_type*, hash_code_t) const
function base_swap (line 681) | void base_swap(hash_code_base& x)
type bucket_index_t (line 722) | typedef uint32_t bucket_index_t;
type hash_node (line 723) | typedef hash_node<Value, true> node_type;
function bucket_index_t (line 732) | bucket_index_t bucket_index(hash_code_t c, uint32_t nBucketCount) const
function bucket_index_t (line 739) | bucket_index_t bucket_index(const node_type* pNode, uint32_t nBucketCoun...
function copy_code (line 746) | void copy_code(node_type* pDest, const node_type* pSource) const
function set_code (line 749) | void set_code(node_type* pDest, hash_code_t c) const
function base_swap (line 752) | void base_swap(hash_code_base& x)
function namespace (line 764) | namespace internal {
type Value (line 891) | typedef Value ...
type typename (line 892) | typedef typename ExtractKey::result_type ...
type hash_code_base (line 893) | typedef hash_code_base<Key, Value, ExtractKey, Equal, H1, H2, H, bCacheH...
type typename (line 894) | typedef typename hash_code_base_type::hash_code_t ...
type Allocator (line 895) | typedef Allocator ...
type Equal (line 896) | typedef Equal ...
type difference_type (line 897) | typedef ptrdiff_t ...
type eastl_size_t (line 898) | typedef eastl_size_t ...
type value_type (line 899) | typedef value_type& ...
type value_type (line 900) | typedef const value_type& ...
type node_iterator (line 901) | typedef node_iterator<value_type, !bMutableIterators, bCacheHashCode> ...
type node_iterator (line 902) | typedef node_iterator<value_type, true, bCacheHashCode> ...
type hashtable_iterator (line 903) | typedef hashtable_iterator<value_type, !bMutableIterators, bCacheHashCod...
type hashtable_iterator (line 904) | typedef hashtable_iterator<value_type, true, bCacheHashCod...
type hash_node (line 905) | typedef hash_node<value_type, bCacheHashCode> ...
type typename (line 906) | typedef typename conditional<bUniqueKeys, eastl::pair<iterator, bool>, i...
type hashtable (line 907) | typedef hashtable<Key, Value, Allocator, ExtractKey, Equal, H1, H2, H,
type RehashPolicy (line 909) | typedef RehashPolicy ...
type ExtractKey (line 910) | typedef ExtractKey ...
type H1 (line 911) | typedef H1 ...
type H2 (line 912) | typedef H2 ...
type H (line 913) | typedef H ...
type integral_constant (line 914) | typedef integral_constant<bool, bUniqueKeys> ...
type NodeFindKeyData (line 934) | struct NodeFindKeyData {
function allocator_type (line 960) | const allocator_type& get_allocator() const EA_NOEXCEPT;
function const_iterator (line 1002) | const_iterator cbegin() const EA_NOEXCEPT
function local_iterator (line 1015) | local_iterator begin(size_type n) EA_NOEXCEPT
function const_local_iterator (line 1018) | const_local_iterator begin(size_type n) const EA_NOEXCEPT
function const_local_iterator (line 1021) | const_local_iterator cbegin(size_type n) const EA_NOEXCEPT
function local_iterator (line 1025) | local_iterator end(size_type) EA_NOEXCEPT
function const_local_iterator (line 1028) | const_local_iterator end(size_type) const EA_NOEXCEPT
function const_local_iterator (line 1031) | const_local_iterator cend(size_type) const EA_NOEXCEPT
function size_type (line 1047) | size_type bucket_size(size_type n) const EA_NOEXCEPT
function load_factor (line 1057) | float load_factor() const EA_NOEXCEPT
function size_type (line 1134) | size_type erase(const key_type& k) { return DoErase(k); }
function reset_lose_memory (line 1142) | void reset_lose_memory() EA_NOEXCEPT; // This is a unilateral ...
function const_iterator (line 1147) | const_iterator find(const key_type& key) const { return DoFind(key); }
function contains (line 1156) | bool contains(const key_type& key) const { return DoFind(key) != end(); }
function iterator (line 1238) | iterator find_by_hash(const key_type& k, hash_code_t c)
function const_iterator (line 1246) | const_iterator find_by_hash(const key_type& k, hash_code_t c) const
function size_type (line 1265) | size_type count(const key_type& k) const EA_NOEXCEPT { return DoCount(k); }
function EA_NOEXCEPT (line 1269) | count(const KX& key) const EA_NOEXCEPT { return DoCount(key); }
function validate (line 1281) | bool validate() const;
function iterator (line 1419) | iterator DoInsertKey(false_type, const key_type& key)...
function typename (line 1980) | inline typename H::iterator hashtable_find(H& hashTable, U u)
function typename (line 1985) | inline typename H::const_iterator hashtable_find(const H& hashTable, U u)
function EA_CONSTEXPR_IF (line 2239) | EA_CONSTEXPR_IF(bDeleteOnException) { DoFreeNode(pNodeNew); }
FILE: include/EASTL/internal/in_place_t.h
function namespace (line 16) | namespace eastl
FILE: include/EASTL/internal/integer_sequence.h
function namespace (line 12) | namespace eastl
FILE: include/EASTL/internal/intrusive_hashtable.h
function namespace (line 39) | namespace eastl
type intrusive_hashtable_iterator (line 145) | struct intrusive_hashtable_iterator
function increment_bucket (line 160) | void increment_bucket()
function increment (line 168) | void increment()
type intrusive_hashtable_iterator (line 196) | typedef intrusive_hashtable_iterator<Value, bConst> this...
type intrusive_hashtable_iterator (line 197) | typedef intrusive_hashtable_iterator<Value, false> this...
type typename (line 198) | typedef typename base_type::value_type valu...
type typename (line 199) | typedef typename conditional<bConst, const
type typename (line 200) | typedef typename conditional<bConst, const
type difference_type (line 201) | typedef ptrdiff_t diff...
type eastl (line 202) | typedef eastl::forward_iterator_tag iterator_ca...
function explicit (line 208) | explicit intrusive_hashtable_iterator(value_type* pNode, value_type** pB...
function explicit (line 211) | explicit intrusive_hashtable_iterator(value_type** pBucket)
function reference (line 218) | reference operator*() const
function pointer (line 221) | pointer operator->() const
type Key (line 243) | typedef Key result_type;
function result_type (line 245) | const result_type& operator()(const Node& x) const
type Key (line 261) | typedef Key ...
type Value (line 262) | typedef Value ...
type Value (line 263) | typedef Value ...
type Value (line 264) | typedef Value ...
type hash_code_t (line 265) | typedef uint32_t ...
type Equal (line 266) | typedef Equal ...
type difference_type (line 267) | typedef ptrdiff_t ...
type eastl_size_t (line 268) | typedef eastl_size_t ...
type value_type (line 269) | typedef value_type& ...
type value_type (line 270) | typedef const value_type& ...
type intrusive_node_iterator (line 271) | typedef intrusive_node_iterator<value_type, bConstIterators> ...
type intrusive_node_iterator (line 272) | typedef intrusive_node_iterator<value_type, true> ...
type intrusive_hashtable_iterator (line 273) | typedef intrusive_hashtable_iterator<value_type, bConstIterators> ...
type intrusive_hashtable_iterator (line 274) | typedef intrusive_hashtable_iterator<value_type, true> ...
type typename (line 275) | typedef typename conditional<bUniqueKeys, pair<iterator, bool>, iterator...
type typename (line 276) | typedef typename conditional<bConstIterators, eastl::use_self<Value>,
function iterator (line 295) | iterator begin() EA_NOEXCEPT
function const_iterator (line 327) | const_iterator cbegin() const EA_NOEXCEPT
function local_iterator (line 341) | local_iterator begin(size_type n) EA_NOEXCEPT
function const_local_iterator (line 344) | const_local_iterator begin(size_type n) const EA_NOEXCEPT
function const_local_iterator (line 347) | const_local_iterator cbegin(size_type n) const EA_NOEXCEPT
function local_iterator (line 350) | local_iterator end(size_type) EA_NOEXCEPT
function const_local_iterator (line 353) | const_local_iterator end(size_type) const EA_NOEXCEPT
function const_local_iterator (line 356) | const_local_iterator cend(size_type) const EA_NOEXCEPT
function size_type (line 368) | size_type bucket_size(size_type n) const EA_NOEXCEPT
function size_type (line 371) | size_type bucket(const key_type& k) const EA_NOEXCEPT
function insert_return_type (line 382) | insert_return_type insert(const_iterator, value_type& value)
function typename (line 603) | inline typename H::iterator intrusive_hashtable_find(H& hashTable, const...
function typename (line 608) | inline typename H::const_iterator intrusive_hashtable_find(const H& hash...
FILE: include/EASTL/internal/mem_fn.h
function namespace (line 31) | namespace eastl
FILE: include/EASTL/internal/memory_base.h
function namespace (line 22) | namespace eastl
FILE: include/EASTL/internal/memory_uses_allocator.h
function namespace (line 10) | namespace eastl
FILE: include/EASTL/internal/move_help.h
function namespace (line 67) | namespace eastl
FILE: include/EASTL/internal/pair_fwd_decls.h
function namespace (line 10) | namespace eastl
FILE: include/EASTL/internal/piecewise_construct_t.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/internal/red_black_tree.h
function namespace (line 40) | namespace eastl
function compare (line 302) | rb_base(const Compare& compare) : rb_base_compare_ebo<Compare>(compare) {}
function compare (line 322) | rb_base(const Compare& compare) : rb_base_compare_ebo<Compare>(compare) {}
type eastl (line 332) | typedef eastl::use_first<Pair> extract_key;
function compare (line 339) | rb_base(const Compare& compare) : rb_base_compare_ebo<Compare>(compare) {}
type eastl (line 349) | typedef eastl::use_first<Pair> extract_key;
function compare (line 356) | rb_base(const Compare& compare) : rb_base_compare_ebo<Compare>(compare) {}
type eastl_size_t (line 438) | typedef eastl_size_t ...
type Key (line 439) | typedef Key ...
type Value (line 440) | typedef Value ...
type rbtree_node (line 441) | typedef rbtree_node<value_type> ...
type value_type (line 442) | typedef value_type& ...
type value_type (line 443) | typedef const value_type& ...
type value_type (line 444) | typedef value_type* ...
type value_type (line 445) | typedef const value_type* ...
type typename (line 447) | typedef typename conditional<bMutableIterators,
type rbtree_iterator (line 450) | typedef rbtree_iterator<value_type, const
type eastl (line 451) | typedef eastl::reverse_iterator<iterator> ...
type eastl (line 452) | typedef eastl::reverse_iterator<const_iterator> ...
type Allocator (line 454) | typedef Allocator ...
type Compare (line 455) | typedef Compare ...
type typename (line 456) | typedef typename conditional<bUniqueKeys, eastl::pair<iterator, bool>, i...
type rbtree (line 457) | typedef rbtree<Key, Value, Compare, Allocator,
type rb_base (line 459) | typedef rb_base<Key, Value, Compare, ExtractKey, bUniqueKeys, this_type>...
type integral_constant (line 460) | typedef integral_constant<bool, bUniqueKeys> ...
type typename (line 461) | typedef typename base_type::extract_key ...
function iterator (line 589) | iterator find(const key_type& key) { return DoFind(key); }
function const_iterator (line 590) | const_iterator find(const key_type& key) const { return DoFind(key); }
function contains (line 611) | bool contains(const key_type& key) const { return DoFind(key) != end(); }
function iterator (line 616) | iterator lower_bound(const key_type& key) { return DoLowerBound(ke...
function const_iterator (line 617) | const_iterator lower_bound(const key_type& key) const { return DoLowerBo...
function iterator (line 624) | iterator upper_bound(const key_type& key) { return DoUpperBound(ke...
function const_iterator (line 625) | const_iterator upper_bound(const key_type& key) const { return DoUpperBo...
function validate (line 632) | bool validate() const;
function EASTL_API (line 727) | EASTL_API inline rbtree_node_base* RBTreeGetMaxChild(const rbtree_node_b...
function mpNode (line 745) | mpNode(NULL) { }
function key_type (line 1613) | const key_type& key(extract_key{}
function key_type (line 1647) | const key_type& key(extract_key{}
FILE: include/EASTL/internal/smart_ptr.h
function namespace (line 18) | namespace eastl
FILE: include/EASTL/internal/special_member_functions.h
function namespace (line 12) | namespace eastl
FILE: include/EASTL/internal/special_member_functions_variant_optional.h
function namespace (line 11) | namespace eastl
FILE: include/EASTL/internal/thread_support.h
function namespace (line 92) | namespace eastl
FILE: include/EASTL/internal/tuple_fwd_decls.h
function namespace (line 12) | namespace eastl
FILE: include/EASTL/internal/type_compound.h
function namespace (line 22) | namespace eastl
FILE: include/EASTL/internal/type_detected.h
function namespace (line 17) | namespace eastl
function namespace (line 34) | namespace internal
FILE: include/EASTL/internal/type_fundamental.h
function namespace (line 17) | namespace eastl
function true_type (line 119) | struct is_integral_helper<unsigned char> : public true_type{}
function true_type (line 120) | struct is_integral_helper<unsigned short> : public true_type{}
function true_type (line 121) | struct is_integral_helper<unsigned int> : public true_type{}
function true_type (line 122) | struct is_integral_helper<unsigned long> : public true_type{}
type is_integral_helper (line 123) | struct is_integral_helper
function true_type (line 123) | long> : public true_type{}
function true_type (line 125) | struct is_integral_helper<signed char> : public true_type{}
function true_type (line 126) | struct is_integral_helper<signed short> : public true_type{}
function true_type (line 127) | struct is_integral_helper<signed int> : public true_type{}
function true_type (line 128) | struct is_integral_helper<signed long> : public true_type{}
type is_integral_helper (line 129) | struct is_integral_helper
function true_type (line 129) | long> : public true_type{}
function true_type (line 131) | struct is_integral_helper<bool> : public true_type{}
function true_type (line 132) | struct is_integral_helper<char> : public true_type{}
type is_integral_helper (line 135) | struct is_integral_helper
type is_integral_helper (line 138) | struct is_integral_helper
type is_integral_helper (line 141) | struct is_integral_helper
function true_type (line 144) | struct is_integral_helper<wchar_t> : public true_type{}
type is_integral_helper (line 147) | struct is_integral_helper
function true_type (line 174) | struct is_floating_point_helper<float> : public true_type{}
function true_type (line 175) | struct is_floating_point_helper<double> : public true_type{}
function true_type (line 176) | struct is_floating_point_helper<long double> : public true_type{}
type int_convertible (line 270) | struct int_convertible{ int_convertible(int); }
type is_enum_helper (line 276) | struct is_enum_helper
type disjunction (line 281) | typedef disjunction<is_arithmetic<T>, is_reference<T>, is_class<T>> sele...
type is_enum_helper (line 282) | typedef is_enum_helper<selector::value> helper_t;
type typename (line 283) | typedef typename add_lvalue_reference<T>::type ref_t;
type typename (line 284) | typedef typename helper_t::template nest<ref_t> result;
function false_type (line 290) | struct is_enum<void> : public false_type {}
function false_type (line 291) | struct is_enum<void const> : public false_type {}
function false_type (line 292) | struct is_enum<void volatile> : public false_type {}
type is_enum (line 293) | struct is_enum
function public (line 293) | volatile> : public false_type {}
FILE: include/EASTL/internal/type_pod.h
function namespace (line 26) | namespace eastl
FILE: include/EASTL/internal/type_properties.h
function namespace (line 19) | namespace eastl
function namespace (line 370) | namespace internal
FILE: include/EASTL/internal/type_transformations.h
function namespace (line 18) | namespace eastl
function namespace (line 275) | namespace internal
type typename (line 366) | typedef typename eastl::internal::make_unsigned_helper<T>::type type;
function bool (line 369) | struct make_unsigned<bool> {}
function signed (line 370) | struct make_unsigned<signed char> { typedef unsigned char ...
function unsigned (line 371) | struct make_unsigned<unsigned char> { typedef unsigned char ...
function signed (line 372) | struct make_unsigned<signed short> { typedef unsigned short ...
function unsigned (line 373) | struct make_unsigned<unsigned short> { typedef unsigned short ...
function signed (line 374) | struct make_unsigned<signed int> { typedef unsigned int ...
function unsigned (line 375) | struct make_unsigned<unsigned int> { typedef unsigned int ...
function signed (line 376) | struct make_unsigned<signed long> { typedef unsigned long ...
function unsigned (line 377) | struct make_unsigned<unsigned long> { typedef unsigned long ...
type make_unsigned (line 378) | struct make_unsigned
type type (line 378) | typedef unsigned long long type;
type make_unsigned (line 379) | struct make_unsigned
type type (line 379) | typedef unsigned long long type;
type make_unsigned (line 381) | struct make_unsigned
type __uint128_t (line 381) | typedef __uint128_t type;
function __uint128_t (line 382) | struct make_unsigned<__uint128_t> { typedef __uint128_t type; }
type make_unsigned (line 386) | struct make_unsigned
type type (line 386) | typedef unsigned char type;
type make_unsigned (line 390) | struct make_unsigned
type type (line 390) | typedef unsigned char type;
type T (line 432) | typedef T type;
type T (line 433) | typedef T type;
type T (line 434) | typedef T type;
type T (line 435) | typedef T type;
type T (line 436) | typedef T type;
function namespace (line 465) | namespace internal
type T (line 495) | typedef T type;
type T (line 496) | typedef T type;
type T (line 497) | typedef T type;
type T (line 517) | typedef T type;
type typename (line 518) | typedef typename eastl::remove_all_extents<T>::type type;
type typename (line 519) | typedef typename eastl::remove_all_extents<T>::type type;
type type (line 563) | struct type { unsigned char mCharData[N]; }
type type (line 569) | typedef struct {
type type (line 579) | struct type{ unsigned char mCharData[N]; }
type typename (line 597) | typedef typename aligned_storage_helper<N, Align>::type type;
type EA_ALIGN (line 607) | struct EA_ALIGN
type typename (line 668) | typedef typename eastl::aligned_storage<size, alignment_value>::type type;
type typename (line 686) | typedef typename eastl::aligned_storage<size, alignment_value>::type type;
FILE: include/EASTL/internal/type_void_t.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/intrusive_hash_map.h
function namespace (line 20) | namespace eastl
type intrusive_hash_multimap (line 72) | typedef intrusive_hash_multimap<Key, T, bucketCount, Hash, Equal> ...
FILE: include/EASTL/intrusive_hash_set.h
function namespace (line 20) | namespace eastl
type intrusive_hash_multiset (line 70) | typedef intrusive_hash_multiset<T, bucketCount, Hash, Equal> ...
FILE: include/EASTL/intrusive_list.h
function namespace (line 94) | namespace eastl
type intrusive_list_iterator (line 136) | typedef intrusive_list_iterator<T, T*, T&> iterator;
type intrusive_list_iterator (line 137) | typedef intrusive_list_iterator<T, const
type T (line 138) | typedef T value_type;
type T (line 139) | typedef T node_type;
type intrusive_list_node (line 140) | typedef intrusive_list_node base_node_type;
type difference_type (line 141) | typedef ptrdiff_t difference_type;
type Pointer (line 142) | typedef Pointer pointer;
type Reference (line 143) | typedef Reference reference;
type eastl (line 144) | typedef eastl::bidirectional_iterator_tag iterator_category;
function class (line 210) | class intrusive_list_base
function pop_back (line 561) | inline void intrusive_list_base::pop_back()
FILE: include/EASTL/intrusive_ptr.h
function namespace (line 19) | namespace eastl
type intrusive_ptr (line 72) | typedef intrusive_ptr<T> this_type;
function mpObject (line 91) | mpObject(NULL)
function mpObject (line 103) | mpObject(p)
function mpObject (line 111) | intrusive_ptr(const intrusive_ptr& ip)
function mpObject (line 122) | mpObject(nullptr)
function T (line 275) | T* detach()
type T (line 292) | typedef T* (this_type::*bool_)() const;
function T (line 317) | T* get_pointer(const intrusive_ptr<T>& intrusivePtr)
FILE: include/EASTL/iterator.h
function namespace (line 44) | namespace eastl
type T (line 143) | typedef T value_type;
type difference_type (line 144) | typedef ptrdiff_t difference_type;
type T (line 145) | typedef const T* pointer;
type T (line 146) | typedef const T& reference;
function EASTL_REMOVE_AT_2024_SEPT (line 176) | EASTL_REMOVE_AT_2024_SEPT is_iterator_wrapper
function EASTL_REMOVE_AT_2024_SEPT (line 213) | EASTL_REMOVE_AT_2024_SEPT is_iterator_wrapper_helper
function iterator_type (line 235) | static iterator_type get_unwrapped(Iterator it) { return it.unwrap(); }
type typename (line 264) | typedef typename eastl::iterator_traits<Iterator>::iterator_category ite...
type typename (line 265) | typedef typename eastl::iterator_traits<Iterator>::value_type value_type;
type typename (line 266) | typedef typename eastl::iterator_traits<Iterator>::difference_type diff...
type typename (line 267) | typedef typename eastl::iterator_traits<Iterator>::pointer pointer;
type typename (line 268) | typedef typename eastl::iterator_traits<Iterator>::reference reference;
function EA_CPP14_CONSTEXPR (line 277) | EA_CPP14_CONSTEXPR explicit reverse_iterator(iterator_type i)
function EASTL_REMOVE_AT_2024_SEPT (line 426) | EASTL_REMOVE_AT_2024_SEPT is_reverse_iterator
type iterator_traits (line 467) | typedef iterator_traits<Iterator> traits_type;
type typename (line 468) | typedef typename traits_type::iterator_category iterator_category;
type typename (line 469) | typedef typename traits_type::value_type value_type;
type typename (line 470) | typedef typename traits_type::difference_type difference_type;
type Iterator (line 471) | typedef Iterator pointer;
function explicit (line 485) | explicit move_iterator(iterator_type mi)
function reference (line 504) | reference operator*() const { return static_cast<reference>(*mIterator); }
function pointer (line 506) | pointer operator->() const
function reference (line 553) | reference operator[](difference_type n) const
function IteratorType (line 630) | IteratorType make_move_if_noexcept_iterator(Iterator i)
function EASTL_REMOVE_AT_2024_SEPT (line 650) | EASTL_REMOVE_AT_2024_SEPT is_move_iterator
type Container (line 693) | typedef Container container_type;
type typename (line 694) | typedef typename Container::const_reference const_reference;
type eastl (line 695) | typedef eastl::output_iterator_tag iterator_category;
type value_type (line 696) | typedef void value_type;
type difference_type (line 697) | typedef void difference_type;
type pointer (line 698) | typedef void pointer;
type reference (line 699) | typedef void reference;
type Container (line 750) | typedef Container container_type;
type typename (line 751) | typedef typename Container::const_reference const_reference;
type eastl (line 752) | typedef eastl::output_iterator_tag iterator_category;
type value_type (line 753) | typedef void value_type;
type difference_type (line 754) | typedef void difference_type;
type pointer (line 755) | typedef void pointer;
type reference (line 756) | typedef void reference;
type typename (line 814) | typedef typename Container::iterator iterator_type;
type typename (line 815) | typedef typename Container::const_reference const_reference;
type eastl (line 816) | typedef eastl::output_iterator_tag iterator_category;
type value_type (line 817) | typedef void value_type;
type difference_type (line 818) | typedef void difference_type;
type pointer (line 819) | typedef void pointer;
type reference (line 820) | typedef void reference;
type typename (line 860) | typedef typename Container::iterator iterator;
type typename (line 941) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type advance_bi_impl (line 976) | struct advance_bi_impl
type typename (line 1024) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
function decltype (line 1063) | auto data(const Container& c) -> decltype(c.data())
function E (line 1071) | const E* data(std::initializer_list<E> il) EA_NOEXCEPT
function decltype (line 1080) | auto size(const C& c) -> decltype(c.size())
function size (line 1084) | size_t size(const T (&)[N]) EA_NOEXCEPT
function ssize (line 1093) | ptrdiff_t ssize(const T(&)[N]) EA_NOEXCEPT
function decltype (line 1110) | auto empty(const Container& c) -> decltype(c.empty())
function empty (line 1114) | bool empty(const T (&)[N]) EA_NOEXCEPT
function empty (line 1118) | bool empty(std::initializer_list<E> il) EA_NOEXCEPT
function decltype (line 1146) | inline auto begin(Container& container) -> decltype(container.begin())
function decltype (line 1152) | inline auto begin(const Container& container) -> decltype(container.begi...
function decltype (line 1164) | inline auto cbegin(const Container& container) -> decltype(eastl::begin(...
function decltype (line 1170) | inline auto end(Container& container) -> decltype(container.end())
function decltype (line 1176) | inline auto end(const Container& container) -> decltype(container.end())
function decltype (line 1188) | inline auto cend(const Container& container) -> decltype(eastl::end(cont...
function decltype (line 1194) | inline auto rbegin(Container& container) -> decltype(container.rbegin())
function decltype (line 1200) | inline auto rbegin(const Container& container) -> decltype(container.rbe...
function decltype (line 1206) | inline auto rend(Container& container) -> decltype(container.rend())
function decltype (line 1212) | inline auto rend(const Container& container) -> decltype(container.rend())
function decltype (line 1218) | inline auto crbegin(const Container& container) -> decltype(eastl::rbegi...
function decltype (line 1224) | inline auto crend(const Container& container) -> decltype(eastl::rend(co...
FILE: include/EASTL/linked_array.h
function namespace (line 26) | namespace eastl
type T (line 241) | typedef T* (this_type::*bool_)() const;
FILE: include/EASTL/linked_ptr.h
function namespace (line 22) | namespace eastl
type T (line 307) | typedef T* (this_type::*bool_)() const;
function T (line 367) | T* get_pointer(const linked_ptr<T, D>& linkedPtr)
FILE: include/EASTL/list.h
function namespace (line 69) | namespace eastl
type Allocator (line 180) | typedef Allocator allocator_type;
type ListNode (line 181) | typedef ListNode<T> node_type;
type eastl_size_t (line 182) | typedef eastl_size_t size_type;
type difference_type (line 183) | typedef ptrdiff_t difference_type;
type ListNodeBase (line 184) | typedef ListNodeBase base_node_type;
type list (line 247) | typedef list<T, Allocator> this_type;
type T (line 263) | typedef T* pointer;
type T (line 264) | typedef const T* const_pointer;
type T (line 265) | typedef T& reference;
type T (line 266) | typedef const T& const_reference;
type ListIterator (line 267) | typedef ListIterator<T, T*, T&> iterator;
type ListIterator (line 268) | typedef ListIterator<T, const
type eastl (line 269) | typedef eastl::reverse_iterator<iterator> reverse_iterator;
type eastl (line 270) | typedef eastl::reverse_iterator<const_iterator> const_reverse_iterator;
type typename (line 271) | typedef typename base_type::size_type size_type;
type typename (line 272) | typedef typename base_type::difference_type difference_type;
type typename (line 273) | typedef typename base_type::allocator_type allocator_type;
type typename (line 274) | typedef typename base_type::node_type node_type;
type typename (line 275) | typedef typename base_type::base_node_type base_node_type;
function const_reverse_iterator (line 324) | const_reverse_iterator rend() const EA_NOEXCEPT;
function insert (line 520) | inline void ListNodeBase::insert(ListNodeBase* pNext) EA_NOEXCEPT
function remove (line 531) | inline void ListNodeBase::remove() EA_NOEXCEPT
function insert_range (line 541) | inline void ListNodeBase::insert_range(ListNodeBase* pFirst, ListNodeBas...
function remove_range (line 552) | inline void ListNodeBase::remove_range(ListNodeBase* pFirst, ListNodeBas...
function base_type (line 791) | base_type(allocator)
function base_type (line 799) | base_type(allocator)
function base_type (line 807) | base_type(allocator)
function base_type (line 823) | base_type(allocator)
function base_type (line 839) | base_type(allocator)
function base_type (line 847) | base_type(allocator)
function base_type (line 856) | base_type(EASTL_LIST_DEFAULT_ALLOCATOR)
function const_iterator (line 1421) | const_iterator itFirstBase((++first).base());
FILE: include/EASTL/map.h
function namespace (line 24) | namespace eastl
type multimap (line 259) | typedef multimap<Key, T, Compare, Allocator> ...
type typename (line 260) | typedef typename base_type::size_type ...
type typename (line 261) | typedef typename base_type::key_type ...
type T (line 262) | typedef T ...
type typename (line 263) | typedef typename base_type::value_type ...
type typename (line 264) | typedef typename base_type::node_type ...
type typename (line 265) | typedef typename base_type::iterator ...
type typename (line 266) | typedef typename base_type::const_iterator ...
type typename (line 267) | typedef typename base_type::allocator_type ...
type typename (line 268) | typedef typename base_type::insert_return_type ...
type typename (line 269) | typedef typename base_type::extract_key ...
function compare (line 293) | value_compare(Compare c) : compare(c) {}
function size_type (line 347) | size_type count(const Key& key) const { return DoCount(key); }
function base_type (line 402) | base_type(allocator)
function base_type (line 416) | base_type(x)
function base_type (line 710) | base_type(allocator)
function base_type (line 724) | base_type(x)
FILE: include/EASTL/memory.h
function destruct (line 171) | void destruct()
function ForwardIterator (line 267) | ForwardIterator impl(InputIterator first, InputIterator last, ForwardIte...
function ForwardIterator (line 402) | static inline ForwardIterator impl(InputIterator first, Count n, Forward...
function ForwardIterator (line 410) | ForwardIterator uninitialized_copy_n(InputIterator first, Count n, Forwa...
function Result (line 424) | inline Result uninitialized_copy_ptr(First first, Last last, Result result)
function Result (line 437) | inline Result uninitialized_move_ptr(First first, Last last, Result dest)
function ForwardIterator (line 456) | ForwardIterator uninitialized_move(InputIterator first, InputIterator la...
function ForwardIterator (line 468) | ForwardIterator uninitialized_move_if_noexcept(InputIterator first, Inpu...
function Result (line 481) | inline Result uninitialized_move_ptr_if_noexcept(First first, Last last,...
function ForwardIterator (line 498) | ForwardIterator uninitialized_move_n(InputIterator first, Count n, Forwa...
type typename (line 516) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 545) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function uninitialized_fill_impl (line 579) | void uninitialized_fill_impl(ForwardIterator first, ForwardIterator last...
type typename (line 587) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function uninitialized_fill (line 609) | void uninitialized_fill(ForwardIterator first, ForwardIterator last, con...
type typename (line 628) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 661) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function uninitialized_fill_ptr (line 689) | inline void uninitialized_fill_ptr(T* first, T* last, const T& value)
function uninitialized_fill_n_impl (line 707) | void uninitialized_fill_n_impl(ForwardIterator first, Count n, const T& ...
type typename (line 716) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function uninitialized_fill_n (line 738) | void uninitialized_fill_n(ForwardIterator first, Count n, const T& value)
function uninitialized_fill_n_ptr (line 753) | inline void uninitialized_fill_n_ptr(T* first, Count n, const T& value)
type typename (line 773) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 802) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 833) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
type typename (line 861) | typedef typename eastl::iterator_traits<ForwardIterator>::value_type val...
function ForwardIterator (line 885) | ForwardIterator
type Pointer (line 1183) | typedef Pointer pointer;
type typename (line 1184) | typedef typename Internal::pointer_element_type<pointer>::type elemen...
type typename (line 1185) | typedef typename Internal::pointer_difference_type<pointer>::type differ...
type typename (line 1189) | typedef typename Internal::pointer_rebind<pointer, U>::type other;
type T (line 1205) | typedef T element_type;
type difference_type (line 1206) | typedef ptrdiff_t difference_type;
type U (line 1210) | typedef U* other;
function namespace (line 1228) | namespace Internal
function T (line 1238) | T* to_address(T* p) noexcept
FILE: include/EASTL/meta.h
function namespace (line 21) | namespace eastl
type type (line 164) | typedef decltype(types(declval<typename unique_type_list<Ts...>::type>()...
FILE: include/EASTL/numeric.h
function namespace (line 24) | namespace eastl
function namespace (line 246) | namespace eastl
function namespace (line 261) | namespace eastl
function namespace (line 289) | namespace eastl
function namespace (line 387) | namespace eastl
FILE: include/EASTL/numeric_limits.h
function namespace (line 107) | namespace eastl
FILE: include/EASTL/optional.h
function namespace (line 48) | namespace eastl
function EA_CPP20_CONSTEXPR (line 137) | inline EA_CPP20_CONSTEXPR void destruct_value() {}
function ConstructFrom (line 174) | void ConstructFrom(optional_base&& other)
function EA_CONSTEXPR (line 253) | inline EA_CONSTEXPR T* get_value_address() EA_NOEXCEPT
function EA_CONSTEXPR (line 258) | inline EA_CONSTEXPR const T* get_value_address() const EA_NOEXCEPT
function private (line 278) | private Internal::optional_base<T>
function optional (line 732) | inline optional or_else(F&& f) const&
function optional (line 746) | inline optional or_else(F&& f) &&
function EA_CPP20_CONSTEXPR (line 811) | inline EA_CPP20_CONSTEXPR void reset() EA_NOEXCEPT
function nullopt_t (line 884) | nullopt_t) EA_NOEXCEPT
function nullopt_t (line 896) | nullopt_t) EA_NOEXCEPT
function nullopt_t (line 904) | nullopt_t) EA_NOEXCEPT
function nullopt_t (line 912) | nullopt_t) EA_NOEXCEPT
function nullopt_t (line 920) | nullopt_t) EA_NOEXCEPT
function nullopt_t (line 928) | nullopt_t) EA_NOEXCEPT
FILE: include/EASTL/priority_queue.h
function namespace (line 42) | namespace eastl
function Container (line 346) | Container, Compare>::push(value_type&& value)
function Container (line 368) | Container, Compare>::emplace(Args&&... args)
function Container (line 375) | Container, Compare>::pop()
function Container (line 401) | Container, Compare>::pop(value_type& value)
function Container (line 414) | Container, Compare>::change(size_type n) // This function is not in the ...
function Container (line 426) | Container, Compare>::remove(size_type n) // This function is not in the ...
function Container (line 455) | Container, Compare>::swap(this_type& x) EA_NOEXCEPT_IF((eastl::is_nothro...
FILE: include/EASTL/queue.h
function namespace (line 27) | namespace eastl
FILE: include/EASTL/random.h
function namespace (line 41) | namespace eastl
FILE: include/EASTL/ratio.h
function namespace (line 82) | namespace eastl
FILE: include/EASTL/safe_ptr.h
function namespace (line 19) | namespace eastl
function eastl (line 182) | inline eastl::safe_object::safe_object()
function eastl (line 206) | inline eastl::safe_object::~safe_object()
function add (line 220) | inline void eastl::safe_object::add(safe_ptr_base* pBase) const
function remove (line 227) | inline void eastl::safe_object::remove(safe_ptr_base* pBase) const
function eastl (line 253) | inline eastl::safe_ptr_base::safe_ptr_base(const safe_ptr_base& safePtrB...
function eastl (line 264) | inline eastl::safe_ptr_base::safe_ptr_base()
function reset (line 287) | inline void eastl::safe_ptr_base::reset()
function reset (line 303) | inline void eastl::safe_ptr_base::reset(const safe_object* pNewObject)
function rhs (line 382) | bool eastl::safe_ptr<T>::operator==(const this_type& rhs) const
FILE: include/EASTL/scoped_array.h
function namespace (line 27) | namespace eastl
FILE: include/EASTL/scoped_ptr.h
function namespace (line 27) | namespace eastl
FILE: include/EASTL/segmented_vector.h
function namespace (line 18) | namespace eastl
function Count (line 667) | Count, Allocator>::push_back()
function Count (line 674) | Count, Allocator>::push_back(const T& value)
function Count (line 681) | Count, Allocator>::push_back(T&& value)
function Count (line 695) | Count, Allocator>::emplace_back(Args&&... args)
function swap (line 1057) | inline void swap(segmented_vector<T, Count, Allocator>& a, segmented_vec...
FILE: include/EASTL/set.h
function namespace (line 21) | namespace eastl
type multiset (line 233) | typedef multiset<Key, Compare, Allocator> ...
type typename (line 234) | typedef typename base_type::size_type ...
type typename (line 235) | typedef typename base_type::value_type ...
type typename (line 236) | typedef typename base_type::iterator ...
type typename (line 237) | typedef typename base_type::const_iterator ...
type typename (line 238) | typedef typename base_type::reverse_iterator ...
type typename (line 239) | typedef typename base_type::const_reverse_iterator ...
type typename (line 240) | typedef typename base_type::allocator_type ...
type Compare (line 241) | typedef Compare ...
type typename (line 242) | typedef typename base_type::insert_return_type insert_return_type;
function size_type (line 289) | size_type erase(const Key& k) { return DoErase(k); }
function insert_return_type (line 304) | insert_return_type insert(P&& otherValue) { return base_type::emplace(ea...
function size_type (line 306) | size_type count(const Key& key) const { return DoCount(key); }
function base_type (line 358) | base_type(allocator)
function base_type (line 372) | base_type(x)
function base_type (line 563) | base_type(allocator)
function base_type (line 577) | base_type(x)
FILE: include/EASTL/shared_array.h
function namespace (line 82) | namespace eastl
function swap (line 235) | void swap(this_type& sharedArray)
FILE: include/EASTL/shared_ptr.h
function namespace (line 76) | namespace eastl
type T (line 262) | typedef T ...
type Allocator (line 263) | typedef Allocator ...
function value_type (line 269) | value_type* GetValue() { return static_cast<value_type*>(static_cast<voi...
function free_value (line 278) | void free_value() EA_NOEXCEPT
function free_ref_count_sp (line 283) | void free_ref_count_sp() EA_NOEXCEPT
type T (line 333) | typedef T& reference_type;
function void (line 335) | struct shared_ptr_traits<void>
type shared_ptr_traits (line 338) | struct shared_ptr_traits
type reference_type (line 339) | typedef void reference_type;
type shared_ptr_traits (line 341) | struct shared_ptr_traits
type reference_type (line 342) | typedef void reference_type;
type shared_ptr_traits (line 344) | struct shared_ptr_traits
type reference_type (line 345) | typedef void reference_type;
type T (line 371) | typedef T element_type;
type typename (line 372) | typedef typename shared_ptr_traits<T>::reference_type reference_type;
type EASTLAllocatorType (line 373) | typedef EASTLAllocatorType default_allocat...
type default_delete (line 374) | typedef default_delete<T> default_deleter...
type weak_ptr (line 375) | typedef weak_ptr<T> weak_type;
function reset (line 713) | void reset() EA_NOEXCEPT
function swap (line 755) | void swap(this_type& sharedPtr) EA_NOEXCEPT
function reference_type (line 772) | reference_type operator*() const EA_NOEXCEPT
function EA_NOEXCEPT (line 783) | const EA_NOEXCEPT
function element_type (line 813) | element_type* get() const EA_NOEXCEPT
function EA_NOEXCEPT (line 849) | const EA_NOEXCEPT
type T (line 867) | typedef T* (this_type::*bool_)() const;
type ref_count_sp_t (line 912) | typedef ref_count_sp_t<U, Allocator, Deleter> ref_count_type;
type typename (line 1004) | typedef typename eastl::common_type<T*, U*>::type CPointer;
function const (line 1202) | size_t operator()(const shared_ptr<T>& x) const EA_NOEXCEPT
type ref_count_sp_t_inst (line 1218) | typedef ref_count_sp_t_inst<T, Allocator> ref_count_type;
function atomic_is_lock_free (line 1260) | bool atomic_is_lock_free(const shared_ptr<T>*)
type T (line 1390) | typedef T element_type;
function EA_NOEXCEPT (line 1524) | const EA_NOEXCEPT
function reset (line 1546) | void reset()
function swap (line 1555) | void swap(this_type& weakPtr)
function assign (line 1620) | void assign(element_type* pValue, ref_count_sp* pRefCount)
function const (line 1684) | bool operator()(shared_ptr<T> const& a, weak_ptr<T> const& b) const EA_N...
function const (line 1687) | bool operator()(weak_ptr<T> const& a, shared_ptr<T> const& b) const EA_N...
function const (line 1697) | bool operator()(weak_ptr<T> const& a, shared_ptr<T> const& b) const EA_N...
function const (line 1700) | bool operator()(shared_ptr<T> const& a, weak_ptr<T> const& b) const EA_N...
function void (line 1705) | struct owner_less<void>
FILE: include/EASTL/slist.h
function namespace (line 62) | namespace eastl
function base_type (line 715) | base_type(allocator)
function base_type (line 723) | base_type(allocator)
function base_type (line 731) | base_type(allocator)
function base_type (line 754) | base_type(allocator)
function base_type (line 762) | base_type(allocator)
function base_type (line 771) | base_type(EASTL_SLIST_DEFAULT_ALLOCATOR)
type typename (line 1871) | typedef typename Container::const_reference const_reference;
type typename (line 1872) | typedef typename Container::iterator iterator_type;
type eastl (line 1873) | typedef eastl::output_iterator_tag iterator_category;
type value_type (line 1874) | typedef void value_type;
type difference_type (line 1875) | typedef void difference_type;
type pointer (line 1876) | typedef void pointer;
type reference (line 1877) | typedef void reference;
FILE: include/EASTL/sort.h
function namespace (line 75) | namespace eastl
function OutputIterator (line 211) | OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputI...
type typename (line 236) | typedef typename eastl::iterator_traits<BidirectionalIterator>::value_ty...
type eastl (line 262) | typedef eastl::less<typename
type typename (line 282) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
function shell_sort (line 341) | void shell_sort(RandomAccessIterator first, RandomAccessIterator last)
function heap_sort (line 365) | void heap_sort(RandomAccessIterator first, RandomAccessIterator last)
function namespace (line 374) | namespace Internal
type ResultLocation (line 443) | enum ResultLocation
function ResultLocation (line 457) | static ResultLocation sort_impl(RandomAccessIterator first, RandomAccess...
function ResultLocation (line 504) | static ResultLocation merge_halves(RandomAccessIterator first, RandomAcc...
type typename (line 547) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
function merge_sort_buffer (line 552) | void merge_sort_buffer(RandomAccessIterator first, RandomAccessIterator ...
type typename (line 572) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
type typename (line 573) | typedef typename eastl::iterator_traits<RandomAccessIterator>::value_typ...
function merge_sort (line 592) | void merge_sort(RandomAccessIterator first, RandomAccessIterator last, A...
type typename (line 654) | typedef typename iterator_traits<ForwardIterator>::value_type value_type;
function namespace (line 710) | namespace Internal
function RandomAccessIterator (line 737) | RandomAccessIterator get_partition_impl(RandomAccessIterator first, Rand...
function RandomAccessIterator (line 768) | RandomAccessIterator get_partition(RandomAccessIterator first, RandomAcc...
function RandomAccessIterator (line 775) | RandomAccessIterator get_partition(RandomAccessIterator first, RandomAcc...
function RandomAccessIterator (line 782) | RandomAccessIterator get_partition_impl(RandomAccessIterator first, Rand...
function RandomAccessIterator (line 807) | RandomAccessIterator get_partition(RandomAccessIterator first, RandomAcc...
function RandomAccessIterator (line 814) | RandomAccessIterator get_partition(RandomAccessIterator first, RandomAcc...
function namespace (line 821) | namespace Internal
function partial_sort (line 875) | void partial_sort(RandomAccessIterator first, RandomAccessIterator middl...
function partial_sort (line 899) | void partial_sort(RandomAccessIterator first, RandomAccessIterator middl...
function nth_element (line 923) | void nth_element(RandomAccessIterator first, RandomAccessIterator nth, R...
function nth_element (line 943) | void nth_element(RandomAccessIterator first, RandomAccessIterator nth, R...
function namespace (line 962) | namespace Internal
type typename (line 1064) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
type typename (line 1084) | typedef typename eastl::iterator_traits<RandomAccessIterator>::differenc...
function namespace (line 1103) | namespace Internal
function timsort_compute_minrun (line 1206) | static inline intptr_t timsort_compute_minrun(intptr_t size)
type typename (line 1236) | typedef typename eastl::iterator_traits<RandomAccessIterator>::value_typ...
function timsort_check_invariant (line 1295) | static inline bool timsort_check_invariant(tim_sort_run* run_stack, cons...
function tim_sort_buffer (line 1559) | void tim_sort_buffer(RandomAccessIterator first, RandomAccessIterator la...
function namespace (line 1604) | namespace Internal
type typename (line 1746) | typedef typename eastl::iterator_traits<ForwardIterator>::difference_typ...
function comb_sort (line 1775) | void comb_sort(ForwardIterator first, ForwardIterator last)
function namespace (line 1792) | namespace Internal
function bubble_sort (line 1845) | void bubble_sort(ForwardIterator first, ForwardIterator last, StrictWeak...
function bubble_sort (line 1853) | void bubble_sort(ForwardIterator first, ForwardIterator last)
function sort (line 1879) | void sort(RandomAccessIterator first, RandomAccessIterator last)
function sort (line 1889) | void sort(RandomAccessIterator first, RandomAccessIterator last, Compare...
FILE: include/EASTL/span.h
function namespace (line 31) | namespace eastl
FILE: include/EASTL/stack.h
function namespace (line 27) | namespace eastl
FILE: include/EASTL/string.h
function namespace (line 164) | namespace EA
function namespace (line 181) | namespace eastl
function namespace (line 214) | namespace eastl
function namespace (line 240) | namespace eastl
function Layout (line 494) | inline Layout& internalLayout() EA_NOEXCEPT { ret...
function Layout (line 495) | inline const Layout& internalLayout() const EA_NOEXCEPT { ret...
function allocator_type (line 497) | inline const allocator_type& internalAllocator() const EA_NOEXCEPT { ret...
function clear (line 668) | void clear() EA_NOEXCEPT;
function mPair (line 820) | mPair(allocator)
function mPair (line 860) | mPair(allocator)
function mPair (line 883) | mPair(allocator)
function mPair (line 893) | mPair(allocator)
function mPair (line 902) | mPair(allocator)
function mPair (line 910) | mPair(allocator)
function mPair (line 918) | mPair(allocator)
function mPair (line 928) | mPair(allocator)
function else (line 1388) | else if(n < internalLayout().GetSize())
type typename (line 3418) | typedef typename basic_string<T, Allocator>::CtorDoNotInitialize CtorDoN...
type typename (line 3431) | typedef typename basic_string<T, Allocator>::CtorDoNotInitialize CtorDoN...
type typename (line 3443) | typedef typename basic_string<T, Allocator>::CtorDoNotInitialize CtorDoN...
type typename (line 3456) | typedef typename basic_string<T, Allocator>::CtorDoNotInitialize CtorDoN...
type typename (line 3547) | typedef typename basic_string<T, Allocator>::size_type string_size_type;
type typename (line 3556) | typedef typename basic_string<T, Allocator>::size_type string_size_type;
type typename (line 3571) | typedef typename basic_string<T, Allocator>::size_type string_size_type;
type typename (line 3579) | typedef typename basic_string<T, Allocator>::view_type view_type;
type typename (line 3592) | typedef typename basic_string<T, Allocator>::view_type view_type;
type typename (line 3603) | typedef typename basic_string<T, Allocator>::view_type view_type;
type typename (line 3660) | typedef typename basic_string<T, Allocator>::size_type string_size_type;
type typename (line 3669) | typedef typename basic_string<T, Allocator>::size_type string_size_type;
type typename (line 3682) | typedef typename basic_string<T, Allocator>::view_type view_type;
type typename (line 3694) | typedef typename basic_string<T, Allocator>::view_type view_type;
type basic_string (line 3836) | typedef basic_string<char> string;
type basic_string (line 3837) | typedef basic_string<wchar_t> wstring;
type basic_string (line 3840) | typedef basic_string<char> string8;
type basic_string (line 3841) | typedef basic_string<char16_t> string16;
type basic_string (line 3842) | typedef basic_string<char32_t> string32;
type basic_string (line 3845) | typedef basic_string<char8_t> u8string;
type basic_string (line 3846) | typedef basic_string<char16_t> u16string;
type basic_string (line 3847) | typedef basic_string<char32_t> u32string;
function const (line 3863) | size_t operator()(const basic_string<char, Allocator>& x) const
function const (line 3891) | size_t operator()(const basic_string<char16_t, Allocator>& x) const
function const (line 3904) | size_t operator()(const basic_string<char32_t, Allocator>& x) const
function namespace (line 3929) | namespace internal {
type transparent_string_hash (line 3945) | struct transparent_string_hash
type transparent_string16_hash (line 3958) | struct transparent_string16_hash
type transparent_string32_hash (line 3971) | struct transparent_string32_hash
type transparent_wstring_hash (line 3984) | struct transparent_wstring_hash
function string (line 4013) | inline string to_string(int value)
function string (line 4015) | inline string to_string(long value)
function string (line 4017) | inline string to_string(long long value)
function string (line 4019) | inline string to_string(unsigned value)
function string (line 4021) | inline string to_string(unsigned long value)
function string (line 4023) | inline string to_string(unsigned long long value)
function string (line 4025) | inline string to_string(float value)
function string (line 4027) | inline string to_string(double value)
function string (line 4029) | inline string to_string(long double value)
function wstring (line 4041) | inline wstring to_wstring(int value)
function wstring (line 4043) | inline wstring to_wstring(long value)
function wstring (line 4045) | inline wstring to_wstring(long long value)
function wstring (line 4047) | inline wstring to_wstring(unsigned value)
function wstring (line 4049) | inline wstring to_wstring(unsigned long value)
function wstring (line 4051) | inline wstring to_wstring(unsigned long long value)
function wstring (line 4053) | inline wstring to_wstring(float value)
function wstring (line 4055) | inline wstring to_wstring(double value)
function wstring (line 4057) | inline wstring to_wstring(long double value)
function namespace (line 4077) | inline namespace literals
FILE: include/EASTL/string_hash_map.h
function namespace (line 15) | namespace eastl
function base (line 107) | base(allocator)
FILE: include/EASTL/string_map.h
function namespace (line 15) | namespace eastl
function base (line 62) | base(allocator)
FILE: include/EASTL/string_view.h
function namespace (line 33) | namespace eastl
function EA_CONSTEXPR (line 89) | EA_CONSTEXPR const_reference operator[](size_type pos) const
function EA_CPP14_CONSTEXPR (line 95) | EA_CPP14_CONSTEXPR const_reference at(size_type pos) const
function EA_CPP14_CONSTEXPR (line 126) | EA_CPP14_CONSTEXPR void remove_prefix(size_type n)
function EA_CPP14_CONSTEXPR (line 133) | EA_CPP14_CONSTEXPR void remove_suffix(size_type n)
function EA_CPP14_CONSTEXPR (line 171) | static EA_CPP14_CONSTEXPR int compare(const T* pBegin1, const T* pEnd1, ...
function EA_CPP14_CONSTEXPR (line 181) | EA_CPP14_CONSTEXPR int compare(basic_string_view sw) const EA_NOEXCEPT
function EA_CONSTEXPR (line 186) | EA_CONSTEXPR int compare(size_type pos1, size_type count1, basic_string_...
function EA_CONSTEXPR (line 191) | EA_CONSTEXPR int compare(size_type pos1,
function EA_CONSTEXPR (line 200) | EA_CONSTEXPR int compare(const T* s) const { return compare(basic_string...
function EA_CONSTEXPR (line 202) | EA_CONSTEXPR int compare(size_type pos1, size_type count1, const T* s) c...
function EA_CONSTEXPR (line 207) | EA_CONSTEXPR int compare(size_type pos1, size_type count1, const T* s, s...
function EA_CONSTEXPR (line 230) | EA_CONSTEXPR size_type find(const T* s, size_type pos, size_type count) ...
function EA_CONSTEXPR (line 235) | EA_CONSTEXPR size_type find(const T* s, size_type pos = 0) const { retur...
function EA_CPP14_CONSTEXPR (line 242) | EA_CPP14_CONSTEXPR size_type rfind(T c, size_type pos = npos) const EA_N...
function EA_CPP14_CONSTEXPR (line 255) | EA_CPP14_CONSTEXPR size_type rfind(const T* s, size_type pos, size_type ...
function EA_CONSTEXPR (line 286) | EA_CONSTEXPR size_type rfind(const T* s, size_type pos = npos) const
function EA_CPP14_CONSTEXPR (line 298) | EA_CPP14_CONSTEXPR size_type find_first_of(const T* s, size_type pos, si...
function EA_CONSTEXPR (line 313) | EA_CONSTEXPR size_type find_first_of(const T* s, size_type pos = 0) const
function EA_CONSTEXPR (line 323) | EA_CONSTEXPR size_type find_last_of(T c, size_type pos = npos) const EA_...
function EA_CPP14_CONSTEXPR (line 325) | EA_CPP14_CONSTEXPR size_type find_last_of(const T* s, size_type pos, siz...
function EA_CONSTEXPR (line 339) | EA_CONSTEXPR size_type find_last_of(const T* s, size_type pos = npos) const
function EA_CPP14_CONSTEXPR (line 363) | EA_CPP14_CONSTEXPR size_type find_first_not_of(const T* s, size_type pos...
function EA_CONSTEXPR (line 376) | EA_CONSTEXPR size_type find_first_not_of(const T* s, size_type pos = 0) ...
function EA_CPP14_CONSTEXPR (line 386) | EA_CPP14_CONSTEXPR size_type find_last_not_of(T c, size_type pos = npos)...
function EA_CPP14_CONSTEXPR (line 400) | EA_CPP14_CONSTEXPR size_type find_last_not_of(const T* s, size_type pos,...
function EA_CONSTEXPR (line 413) | EA_CONSTEXPR size_type find_last_not_of(const T* s, size_type pos = npos...
function EA_CONSTEXPR (line 419) | EA_CONSTEXPR bool starts_with(basic_string_view x) const EA_NOEXCEPT
function EA_CONSTEXPR (line 424) | EA_CONSTEXPR bool starts_with(T x) const EA_NOEXCEPT
function EA_CONSTEXPR (line 429) | EA_CONSTEXPR bool starts_with(const T* s) const
function EA_CONSTEXPR (line 435) | EA_CONSTEXPR bool ends_with(basic_string_view x) const EA_NOEXCEPT
function EA_CONSTEXPR (line 440) | EA_CONSTEXPR bool ends_with(T x) const EA_NOEXCEPT
function EA_CONSTEXPR (line 445) | EA_CONSTEXPR bool ends_with(const T* s) const
type basic_string_view (line 485) | typedef basic_string_view<CharT> view_type;
type basic_string_view (line 586) | typedef basic_string_view<char> string_view;
type basic_string_view (line 587) | typedef basic_string_view<wchar_t> wstring_view;
type basic_string_view (line 590) | typedef basic_string_view<char8_t> u8string_view;
type basic_string_view (line 591) | typedef basic_string_view<char16_t> u16string_view;
type basic_string_view (line 592) | typedef basic_string_view<char32_t> u32string_view;
function string_view (line 605) | struct hash<string_view>
type hash (line 619) | struct hash
function const (line 621) | size_t operator()(const u8string_view& x) const
function u16string_view (line 633) | struct hash<u16string_view>
function u32string_view (line 646) | struct hash<u32string_view>
type hash (line 660) | struct hash
function const (line 662) | size_t operator()(const wstring_view& x) const
function namespace (line 683) | inline namespace literals
FILE: include/EASTL/tuple.h
function namespace (line 21) | namespace eastl
type typename (line 95) | typedef typename add_volatile<tuple_element_t<I, TupleTypes<Ts...>>>::ty...
type typename (line 102) | typedef typename add_cv<tuple_element_t<I, TupleTypes<Ts...>>>::type type;
function namespace (line 166) | namespace Internal
function swap (line 351) | void swap(TupleImpl& t) { swallow(TupleLeaf<Indices, Ts>::swap(static_ca...
type tuple_element_t (line 364) | typedef tuple_element_t<I, TupleImpl<Indices, Ts...>> Type;
type tuple_index (line 378) | typedef tuple_index<T, TupleImpl<Indices, Ts...>> Index;
type tuple_index (line 385) | typedef tuple_index<T, TupleImpl<Indices, Ts...>> Index;
type tuple_index (line 392) | typedef tuple_index<T, TupleImpl<Indices, Ts...>> Index;
type TupleEqual (line 546) | struct TupleEqual
type T (line 585) | typedef T type;
type T (line 586) | typedef T& type;
function EA_CONSTEXPR (line 629) | EA_CONSTEXPR tuple(const T& t, const Ts&... ts)
function swap (line 665) | void swap(tuple& t) { mImpl.swap(t.mImpl); }
function namespace (line 769) | namespace Internal
function ResultType (line 805) | inline ResultType DoCat2(Tuple1&& t1, Tuple2&& t2)
function ResultType (line 823) | inline ResultType DoCat(TupleArg1&& t1, TupleArg2&& t2, TupleArgsRest&&....
function ResultType (line 838) | inline ResultType DoCat(TupleArg1&& t1, TupleArg2&& t2)
type TupleCat (line 857) | struct TupleCat<>
function typename (line 872) | typename Internal::TupleCat<eastl::remove_cvref_t<Tuples>...>::ResultTyp...
function namespace (line 904) | namespace Internal
function namespace (line 940) | namespace detail
function apply (line 950) | decltype(auto) apply(F&& f, Tuple&& t)
function namespace (line 988) | namespace std
FILE: include/EASTL/type_traits.h
function namespace (line 226) | namespace eastl
type T (line 584) | typedef T type;
type T (line 585) | typedef T type;
type T (line 586) | typedef T type[];
type T (line 587) | typedef T type[N];
type T (line 611) | typedef T type;
type T (line 612) | typedef T type;
type T (line 613) | typedef T type[];
type T (line 614) | typedef T type[N];
type typename (line 639) | typedef typename eastl::remove_volatile<typename
type T (line 661) | typedef T type;
type T (line 662) | typedef T type;
type T (line 663) | typedef T type;
type typename (line 686) | typedef typename eastl::remove_volatile<typename
function namespace (line 711) | namespace internal
function namespace (line 750) | namespace internal
function endian (line 839) | enum class endian
function namespace (line 865) | namespace eastl
FILE: include/EASTL/unique_ptr.h
function namespace (line 25) | namespace eastl
function reset (line 211) | void reset(pointer pValue = pointer()) EA_NOEXCEPT
function pointer (line 227) | pointer release() EA_NOEXCEPT
function pointer (line 236) | pointer detach() EA_NOEXCEPT { return release(); }
function swap (line 240) | void swap(this_type& x) EA_NOEXCEPT
function typename (line 250) | typename add_lvalue_reference<T>::type operator*() const // Not noexcept...
function pointer (line 261) | pointer operator->() const EA_NOEXCEPT
type T (line 301) | typedef T* (this_type::*bool_)() const;
type Deleter (line 358) | typedef Deleter ...
type T (line 359) | typedef T ...
type unique_ptr (line 360) | typedef unique_ptr<element_type[], deleter_type> ...
type typename (line 361) | typedef typename Internal::unique_pointer_type<element_type, deleter_typ...
function EA_CPP14_CONSTEXPR (line 370) | EA_CPP14_CONSTEXPR unique_ptr(std::nullptr_t) EA_NOEXCEPT
function reset (line 435) | void reset(pointer pArray = pointer()) EA_NOEXCEPT
function pointer (line 444) | pointer release() EA_NOEXCEPT
function pointer (line 453) | pointer detach() EA_NOEXCEPT { return release(); }
function swap (line 455) | void swap(this_type& x) EA_NOEXCEPT
function typename (line 466) | typename add_lvalue_reference<T>::type operator[](ptrdiff_t i) const
type T (line 488) | typedef T* (this_type::*bool_)() const;
type typename (line 609) | typedef typename eastl::unique_ptr<T1, D1>::pointer P1;
type typename (line 610) | typedef typename eastl::unique_ptr<T2, D2>::pointer P2;
type typename (line 611) | typedef typename eastl::common_type<P1, P2>::type PCommon;
type typename (line 672) | typedef typename unique_ptr<T, D>::pointer pointer;
type typename (line 679) | typedef typename unique_ptr<T, D>::pointer pointer;
FILE: include/EASTL/unordered_map.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/unordered_set.h
function namespace (line 15) | namespace eastl
FILE: include/EASTL/utility.h
function namespace (line 38) | namespace eastl
function iter_swap (line 206) | void iter_swap(ForwardIterator1 a, ForwardIterator2 b)
type iter_swap_impl (line 217) | struct iter_swap_impl
function iter_swap (line 220) | void iter_swap(ForwardIterator1 a, ForwardIterator2 b)
function iter_swap (line 240) | void iter_swap(ForwardIterator1 a, ForwardIterator2 b)
function ForwardIterator2 (line 268) | ForwardIterator2
function typename (line 316) | typename eastl::add_const<T>::type& as_const(T& t) EA_NOEXCEPT
function namespace (line 338) | namespace rel_ops
function cmp_equal (line 363) | bool cmp_equal(const T x, const U y) EA_NOEXCEPT
type Pair (line 685) | typedef Pair argument_type;
type typename (line 686) | typedef typename Pair::second_type result_type;
function result_type (line 688) | const result_type& operator()(const Pair& x) const
type typename (line 777) | typedef typename eastl::remove_reference_wrapper<typename
type typename (line 778) | typedef typename eastl::remove_reference_wrapper<typename
type typename (line 813) | typedef typename eastl::remove_reference_wrapper<typename
type typename (line 814) | typedef typename eastl::remove_reference_wrapper<typename
type T2 (line 842) | typedef T2 type;
type T1 (line 849) | typedef const T1 type;
type T2 (line 856) | typedef const T2 type;
function namespace (line 859) | namespace internal
function namespace (line 1006) | namespace std
FILE: include/EASTL/variant.h
function namespace (line 87) | namespace eastl
function namespace (line 191) | namespace internal {
function holds_alternative (line 344) | bool holds_alternative(const variant<Types...>& v) EA_NOEXCEPT
function namespace (line 350) | namespace internal {
function destroy (line 429) | void destroy()
function destroy (line 468) | void destroy()
function genericVisitor (line 552) | auto genericVisitor = [&rhs](auto& thisAlternative)
function genericVisitor (line 571) | auto genericVisitor = [&rhs](auto& thisAlternative)
function genericVisitor (line 602) | auto genericVisitor = [&rhs](auto& thisAlternative)
function else (line 611) | else
function genericVisitor (line 649) | auto genericVisitor = [&rhs](auto& thisAlternative)
function else (line 658) | else
function private (line 721) | private internal::variant_base<Types...>
function emplace (line 825) | decltype(auto) emplace(Args&&... args)
function emplace (line 839) | decltype(auto) emplace(std::initializer_list<U> il, Args&&... args)
function else (line 953) | else if (this->mIndex == other.mIndex)
function EA_CONSTEXPR (line 1184) | EA_CONSTEXPR auto make_invoke_visitor_leaf(index_sequence<VariantArgIndi...
function EA_CONSTEXPR (line 1199) | EA_CONSTEXPR auto make_invoke_visitor_recurse(index_sequence<VariantArgI...
function EA_CONSTEXPR (line 1266) | EA_CONSTEXPR auto make_invoke_visitor_leaf_r(index_sequence<VariantArgIn...
function EA_CONSTEXPR (line 1284) | EA_CONSTEXPR auto make_invoke_visitor_recurse_r(index_sequence<VariantAr...
type visitor_caller_one (line 1320) | struct visitor_caller_one
type visitor_r (line 1363) | struct visitor_r<void>
type visitor_r (line 1372) | struct visitor_r
type visitor_r (line 1373) | struct visitor_r
type visitor_r (line 1374) | struct visitor_r
type visitor_caller_one_r (line 1377) | struct visitor_caller_one_r
function namespace (line 1439) | namespace internal
function visit (line 1502) | decltype(auto) visit(Visitor&& visitor, Variants&&... variants)
function namespace (line 1543) | namespace internal
function EA_CONSTEXPR (line 1576) | EA_CONSTEXPR std::compare_three_way_result_t<Variant> invoke_relational_...
function EA_CONSTEXPR (line 1582) | EA_CONSTEXPR std::compare_three_way_result_t<Variant> call_index_three_w...
function EA_CONSTEXPR (line 1607) | EA_CONSTEXPR std::compare_three_way_result_t<Variant> CompareVariantRela...
FILE: include/EASTL/vector.h
function namespace (line 78) | namespace eastl
function base_type (line 611) | base_type(allocator)
function base_type (line 625) | base_type(allocator)
function base_type (line 634) | base_type(allocator)
type typename (line 687) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type typename (line 727) | typedef typename std::initializer_list<value_type>::iterator InputIterator;
type typename (line 728) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type typename (line 1480) | typedef typename eastl::iterator_traits<InputIterator>:: iterator_catego...
type typename (line 1526) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
type typename (line 1621) | typedef typename eastl::iterator_traits<InputIterator>::iterator_categor...
FILE: include/EASTL/vector_map.h
function namespace (line 53) | namespace eastl
function mapped_type (line 321) | const mapped_type& at_key(const key_type& k) const { return DoAtKey(k); }
FILE: include/EASTL/vector_multimap.h
function namespace (line 50) | namespace eastl
FILE: include/EASTL/vector_multiset.h
function namespace (line 48) | namespace eastl
FILE: include/EASTL/vector_set.h
function namespace (line 49) | namespace eastl
FILE: source/allocator_eastl.cpp
type eastl (line 22) | namespace eastl
function EASTL_API (line 30) | EASTL_API allocator* GetDefaultAllocator()
function EASTL_API (line 35) | EASTL_API allocator* SetDefaultAllocator(allocator* pAllocator)
FILE: source/assert.cpp
type eastl (line 31) | namespace eastl
function EASTL_API (line 55) | EASTL_API void SetAssertionFailureFunction(EASTL_AssertionFailureFunct...
function EASTL_API (line 68) | EASTL_API void SetAssertionFailureFunction(EASTL_AssertionFailureFunct...
function AssertionFailureFunctionDefault (line 77) | void AssertionFailureFunctionDefault(void* instructionPointer, const c...
function EASTL_API (line 83) | EASTL_API void AssertionFailureFunctionDefault(const char* pExpression...
function EASTL_API (line 108) | EASTL_API void AssertionFailure(const char* pExpression)
function EASTL_API (line 113) | EASTL_API void AssertionFailure(void* instructionPointer, const char* ...
FILE: source/atomic.cpp
type eastl (line 9) | namespace eastl
type internal (line 12) | namespace internal
function EastlCompilerBarrierDataDependencyFunc (line 16) | static void EastlCompilerBarrierDataDependencyFunc(void*)
FILE: source/fixed_pool.cpp
type eastl (line 11) | namespace eastl
function EASTL_API (line 15) | EASTL_API void fixed_pool_base::init(void* pMemory, size_t memorySize,...
FILE: source/hashtable.cpp
type eastl (line 15) | namespace eastl
FILE: source/intrusive_list.cpp
type eastl (line 8) | namespace eastl
function EASTL_API (line 12) | EASTL_API void intrusive_list_base::reverse() EA_NOEXCEPT
function EASTL_API (line 26) | EASTL_API bool intrusive_list_base::validate() const
FILE: source/numeric_limits.cpp
type eastl (line 9) | namespace eastl
FILE: source/red_black_tree.cpp
type eastl (line 33) | namespace eastl
function EASTL_API (line 44) | EASTL_API rbtree_node_base* RBTreeIncrement(const rbtree_node_base* pN...
function EASTL_API (line 75) | EASTL_API rbtree_node_base* RBTreeDecrement(const rbtree_node_base* pN...
function EASTL_API (line 108) | EASTL_API size_t RBTreeGetBlackCount(const rbtree_node_base* pNodeTop,...
function rbtree_node_base (line 130) | rbtree_node_base* RBTreeRotateLeft(rbtree_node_base* pNode, rbtree_nod...
function rbtree_node_base (line 160) | rbtree_node_base* RBTreeRotateRight(rbtree_node_base* pNode, rbtree_no...
function EASTL_API (line 190) | EASTL_API void RBTreeInsert(rbtree_node_base* pNode,
function EASTL_API (line 294) | EASTL_API void RBTreeErase(rbtree_node_base* pNode, rbtree_node_base* ...
FILE: source/string.cpp
type eastl (line 12) | namespace eastl
function UCS4ToUTF8 (line 24) | inline bool UCS4ToUTF8(uint32_t c, char*& pResult)
function UCS2ToUTF8 (line 76) | inline bool UCS2ToUTF8(uint16_t c, char*& pResult)
function UTF8ToUCS4 (line 84) | inline bool UTF8ToUCS4(const char*& p, const char* pEnd, uint32_t& res...
function UTF8ToUCS2 (line 260) | inline bool UTF8ToUCS2(const char*& p, const char* pEnd, uint16_t& res...
function EASTL_API (line 283) | EASTL_API bool DecodePart(const char*& pSrc, const char* pSrcEnd, char...
function EASTL_API (line 299) | EASTL_API bool DecodePart(const char*& pSrc, const char* pSrcEnd, char...
function EASTL_API (line 309) | EASTL_API bool DecodePart(const char*& pSrc, const char* pSrcEnd, char...
function EASTL_API (line 320) | EASTL_API bool DecodePart(const char16_t*& pSrc, const char16_t* pSrcE...
function EASTL_API (line 333) | EASTL_API bool DecodePart(const char16_t*& pSrc, const char16_t* pSrcE...
function EASTL_API (line 349) | EASTL_API bool DecodePart(const char16_t*& pSrc, const char16_t* pSrcE...
function EASTL_API (line 364) | EASTL_API bool DecodePart(const char32_t*& pSrc, const char32_t* pSrcE...
function EASTL_API (line 377) | EASTL_API bool DecodePart(const char32_t*& pSrc, const char32_t* pSrcE...
function EASTL_API (line 391) | EASTL_API bool DecodePart(const char32_t*& pSrc, const char32_t* pSrcE...
function EASTL_API (line 407) | EASTL_API bool DecodePart(const int*& pSrc, const int* pSrcEnd, char*&...
function EASTL_API (line 420) | EASTL_API bool DecodePart(const int*& pSrc, const int* pSrcEnd, char16...
function EASTL_API (line 434) | EASTL_API bool DecodePart(const int*& pSrc, const int* pSrcEnd, char32...
FILE: source/thread_support.cpp
type eastl (line 21) | namespace eastl
type Internal (line 23) | namespace Internal
FILE: test/source/ConceptImpls.h
function class (line 20) | class Destructible
function class (line 43) | class DefaultConstructible
type NotDefaultConstructible (line 60) | struct NotDefaultConstructible
function class (line 67) | class CopyConstructible
function class (line 104) | class MoveConstructible
function class (line 126) | class MoveAssignable
type MoveAndDefaultConstructible (line 152) | struct MoveAndDefaultConstructible
type MissingMoveConstructor (line 167) | struct MissingMoveConstructor
type MissingMoveAssignable (line 176) | struct MissingMoveAssignable
FILE: test/source/EASTLTest.cpp
function EASTLTest_CheckMemory_Imp (line 140) | int EASTLTest_CheckMemory_Imp(const char* pFile, int nLine)
function StdSTLType (line 169) | StdSTLType GetStdSTLType()
FILE: test/source/EASTLTest.h
type EASTL_TestLevel (line 184) | enum EASTL_TestLevel
type StdSTLType (line 225) | enum StdSTLType
function class (line 283) | class EASTLTest_Rand
function mRand (line 336) | RandGenT(eastl_size_t nSeed)
function Integer (line 339) | Integer operator()()
function Integer (line 342) | Integer operator()(eastl_size_t n)
type TestObject (line 369) | struct TestObject
type ThrowOnConstruct (line 408) | struct ThrowOnConstruct {}
function ThrowOnConstruct (line 409) | static inline constexpr ThrowOnConstruct throw_on_construct{}
function explicit (line 411) | explicit TestObject(ThrowOnConstruct)
function Reset (line 508) | static bool Reset()
function EA_NODISCARD (line 526) | EA_NODISCARD static bool IsClear() // Returns true if there are no exist...
function swap (line 555) | inline void swap(TestObject& t1, TestObject& t2)
function namespace (line 563) | namespace eastl
function const (line 580) | int operator()(const T& t) const { return t.mX; }
type TestObjectHash (line 590) | struct TestObjectHash
function ImplicitlyConvertible (line 600) | struct ImplicitlyConvertible
type alignas (line 636) | struct alignas
type alignas (line 653) | struct alignas
type alignas (line 669) | struct alignas
function Align64 (line 684) | struct hash < Align64 >
function T (line 704) | const T& operator()(const T& x) const
function T (line 737) | T operator()()
type typename (line 899) | typedef typename eastl::iterator_traits<InputIterator>::value_type value...
type Iterator (line 1020) | typedef Iterator ite...
type IteratorCategory (line 1021) | typedef IteratorCategory ite...
type typename (line 1022) | typedef typename eastl::iterator_traits<Iterator>::value_type val...
type typename (line 1023) | typedef typename eastl::iterator_traits<Iterator>::difference_type dif...
type typename (line 1024) | typedef typename eastl::iterator_traits<Iterator>::reference ref...
type typename (line 1025) | typedef typename eastl::iterator_traits<Iterator>::pointer poi...
function explicit (line 1030) | explicit demoted_iterator(const Iterator& i)
function mIterator (line 1033) | demoted_iterator(const this_type& x)
function reference (line 1042) | reference operator*() const
function pointer (line 1045) | pointer operator->() const
function reference (line 1060) | reference operator[](const difference_type& n) const
function class (line 1160) | class MallocAllocator
function MallocAllocator (line 1206) | const MallocAllocator&, const MallocAllocator&) { return false; }
function class (line 1218) | class CustomAllocator
function set_name (line 1231) | void set_name(const char*) {}
function CustomAllocator (line 1235) | const CustomAllocator&, const CustomAllocator&) { return false; }
function class (line 1244) | class UnequalAllocator
function deallocate (line 1260) | void deallocate(void* p, size_t n) { return mAllocator.deallocate(p, n); }
function set_name (line 1263) | void set_name(const char* pName) { mAllocator.set_name(pName); }
function UnequalAllocator (line 1270) | const UnequalAllocator&, const UnequalAllocator&) { return true; }
function class (line 1278) | class CountingAllocator : public eastl::allocator
function deallocate (line 1328) | void deallocate(void* p, size_t n)
function set_name (line 1337) | void set_name(const char* pName) { base_type::set_name(pName); }
function resetCount (line 1345) | static void resetCount()
function class (line 1395) | class InstanceAllocator
function deallocate (line 1439) | void deallocate(void* p, size_t /*n*/)
function set_name (line 1457) | void set_name(const char*) {}
function EA_NODISCARD (line 1459) | EA_NODISCARD static bool reset_all()
function mbShouldThrow (line 1493) | ThrowingAllocator(const ThrowingAllocator& x) : mbShouldThrow(x.mbShould...
function deallocate (line 1520) | void deallocate(void* p, size_t) { free(p); }
function set_name (line 1523) | void set_name(const char*) {}
function set_should_throw (line 1525) | void set_should_throw(bool shouldThrow) { mbShouldThrow = shouldThrow; }
function const (line 1548) | struct TestStrCmpI_2
function StompDetectAllocator (line 1564) | struct StompDetectAllocator
function deallocate (line 1573) | void deallocate(void* p, size_t n) { mMallocAllocator.deallocate(p, n); }
function set_name (line 1576) | void set_name(const char*) {}
function ReturnVal (line 1607) | inline int ReturnVal(int param) { return param; }
function ReturnZero (line 1608) | inline int ReturnZero() { return 0; }
function ReturnOne (line 1609) | inline int ReturnOne() { return 1; }
function T (line 1625) | T get() { return mV; }
type NoCopyMove (line 1630) | struct NoCopyMove
type NoCopyMoveNonEmpty (line 1643) | struct NoCopyMoveNonEmpty
type MoveOnlyType (line 1660) | struct MoveOnlyType
type MoveOnlyTypeDefaultCtor (line 1679) | struct MoveOnlyTypeDefaultCtor
function NonTriviallyCopyable (line 1699) | struct NonTriviallyCopyable {
type TriviallyCopyableWithCopy (line 1716) | struct TriviallyCopyableWithCopy {
type TriviallyCopyableWithMove (line 1743) | struct TriviallyCopyableWithMove {
type TriviallyCopyableWithCopyCtor (line 1769) | struct TriviallyCopyableWithCopyCtor {
type TriviallyCopyableWithCopyAssign (line 1787) | struct TriviallyCopyableWithCopyAssign {
type TriviallyCopyableWithMoveCtor (line 1805) | struct TriviallyCopyableWithMoveCtor {
type TriviallyCopyableWithMoveAssign (line 1824) | struct TriviallyCopyableWithMoveAssign {
type NoDataMembers (line 1843) | struct NoDataMembers {}
function AutoDefaultAllocator (line 1850) | struct AutoDefaultAllocator
function Additional (line 1866) | struct ExplicitString {
function mString (line 1882) | mString(str) {}
function ExplicitString (line 1885) | static ExplicitString Create(const char* str)
function const (line 1904) | struct ExplicitStringHash {
function namespace (line 1918) | namespace detail
FILE: test/source/EASTLTestAllocator.cpp
type EA (line 31) | namespace EA
type Allocator (line 33) | namespace Allocator
function EASTLTest_ValidateHeap (line 66) | bool EASTLTest_ValidateHeap()
function PlatformFree (line 128) | void PlatformFree(void* p)
function InternalFree (line 213) | void InternalFree(void* p)
class EASTLTestICA (line 228) | class EASTLTestICA : public EA::Allocator::ICoreAllocator
method EASTLTestICA (line 231) | EASTLTestICA()
method Free (line 250) | virtual void Free(void* pData, size_t /*size*/)
function EA_THROW_SPEC_NEW_NONE (line 266) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 272) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_NEW_NONE (line 282) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 292) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_NEW_NONE (line 365) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_NEW_NONE (line 383) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 391) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 401) | EA_THROW_SPEC_DELETE_NONE()
function EASTLTest_SetGeneralAllocator (line 410) | void EASTLTest_SetGeneralAllocator()
type Internal (line 423) | namespace Internal
function EASTLAlignedFree (line 437) | void EASTLAlignedFree(void* p)
function EA_THROW_SPEC_NEW_NONE (line 462) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_NEW_NONE (line 468) | EA_THROW_SPEC_NEW_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 472) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 475) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 478) | EA_THROW_SPEC_DELETE_NONE()
function EA_THROW_SPEC_DELETE_NONE (line 481) | EA_THROW_SPEC_DELETE_NONE()
function EASTLTest_SetGeneralAllocator (line 484) | void EASTLTest_SetGeneralAllocator() { /* intentionally blank */ }
function EASTLTest_ValidateHeap (line 485) | bool EASTLTest_ValidateHeap() { return true; }
FILE: test/source/EASTLTestIterators.h
type EndSentinel (line 25) | struct EndSentinel {}
function Integer (line 34) | Integer mEnd{0}
type Integer (line 38) | typedef Integer value_type;
type Integer (line 39) | typedef Integer* pointer;
type Integer (line 40) | typedef Integer& reference;
type eastl (line 41) | typedef eastl::input_iterator_tag iterator_category;
function explicit (line 43) | explicit InputIterator(Integer* i) noexcept
function explicit (line 46) | explicit InputIterator(EndSentinel, Integer end) noexcept
function reference (line 55) | reference operator*() const
function pointer (line 60) | pointer operator->() const
FILE: test/source/GetTypeName.h
function string (line 63) | string GetTypeName()
FILE: test/source/TestAlgorithm.cpp
type eastl (line 27) | namespace eastl
type A (line 66) | struct A{
method A (line 67) | A(int n) : a(n){}
type LessStruct (line 70) | struct LessStruct{ bool operator()(const A& a1, const A& a2){ return a1....
type B (line 73) | struct B{
method B (line 74) | B(int n) : b(n){}
function LessFunction (line 77) | inline bool LessFunction(const B& b1, const B& b2){ return b1.b < b2.b; }
type TestMinMaxEnum (line 80) | enum TestMinMaxEnum
type Greater (line 93) | struct Greater
type DivisibleBy (line 103) | struct DivisibleBy
method DivisibleBy (line 106) | DivisibleBy(int n = 1) : d(n) {}
type TestObjectNegate (line 114) | struct TestObjectNegate
method TestObject (line 116) | TestObject operator()(const TestObject& a) const
function TestMinMax (line 120) | static int TestMinMax()
function TestClamp (line 657) | static int TestClamp()
function TestAlgorithm (line 694) | int TestAlgorithm()
FILE: test/source/TestAllocator.cpp
type fixed_pool_reference (line 20) | struct fixed_pool_reference
method fixed_pool_reference (line 23) | fixed_pool_reference(const char* = NULL)
method fixed_pool_reference (line 28) | fixed_pool_reference(eastl::fixed_pool& fixedPool)
method fixed_pool_reference (line 33) | fixed_pool_reference(const fixed_pool_reference& x)
method fixed_pool_reference (line 38) | fixed_pool_reference& operator=(const fixed_pool_reference& x)
method deallocate (line 54) | void deallocate(void* p, size_t /*n*/)
method set_name (line 64) | void set_name(const char* /*pName*/)
function TestFixedAllocator (line 91) | static int TestFixedAllocator()
function TestAllocatorMalloc (line 211) | static int TestAllocatorMalloc()
type EASTLTestCoreAllocator (line 247) | struct EASTLTestCoreAllocator
method Free (line 261) | void Free(void* p, size_t /*size*/ = 0)
function EASTLTestCoreAllocator (line 271) | EASTLTestCoreAllocator* EASTLTestCoreAllocator::GetDefaultAllocator()
method Free (line 261) | void Free(void* p, size_t /*size*/ = 0)
type TestClass (line 278) | struct TestClass
method TestClass (line 282) | TestClass() : mX(37) { }
method Increment (line 284) | void Increment()
method IncrementConst (line 287) | void IncrementConst() const
method MultiplyBy (line 290) | int MultiplyBy(int x)
method MultiplyByConst (line 293) | int MultiplyByConst(int x) const
function TestCoreAllocatorAdapter (line 300) | static int TestCoreAllocatorAdapter()
function TestSwapAllocator (line 327) | static int TestSwapAllocator()
function TestAllocationOffsetAndAlignment (line 345) | static int TestAllocationOffsetAndAlignment()
function TestAllocator (line 382) | int TestAllocator()
FILE: test/source/TestAllocatorPropagate.cpp
function TestPropagateOnContainerCopyAssignment (line 24) | int TestPropagateOnContainerCopyAssignment(std::initializer_list<Elem> i...
function TestPropagateOnContainerMoveAssignment (line 56) | int TestPropagateOnContainerMoveAssignment(std::initializer_list<Elem> i...
function TestPropagateOnContainerSwap (line 86) | int TestPropagateOnContainerSwap(std::initializer_list<Elem> ilist1, std...
function TestAllocatorPropagate (line 117) | int TestAllocatorPropagate()
FILE: test/source/TestAny.cpp
type SmallTestObject (line 16) | struct SmallTestObject
method SmallTestObject (line 20) | SmallTestObject() EA_NOEXCEPT { mCtorCount++; }
method SmallTestObject (line 21) | SmallTestObject(const SmallTestObject&) EA_NOEXCEPT { mCtorCount++; }
method SmallTestObject (line 22) | SmallTestObject(SmallTestObject&&) EA_NOEXCEPT { mCtorCount++; }
method SmallTestObject (line 23) | SmallTestObject& operator=(const SmallTestObject&) EA_NOEXCEPT { mCtor...
method Reset (line 26) | static void Reset() { mCtorCount = 0; }
method IsClear (line 27) | static bool IsClear() { return mCtorCount == 0; }
type RequiresInitList (line 35) | struct RequiresInitList
method RequiresInitList (line 37) | RequiresInitList(std::initializer_list<int> ilist)
function TestAny (line 44) | int TestAny()
FILE: test/source/TestArray.cpp
type eastl::array<int, 0> (line 18) | struct eastl::array<int, 0>
type eastl::array<int, 5> (line 19) | struct eastl::array<int, 5>
type eastl::array<Align32, 5> (line 20) | struct eastl::array<Align32, 5>
class TP (line 22) | class TP
type has_tuple_element_type (line 26) | struct has_tuple_element_type : false_type {}
type has_tuple_element_type<I, T, void_t<typename tuple_element<I, T>::type>> (line 29) | struct has_tuple_element_type<I, T, void_t<typename tuple_element<I, T>:...
function TestArray (line 34) | int TestArray()
FILE: test/source/TestAtomicAsm.cpp
type UserType128 (line 13) | struct UserType128
function EA_NO_INLINE (line 32) | EA_NO_INLINE static void TestAtomicU32StoreRelaxed()
function EA_NO_INLINE (line 41) | EA_NO_INLINE static void TestAtomicU32StoreRelease()
function EA_NO_INLINE (line 50) | EA_NO_INLINE static void TestAtomicU32StoreSeqCst()
function EA_NO_INLINE (line 59) | EA_NO_INLINE static void TestAtomicU32Store()
function EA_NO_INLINE (line 68) | EA_NO_INLINE static void TestAtomicU32StoreOrders()
function EA_NO_INLINE (line 83) | EA_NO_INLINE static void TestAtomicU64StoreRelaxed()
function EA_NO_INLINE (line 92) | EA_NO_INLINE static void TestAtomicU64StoreRelease()
function EA_NO_INLINE (line 101) | EA_NO_INLINE static void TestAtomicU64StoreSeqCst()
function EA_NO_INLINE (line 110) | EA_NO_INLINE static void TestAtomicU64Store()
function EA_NO_INLINE (line 119) | EA_NO_INLINE static void TestAtomicU64StoreOrders()
function EA_NO_INLINE (line 134) | EA_NO_INLINE static void TestAtomic128StoreRelaxed()
function EA_NO_INLINE (line 143) | EA_NO_INLINE static void TestAtomic128StoreRelease()
function EA_NO_INLINE (line 152) | EA_NO_INLINE static void TestAtomic128StoreSeqCst()
function EA_NO_INLINE (line 161) | EA_NO_INLINE static void TestAtomic128Store()
function EA_NO_INLINE (line 170) | EA_NO_INLINE static void TestAtomic128StoreOrders()
function EA_NO_INLINE (line 185) | EA_NO_INLINE static void TestAtomicU32LoadRelaxed()
function EA_NO_INLINE (line 194) | EA_NO_INLINE static void TestAtomicU32LoadAcquire()
function EA_NO_INLINE (line 203) | EA_NO_INLINE static void TestAtomicU32LoadSeqCst()
function EA_NO_INLINE (line 212) | EA_NO_INLINE static void TestAtomicU32Load()
function EA_NO_INLINE (line 221) | EA_NO_INLINE static void TestAtomicU32LoadOrders()
function EA_NO_INLINE (line 236) | EA_NO_INLINE static void TestAtomicU64LoadRelaxed()
function EA_NO_INLINE (line 245) | EA_NO_INLINE static void TestAtomicU64LoadAcquire()
function EA_NO_INLINE (line 254) | EA_NO_INLINE static void TestAtomicU64LoadSeqCst()
function EA_NO_INLINE (line 263) | EA_NO_INLINE static void TestAtomicU64Load()
function EA_NO_INLINE (line 272) | EA_NO_INLINE static void TestAtomicU64LoadOrders()
function EA_NO_INLINE (line 287) | EA_NO_INLINE static void TestAtomic128LoadRelaxed()
function EA_NO_INLINE (line 296) | EA_NO_INLINE static void TestAtomic128LoadAcquire()
function EA_NO_INLINE (line 305) | EA_NO_INLINE static void TestAtomic128LoadSeqCst()
function EA_NO_INLINE (line 314) | EA_NO_INLINE static void TestAtomic128Load()
function EA_NO_INLINE (line 323) | EA_NO_INLINE static void TestAtomic128LoadOrders()
function EA_NO_INLINE (line 338) | EA_NO_INLINE static void TestAtomicU32ExchangeRelaxed()
function EA_NO_INLINE (line 347) | EA_NO_INLINE static void TestAtomicU32ExchangeAcquire()
function EA_NO_INLINE (line 356) | EA_NO_INLINE static void TestAtomicU32ExchangeRelease()
function EA_NO_INLINE (line 365) | EA_NO_INLINE static void TestAtomicU32ExchangeAcqRel()
function EA_NO_INLINE (line 374) | EA_NO_INLINE static void TestAtomicU32ExchangeSeqCst()
function EA_NO_INLINE (line 383) | EA_NO_INLINE static void TestAtomicU32Exchange()
function EA_NO_INLINE (line 392) | EA_NO_INLINE static void TestAtomicU32ExchangeOrders()
function EA_NO_INLINE (line 411) | EA_NO_INLINE static void TestAtomicU64ExchangeRelaxed()
function EA_NO_INLINE (line 420) | EA_NO_INLINE static void TestAtomicU64ExchangeAcquire()
function EA_NO_INLINE (line 429) | EA_NO_INLINE static void TestAtomicU64ExchangeRelease()
function EA_NO_INLINE (line 438) | EA_NO_INLINE static void TestAtomicU64ExchangeAcqRel()
function EA_NO_INLINE (line 447) | EA_NO_INLINE static void TestAtomicU64ExchangeSeqCst()
function EA_NO_INLINE (line 456) | EA_NO_INLINE static void TestAtomicU64Exchange()
function EA_NO_INLINE (line 465) | EA_NO_INLINE static void TestAtomicU64ExchangeOrders()
function EA_NO_INLINE (line 484) | EA_NO_INLINE static void TestAtomic128ExchangeRelaxed()
function EA_NO_INLINE (line 493) | EA_NO_INLINE static void TestAtomic128ExchangeAcquire()
function EA_NO_INLINE (line 502) | EA_NO_INLINE static void TestAtomic128ExchangeRelease()
function EA_NO_INLINE (line 511) | EA_NO_INLINE static void TestAtomic128ExchangeAcqRel()
function EA_NO_INLINE (line 520) | EA_NO_INLINE static void TestAtomic128ExchangeSeqCst()
function EA_NO_INLINE (line 529) | EA_NO_INLINE static void TestAtomic128Exchange()
function EA_NO_INLINE (line 538) | EA_NO_INLINE static void TestAtomic128ExchangeOrders()
function EA_NO_INLINE (line 557) | EA_NO_INLINE static void TestAtomicU32OperatorT()
function EA_NO_INLINE (line 570) | EA_NO_INLINE static void TestAtomicU64OperatorT()
function EA_NO_INLINE (line 583) | EA_NO_INLINE static void TestAtomic128OperatorT()
function EA_NO_INLINE (line 596) | EA_NO_INLINE static void TestAtomicU32OperatorEqual()
function EA_NO_INLINE (line 609) | EA_NO_INLINE static void TestAtomicU64OperatorEqual()
function EA_NO_INLINE (line 622) | EA_NO_INLINE static void TestAtomic128OperatorEqual()
function EA_NO_INLINE (line 635) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongRelaxedRelaxed()
function EA_NO_INLINE (line 645) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcquireRelaxed()
function EA_NO_INLINE (line 655) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcquireAcquire()
function EA_NO_INLINE (line 666) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongReleaseRelaxed()
function EA_NO_INLINE (line 676) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcqRelRelaxed()
function EA_NO_INLINE (line 686) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcqRelAcquire()
function EA_NO_INLINE (line 696) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongSeqCstRelaxed()
function EA_NO_INLINE (line 706) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongSeqCstAcquire()
function EA_NO_INLINE (line 716) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongSeqCstSeqCst()
function EA_NO_INLINE (line 726) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongRelaxed()
function EA_NO_INLINE (line 736) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcquire()
function EA_NO_INLINE (line 746) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongRelease()
function EA_NO_INLINE (line 756) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongAcqRel()
function EA_NO_INLINE (line 766) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongSeqCst()
function EA_NO_INLINE (line 776) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrong()
function EA_NO_INLINE (line 786) | EA_NO_INLINE static void TestAtomicU32CompareExchangeStrongOrders()
function EA_NO_INLINE (line 823) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongRelaxedRelaxed()
function EA_NO_INLINE (line 833) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongAcquireRelaxed()
function EA_NO_INLINE (line 843) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongAcquireAcquire()
function EA_NO_INLINE (line 853) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongReleaseRelaxed()
function EA_NO_INLINE (line 863) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongAcqRelRelaxed()
function EA_NO_INLINE (line 873) | EA_NO_INLINE static void TestAtomicU64CompareExchangeStrongAcqRelAcquire()
function
Condensed preview — 416 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (7,796K chars).
[
{
"path": ".clang-format",
"chars": 1640,
"preview": "#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-#-\nLanguage : Cpp\nBasedOn"
},
{
"path": ".gitattributes",
"chars": 193,
"preview": "# Auto detect text files and perform LF normalization\n# http://git-scm.com/docs/gitattributes\n* text=auto\n.appveyor.yml "
},
{
"path": ".github/workflows/c-cpp.yml",
"chars": 4057,
"preview": "name: EASTL Build & Test Pipeline\n\non:\n push:\n branches: [ master ]\n pull_request:\n branches: [ master ]\n\njobs:\n"
},
{
"path": ".gitignore",
"chars": 549,
"preview": "tags\ncscope.out\n**/*.swp\n**/*.swo\n.swp\n*.swp\n.swo\n.TMP\n-.d\neastl_build_out\nbuild_bench\nbench.bat\nbuild.bat\n.p4config\n\n##"
},
{
"path": ".p4ignore",
"chars": 34,
"preview": "/.git/\ntags\n.gitignore\ncscope.out\n"
},
{
"path": "3RDPARTYLICENSES.TXT",
"chars": 4803,
"preview": "Additional licenses also apply to this software package as detailed below.\n\n\n\nHP STL comes with the following license:\n\n"
},
{
"path": "CMakeLists.txt",
"chars": 4622,
"preview": "#-------------------------------------------------------------------------------------------\n# Copyright (C) Electronic "
},
{
"path": "CONTRIBUTING.md",
"chars": 2785,
"preview": "## Contributing\n\nBefore you can contribute, EA must have a Contributor License Agreement (CLA) on file that has been sig"
},
{
"path": "LICENSE",
"chars": 1523,
"preview": "BSD 3-Clause License\n\nCopyright (c) 2019, Electronic Arts\nAll rights reserved.\n\nRedistribution and use in source and bin"
},
{
"path": "README.md",
"chars": 3519,
"preview": "# EA Standard Template Library\n\n[](https://"
},
{
"path": "_config.yml",
"chars": 27,
"preview": "theme: jekyll-theme-minimal"
},
{
"path": "benchmark/CMakeLists.txt",
"chars": 4814,
"preview": "#-------------------------------------------------------------------------------------------\n# Copyright (C) Electronic "
},
{
"path": "benchmark/source/BenchmarkAlgorithm.cpp",
"chars": 49681,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// BenchmarkAlgorithm.cpp\n//\n// Copyright "
},
{
"path": "benchmark/source/BenchmarkBitset.cpp",
"chars": 10256,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkDeque.cpp",
"chars": 8921,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkHash.cpp",
"chars": 16024,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkHeap.cpp",
"chars": 7336,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkList.cpp",
"chars": 10709,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkMap.cpp",
"chars": 12255,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkSet.cpp",
"chars": 11000,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkSort.cpp",
"chars": 44294,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkString.cpp",
"chars": 17723,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkTupleVector.cpp",
"chars": 19227,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/BenchmarkVector.cpp",
"chars": 11469,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/EASTLBenchmark.cpp",
"chars": 8714,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/EASTLBenchmark.h",
"chars": 6083,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "benchmark/source/main.cpp",
"chars": 4918,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "doc/Benchmarks.md",
"chars": 65706,
"preview": "# EASTL Benchmarks\n\n## Introduction\n\nThis document provides a number of benchmark results of EASTL. Where possible, thes"
},
{
"path": "doc/BestPractices.md",
"chars": 33298,
"preview": "# EASTL Best Practices\n\nIn this document we discuss best practices for using EASTL. The primary emphasis is on performan"
},
{
"path": "doc/Bonus/tuple_vector_readme.md",
"chars": 18849,
"preview": "## Introduction to tuple_vector\n\n`tuple_vector` is a data container that is designed to abstract and simplify\nthe handli"
},
{
"path": "doc/CMake/EASTL_Project_Integration.md",
"chars": 2846,
"preview": "## Using EASTL in your own projects\n\nThis page describes the steps needed to use EASTL in your own projects\n\n## Setting "
},
{
"path": "doc/Design.md",
"chars": 22257,
"preview": "# EASTL Design\n\n## Introduction\n\nEASTL (EA Standard Template Library) is designed to be a template library which encompa"
},
{
"path": "doc/EASTL.natvis",
"chars": 49456,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\n<!-- \n This is a Microsoft natvis file, which allows visualization of comple"
},
{
"path": "doc/FAQ.md",
"chars": 152427,
"preview": "# EASTL FAQ\n\nWe provide a FAQ (frequently asked questions) list here for a number of commonly asked questions about EAST"
},
{
"path": "doc/Glossary.md",
"chars": 19472,
"preview": "# EASTL Glossary\n\nThis document provides definitions to various terms related to EASTL. Items that are capitalized are i"
},
{
"path": "doc/Gotchas.md",
"chars": 14126,
"preview": "# EASTL Gotchas\n\nThere are some cases where the EASTL design results in \"gotchas\" or behavior that isn't necessarily wha"
},
{
"path": "doc/Introduction.md",
"chars": 2248,
"preview": "# EASTL Introduction\n\nEASTL stands for Electronic Arts Standard Template Library. It is a C++ template library of contai"
},
{
"path": "doc/Maintenance.md",
"chars": 20259,
"preview": "# EASTL Maintenance\n\n## Introduction\n\nThe purpose of this document is to provide some necessary background for anybody w"
},
{
"path": "doc/Modules.md",
"chars": 8784,
"preview": "# EASTL Modules\n\n## Introduction\n\nWe provide here a list of all top-level modules present or planned for future presence"
},
{
"path": "doc/html/EASTL Benchmarks.html",
"chars": 74484,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n <title>EASTL Benchmarks</title>\n <m"
},
{
"path": "doc/html/EASTL Best Practices.html",
"chars": 55098,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n <title>EASTL Best Practices</title>\n\t<"
},
{
"path": "doc/html/EASTL Design.html",
"chars": 30153,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Design</title>\n\t<meta conten"
},
{
"path": "doc/html/EASTL FAQ.html",
"chars": 184870,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL FAQ</title>\n\t<meta content=\""
},
{
"path": "doc/html/EASTL Glossary.html",
"chars": 22474,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Glossary</title>\n\t<meta cont"
},
{
"path": "doc/html/EASTL Gotchas.html",
"chars": 16775,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Gotchas</title>\n\t<meta conte"
},
{
"path": "doc/html/EASTL Introduction.html",
"chars": 2825,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Introduction</title>\n\t<meta "
},
{
"path": "doc/html/EASTL Maintenance.html",
"chars": 22941,
"preview": "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Maintenance</title>\n\t<meta c"
},
{
"path": "doc/html/EASTL Modules.html",
"chars": 23511,
"preview": "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n<html>\n<head>\n\t<title>EASTL Modules</title>\n\t<meta conte"
},
{
"path": "doc/html/EASTLDoc.css",
"chars": 1292,
"preview": "body \n{\n\tfont-family: Georgia, \"Times New Roman\", Times, serif;\n\tfont-size: 12pt;\n}\n\nh1\n{\n\tfont-family: Verdana, Arial, "
},
{
"path": "include/EASTL/algorithm.h",
"chars": 156612,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/allocator.h",
"chars": 12416,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/allocator_malloc.h",
"chars": 3730,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/any.h",
"chars": 19723,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/array.h",
"chars": 21711,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/atomic.h",
"chars": 128875,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/atomic_raw.h",
"chars": 19075,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/bit.h",
"chars": 10838,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bitset.h",
"chars": 61016,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bitvector.h",
"chars": 46966,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/adaptors.h",
"chars": 2638,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/call_traits.h",
"chars": 2822,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/compressed_pair.h",
"chars": 16810,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/fixed_ring_buffer.h",
"chars": 1844,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/bonus/fixed_tuple_vector.h",
"chars": 8788,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/bonus/flags.h",
"chars": 23570,
"preview": "// Copyright (c) Electronic Arts Inc. All rights reserved.\n\n#pragma once\n\n//\n// introduction\n// --------------\n// \n// he"
},
{
"path": "include/EASTL/bonus/intrusive_sdlist.h",
"chars": 22845,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/intrusive_slist.h",
"chars": 13001,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/list_map.h",
"chars": 35343,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/lru_cache.h",
"chars": 13350,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/bonus/overloaded.h",
"chars": 2656,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/ring_buffer.h",
"chars": 57041,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/sort_extra.h",
"chars": 5692,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/bonus/tuple_vector.h",
"chars": 59283,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/chrono.h",
"chars": 32985,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/compare.h",
"chars": 1062,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/core_allocator.h",
"chars": 2203,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/core_allocator_adapter.h",
"chars": 12356,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/deque.h",
"chars": 118043,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/expected.h",
"chars": 52948,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/finally.h",
"chars": 2652,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_allocator.h",
"chars": 13710,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_function.h",
"chars": 6348,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_hash_map.h",
"chars": 38404,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_hash_set.h",
"chars": 36820,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_list.h",
"chars": 15439,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_map.h",
"chars": 24304,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_set.h",
"chars": 23078,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_slist.h",
"chars": 15237,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_string.h",
"chars": 32762,
"preview": "/////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. All "
},
{
"path": "include/EASTL/fixed_substring.h",
"chars": 9889,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/fixed_vector.h",
"chars": 28000,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/functional.h",
"chars": 25515,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/hash_map.h",
"chars": 30318,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/hash_set.h",
"chars": 24586,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/heap.h",
"chars": 28796,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/initializer_list.h",
"chars": 3166,
"preview": "///////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. Al"
},
{
"path": "include/EASTL/internal/atomic/arch/arch.h",
"chars": 1442,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_acquire_fence.h",
"chars": 531,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_add_fetch.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_and_fetch.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_cmpxchg_strong.h",
"chars": 18700,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_cmpxchg_weak.h",
"chars": 18223,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_compiler_barrier.h",
"chars": 583,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_cpu_pause.h",
"chars": 713,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// copyright (c) electronic arts inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_exchange.h",
"chars": 5175,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_fetch_add.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_fetch_and.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_fetch_or.h",
"chars": 5175,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_fetch_sub.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_fetch_xor.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_load.h",
"chars": 3139,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_memory_barrier.h",
"chars": 1260,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_or_fetch.h",
"chars": 5175,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_signal_fence.h",
"chars": 739,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_store.h",
"chars": 3188,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_sub_fetch.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_thread_fence.h",
"chars": 1504,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arch_xor_fetch.h",
"chars": 5254,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm.h",
"chars": 2336,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm_acquire_fence.h",
"chars": 581,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm_load.h",
"chars": 4944,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm_memory_barrier.h",
"chars": 2394,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm_store.h",
"chars": 4528,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/arm/arch_arm_thread_fence.h",
"chars": 984,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86.h",
"chars": 5159,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_acquire_fence.h",
"chars": 496,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_add_fetch.h",
"chars": 3941,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_and_fetch.h",
"chars": 3941,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_cmpxchg_strong.h",
"chars": 3425,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_cmpxchg_weak.h",
"chars": 2393,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_exchange.h",
"chars": 3674,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_fetch_add.h",
"chars": 3645,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_fetch_and.h",
"chars": 3645,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_fetch_or.h",
"chars": 3624,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_fetch_sub.h",
"chars": 3645,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_fetch_xor.h",
"chars": 3645,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_load.h",
"chars": 6116,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_memory_barrier.h",
"chars": 2931,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_or_fetch.h",
"chars": 3908,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_store.h",
"chars": 5423,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_sub_fetch.h",
"chars": 3941,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_thread_fence.h",
"chars": 1105,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/arch/x86/arch_x86_xor_fetch.h",
"chars": 3941,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic.h",
"chars": 7637,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_asserts.h",
"chars": 3545,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_base_width.h",
"chars": 14233,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_casts.h",
"chars": 6532,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_flag.h",
"chars": 4093,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_flag_standalone.h",
"chars": 1701,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_integral.h",
"chars": 11584,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros.h",
"chars": 3928,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_acquire_fence.h",
"chars": 480,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_add_fetch.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_and_fetch.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_base.h",
"chars": 2425,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_cmpxchg_strong.h",
"chars": 14446,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_cmpxchg_weak.h",
"chars": 14156,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_compiler_barrier.h",
"chars": 1002,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_cpu_pause.h",
"chars": 650,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_exchange.h",
"chars": 4226,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_fetch_add.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_fetch_and.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_fetch_or.h",
"chars": 4226,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_fetch_sub.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_fetch_xor.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_load.h",
"chars": 3354,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_memory_barrier.h",
"chars": 1069,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_or_fetch.h",
"chars": 4226,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_signal_fence.h",
"chars": 1135,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_store.h",
"chars": 2556,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_sub_fetch.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_thread_fence.h",
"chars": 1135,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros/atomic_macros_xor_fetch.h",
"chars": 4280,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_macros.h",
"chars": 3279,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_memory_order.h",
"chars": 1372,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_pointer.h",
"chars": 11417,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_size_aligned.h",
"chars": 5678,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/atomic_standalone.h",
"chars": 14843,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler.h",
"chars": 3411,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_acquire_fence.h",
"chars": 547,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_add_fetch.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_and_fetch.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_barrier.h",
"chars": 1165,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_cmpxchg_strong.h",
"chars": 19659,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_cmpxchg_weak.h",
"chars": 19183,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_cpu_pause.h",
"chars": 804,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_exchange.h",
"chars": 5491,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_fetch_add.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_fetch_and.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_fetch_or.h",
"chars": 5491,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_fetch_sub.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_fetch_xor.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_load.h",
"chars": 3334,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_memory_barrier.h",
"chars": 1320,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_or_fetch.h",
"chars": 5491,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_signal_fence.h",
"chars": 1580,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_store.h",
"chars": 3384,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_sub_fetch.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_thread_fence.h",
"chars": 1580,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
},
{
"path": "include/EASTL/internal/atomic/compiler/compiler_xor_fetch.h",
"chars": 5570,
"preview": "/////////////////////////////////////////////////////////////////////////////////\n// Copyright (c) Electronic Arts Inc. "
}
]
// ... and 216 more files (download for full content)
About this extraction
This page contains the full source code of the electronicarts/EASTL GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 416 files (6.9 MB), approximately 1.8M tokens, and a symbol index with 3620 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.