Copy disabled (too large)
Download .txt
Showing preview only (16,029K chars total). Download the full file to get everything.
Repository: Snapchat/KeyDB
Branch: main
Commit: 603ebb27fb82
Files: 1622
Total size: 16.1 MB
Directory structure:
gitextract__91v1dat/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── crash_report.md
│ │ ├── feature_request.md
│ │ └── other_stuff.md
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── .gitmodules
├── 00-RELEASENOTES
├── BUGS
├── CONDUCT
├── COPYING
├── INSTALL
├── Makefile
├── README.md
├── TLS.md
├── build.yaml
├── ci.yaml
├── deps/
│ ├── Makefile
│ ├── README.md
│ ├── concurrentqueue/
│ │ ├── blockingconcurrentqueue.h
│ │ ├── concurrentqueue.h
│ │ └── lightweightsemaphore.h
│ ├── cpp-statsd-client/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ ├── coverage.yml
│ │ │ ├── lint.yml
│ │ │ ├── linux.yml
│ │ │ └── windows.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── cmake/
│ │ │ ├── CodeCoverage.cmake
│ │ │ ├── Config.cmake.in
│ │ │ └── cpp-statsd-clientConfig.cmake.in
│ │ ├── include/
│ │ │ └── cpp-statsd-client/
│ │ │ ├── StatsdClient.hpp
│ │ │ └── UDPSender.hpp
│ │ └── tests/
│ │ ├── StatsdServer.hpp
│ │ └── testStatsdClient.cpp
│ ├── hdr_histogram/
│ │ ├── COPYING.txt
│ │ ├── LICENSE.txt
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── hdr_atomic.h
│ │ ├── hdr_histogram.c
│ │ └── hdr_histogram.h
│ ├── hiredis/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CHANGELOG.md
│ │ ├── CMakeLists.txt
│ │ ├── COPYING
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── adapters/
│ │ │ ├── ae.h
│ │ │ ├── glib.h
│ │ │ ├── ivykis.h
│ │ │ ├── libev.h
│ │ │ ├── libevent.h
│ │ │ ├── libuv.h
│ │ │ ├── macosx.h
│ │ │ └── qt.h
│ │ ├── alloc.c
│ │ ├── alloc.h
│ │ ├── appveyor.yml
│ │ ├── async.c
│ │ ├── async.h
│ │ ├── async_private.h
│ │ ├── dict.c
│ │ ├── dict.h
│ │ ├── examples/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── example-ae.c
│ │ │ ├── example-glib.c
│ │ │ ├── example-ivykis.c
│ │ │ ├── example-libev.c
│ │ │ ├── example-libevent-ssl.c
│ │ │ ├── example-libevent.c
│ │ │ ├── example-libuv.c
│ │ │ ├── example-macosx.c
│ │ │ ├── example-push.c
│ │ │ ├── example-qt.cpp
│ │ │ ├── example-qt.h
│ │ │ ├── example-ssl.c
│ │ │ └── example.c
│ │ ├── fmacros.h
│ │ ├── hiredis-config.cmake.in
│ │ ├── hiredis.c
│ │ ├── hiredis.h
│ │ ├── hiredis.pc.in
│ │ ├── hiredis_ssl-config.cmake.in
│ │ ├── hiredis_ssl.h
│ │ ├── hiredis_ssl.pc.in
│ │ ├── net.c
│ │ ├── net.h
│ │ ├── read.c
│ │ ├── read.h
│ │ ├── sds.c
│ │ ├── sds.h
│ │ ├── sdsalloc.h
│ │ ├── sockcompat.c
│ │ ├── sockcompat.h
│ │ ├── ssl.c
│ │ ├── test.c
│ │ ├── test.sh
│ │ └── win32.h
│ ├── jemalloc/
│ │ ├── .appveyor.yml
│ │ ├── .autom4te.cfg
│ │ ├── .cirrus.yml
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── COPYING
│ │ ├── ChangeLog
│ │ ├── INSTALL.md
│ │ ├── Makefile.in
│ │ ├── README
│ │ ├── TUNING.md
│ │ ├── VERSION
│ │ ├── autogen.sh
│ │ ├── bin/
│ │ │ ├── jemalloc-config.in
│ │ │ ├── jemalloc.sh.in
│ │ │ └── jeprof.in
│ │ ├── build-aux/
│ │ │ ├── config.guess
│ │ │ ├── config.sub
│ │ │ └── install-sh
│ │ ├── config.stamp.in
│ │ ├── configure
│ │ ├── configure.ac
│ │ ├── doc/
│ │ │ ├── html.xsl.in
│ │ │ ├── jemalloc.xml.in
│ │ │ ├── manpages.xsl.in
│ │ │ └── stylesheet.xsl
│ │ ├── include/
│ │ │ ├── jemalloc/
│ │ │ │ ├── internal/
│ │ │ │ │ ├── arena_externs.h
│ │ │ │ │ ├── arena_inlines_a.h
│ │ │ │ │ ├── arena_inlines_b.h
│ │ │ │ │ ├── arena_stats.h
│ │ │ │ │ ├── arena_structs_a.h
│ │ │ │ │ ├── arena_structs_b.h
│ │ │ │ │ ├── arena_types.h
│ │ │ │ │ ├── assert.h
│ │ │ │ │ ├── atomic.h
│ │ │ │ │ ├── atomic_c11.h
│ │ │ │ │ ├── atomic_gcc_atomic.h
│ │ │ │ │ ├── atomic_gcc_sync.h
│ │ │ │ │ ├── atomic_msvc.h
│ │ │ │ │ ├── background_thread_externs.h
│ │ │ │ │ ├── background_thread_inlines.h
│ │ │ │ │ ├── background_thread_structs.h
│ │ │ │ │ ├── base_externs.h
│ │ │ │ │ ├── base_inlines.h
│ │ │ │ │ ├── base_structs.h
│ │ │ │ │ ├── base_types.h
│ │ │ │ │ ├── bin.h
│ │ │ │ │ ├── bin_stats.h
│ │ │ │ │ ├── bin_types.h
│ │ │ │ │ ├── bit_util.h
│ │ │ │ │ ├── bitmap.h
│ │ │ │ │ ├── cache_bin.h
│ │ │ │ │ ├── ckh.h
│ │ │ │ │ ├── ctl.h
│ │ │ │ │ ├── div.h
│ │ │ │ │ ├── emitter.h
│ │ │ │ │ ├── extent_dss.h
│ │ │ │ │ ├── extent_externs.h
│ │ │ │ │ ├── extent_inlines.h
│ │ │ │ │ ├── extent_mmap.h
│ │ │ │ │ ├── extent_structs.h
│ │ │ │ │ ├── extent_types.h
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── hook.h
│ │ │ │ │ ├── jemalloc_internal_decls.h
│ │ │ │ │ ├── jemalloc_internal_defs.h.in
│ │ │ │ │ ├── jemalloc_internal_externs.h
│ │ │ │ │ ├── jemalloc_internal_includes.h
│ │ │ │ │ ├── jemalloc_internal_inlines_a.h
│ │ │ │ │ ├── jemalloc_internal_inlines_b.h
│ │ │ │ │ ├── jemalloc_internal_inlines_c.h
│ │ │ │ │ ├── jemalloc_internal_macros.h
│ │ │ │ │ ├── jemalloc_internal_types.h
│ │ │ │ │ ├── jemalloc_preamble.h.in
│ │ │ │ │ ├── large_externs.h
│ │ │ │ │ ├── log.h
│ │ │ │ │ ├── malloc_io.h
│ │ │ │ │ ├── mutex.h
│ │ │ │ │ ├── mutex_pool.h
│ │ │ │ │ ├── mutex_prof.h
│ │ │ │ │ ├── nstime.h
│ │ │ │ │ ├── pages.h
│ │ │ │ │ ├── ph.h
│ │ │ │ │ ├── private_namespace.sh
│ │ │ │ │ ├── private_symbols.sh
│ │ │ │ │ ├── prng.h
│ │ │ │ │ ├── prof_externs.h
│ │ │ │ │ ├── prof_inlines_a.h
│ │ │ │ │ ├── prof_inlines_b.h
│ │ │ │ │ ├── prof_structs.h
│ │ │ │ │ ├── prof_types.h
│ │ │ │ │ ├── public_namespace.sh
│ │ │ │ │ ├── public_unnamespace.sh
│ │ │ │ │ ├── ql.h
│ │ │ │ │ ├── qr.h
│ │ │ │ │ ├── quantum.h
│ │ │ │ │ ├── rb.h
│ │ │ │ │ ├── rtree.h
│ │ │ │ │ ├── rtree_tsd.h
│ │ │ │ │ ├── safety_check.h
│ │ │ │ │ ├── sc.h
│ │ │ │ │ ├── seq.h
│ │ │ │ │ ├── smoothstep.h
│ │ │ │ │ ├── smoothstep.sh
│ │ │ │ │ ├── spin.h
│ │ │ │ │ ├── stats.h
│ │ │ │ │ ├── sz.h
│ │ │ │ │ ├── tcache_externs.h
│ │ │ │ │ ├── tcache_inlines.h
│ │ │ │ │ ├── tcache_structs.h
│ │ │ │ │ ├── tcache_types.h
│ │ │ │ │ ├── test_hooks.h
│ │ │ │ │ ├── ticker.h
│ │ │ │ │ ├── tsd.h
│ │ │ │ │ ├── tsd_generic.h
│ │ │ │ │ ├── tsd_malloc_thread_cleanup.h
│ │ │ │ │ ├── tsd_tls.h
│ │ │ │ │ ├── tsd_types.h
│ │ │ │ │ ├── tsd_win.h
│ │ │ │ │ ├── util.h
│ │ │ │ │ └── witness.h
│ │ │ │ ├── jemalloc.sh
│ │ │ │ ├── jemalloc_defs.h.in
│ │ │ │ ├── jemalloc_macros.h.in
│ │ │ │ ├── jemalloc_mangle.sh
│ │ │ │ ├── jemalloc_protos.h.in
│ │ │ │ ├── jemalloc_rename.sh
│ │ │ │ └── jemalloc_typedefs.h.in
│ │ │ └── msvc_compat/
│ │ │ ├── C99/
│ │ │ │ ├── stdbool.h
│ │ │ │ └── stdint.h
│ │ │ ├── strings.h
│ │ │ └── windows_extra.h
│ │ ├── jemalloc.pc.in
│ │ ├── m4/
│ │ │ └── ax_cxx_compile_stdcxx.m4
│ │ ├── msvc/
│ │ │ ├── ReadMe.txt
│ │ │ ├── jemalloc_vc2015.sln
│ │ │ ├── jemalloc_vc2017.sln
│ │ │ ├── projects/
│ │ │ │ ├── vc2015/
│ │ │ │ │ ├── jemalloc/
│ │ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ │ └── test_threads/
│ │ │ │ │ ├── test_threads.vcxproj
│ │ │ │ │ └── test_threads.vcxproj.filters
│ │ │ │ └── vc2017/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ └── test_threads/
│ │ │ │ ├── test_threads.vcxproj
│ │ │ │ └── test_threads.vcxproj.filters
│ │ │ └── test_threads/
│ │ │ ├── test_threads.cpp
│ │ │ ├── test_threads.h
│ │ │ └── test_threads_main.cpp
│ │ ├── run_tests.sh
│ │ ├── scripts/
│ │ │ ├── gen_run_tests.py
│ │ │ └── gen_travis.py
│ │ ├── src/
│ │ │ ├── arena.c
│ │ │ ├── background_thread.c
│ │ │ ├── base.c
│ │ │ ├── bin.c
│ │ │ ├── bitmap.c
│ │ │ ├── ckh.c
│ │ │ ├── ctl.c
│ │ │ ├── div.c
│ │ │ ├── extent.c
│ │ │ ├── extent_dss.c
│ │ │ ├── extent_mmap.c
│ │ │ ├── hash.c
│ │ │ ├── hook.c
│ │ │ ├── jemalloc.c
│ │ │ ├── jemalloc_cpp.cpp
│ │ │ ├── large.c
│ │ │ ├── log.c
│ │ │ ├── malloc_io.c
│ │ │ ├── mutex.c
│ │ │ ├── mutex_pool.c
│ │ │ ├── nstime.c
│ │ │ ├── pages.c
│ │ │ ├── prng.c
│ │ │ ├── prof.c
│ │ │ ├── rtree.c
│ │ │ ├── safety_check.c
│ │ │ ├── sc.c
│ │ │ ├── stats.c
│ │ │ ├── sz.c
│ │ │ ├── tcache.c
│ │ │ ├── test_hooks.c
│ │ │ ├── ticker.c
│ │ │ ├── tsd.c
│ │ │ ├── witness.c
│ │ │ └── zone.c
│ │ └── test/
│ │ ├── include/
│ │ │ └── test/
│ │ │ ├── SFMT-alti.h
│ │ │ ├── SFMT-params.h
│ │ │ ├── SFMT-params11213.h
│ │ │ ├── SFMT-params1279.h
│ │ │ ├── SFMT-params132049.h
│ │ │ ├── SFMT-params19937.h
│ │ │ ├── SFMT-params216091.h
│ │ │ ├── SFMT-params2281.h
│ │ │ ├── SFMT-params4253.h
│ │ │ ├── SFMT-params44497.h
│ │ │ ├── SFMT-params607.h
│ │ │ ├── SFMT-params86243.h
│ │ │ ├── SFMT-sse2.h
│ │ │ ├── SFMT.h
│ │ │ ├── btalloc.h
│ │ │ ├── extent_hooks.h
│ │ │ ├── jemalloc_test.h.in
│ │ │ ├── jemalloc_test_defs.h.in
│ │ │ ├── math.h
│ │ │ ├── mq.h
│ │ │ ├── mtx.h
│ │ │ ├── test.h
│ │ │ ├── thd.h
│ │ │ └── timer.h
│ │ ├── integration/
│ │ │ ├── MALLOCX_ARENA.c
│ │ │ ├── aligned_alloc.c
│ │ │ ├── allocated.c
│ │ │ ├── cpp/
│ │ │ │ └── basic.cpp
│ │ │ ├── extent.c
│ │ │ ├── extent.sh
│ │ │ ├── malloc.c
│ │ │ ├── mallocx.c
│ │ │ ├── mallocx.sh
│ │ │ ├── overflow.c
│ │ │ ├── posix_memalign.c
│ │ │ ├── rallocx.c
│ │ │ ├── sdallocx.c
│ │ │ ├── slab_sizes.c
│ │ │ ├── slab_sizes.sh
│ │ │ ├── smallocx.c
│ │ │ ├── smallocx.sh
│ │ │ ├── thread_arena.c
│ │ │ ├── thread_tcache_enabled.c
│ │ │ ├── xallocx.c
│ │ │ └── xallocx.sh
│ │ ├── src/
│ │ │ ├── SFMT.c
│ │ │ ├── btalloc.c
│ │ │ ├── btalloc_0.c
│ │ │ ├── btalloc_1.c
│ │ │ ├── math.c
│ │ │ ├── mq.c
│ │ │ ├── mtx.c
│ │ │ ├── test.c
│ │ │ ├── thd.c
│ │ │ └── timer.c
│ │ ├── stress/
│ │ │ ├── hookbench.c
│ │ │ └── microbench.c
│ │ ├── test.sh.in
│ │ └── unit/
│ │ ├── SFMT.c
│ │ ├── a0.c
│ │ ├── arena_reset.c
│ │ ├── arena_reset_prof.c
│ │ ├── arena_reset_prof.sh
│ │ ├── atomic.c
│ │ ├── background_thread.c
│ │ ├── background_thread_enable.c
│ │ ├── base.c
│ │ ├── binshard.c
│ │ ├── binshard.sh
│ │ ├── bit_util.c
│ │ ├── bitmap.c
│ │ ├── ckh.c
│ │ ├── decay.c
│ │ ├── decay.sh
│ │ ├── div.c
│ │ ├── emitter.c
│ │ ├── extent_quantize.c
│ │ ├── extent_util.c
│ │ ├── fork.c
│ │ ├── hash.c
│ │ ├── hook.c
│ │ ├── huge.c
│ │ ├── junk.c
│ │ ├── junk.sh
│ │ ├── junk_alloc.c
│ │ ├── junk_alloc.sh
│ │ ├── junk_free.c
│ │ ├── junk_free.sh
│ │ ├── log.c
│ │ ├── mallctl.c
│ │ ├── malloc_io.c
│ │ ├── math.c
│ │ ├── mq.c
│ │ ├── mtx.c
│ │ ├── nstime.c
│ │ ├── pack.c
│ │ ├── pack.sh
│ │ ├── pages.c
│ │ ├── ph.c
│ │ ├── prng.c
│ │ ├── prof_accum.c
│ │ ├── prof_accum.sh
│ │ ├── prof_active.c
│ │ ├── prof_active.sh
│ │ ├── prof_gdump.c
│ │ ├── prof_gdump.sh
│ │ ├── prof_idump.c
│ │ ├── prof_idump.sh
│ │ ├── prof_log.c
│ │ ├── prof_log.sh
│ │ ├── prof_reset.c
│ │ ├── prof_reset.sh
│ │ ├── prof_tctx.c
│ │ ├── prof_tctx.sh
│ │ ├── prof_thread_name.c
│ │ ├── prof_thread_name.sh
│ │ ├── ql.c
│ │ ├── qr.c
│ │ ├── rb.c
│ │ ├── retained.c
│ │ ├── rtree.c
│ │ ├── safety_check.c
│ │ ├── safety_check.sh
│ │ ├── sc.c
│ │ ├── seq.c
│ │ ├── size_classes.c
│ │ ├── slab.c
│ │ ├── smoothstep.c
│ │ ├── spin.c
│ │ ├── stats.c
│ │ ├── stats_print.c
│ │ ├── test_hooks.c
│ │ ├── ticker.c
│ │ ├── tsd.c
│ │ ├── witness.c
│ │ ├── zero.c
│ │ └── zero.sh
│ ├── license/
│ │ ├── arm64/
│ │ │ └── libkey.a
│ │ ├── keycheck.h
│ │ └── x64/
│ │ └── libkey.a
│ ├── linenoise/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── README.markdown
│ │ ├── example.c
│ │ ├── linenoise.c
│ │ └── linenoise.h
│ ├── lua/
│ │ ├── COPYRIGHT
│ │ ├── HISTORY
│ │ ├── INSTALL
│ │ ├── Makefile
│ │ ├── README
│ │ ├── doc/
│ │ │ ├── contents.html
│ │ │ ├── lua.1
│ │ │ ├── lua.css
│ │ │ ├── lua.html
│ │ │ ├── luac.1
│ │ │ ├── luac.html
│ │ │ ├── manual.css
│ │ │ ├── manual.html
│ │ │ └── readme.html
│ │ ├── etc/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── all.c
│ │ │ ├── lua.hpp
│ │ │ ├── lua.pc
│ │ │ ├── luavs.bat
│ │ │ ├── min.c
│ │ │ ├── noparser.c
│ │ │ └── strict.lua
│ │ ├── src/
│ │ │ ├── Makefile
│ │ │ ├── fpconv.c
│ │ │ ├── fpconv.h
│ │ │ ├── lapi.c
│ │ │ ├── lapi.h
│ │ │ ├── lauxlib.c
│ │ │ ├── lauxlib.h
│ │ │ ├── lbaselib.c
│ │ │ ├── lcode.c
│ │ │ ├── lcode.h
│ │ │ ├── ldblib.c
│ │ │ ├── ldebug.c
│ │ │ ├── ldebug.h
│ │ │ ├── ldo.c
│ │ │ ├── ldo.h
│ │ │ ├── ldump.c
│ │ │ ├── lfunc.c
│ │ │ ├── lfunc.h
│ │ │ ├── lgc.c
│ │ │ ├── lgc.h
│ │ │ ├── linit.c
│ │ │ ├── liolib.c
│ │ │ ├── llex.c
│ │ │ ├── llex.h
│ │ │ ├── llimits.h
│ │ │ ├── lmathlib.c
│ │ │ ├── lmem.c
│ │ │ ├── lmem.h
│ │ │ ├── loadlib.c
│ │ │ ├── lobject.c
│ │ │ ├── lobject.h
│ │ │ ├── lopcodes.c
│ │ │ ├── lopcodes.h
│ │ │ ├── loslib.c
│ │ │ ├── lparser.c
│ │ │ ├── lparser.h
│ │ │ ├── lstate.c
│ │ │ ├── lstate.h
│ │ │ ├── lstring.c
│ │ │ ├── lstring.h
│ │ │ ├── lstrlib.c
│ │ │ ├── ltable.c
│ │ │ ├── ltable.h
│ │ │ ├── ltablib.c
│ │ │ ├── ltm.c
│ │ │ ├── ltm.h
│ │ │ ├── lua.c
│ │ │ ├── lua.h
│ │ │ ├── lua_bit.c
│ │ │ ├── lua_cjson.c
│ │ │ ├── lua_cmsgpack.c
│ │ │ ├── lua_struct.c
│ │ │ ├── luac.c
│ │ │ ├── luaconf.h
│ │ │ ├── lualib.h
│ │ │ ├── lundump.c
│ │ │ ├── lundump.h
│ │ │ ├── lvm.c
│ │ │ ├── lvm.h
│ │ │ ├── lzio.c
│ │ │ ├── lzio.h
│ │ │ ├── print.c
│ │ │ ├── strbuf.c
│ │ │ └── strbuf.h
│ │ └── test/
│ │ ├── README
│ │ ├── bisect.lua
│ │ ├── cf.lua
│ │ ├── echo.lua
│ │ ├── env.lua
│ │ ├── factorial.lua
│ │ ├── fib.lua
│ │ ├── fibfor.lua
│ │ ├── globals.lua
│ │ ├── hello.lua
│ │ ├── life.lua
│ │ ├── luac.lua
│ │ ├── printf.lua
│ │ ├── readonly.lua
│ │ ├── sieve.lua
│ │ ├── sort.lua
│ │ ├── table.lua
│ │ ├── trace-calls.lua
│ │ ├── trace-globals.lua
│ │ └── xd.lua
│ ├── memkind/
│ │ ├── Makefile
│ │ └── src/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── AUTHORS
│ │ ├── CONTRIBUTING
│ │ ├── COPYING
│ │ ├── ChangeLog
│ │ ├── INSTALL
│ │ ├── MANIFEST
│ │ ├── Makefile.am
│ │ ├── NEWS
│ │ ├── PULL_REQUEST_TEMPLATE.md
│ │ ├── README
│ │ ├── astyle.sh
│ │ ├── autogen.sh
│ │ ├── autohbw/
│ │ │ ├── Makefile.mk
│ │ │ ├── autohbw.c
│ │ │ ├── autohbw_README
│ │ │ ├── autohbw_api.h
│ │ │ ├── autohbw_get_src_lines.pl
│ │ │ └── autohbw_test.sh
│ │ ├── build.sh
│ │ ├── build_jemalloc.sh
│ │ ├── config.h.in~
│ │ ├── configure.ac
│ │ ├── copying_headers/
│ │ │ ├── MANIFEST.EXEMPT
│ │ │ ├── MANIFEST.freeBSD
│ │ │ ├── MANIFEST.freeBSD3
│ │ │ ├── header.freeBSD
│ │ │ ├── header.freeBSD3
│ │ │ └── header.intel-acpi
│ │ ├── debian/
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ └── rules
│ │ ├── examples/
│ │ │ ├── Makefile.mk
│ │ │ ├── README
│ │ │ ├── autohbw_candidates.c
│ │ │ ├── filter_example.c
│ │ │ ├── hello_hbw_example.c
│ │ │ ├── hello_memkind_example.c
│ │ │ ├── memkind_allocated.hpp
│ │ │ ├── memkind_allocated_example.cpp
│ │ │ ├── memkind_decorator_debug.c
│ │ │ ├── pmem_alignment.c
│ │ │ ├── pmem_and_default_kind.c
│ │ │ ├── pmem_cpp_allocator.cpp
│ │ │ ├── pmem_free_with_unknown_kind.c
│ │ │ ├── pmem_kinds.c
│ │ │ ├── pmem_malloc.c
│ │ │ ├── pmem_malloc_unlimited.c
│ │ │ ├── pmem_multithreads.c
│ │ │ ├── pmem_multithreads_onekind.c
│ │ │ └── pmem_usable_size.c
│ │ ├── include/
│ │ │ ├── hbw_allocator.h
│ │ │ ├── hbwmalloc.h
│ │ │ ├── memkind/
│ │ │ │ └── internal/
│ │ │ │ ├── heap_manager.h
│ │ │ │ ├── memkind_arena.h
│ │ │ │ ├── memkind_default.h
│ │ │ │ ├── memkind_gbtlb.h
│ │ │ │ ├── memkind_hbw.h
│ │ │ │ ├── memkind_hugetlb.h
│ │ │ │ ├── memkind_interleave.h
│ │ │ │ ├── memkind_log.h
│ │ │ │ ├── memkind_pmem.h
│ │ │ │ ├── memkind_private.h
│ │ │ │ ├── memkind_regular.h
│ │ │ │ ├── tbb_mem_pool_policy.h
│ │ │ │ └── tbb_wrapper.h
│ │ │ ├── memkind.h
│ │ │ ├── memkind_deprecated.h
│ │ │ └── pmem_allocator.h
│ │ ├── install_astyle.sh
│ │ ├── jemalloc/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .autom4te.cfg
│ │ │ ├── .gitattributes
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── COPYING
│ │ │ ├── ChangeLog
│ │ │ ├── INSTALL.md
│ │ │ ├── Makefile.in
│ │ │ ├── README
│ │ │ ├── autogen.sh
│ │ │ ├── bin/
│ │ │ │ ├── jemalloc-config.in
│ │ │ │ ├── jemalloc.sh.in
│ │ │ │ └── jeprof.in
│ │ │ ├── build-aux/
│ │ │ │ ├── config.guess
│ │ │ │ ├── config.sub
│ │ │ │ └── install-sh
│ │ │ ├── config.stamp.in
│ │ │ ├── configure.ac
│ │ │ ├── doc/
│ │ │ │ ├── html.xsl.in
│ │ │ │ ├── jemalloc.xml.in
│ │ │ │ ├── manpages.xsl.in
│ │ │ │ └── stylesheet.xsl
│ │ │ ├── include/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── arena_externs.h
│ │ │ │ │ │ ├── arena_inlines_a.h
│ │ │ │ │ │ ├── arena_inlines_b.h
│ │ │ │ │ │ ├── arena_structs_a.h
│ │ │ │ │ │ ├── arena_structs_b.h
│ │ │ │ │ │ ├── arena_types.h
│ │ │ │ │ │ ├── assert.h
│ │ │ │ │ │ ├── atomic.h
│ │ │ │ │ │ ├── atomic_c11.h
│ │ │ │ │ │ ├── atomic_gcc_atomic.h
│ │ │ │ │ │ ├── atomic_gcc_sync.h
│ │ │ │ │ │ ├── atomic_msvc.h
│ │ │ │ │ │ ├── background_thread_externs.h
│ │ │ │ │ │ ├── background_thread_inlines.h
│ │ │ │ │ │ ├── background_thread_structs.h
│ │ │ │ │ │ ├── base_externs.h
│ │ │ │ │ │ ├── base_inlines.h
│ │ │ │ │ │ ├── base_structs.h
│ │ │ │ │ │ ├── base_types.h
│ │ │ │ │ │ ├── bit_util.h
│ │ │ │ │ │ ├── bitmap.h
│ │ │ │ │ │ ├── ckh.h
│ │ │ │ │ │ ├── ctl.h
│ │ │ │ │ │ ├── extent_dss.h
│ │ │ │ │ │ ├── extent_externs.h
│ │ │ │ │ │ ├── extent_inlines.h
│ │ │ │ │ │ ├── extent_mmap.h
│ │ │ │ │ │ ├── extent_structs.h
│ │ │ │ │ │ ├── extent_types.h
│ │ │ │ │ │ ├── hash.h
│ │ │ │ │ │ ├── hooks.h
│ │ │ │ │ │ ├── jemalloc_internal_decls.h
│ │ │ │ │ │ ├── jemalloc_internal_defs.h.in
│ │ │ │ │ │ ├── jemalloc_internal_externs.h
│ │ │ │ │ │ ├── jemalloc_internal_includes.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_a.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_b.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_c.h
│ │ │ │ │ │ ├── jemalloc_internal_macros.h
│ │ │ │ │ │ ├── jemalloc_internal_types.h
│ │ │ │ │ │ ├── jemalloc_preamble.h.in
│ │ │ │ │ │ ├── large_externs.h
│ │ │ │ │ │ ├── malloc_io.h
│ │ │ │ │ │ ├── mutex.h
│ │ │ │ │ │ ├── mutex_pool.h
│ │ │ │ │ │ ├── mutex_prof.h
│ │ │ │ │ │ ├── nstime.h
│ │ │ │ │ │ ├── pages.h
│ │ │ │ │ │ ├── ph.h
│ │ │ │ │ │ ├── private_namespace.sh
│ │ │ │ │ │ ├── private_symbols.sh
│ │ │ │ │ │ ├── prng.h
│ │ │ │ │ │ ├── prof_externs.h
│ │ │ │ │ │ ├── prof_inlines_a.h
│ │ │ │ │ │ ├── prof_inlines_b.h
│ │ │ │ │ │ ├── prof_structs.h
│ │ │ │ │ │ ├── prof_types.h
│ │ │ │ │ │ ├── public_namespace.sh
│ │ │ │ │ │ ├── public_unnamespace.sh
│ │ │ │ │ │ ├── ql.h
│ │ │ │ │ │ ├── qr.h
│ │ │ │ │ │ ├── rb.h
│ │ │ │ │ │ ├── rtree.h
│ │ │ │ │ │ ├── rtree_tsd.h
│ │ │ │ │ │ ├── size_classes.sh
│ │ │ │ │ │ ├── smoothstep.h
│ │ │ │ │ │ ├── smoothstep.sh
│ │ │ │ │ │ ├── spin.h
│ │ │ │ │ │ ├── stats.h
│ │ │ │ │ │ ├── stats_tsd.h
│ │ │ │ │ │ ├── sz.h
│ │ │ │ │ │ ├── tcache_externs.h
│ │ │ │ │ │ ├── tcache_inlines.h
│ │ │ │ │ │ ├── tcache_structs.h
│ │ │ │ │ │ ├── tcache_types.h
│ │ │ │ │ │ ├── ticker.h
│ │ │ │ │ │ ├── tsd.h
│ │ │ │ │ │ ├── tsd_generic.h
│ │ │ │ │ │ ├── tsd_malloc_thread_cleanup.h
│ │ │ │ │ │ ├── tsd_tls.h
│ │ │ │ │ │ ├── tsd_types.h
│ │ │ │ │ │ ├── tsd_win.h
│ │ │ │ │ │ ├── util.h
│ │ │ │ │ │ └── witness.h
│ │ │ │ │ ├── jemalloc.sh
│ │ │ │ │ ├── jemalloc_defs.h.in
│ │ │ │ │ ├── jemalloc_macros.h.in
│ │ │ │ │ ├── jemalloc_mangle.sh
│ │ │ │ │ ├── jemalloc_protos.h.in
│ │ │ │ │ ├── jemalloc_rename.sh
│ │ │ │ │ └── jemalloc_typedefs.h.in
│ │ │ │ └── msvc_compat/
│ │ │ │ ├── C99/
│ │ │ │ │ ├── stdbool.h
│ │ │ │ │ └── stdint.h
│ │ │ │ ├── strings.h
│ │ │ │ └── windows_extra.h
│ │ │ ├── jemalloc.pc.in
│ │ │ ├── m4/
│ │ │ │ └── ax_cxx_compile_stdcxx.m4
│ │ │ ├── msvc/
│ │ │ │ ├── ReadMe.txt
│ │ │ │ ├── jemalloc_vc2015.sln
│ │ │ │ └── projects/
│ │ │ │ └── vc2015/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ └── test_threads/
│ │ │ │ ├── test_threads.cpp
│ │ │ │ ├── test_threads.h
│ │ │ │ ├── test_threads.vcxproj
│ │ │ │ ├── test_threads.vcxproj.filters
│ │ │ │ └── test_threads_main.cpp
│ │ │ ├── run_tests.sh
│ │ │ ├── scripts/
│ │ │ │ ├── gen_run_tests.py
│ │ │ │ └── gen_travis.py
│ │ │ ├── src/
│ │ │ │ ├── arena.c
│ │ │ │ ├── background_thread.c
│ │ │ │ ├── base.c
│ │ │ │ ├── bitmap.c
│ │ │ │ ├── ckh.c
│ │ │ │ ├── ctl.c
│ │ │ │ ├── extent.c
│ │ │ │ ├── extent_dss.c
│ │ │ │ ├── extent_mmap.c
│ │ │ │ ├── hash.c
│ │ │ │ ├── hooks.c
│ │ │ │ ├── jemalloc.c
│ │ │ │ ├── jemalloc_cpp.cpp
│ │ │ │ ├── large.c
│ │ │ │ ├── malloc_io.c
│ │ │ │ ├── mutex.c
│ │ │ │ ├── mutex_pool.c
│ │ │ │ ├── nstime.c
│ │ │ │ ├── pages.c
│ │ │ │ ├── prng.c
│ │ │ │ ├── prof.c
│ │ │ │ ├── rtree.c
│ │ │ │ ├── spin.c
│ │ │ │ ├── stats.c
│ │ │ │ ├── sz.c
│ │ │ │ ├── tcache.c
│ │ │ │ ├── ticker.c
│ │ │ │ ├── tsd.c
│ │ │ │ ├── witness.c
│ │ │ │ └── zone.c
│ │ │ └── test/
│ │ │ ├── include/
│ │ │ │ └── test/
│ │ │ │ ├── SFMT-alti.h
│ │ │ │ ├── SFMT-params.h
│ │ │ │ ├── SFMT-params11213.h
│ │ │ │ ├── SFMT-params1279.h
│ │ │ │ ├── SFMT-params132049.h
│ │ │ │ ├── SFMT-params19937.h
│ │ │ │ ├── SFMT-params216091.h
│ │ │ │ ├── SFMT-params2281.h
│ │ │ │ ├── SFMT-params4253.h
│ │ │ │ ├── SFMT-params44497.h
│ │ │ │ ├── SFMT-params607.h
│ │ │ │ ├── SFMT-params86243.h
│ │ │ │ ├── SFMT-sse2.h
│ │ │ │ ├── SFMT.h
│ │ │ │ ├── btalloc.h
│ │ │ │ ├── extent_hooks.h
│ │ │ │ ├── jemalloc_test.h.in
│ │ │ │ ├── jemalloc_test_defs.h.in
│ │ │ │ ├── math.h
│ │ │ │ ├── mq.h
│ │ │ │ ├── mtx.h
│ │ │ │ ├── test.h
│ │ │ │ ├── thd.h
│ │ │ │ └── timer.h
│ │ │ ├── integration/
│ │ │ │ ├── MALLOCX_ARENA.c
│ │ │ │ ├── aligned_alloc.c
│ │ │ │ ├── allocated.c
│ │ │ │ ├── extent.c
│ │ │ │ ├── extent.sh
│ │ │ │ ├── mallocx.c
│ │ │ │ ├── mallocx.sh
│ │ │ │ ├── overflow.c
│ │ │ │ ├── posix_memalign.c
│ │ │ │ ├── rallocx.c
│ │ │ │ ├── sdallocx.c
│ │ │ │ ├── thread_arena.c
│ │ │ │ ├── thread_tcache_enabled.c
│ │ │ │ ├── xallocx.c
│ │ │ │ └── xallocx.sh
│ │ │ ├── src/
│ │ │ │ ├── SFMT.c
│ │ │ │ ├── btalloc.c
│ │ │ │ ├── btalloc_0.c
│ │ │ │ ├── btalloc_1.c
│ │ │ │ ├── math.c
│ │ │ │ ├── mq.c
│ │ │ │ ├── mtx.c
│ │ │ │ ├── test.c
│ │ │ │ ├── thd.c
│ │ │ │ └── timer.c
│ │ │ ├── stress/
│ │ │ │ └── microbench.c
│ │ │ ├── test.sh.in
│ │ │ └── unit/
│ │ │ ├── SFMT.c
│ │ │ ├── a0.c
│ │ │ ├── arena_reset.c
│ │ │ ├── arena_reset_prof.c
│ │ │ ├── arena_reset_prof.sh
│ │ │ ├── atomic.c
│ │ │ ├── background_thread.c
│ │ │ ├── base.c
│ │ │ ├── bit_util.c
│ │ │ ├── bitmap.c
│ │ │ ├── ckh.c
│ │ │ ├── decay.c
│ │ │ ├── decay.sh
│ │ │ ├── extent_quantize.c
│ │ │ ├── fork.c
│ │ │ ├── hash.c
│ │ │ ├── hooks.c
│ │ │ ├── junk.c
│ │ │ ├── junk.sh
│ │ │ ├── junk_alloc.c
│ │ │ ├── junk_alloc.sh
│ │ │ ├── junk_free.c
│ │ │ ├── junk_free.sh
│ │ │ ├── mallctl.c
│ │ │ ├── malloc_io.c
│ │ │ ├── math.c
│ │ │ ├── mq.c
│ │ │ ├── mtx.c
│ │ │ ├── nstime.c
│ │ │ ├── pack.c
│ │ │ ├── pack.sh
│ │ │ ├── pages.c
│ │ │ ├── ph.c
│ │ │ ├── prng.c
│ │ │ ├── prof_accum.c
│ │ │ ├── prof_accum.sh
│ │ │ ├── prof_active.c
│ │ │ ├── prof_active.sh
│ │ │ ├── prof_gdump.c
│ │ │ ├── prof_gdump.sh
│ │ │ ├── prof_idump.c
│ │ │ ├── prof_idump.sh
│ │ │ ├── prof_reset.c
│ │ │ ├── prof_reset.sh
│ │ │ ├── prof_tctx.c
│ │ │ ├── prof_tctx.sh
│ │ │ ├── prof_thread_name.c
│ │ │ ├── prof_thread_name.sh
│ │ │ ├── ql.c
│ │ │ ├── qr.c
│ │ │ ├── rb.c
│ │ │ ├── retained.c
│ │ │ ├── rtree.c
│ │ │ ├── size_classes.c
│ │ │ ├── slab.c
│ │ │ ├── smoothstep.c
│ │ │ ├── spin.c
│ │ │ ├── stats.c
│ │ │ ├── stats_print.c
│ │ │ ├── ticker.c
│ │ │ ├── tsd.c
│ │ │ ├── witness.c
│ │ │ ├── zero.c
│ │ │ └── zero.sh
│ │ ├── m4/
│ │ │ ├── ax_cxx_compile_stdcxx.m4
│ │ │ ├── ax_cxx_compile_stdcxx_11.m4
│ │ │ └── ax_pthread.m4
│ │ ├── make_rpm.mk
│ │ ├── man/
│ │ │ ├── autohbw.7
│ │ │ ├── hbwallocator.3
│ │ │ ├── hbwmalloc.3
│ │ │ ├── memkind-hbw-nodes.1
│ │ │ ├── memkind.3
│ │ │ ├── memkind_arena.3
│ │ │ ├── memkind_default.3
│ │ │ ├── memkind_hbw.3
│ │ │ ├── memkind_hugetlb.3
│ │ │ ├── memkind_interleave.3
│ │ │ ├── memkind_pmem.3
│ │ │ └── pmemallocator.3
│ │ ├── memkind.spec.mk
│ │ ├── src/
│ │ │ ├── Makefile.mk
│ │ │ ├── hbwmalloc.c
│ │ │ ├── heap_manager.c
│ │ │ ├── memkind-hbw-nodes.c
│ │ │ ├── memkind.c
│ │ │ ├── memkind_arena.c
│ │ │ ├── memkind_default.c
│ │ │ ├── memkind_gbtlb.c
│ │ │ ├── memkind_hbw.c
│ │ │ ├── memkind_hugetlb.c
│ │ │ ├── memkind_interleave.c
│ │ │ ├── memkind_log.c
│ │ │ ├── memkind_pmem.c
│ │ │ ├── memkind_regular.c
│ │ │ └── tbb_wrapper.c
│ │ └── test/
│ │ ├── Allocator.hpp
│ │ ├── Makefile.mk
│ │ ├── README
│ │ ├── TestPolicy.hpp
│ │ ├── alloc_benchmark.c
│ │ ├── alloc_performance_tests.cpp
│ │ ├── allocate_to_max_stress_test.cpp
│ │ ├── allocator_perf_tool/
│ │ │ ├── AllocationSizes.hpp
│ │ │ ├── Allocation_info.cpp
│ │ │ ├── Allocation_info.hpp
│ │ │ ├── Allocator.hpp
│ │ │ ├── AllocatorFactory.hpp
│ │ │ ├── CSVLogger.hpp
│ │ │ ├── CommandLine.hpp
│ │ │ ├── Configuration.hpp
│ │ │ ├── ConsoleLog.hpp
│ │ │ ├── FunctionCalls.hpp
│ │ │ ├── FunctionCallsPerformanceTask.cpp
│ │ │ ├── FunctionCallsPerformanceTask.h
│ │ │ ├── GTestAdapter.hpp
│ │ │ ├── HBWmallocAllocatorWithTimer.hpp
│ │ │ ├── HugePageOrganizer.hpp
│ │ │ ├── HugePageUnmap.hpp
│ │ │ ├── Iterator.hpp
│ │ │ ├── JemallocAllocatorWithTimer.hpp
│ │ │ ├── Makefile
│ │ │ ├── MemkindAllocatorWithTimer.hpp
│ │ │ ├── Numastat.hpp
│ │ │ ├── PmemMockup.cpp
│ │ │ ├── PmemMockup.hpp
│ │ │ ├── Runnable.hpp
│ │ │ ├── ScenarioWorkload.cpp
│ │ │ ├── ScenarioWorkload.h
│ │ │ ├── StandardAllocatorWithTimer.hpp
│ │ │ ├── Stats.hpp
│ │ │ ├── StressIncreaseToMax.cpp
│ │ │ ├── StressIncreaseToMax.h
│ │ │ ├── Task.hpp
│ │ │ ├── TaskFactory.hpp
│ │ │ ├── Tests.hpp
│ │ │ ├── Thread.hpp
│ │ │ ├── TimerSysTime.hpp
│ │ │ ├── VectorIterator.hpp
│ │ │ ├── Workload.hpp
│ │ │ ├── WrappersMacros.hpp
│ │ │ └── main.cpp
│ │ ├── autohbw_test.py
│ │ ├── autohbw_test_helper.c
│ │ ├── bat_tests.cpp
│ │ ├── check.cpp
│ │ ├── check.h
│ │ ├── common.h
│ │ ├── decorator_test.cpp
│ │ ├── decorator_test.h
│ │ ├── dlopen_test.cpp
│ │ ├── draw_plots.py
│ │ ├── environ_err_hbw_malloc_test.cpp
│ │ ├── error_message_tests.cpp
│ │ ├── freeing_memory_segfault_test.cpp
│ │ ├── gb_page_tests_bind_policy.cpp
│ │ ├── get_arena_test.cpp
│ │ ├── gtest_fused/
│ │ │ └── gtest/
│ │ │ ├── gtest-all.cc
│ │ │ └── gtest.h
│ │ ├── hbw_allocator_tests.cpp
│ │ ├── hbw_detection_test.py
│ │ ├── hbw_verify_function_test.cpp
│ │ ├── heap_manager_init_perf_test.cpp
│ │ ├── huge_page_test.cpp
│ │ ├── load_tbbmalloc_symbols.c
│ │ ├── locality_test.cpp
│ │ ├── main.cpp
│ │ ├── memkind-afts-ext.ts
│ │ ├── memkind-afts.ts
│ │ ├── memkind-perf-ext.ts
│ │ ├── memkind-perf.ts
│ │ ├── memkind-pytests.ts
│ │ ├── memkind-slts.ts
│ │ ├── memkind_pmem_long_time_tests.cpp
│ │ ├── memkind_pmem_tests.cpp
│ │ ├── memkind_versioning_tests.cpp
│ │ ├── memory_footprint_test.cpp
│ │ ├── memory_manager.h
│ │ ├── multithreaded_tests.cpp
│ │ ├── negative_tests.cpp
│ │ ├── performance/
│ │ │ ├── framework.cpp
│ │ │ ├── framework.hpp
│ │ │ ├── operations.hpp
│ │ │ ├── perf_tests.cpp
│ │ │ └── perf_tests.hpp
│ │ ├── pmem_allocator_tests.cpp
│ │ ├── proc_stat.h
│ │ ├── python_framework/
│ │ │ ├── __init__.py
│ │ │ ├── cmd_helper.py
│ │ │ └── huge_page_organizer.py
│ │ ├── random_sizes_allocator.h
│ │ ├── run_alloc_benchmark.sh
│ │ ├── static_kinds_list.h
│ │ ├── static_kinds_tests.cpp
│ │ ├── tbbmalloc.h
│ │ ├── test.sh
│ │ ├── trace_mechanism_test.py
│ │ ├── trace_mechanism_test_helper.c
│ │ ├── trial_generator.cpp
│ │ └── trial_generator.h
│ └── update-jemalloc.sh
├── fuzz/
│ └── rdb/
│ ├── dict.txt
│ └── testcases/
│ ├── empty.rdb
│ ├── expire.rdb
│ ├── expireonload.rdb
│ ├── integer.rdb
│ ├── integer_shared.rdb
│ ├── multidb.rdb
│ ├── replica.rdb
│ ├── set.rdb
│ └── string.rdb
├── keydb.conf
├── machamp_scripts/
│ ├── Dockerfile
│ └── build.sh
├── monkey/
│ └── monkey.py
├── pkg/
│ ├── README.md
│ ├── deb/
│ │ ├── README.md
│ │ ├── conf/
│ │ │ ├── keydb.conf
│ │ │ └── sentinel.conf
│ │ ├── deb-buildsource.sh
│ │ ├── deb_files_generated/
│ │ │ └── .gitkeep
│ │ ├── debian/
│ │ │ ├── bash_completion.d/
│ │ │ │ └── keydb-cli
│ │ │ ├── bin/
│ │ │ │ └── generate-systemd-service-files
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ ├── copyright
│ │ │ ├── keydb-benchmark.1
│ │ │ ├── keydb-check-aof.1
│ │ │ ├── keydb-check-rdb.1
│ │ │ ├── keydb-cli.1
│ │ │ ├── keydb-sentinel.1
│ │ │ ├── keydb-sentinel.install
│ │ │ ├── keydb-sentinel.logrotate
│ │ │ ├── keydb-sentinel.manpages
│ │ │ ├── keydb-sentinel.postinst
│ │ │ ├── keydb-sentinel.postrm
│ │ │ ├── keydb-server.1
│ │ │ ├── keydb-server.docs
│ │ │ ├── keydb-server.install
│ │ │ ├── keydb-server.logrotate
│ │ │ ├── keydb-server.manpages
│ │ │ ├── keydb-server.postinst
│ │ │ ├── keydb-server.postrm
│ │ │ ├── keydb-tools.examples
│ │ │ ├── keydb-tools.install
│ │ │ ├── keydb-tools.manpages
│ │ │ ├── keydb-tools.postinst
│ │ │ ├── keydb-tools.postrm
│ │ │ ├── rules
│ │ │ ├── source/
│ │ │ │ ├── format
│ │ │ │ └── lintian-overrides
│ │ │ ├── tests/
│ │ │ │ ├── 0001-keydb-cli
│ │ │ │ ├── 0002-benchmark
│ │ │ │ ├── 0003-keydb-check-aof
│ │ │ │ ├── 0004-keydb-check-rdb
│ │ │ │ └── control
│ │ │ ├── watch
│ │ │ └── zsh-completion/
│ │ │ └── _keydb-cli
│ │ ├── debian_dh9/
│ │ │ ├── NEWS
│ │ │ ├── bash_completion.d/
│ │ │ │ └── keydb-cli
│ │ │ ├── bin/
│ │ │ │ └── generate-systemd-service-files
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ ├── copyright
│ │ │ ├── files
│ │ │ ├── gbp.conf
│ │ │ ├── keydb-benchmark.1
│ │ │ ├── keydb-check-aof.1
│ │ │ ├── keydb-check-rdb.1
│ │ │ ├── keydb-cli.1
│ │ │ ├── keydb-sentinel.1
│ │ │ ├── keydb-sentinel.default
│ │ │ ├── keydb-sentinel.init
│ │ │ ├── keydb-sentinel.install
│ │ │ ├── keydb-sentinel.logrotate
│ │ │ ├── keydb-sentinel.maintscript
│ │ │ ├── keydb-sentinel.manpages
│ │ │ ├── keydb-sentinel.postinst
│ │ │ ├── keydb-sentinel.postrm
│ │ │ ├── keydb-server.1
│ │ │ ├── keydb-server.default
│ │ │ ├── keydb-server.docs
│ │ │ ├── keydb-server.init
│ │ │ ├── keydb-server.install
│ │ │ ├── keydb-server.logrotate
│ │ │ ├── keydb-server.maintscript
│ │ │ ├── keydb-server.manpages
│ │ │ ├── keydb-server.postinst
│ │ │ ├── keydb-server.postrm
│ │ │ ├── keydb-tools.examples
│ │ │ ├── keydb-tools.install
│ │ │ ├── keydb-tools.manpages
│ │ │ ├── keydb-tools.postinst
│ │ │ ├── keydb-tools.postrm
│ │ │ ├── patches/
│ │ │ │ ├── 0001-fix-ftbfs-on-kfreebsd.patch
│ │ │ │ ├── 0010-Use-get_current_dir_name-over-PATHMAX-etc.patch
│ │ │ │ ├── 0011-Add-support-for-a-USE_SYSTEM_LUA-flag.patch
│ │ │ │ ├── debian-packaging/
│ │ │ │ │ ├── 0003-dpkg-buildflags.patch
│ │ │ │ │ └── 0007-Set-Debian-configuration-defaults.patch
│ │ │ │ ├── series
│ │ │ │ └── test
│ │ │ ├── rules
│ │ │ ├── source/
│ │ │ │ ├── format
│ │ │ │ ├── include-binaries
│ │ │ │ ├── lintian-overrides
│ │ │ │ └── options
│ │ │ ├── tests/
│ │ │ │ ├── 0001-keydb-cli
│ │ │ │ ├── 0002-benchmark
│ │ │ │ ├── 0003-keydb-check-aof
│ │ │ │ ├── 0004-keydb-check-rdb
│ │ │ │ └── control
│ │ │ └── watch
│ │ └── master_changelog
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile_Alpine
│ │ └── README.md
│ └── rpm/
│ ├── README.md
│ ├── generate_rpms.sh
│ ├── keydb_build/
│ │ ├── keydb.spec
│ │ └── keydb_rpm/
│ │ ├── etc/
│ │ │ ├── keydb/
│ │ │ │ ├── keydb.conf
│ │ │ │ └── sentinel.conf
│ │ │ ├── logrotate.d/
│ │ │ │ └── keydb
│ │ │ └── systemd/
│ │ │ └── system/
│ │ │ ├── keydb-sentinel.service.d/
│ │ │ │ └── limit.conf
│ │ │ └── keydb.service.d/
│ │ │ └── limit.conf
│ │ └── usr/
│ │ ├── lib/
│ │ │ └── systemd/
│ │ │ └── system/
│ │ │ ├── keydb-sentinel.service
│ │ │ └── keydb.service
│ │ ├── libexec/
│ │ │ └── keydb-shutdown
│ │ └── share/
│ │ └── licenses/
│ │ └── keydb/
│ │ ├── COPYING
│ │ ├── COPYING-hiredis
│ │ ├── COPYING-jemalloc
│ │ └── COPYRIGHT-lua
│ └── rpm_files_generated/
│ └── .gitkeep
├── runtest
├── runtest-cluster
├── runtest-moduleapi
├── runtest-rotation
├── runtest-sentinel
├── sentinel.conf
├── src/
│ ├── .gitignore
│ ├── AsyncWorkQueue.cpp
│ ├── AsyncWorkQueue.h
│ ├── IStorage.h
│ ├── Makefile
│ ├── SnapshotPayloadParseState.cpp
│ ├── SnapshotPayloadParseState.h
│ ├── StorageCache.cpp
│ ├── StorageCache.h
│ ├── acl.cpp
│ ├── adlist.c
│ ├── adlist.h
│ ├── ae.cpp
│ ├── ae.h
│ ├── ae_epoll.cpp
│ ├── ae_evport.c
│ ├── ae_kqueue.c
│ ├── ae_select.c
│ ├── aelocker.h
│ ├── anet.c
│ ├── anet.h
│ ├── aof.cpp
│ ├── asciilogo.h
│ ├── atomicvar.h
│ ├── bio.cpp
│ ├── bio.h
│ ├── bitops.cpp
│ ├── blocked.cpp
│ ├── childinfo.cpp
│ ├── cli_common.c
│ ├── cli_common.h
│ ├── cluster.cpp
│ ├── cluster.h
│ ├── compactvector.h
│ ├── config.cpp
│ ├── config.h
│ ├── connection.cpp
│ ├── connection.h
│ ├── connhelpers.h
│ ├── cowptr.h
│ ├── crc16.c
│ ├── crc16_slottable.h
│ ├── crc64.c
│ ├── crc64.h
│ ├── crcspeed.c
│ ├── crcspeed.h
│ ├── cron.cpp
│ ├── cron.h
│ ├── db.cpp
│ ├── debug.cpp
│ ├── debugmacro.h
│ ├── defrag.cpp
│ ├── dict.cpp
│ ├── dict.h
│ ├── endianconv.c
│ ├── endianconv.h
│ ├── evict.cpp
│ ├── expire.cpp
│ ├── expire.h
│ ├── fastlock.cpp
│ ├── fastlock.h
│ ├── fastlock_x64.asm
│ ├── fmacros.h
│ ├── gc.h
│ ├── geo.cpp
│ ├── geo.h
│ ├── geohash.c
│ ├── geohash.h
│ ├── geohash_helper.cpp
│ ├── geohash_helper.h
│ ├── help.h
│ ├── hyperloglog.cpp
│ ├── intset.c
│ ├── intset.h
│ ├── keydb-diagnostic-tool.cpp
│ ├── keydbutils.cpp
│ ├── latency.cpp
│ ├── latency.h
│ ├── lazyfree.cpp
│ ├── listpack.c
│ ├── listpack.h
│ ├── listpack_malloc.h
│ ├── localtime.c
│ ├── lolwut.c
│ ├── lolwut.h
│ ├── lolwut5.c
│ ├── lolwut6.c
│ ├── lzf.h
│ ├── lzfP.h
│ ├── lzf_c.c
│ ├── lzf_d.c
│ ├── meminfo.cpp
│ ├── memtest.c
│ ├── mkreleasehdr.sh
│ ├── module.cpp
│ ├── modules/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── gendoc.rb
│ │ ├── helloacl.c
│ │ ├── helloblock.c
│ │ ├── hellocluster.c
│ │ ├── hellodict.c
│ │ ├── hellohook.c
│ │ ├── hellotimer.c
│ │ ├── hellotype.c
│ │ ├── helloworld.c
│ │ └── keydb_modstatsd/
│ │ ├── Makefile
│ │ ├── modmain.cpp
│ │ └── redismodule.h
│ ├── monotonic.c
│ ├── monotonic.h
│ ├── motd.cpp
│ ├── motd.h
│ ├── mt19937-64.c
│ ├── mt19937-64.h
│ ├── multi.cpp
│ ├── networking.cpp
│ ├── new.cpp
│ ├── new.h
│ ├── notify.cpp
│ ├── object.cpp
│ ├── pqsort.c
│ ├── pqsort.h
│ ├── pubsub.cpp
│ ├── quicklist.c
│ ├── quicklist.h
│ ├── rand.c
│ ├── rand.h
│ ├── rax.c
│ ├── rax.h
│ ├── rax_malloc.h
│ ├── rdb-s3.cpp
│ ├── rdb.cpp
│ ├── rdb.h
│ ├── readwritelock.h
│ ├── redis-benchmark.cpp
│ ├── redis-check-aof.cpp
│ ├── redis-check-rdb.cpp
│ ├── redis-cli-cpphelper.cpp
│ ├── redis-cli.c
│ ├── redis-cli.h
│ ├── redis-trib.rb
│ ├── redisassert.h
│ ├── redismodule.h
│ ├── release.c
│ ├── replication.cpp
│ ├── rio.cpp
│ ├── rio.h
│ ├── scripting.cpp
│ ├── sds.c
│ ├── sds.h
│ ├── sdsalloc.h
│ ├── sdscompat.h
│ ├── semiorderedset.h
│ ├── sentinel.cpp
│ ├── server.cpp
│ ├── server.h
│ ├── serverassert.h
│ ├── setcpuaffinity.c
│ ├── setproctitle.c
│ ├── sha1.c
│ ├── sha1.h
│ ├── sha256.c
│ ├── sha256.h
│ ├── siphash.c
│ ├── slowlog.cpp
│ ├── slowlog.h
│ ├── snapshot.cpp
│ ├── solarisfixes.h
│ ├── sort.cpp
│ ├── sparkline.cpp
│ ├── sparkline.h
│ ├── storage/
│ │ ├── rocksdb.cpp
│ │ ├── rocksdb.h
│ │ ├── rocksdbfactor_internal.h
│ │ ├── rocksdbfactory.cpp
│ │ ├── rocksdbfactory.h
│ │ ├── teststorageprovider.cpp
│ │ └── teststorageprovider.h
│ ├── storage-lite.c
│ ├── storage.cpp
│ ├── storage.h
│ ├── stream.h
│ ├── syncio.cpp
│ ├── t_hash.cpp
│ ├── t_list.cpp
│ ├── t_nhash.cpp
│ ├── t_nhash.h
│ ├── t_set.cpp
│ ├── t_stream.cpp
│ ├── t_string.cpp
│ ├── t_zset.cpp
│ ├── testhelp.h
│ ├── timeout.cpp
│ ├── tls.cpp
│ ├── tracking.cpp
│ ├── util.c
│ ├── util.h
│ ├── uuid.h
│ ├── valgrind.sup
│ ├── version.h
│ ├── ziplist.c
│ ├── ziplist.h
│ ├── zipmap.c
│ ├── zipmap.h
│ ├── zmalloc.cpp
│ └── zmalloc.h
├── tests/
│ ├── assets/
│ │ ├── corrupt_empty_keys.rdb
│ │ ├── corrupt_ziplist.rdb
│ │ ├── default.conf
│ │ ├── encodings.rdb
│ │ ├── hash-zipmap.rdb
│ │ ├── minimal.conf
│ │ ├── nodefaultuser.acl
│ │ ├── redis-module-save.rdb
│ │ ├── redis-save.rdb
│ │ └── user.acl
│ ├── cluster/
│ │ ├── cluster.tcl
│ │ ├── run.tcl
│ │ ├── tests/
│ │ │ ├── 00-base.tcl
│ │ │ ├── 01-faildet.tcl
│ │ │ ├── 02-failover.tcl
│ │ │ ├── 03-failover-loop.tcl
│ │ │ ├── 04-resharding.tcl
│ │ │ ├── 05-slave-selection.tcl
│ │ │ ├── 06-slave-stop-cond.tcl
│ │ │ ├── 07-replica-migration.tcl
│ │ │ ├── 08-update-msg.tcl
│ │ │ ├── 09-pubsub.tcl
│ │ │ ├── 10-manual-failover.tcl
│ │ │ ├── 11-manual-takeover.tcl
│ │ │ ├── 12-replica-migration-2.tcl
│ │ │ ├── 12.1-replica-migration-3.tcl
│ │ │ ├── 13-no-failover-option.tcl
│ │ │ ├── 14-consistency-check.tcl
│ │ │ ├── 15-cluster-slots.tcl
│ │ │ ├── 16-transactions-on-replica.tcl
│ │ │ ├── 17-diskless-load-swapdb.tcl
│ │ │ ├── 18-info.tcl
│ │ │ ├── 19-cluster-nodes-slots.tcl
│ │ │ ├── 20-half-migrated-slot.tcl
│ │ │ ├── 21-many-slot-migration.tcl
│ │ │ ├── helpers/
│ │ │ │ └── onlydots.tcl
│ │ │ └── includes/
│ │ │ ├── init-tests.tcl
│ │ │ └── utils.tcl
│ │ └── tmp/
│ │ └── .gitignore
│ ├── helpers/
│ │ ├── bg_block_op.tcl
│ │ ├── bg_complex_data.tcl
│ │ ├── fake_redis_node.tcl
│ │ ├── gen_climbing_load.tcl
│ │ └── gen_write_load.tcl
│ ├── instances.tcl
│ ├── integration/
│ │ ├── aof-race.tcl
│ │ ├── aof.tcl
│ │ ├── block-repl.tcl
│ │ ├── convert-zipmap-hash-on-load.tcl
│ │ ├── corrupt-dump-fuzzer.tcl
│ │ ├── corrupt-dump.tcl
│ │ ├── failover.tcl
│ │ ├── keydb-benchmark.tcl
│ │ ├── keydb-cli.tcl
│ │ ├── logging.tcl
│ │ ├── multimaster-psync.tcl
│ │ ├── psync2-pingoff.tcl
│ │ ├── psync2-reg-multimaster.tcl
│ │ ├── psync2-reg.tcl
│ │ ├── psync2.tcl
│ │ ├── rdb-repl-tests
│ │ ├── rdb.tcl
│ │ ├── replication-2.tcl
│ │ ├── replication-3.tcl
│ │ ├── replication-4.tcl
│ │ ├── replication-active.tcl
│ │ ├── replication-fast.tcl
│ │ ├── replication-multimaster-connect.tcl
│ │ ├── replication-multimaster.tcl
│ │ ├── replication-psync-flash.tcl
│ │ ├── replication-psync-multimaster.tcl
│ │ ├── replication-psync.tcl
│ │ └── replication.tcl
│ ├── modules/
│ │ ├── Makefile
│ │ ├── auth.c
│ │ ├── basics.c
│ │ ├── blockedclient.c
│ │ ├── blockonbackground.c
│ │ ├── blockonkeys.c
│ │ ├── commandfilter.c
│ │ ├── datatype.c
│ │ ├── defragtest.c
│ │ ├── fork.c
│ │ ├── getkeys.c
│ │ ├── hash.c
│ │ ├── hooks.c
│ │ ├── infotest.c
│ │ ├── keyspace_events.c
│ │ ├── load.c
│ │ ├── misc.c
│ │ ├── propagate.c
│ │ ├── scan.c
│ │ ├── stream.c
│ │ ├── test_lazyfree.c
│ │ ├── testrdb.c
│ │ ├── timer.c
│ │ ├── timers.c
│ │ └── zset.c
│ ├── sentinel/
│ │ ├── run.tcl
│ │ ├── tests/
│ │ │ ├── 00-base.tcl
│ │ │ ├── 01-conf-update.tcl
│ │ │ ├── 02-slaves-reconf.tcl
│ │ │ ├── 03-runtime-reconf.tcl
│ │ │ ├── 04-slave-selection.tcl
│ │ │ ├── 05-manual.tcl
│ │ │ ├── 06-ckquorum.tcl
│ │ │ ├── 07-down-conditions.tcl
│ │ │ ├── 08-hostname-conf.tcl
│ │ │ ├── 09-acl-support.tcl
│ │ │ ├── 10-replica-priority.tcl
│ │ │ ├── helpers/
│ │ │ │ └── check_leaked_fds.tcl
│ │ │ └── includes/
│ │ │ ├── init-tests.tcl
│ │ │ ├── sentinel.conf
│ │ │ └── start-init-tests.tcl
│ │ └── tmp/
│ │ └── .gitignore
│ ├── support/
│ │ ├── benchmark.tcl
│ │ ├── cli.tcl
│ │ ├── cluster.tcl
│ │ ├── keydb.tcl
│ │ ├── server.tcl
│ │ ├── test.tcl
│ │ ├── tmpfile.tcl
│ │ └── util.tcl
│ ├── test_helper.tcl
│ └── unit/
│ ├── acl.tcl
│ ├── aofrw.tcl
│ ├── auth.tcl
│ ├── bitfield.tcl
│ ├── bitops.tcl
│ ├── cron.tcl
│ ├── dump.tcl
│ ├── expire.tcl
│ ├── flash.tcl
│ ├── flash.tcl.save
│ ├── geo.tcl
│ ├── hyperloglog.tcl
│ ├── info.tcl
│ ├── introspection-2.tcl
│ ├── introspection.tcl
│ ├── keyspace.tcl
│ ├── latency-monitor.tcl
│ ├── lazyfree.tcl
│ ├── limits.tcl
│ ├── loadsave.tcl
│ ├── maxmemory.tcl
│ ├── memefficiency.tcl
│ ├── moduleapi/
│ │ ├── auth.tcl
│ │ ├── basics.tcl
│ │ ├── blockedclient.tcl
│ │ ├── blockonbackground.tcl
│ │ ├── blockonkeys.tcl
│ │ ├── commandfilter.tcl
│ │ ├── datatype.tcl
│ │ ├── defrag.tcl
│ │ ├── fork.tcl
│ │ ├── getkeys.tcl
│ │ ├── hash.tcl
│ │ ├── hooks.tcl
│ │ ├── infotest.tcl
│ │ ├── keyspace_events.tcl
│ │ ├── load.tcl
│ │ ├── misc.tcl
│ │ ├── moduleloadsave.tcl
│ │ ├── propagate.tcl
│ │ ├── scan.tcl
│ │ ├── stream.tcl
│ │ ├── test_lazyfree.tcl
│ │ ├── testrdb.tcl
│ │ ├── timer.tcl
│ │ └── zset.tcl
│ ├── multi.tcl
│ ├── networking.tcl
│ ├── obuf-limits.tcl
│ ├── oom-score-adj.tcl
│ ├── other.tcl
│ ├── pause.tcl
│ ├── pendingquerybuf.tcl
│ ├── printver.tcl
│ ├── protocol.tcl
│ ├── pubsub.tcl
│ ├── quit.tcl
│ ├── replication.tcl
│ ├── rreplay.tcl
│ ├── scan.tcl
│ ├── scripting.tcl
│ ├── shutdown.tcl
│ ├── slowlog.tcl
│ ├── soft_shutdown.tcl
│ ├── sort.tcl
│ ├── tls-auditlog.tcl
│ ├── tls-name-validation.tcl
│ ├── tls-rotation.tcl
│ ├── tls.tcl
│ ├── tracking.tcl
│ ├── type/
│ │ ├── hash.tcl
│ │ ├── incr.tcl
│ │ ├── list-2.tcl
│ │ ├── list-3.tcl
│ │ ├── list-common.tcl
│ │ ├── list.tcl
│ │ ├── nestedhash.tcl
│ │ ├── set.tcl
│ │ ├── stream-cgroups.tcl
│ │ ├── stream.tcl
│ │ ├── string.tcl
│ │ └── zset.tcl
│ ├── violations.tcl
│ └── wait.tcl
└── utils/
├── build-static-symbols.tcl
├── cluster_fail_time.tcl
├── compare_config.sh
├── corrupt_rdb.c
├── create-cluster/
│ ├── .gitignore
│ ├── README
│ └── create-cluster
├── gen-test-certs.sh
├── generate-command-help.rb
├── graphs/
│ └── commits-over-time/
│ ├── README.md
│ └── genhtml.tcl
├── hashtable/
│ ├── README
│ └── rehashing.c
├── hyperloglog/
│ ├── .gitignore
│ ├── hll-err.rb
│ └── hll-gnuplot-graph.rb
├── install_server.sh
├── lru/
│ ├── README
│ ├── lfu-simulation.c
│ └── test-lru.rb
├── redis-copy.rb
├── redis-sha1.rb
├── redis_init_script
├── redis_init_script.tpl
├── releasetools/
│ ├── 01_create_tarball.sh
│ ├── 02_upload_tarball.sh
│ ├── 03_test_release.sh
│ ├── 04_release_hash.sh
│ └── changelog.tcl
├── speed-regression.tcl
├── srandmember/
│ ├── README.md
│ ├── showdist.rb
│ └── showfreq.rb
├── systemd-redis_multiple_servers@.service
├── systemd-redis_server.service
├── tracking_collisions.c
└── whatisdoing.sh
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Help us improve KeyDB by reporting a bug
title: '[BUG]'
labels: ''
assignees: ''
---
**Describe the bug**
A short description of the bug.
**To reproduce**
Steps to reproduce the behavior and/or a minimal code sample.
**Expected behavior**
A description of what you expected to happen.
**Additional information**
Any additional information that is relevant to the problem.
================================================
FILE: .github/ISSUE_TEMPLATE/crash_report.md
================================================
---
name: Crash report
about: Submit a crash report
title: '[CRASH]'
labels: ''
assignees: ''
---
**Crash report**
Paste the complete crash log between the quotes below. Please include a few lines from the log preceding the crash report to provide some context.
```
```
**Aditional information**
1. OS distribution and version
2. Steps to reproduce (if any)
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest a feature for KeyDB
title: '[NEW]'
labels: ''
assignees: ''
---
**The problem/use-case that the feature addresses**
A description of the problem that the feature will solve, or the use-case with which the feature will be used.
**Description of the feature**
A description of what you want to happen.
**Alternatives you've considered**
Any alternative solutions or features you've considered, including references to existing open and closed feature requests in this repository.
**Additional information**
Any additional information that is relevant to the feature request.
================================================
FILE: .github/ISSUE_TEMPLATE/other_stuff.md
================================================
---
name: Other
about: Can't find the right issue type? Use this one!
title: ''
labels: ''
assignees: ''
---
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on: [push, pull_request]
jobs:
test-ubuntu-latest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
- name: make
run: |
sudo apt-get update
sudo apt-get -y remove libzstd || true
sudo apt-get -y install uuid-dev libcurl4-openssl-dev libbz2-dev zlib1g-dev libsnappy-dev liblz4-dev libzstd-dev libgflags-dev
make BUILD_TLS=yes -j2 KEYDB_CFLAGS='-Werror' KEYDB_CXXFLAGS='-Werror'
- name: gen-cert
run: ./utils/gen-test-certs.sh
- name: test-tls
run: |
sudo apt-get -y install tcl tcl-tls
./runtest --clients 1 --verbose --tls --config server-threads 3
- name: cluster-test
run: |
./runtest-cluster --tls --config server-threads 3
- name: sentinel test
run: |
./runtest-sentinel
- name: module tests
run: |
./runtest-moduleapi
- name: rotation test
run: |
./runtest-rotation
build-ubuntu-old:
runs-on: ubuntu-20.04
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
- name: make -j2
run: |
sudo apt-get update
sudo apt-get -y remove libzstd || true
sudo apt-get -y install uuid-dev libcurl4-openssl-dev libbz2-dev zlib1g-dev libsnappy-dev liblz4-dev libzstd-dev libgflags-dev
make -j2
build-macos-latest:
runs-on: macos-latest
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
- name: make
run: make KEYDB_CFLAGS='-Werror' KEYDB_CXXFLAGS='-Werror' -j2
build-libc-malloc:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
submodules: recursive
- name: make
run: |
sudo apt-get update
sudo apt-get -y remove libzstd || true
sudo apt-get -y install uuid-dev libcurl4-openssl-dev libbz2-dev zlib1g-dev libsnappy-dev liblz4-dev libzstd-dev libgflags-dev
make KEYDB_CFLAGS='-Werror' KEYDB_CXXFLAGS='-Werror' MALLOC=libc -j2
================================================
FILE: .gitignore
================================================
.*.swp
core
*.o
*.xo
*.so
*.d
!**/bash_completion.d
!**/logrotate.d
!**/keydb.service.d
!**/keydb-sentinel.service.d
*.log
dump.rdb
src/keydb-server
**/bin/keydb-server
**/app/keydb-server
*.deb
*.rpm
src/keydb-cli
**/bin/keydb-cli
**/app/keydb-cli
src/keydb-sentinel
**/bin/keydb-sentinel
**/app/keydb-sentinel
redis-benchmark
keydb-benchmark
redis-check-aof
keydb-check-aof
redis-check-rdb
keydb-check-rdb
redis-check-dump
keydb-check-dump
keydb-diagnostic-tool
redis-cli
redis-sentinel
redis-server
doc-tools
release
misc/*
src/release.h
appendonly.aof
SHORT_TERM_TODO
release.h
src/transfer.sh
src/configs
redis.ds
src/keydb.conf
src/nodes.conf
deps/lua/src/lua
deps/lua/src/luac
deps/lua/src/liblua.a
tests/tls*/*
.make-*
.prerequisites
*.dSYM
Makefile.dep
.vscode/*
.idea/*
.ccls
.ccls-cache/*
compile_commands.json
keydb.code-workspace
================================================
FILE: .gitmodules
================================================
[submodule "deps/rocksdb"]
path = deps/rocksdb
url = https://github.com/facebook/rocksdb.git
[submodule "deps/depot_tools"]
path = deps/depot_tools
url = https://chromium.googlesource.com/chromium/tools/depot_tools.git
================================================
FILE: 00-RELEASENOTES
================================================
Redis 6.2 release notes
=======================
--------------------------------------------------------------------------------
Upgrade urgency levels:
LOW: No need to upgrade unless there are new features you want to use.
MODERATE: Program an upgrade of the server, but it's not urgent.
HIGH: There is a critical bug that may affect a subset of users. Upgrade!
CRITICAL: There is a critical bug affecting MOST USERS. Upgrade ASAP.
SECURITY: There are security fixes in the release.
--------------------------------------------------------------------------------
================================================================================
Redis 6.2.6 Released Mon Oct 4 12:00:00 IDT 2021
================================================================================
Upgrade urgency: SECURITY, contains fixes to security issues.
Security Fixes:
* (CVE-2021-41099) Integer to heap buffer overflow handling certain string
commands and network payloads, when proto-max-bulk-len is manually configured
to a non-default, very large value [reported by yiyuaner].
* (CVE-2021-32762) Integer to heap buffer overflow issue in redis-cli and
redis-sentinel parsing large multi-bulk replies on some older and less common
platforms [reported by Microsoft Vulnerability Research].
* (CVE-2021-32687) Integer to heap buffer overflow with intsets, when
set-max-intset-entries is manually configured to a non-default, very large
value [reported by Pawel Wieczorkiewicz, AWS].
* (CVE-2021-32675) Denial Of Service when processing RESP request payloads with
a large number of elements on many connections.
* (CVE-2021-32672) Random heap reading issue with Lua Debugger [reported by
Meir Shpilraien].
* (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded
data types, when configuring a large, non-default value for
hash-max-ziplist-entries, hash-max-ziplist-value, zset-max-ziplist-entries
or zset-max-ziplist-value [reported by sundb].
* (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when
configuring a non-default, large value for proto-max-bulk-len and
client-query-buffer-limit [reported by sundb].
* (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer
overflow [reported by Meir Shpilraien].
Bug fixes that involve behavior changes:
* GEO* STORE with empty source key deletes the destination key and return 0 (#9271)
Previously it would have returned an empty array like the non-STORE variant.
* PUBSUB NUMPAT replies with number of patterns rather than number of subscriptions (#9209)
This actually changed in 6.2.0 but was overlooked and omitted from the release notes.
Bug fixes that are only applicable to previous releases of Redis 6.2:
* Fix CLIENT PAUSE, used an old timeout from previous PAUSE (#9477)
* Fix CLIENT PAUSE in a replica would mess the replication offset (#9448)
* Add some missing error statistics in INFO errorstats (#9328)
Other bug fixes:
* Fix incorrect reply of COMMAND command key positions for MIGRATE command (#9455)
* Fix appendfsync to always guarantee fsync before reply, on MacOS and FreeBSD (kqueue) (#9416)
* Fix the wrong mis-detection of sync_file_range system call, affecting performance (#9371)
CLI tools:
* When redis-cli received ASK response, it didn't handle it (#8930)
Improvements:
* Add latency monitor sample when key is deleted via lazy expire (#9317)
* Sanitize corrupt payload improvements (#9321, #9399)
* Delete empty keys when loading RDB file or handling a RESTORE command (#9297, #9349)
================================================================================
Redis 6.2.5 Released Wed Jul 21 16:32:19 IDT 2021
================================================================================
Upgrade urgency: SECURITY, contains fixes to security issues that affect
authenticated client connections on 32-bit versions. MODERATE otherwise.
Fix integer overflow in BITFIELD on 32-bit versions (CVE-2021-32761).
An integer overflow bug in Redis version 2.2 or newer can be exploited using the
BITFIELD command to corrupt the heap and potentially result with remote code
execution.
Bug fixes that involve behavior changes:
* Change reply type for ZPOPMAX/MIN with count in RESP3 to nested array (#8981).
Was using a flat array like in RESP2 instead of a nested array like ZRANGE does.
* Fix reply type for HRANDFIELD and ZRANDMEMBER when key is missing (#9178).
Was using a null array instead of an empty array.
* Fix reply type for ZRANGESTORE when source key is missing (#9089).
Was using an empty array like ZRANGE instead of 0 (used in the STORE variant).
Bug fixes that are only applicable to previous releases of Redis 6.2:
* ZRANDMEMBER WITHSCORES with negative COUNT may return bad score (#9162)
* Fix crash after CLIENT UNPAUSE when threaded I/O config is enabled (#9041)
* Fix XTRIM or XADD with LIMIT may delete more entries than the limit (#9048)
* Fix build issue with OpenSSL 1.1.0 (#9233)
Other bug fixes:
* Fail EXEC command in case a watched key is expired (#9194)
* Fix SMOVE not to invalidate dest key (WATCH and tracking) when member already exists (#9244)
* Fix SINTERSTORE not to delete dest key when getting a wrong type error (#9032)
* Fix overflows on 32-bit versions in GETBIT, SETBIT, BITCOUNT, BITPOS, and BITFIELD (#9191)
* Improve MEMORY USAGE on stream keys (#9164)
* Set TCP keepalive on inbound cluster bus connections (#9230)
* Fix diskless replica loading to recover from RDB short read on module AUX data (#9199)
* Fix race in client side tracking (#9116)
* Fix ziplist length updates on big-endian platforms (#2080)
CLI tools:
* redis-cli cluster import command may issue wrong MIGRATE command, sending COPY instead of REPLACE (#8945)
* redis-cli --rdb fixes when using "-" to write to stdout (#9136, #9135)
* redis-cli support for RESP3 set type in CSV and RAW output (#7338)
Modules:
* Module API for getting current command name (#8792)
* Fix RM_StringTruncate when newlen is 0 (#3718)
* Fix CLIENT UNBLOCK crashing modules without timeout callback (#9167)
================================================================================
Redis 6.2.4 Released Tue June 1 12:00:00 IST 2021
================================================================================
Upgrade urgency: SECURITY, Contains fixes to security issues that affect
authenticated client connections. MODERATE otherwise.
Fix integer overflow in STRALGO LCS (CVE-2021-32625)
An integer overflow bug in Redis version 6.0 or newer can be exploited using the
STRALGO LCS command to corrupt the heap and potentially result with remote code
execution. This is a result of an incomplete fix by CVE-2021-29477.
Bug fixes that are only applicable to previous releases of Redis 6.2:
* Fix crash after a diskless replication fork child is terminated (#8991)
* Fix redis-benchmark crash on unsupported configs (#8916)
Other bug fixes:
* Fix crash in UNLINK on a stream key with deleted consumer groups (#8932)
* SINTERSTORE: Add missing keyspace del event when none of the sources exist (#8949)
* Sentinel: Fix CONFIG SET of empty string sentinel-user/sentinel-pass configs (#8958)
* Enforce client output buffer soft limit when no traffic (#8833)
Improvements:
* Hide AUTH passwords in MIGRATE command from slowlog (#8859)
================================================================================
Redis 6.2.3 Released Mon May 3 19:00:00 IST 2021
================================================================================
Upgrade urgency: SECURITY, Contains fixes to security issues that affect
authenticated client connections. LOW otherwise.
Integer overflow in STRALGO LCS command (CVE-2021-29477):
An integer overflow bug in Redis version 6.0 or newer could be exploited using
the STRALGO LCS command to corrupt the heap and potentially result in remote
code execution. The integer overflow bug exists in all versions of Redis
starting with 6.0.
Integer overflow in COPY command for large intsets (CVE-2021-29478):
An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and
potentially result with remote code execution. The vulnerability involves
changing the default set-max-intset-entries configuration value, creating a
large set key that consists of integer values and using the COPY command to
duplicate it. The integer overflow bug exists in all versions of Redis starting
with 2.6, where it could result with a corrupted RDB or DUMP payload, but not
exploited through COPY (which did not exist before 6.2).
Bug fixes that are only applicable to previous releases of Redis 6.2:
* Fix memory leak in moduleDefragGlobals (#8853)
* Fix memory leak when doing lazy freeing client tracking table (#8822)
* Block abusive replicas from sending command that could assert and crash redis (#8868)
Other bug fixes:
* Use a monotonic clock to check for Lua script timeout (#8812)
* redis-cli: Do not use unix socket when we got redirected in cluster mode (#8870)
Modules:
* Fix RM_GetClusterNodeInfo() to correctly populate master id (#8846)
================================================================================
Redis 6.2.2 Released Mon April 19 19:00:00 IST 2021
================================================================================
Upgrade urgency: HIGH, if you're using ACL and pub/sub, CONFIG REWRITE, or
suffering from performance regression. see below.
Bug fixes for regressions in previous releases of Redis 6.2:
* Fix BGSAVE, AOFRW, and replication slowdown due to child reporting CoW (#8645)
* Fix short busy loop when timer event is about to fire (#8764)
* Fix default user, overwritten and reset users losing pubsub channel permissions (#8723)
* Fix config rewrite with an empty `save` config resulsing in default `save` values (#8719)
* Fix not starting on alpine/libmusl without IPv6 (#8655)
* Fix issues with propagation and MULTI/EXEC in modules (#8617)
Several issues around nested calls and thread safe contexts
Bug fixes that are only applicable to previous releases of Redis 6.2:
* ACL Pub/Sub channels permission handling for save/load scenario (#8794)
* Fix early rejection of PUBLISH inside MULTI-EXEC transaction (#8534)
* Fix missing SLOWLOG records for blocked commands (#8632)
* Allow RESET command during busy scripts (#8629)
* Fix some error replies were not counted on stats (#8659)
Bug fixes:
* Add a timeout mechanism for replicas stuck in fullsync (#8762)
* Process HELLO command even if the default user has no permissions (#8633)
* Client issuing a long running script and using a pipeline, got disconnected (#8715)
* Fix script kill to work also on scripts that use `pcall` (#8661)
* Fix list-compress-depth may compress more node than required (#8311)
* Fix redis-cli handling of rediss:// URL scheme (#8705)
* Cluster: Skip unnecessary check which may prevent failure detection (#8585)
* Cluster: Fix hang manual failover when replica just started (#8651)
* Sentinel: Fix info-refresh time field before sentinel get first response (#8567)
* Sentinel: Fix possible crash on failed connection attempt (#8627)
* Systemd: Send the readiness notification when a replica is ready to accept connections (#8409)
Command behavior changes:
* ZADD: fix wrong reply when INCR used with GT/LT which blocked the update (#8717)
It was responding with the incremented value rather than nil
* XAUTOCLAIM: fix response to return the next available id as the cursor (#8725)
Previous behavior was retuning the last one which was already scanned
* XAUTOCLAIM: fix JUSTID to prevent incrementing delivery_count (#8724)
New config options:
* Add cluster-allow-replica-migration config option (#5285)
* Add replica-announced config option (#8653)
* Add support for plaintext clients in TLS cluster (#8587)
* Add support for reading encrypted keyfiles (#8644)
Improvements:
* Fix performance regression in BRPOP on Redis 6.0 (#8689)
* Avoid adding slowlog entries for config with sensitive data (#8584)
* Improve redis-cli non-binary safe string handling (#8566)
* Optimize CLUSTER SLOTS reply (#8541)
* Handle remaining fsync errors (#8419)
Info fields and introspection changes:
* Strip % sign from current_fork_perc info field (#8628)
* Fix RSS memory info on FreeBSD (#8620)
* Fix client_recent_max_input/output_buffer in 'INFO CLIENTS' when all clients drop (#8588)
* Fix invalid master_link_down_since_seconds in info replication (#8785)
Platform and deployment-related changes:
* Fix FreeBSD <12.x builds (#8603)
Modules:
* Add macros for RedisModule_log logging levels (#4246)
* Add RedisModule_GetAbsExpire / RedisModule_SetAbsExpire (#8564)
* Add a module type for key space notification (#8759)
* Set module eviction context flag only in masters (#8631)
* Fix unusable RedisModule_IsAOFClient API (#8596)
* Fix missing EXEC on modules propagation after failed EVAL execution (#8654)
* Fix edge-case when a module client is unblocked (#8618)
================================================================================
Redis 6.2.1 Released Mon Mar 1 17:51:36 IST 2021
================================================================================
Upgrade urgency: LOW.
Here is a comprehensive list of changes in this release compared to 6.2.0,
each one includes the PR number that added it, so you can get more details
at https://github.com/redis/redis/pull/<number>
Bug fixes:
* Fix sanitize-dump-payload for stream with deleted records (#8568)
* Prevent client-query-buffer-limit config from being set to lower than 1mb (#8557)
Improvements:
* Make port, tls-port and bind config options modifiable at runtime (#8510)
Platform and deployment-related changes:
* Fix compilation error on non-glibc systems if jemalloc is not used (#8533)
* Improved memory consumption and memory usage tracking on FreeBSD (#8545)
* Fix compilation on ARM64 MacOS with jemalloc (#8458)
Modules:
* New Module API for getting user name of a client (#8508)
* Optimize RM_Call by utilizing a shared reusable client (#8516)
* Fix crash running CLIENT INFO via RM_Call (#8560)
================================================================================
Redis 6.2.0 GA Released Tue Feb 22 14:00:00 IST 2021
================================================================================
Upgrade urgency: SECURITY if you use 32bit build of redis (see bellow), MODERATE
if you used earlier versions of Redis 6.2, LOW otherwise.
Integer overflow on 32-bit systems (CVE-2021-21309):
Redis 4.0 or newer uses a configurable limit for the maximum supported bulk
input size. By default, it is 512MB which is a safe value for all platforms.
If the limit is significantly increased, receiving a large request from a client
may trigger several integer overflow scenarios, which would result with buffer
overflow and heap corruption.
Here is a comprehensive list of changes in this release compared to 6.2 RC3,
each one includes the PR number that added it, so you can get more details
at https://github.com/redis/redis/pull/<number>
Bug fixes:
* Avoid 32-bit overflows when proto-max-bulk-len is set high (#8522)
* Fix broken protocol in client tracking tracking-redir-broken message (#8456)
* Avoid unsafe field name characters in INFO commandstats, errorstats, modules (#8492)
* XINFO able to access expired keys during CLIENT PAUSE WRITE (#8436)
* Fix allowed length for REPLCONF ip-address, needed due to Sentinel's support for hostnames (#8517)
* Fix broken protocol in redis-benchmark when used with -a or --dbnum (#8486)
* XADD counts deleted records too when considering switching to a new listpack (#8390)
Bug fixes that are only applicable to previous releases of Redis 6.2:
* Fixes in GEOSEARCH bybox (accuracy and mismatch between width and height) (#8445)
* Fix risk of OOM panic in HRANDFIELD, ZRANDMEMBER commands with huge negative count (#8429)
* Fix duplicate replicas issue in Sentinel, needed due to hostname support (#8481)
* Fix Sentinel configuration rewrite, an improvement of #8271 (#8480)
Command behavior changes:
* SRANDMEMBER uses RESP3 array type instead of set type (#8504)
* EXPIRE, EXPIREAT, SETEX, GETEX: Return error when provided expire time overflows (#8287)
Other behavior changes:
* Remove ACL subcommand validation if fully added command exists. (#8483)
Improvements:
* Optimize sorting in GEORADIUS / GEOSEARCH with COUNT (#8326)
* Optimize HRANDFIELD and ZRANDMEMBER case 4 when ziplist encoded (#8444)
* Optimize in-place replacement of elements in HSET, HINCRBY, LSET (#8493)
* Remove redundant list to store pubsub patterns (#8472)
* Add --insecure option to command line tools (#8416)
Info fields and introspection changes:
* Add INFO fields to track progress of BGSAVE, AOFRW, replication (#8414)
Modules:
* RM_ZsetRem: Delete key if empty, the bug could leave empty zset keys (#8453)
* RM_HashSet: Add COUNT_ALL flag and set errno (#8446)
================================================================================
Redis 6.2 RC3 Released Tue Feb 1 14:00:00 IST 2021
================================================================================
Upgrade urgency LOW: This is the third Release Candidate of Redis 6.2.
Here is a comprehensive list of changes in this release compared to 6.2 RC2,
each one includes the PR number that added it, so you can get more details
at https://github.com/redis/redis/pull/<number>
New commands / args:
* Add HRANDFIELD and ZRANDMEMBER commands (#8297)
* Add FAILOVER command (#8315)
* Add GETEX, GETDEL commands (#8327)
* Add PXAT/EXAT arguments to SET command (#8327)
* Add SYNC arg to FLUSHALL and FLUSHDB, and ASYNC/SYNC arg to SCRIPT FLUSH (#8258)
Sentinel:
* Add hostname support to Sentinel (#8282)
* Prevent file descriptors from leaking into Sentinel scripts (#8242)
* Fix config file line order dependency and config rewrite sequence (#8271)
New configuration options:
* Add set-proc-title config option to disable changes to the process title (#3623)
* Add proc-title-template option to control what's shown in the process title (#8397)
* Add lazyfree-lazy-user-flush config option to control FLUSHALL, FLUSHDB and SCRIPT FLUSH (#8258)
Bug fixes:
* AOF: recover from last write error by turning on/off appendonly config (#8030)
* Exit on fsync error when the AOF fsync policy is 'always' (#8347)
* Avoid assertions (on older kernels) when testing arm64 CoW bug (#8405)
* CONFIG REWRITE should honor umask settings (#8371)
* Fix firstkey,lastkey,step in COMMAND command for some commands (#8367)
Special considerations:
* Fix misleading description of the save configuration directive (#8337)
Improvements:
* A way to get RDB file via replication without excessive replication buffers (#8303)
* Optimize performance of clusterGenNodesDescription for large clusters (#8182)
Info fields and introspection changes:
* SLOWLOG and LATENCY monitor include unblocking time of blocked commands (#7491)
Modules:
* Add modules API for streams (#8288)
* Add event for fork child birth and termination (#8289)
* Add RM_BlockedClientMeasureTime* etc, to track background processing in commandstats (#7491)
* Fix bug in v6.2, wrong value passed to the new unlink callback (#8381)
* Fix bug in v6.2, modules blocked on keys unblock on commands like LPUSH (#8356)
================================================================================
Redis 6.2 RC2 Released Tue Jan 12 16:17:20 IST 2021
================================================================================
Upgrade urgency LOW: This is the second Release Candidate of Redis 6.2.
IMPORTANT: If you're running Redis on ARM64 or a big-endian system, upgrade may
have significant implications. Please be sure to read the notes below.
Here is a comprehensive list of changes in this release compared to 6.2 RC1,
each one includes the PR number that added it, so you can get more details
at https://github.com/redis/redis/pull/<number>
New commands / args:
* Add the REV, BYLEX and BYSCORE arguments to ZRANGE, and the ZRANGESTORE command (#7844)
* Add the XAUTOCLAIM command (#7973)
* Add the MINID trimming strategy and the LIMIT argument to XADD and XTRIM (#8169)
* Add the ANY argument to GEOSEARCH and GEORADIUS (#8259)
* Add the CH, NX, XX arguments to GEOADD (#8227)
* Add the COUNT argument to LPOP and RPOP (#8179)
* Add the WRITE argument to CLIENT PAUSE for pausing write commands exclusively (#8170)
* Change the proto-ver argument of HELLO to optional (#7377)
* Add the CLIENT TRACKINGINFO subcommand (#7309)
Command behavior changes:
* CLIENT TRACKING yields an error when given overlapping BCAST prefixes (#8176)
* SWAPDB invalidates WATCHed keys (#8239)
* SORT command behaves differently when used on a writable replica (#8283)
Other behavior changes:
* Avoid propagating MULTI/EXEC for read-only transactions (#8216)
* Remove the read-only flag from TIME, ECHO, ROLE, LASTSAVE (#8216)
* Fix the command flags of PFDEBUG (#8222)
* Tracking clients will no longer receive unnecessary key invalidation messages after FLUSHDB (#8039)
* Sentinel: Fix missing updates to the config file after SENTINEL SET command (#8229)
Bug fixes with compatibility implications (bugs introduced in Redis 6.0):
* Fix RDB CRC64 checksum on big-endian systems (#8270)
If you're using big-endian please consider the compatibility implications with
RESTORE, replication and persistence.
* Fix wrong order of key/value in Lua's map response (#8266)
If your scripts use redis.setresp() or return a map (new in Redis 6.0), please
consider the implications.
Bug fixes that are only applicable to previous releases of Redis 6.2:
* Resolve rare assertions in active defragmentation while loading (#8284, #8281)
Bug fixes:
* Fix the selection of a random element from large hash tables (#8133)
* Fix an issue where a forked process deletes the parent's pidfile (#8231)
* Fix crashes when enabling io-threads-do-reads (#8230)
* Fix a crash in redis-cli after executing cluster backup (#8267)
* Fix redis-benchmark to use an IP address for the first cluster node (#8154)
* Fix saving of strings larger than 2GB into RDB files (#8306)
Additional improvements:
* Improve replication handshake time (#8214)
* Release client tracking table memory asynchronously in cases where the DB is also freed asynchronously (#8039)
* Avoid wasteful transient memory allocation in certain cases (#8286, #5954)
* Handle binary string values by the 'requirepass' and 'masterauth' configs (#8200)
Platform and deployment-related changes:
* Install redis-check-rdb and redis-check-aof as symlinks to redis-server (#5745)
* Add a check for an ARM64 Linux kernel bug (#8224)
Due to the potential severity of this issue, Redis will refuse to run on
affected platforms by default.
Info fields and introspection changes:
* Add the errorstats section to the INFO command (#8217)
* Add the failed_calls and rejected_calls fields INFO's commandstats section (#8217)
* Report child copy-on-write metrics continuously (#8264)
Module API changes:
* Add the RedisModule_SendChildCOWInfo API (#8264)
* Add the may-replicate command flag (#8170)
================================================================================
Redis 6.2 RC1 Released Mon Dec 14 11:50:00 IST 2020
================================================================================
Upgrade urgency LOW: This is the first Release Candidate of Redis 6.2.
Introduction to the Redis 6.2 release
=====================================
This release is the first significant Redis release managed by the core team
under the new project governance model.
Redis 6.2 includes many new commands and improvements, but no big features. It
mainly makes Redis more complete and addresses issues that have been requested
by many users frequently or for a long time.
Many of these changes were not eligible for 6.0.x for several reasons:
1. They are not backward compatible, which is always the case with new or
extended commands (that cannot be replicated to an older replica).
2. They require a longer release-candidate test cycle.
Here is a comprehensive list of changes in this release compared to 6.0.9,
each one includes the PR number that added it, so you can get more details
at https://github.com/redis/redis/pull/<number>
New commands / args:
* Add SMISMEMBER command that checks multiple members (#7615)
* Add ZMSCORE command that returns an array of scores (#7593)
* Add LMOVE and BLMOVE commands that pop and push arbitrarily (#6929)
* Add RESET command that resets client connection state (#7982)
* Add COPY command that copies keys (#7953)
* Add ZDIFF and ZDIFFSTORE commands (#7961)
* Add ZINTER and ZUNION commands (#7794)
* Add GEOSEARCH/GEOSEARCHSTORE commands for bounding box spatial queries (#8094)
* Add GET parameter to SET command, for more powerful GETSET (#7852)
* Add exclusive range query to XPENDING (#8130)
* Add exclusive range query to X[REV]RANGE (#8072)
* Add GT and LT options to ZADD for conditional score updates (#7818)
* Add CLIENT INFO and CLIENT LIST for specific ids (#8113)
* Add IDLE argument to XPENDING command (#7972)
* Add local address to CLIENT LIST, and a CLIENT KILL filter. (#7913)
* Add NOMKSTREAM option to XADD command (#7910)
* Add command introspection to Sentinel (#7940)
* Add SENTINEL MYID subcommand (#7858)
New features:
* Dump payload sanitization: prevent corrupt payload causing crashes (#7807)
Has flags to enable full O(N) validation (disabled by default).
* ACL patterns for Pub/Sub channels (#7993)
* Support ACL for Sentinel mode (#7888)
* Support getting configuration from both stdin and file at the same time (#7893)
Lets you avoid storing secrets on the disk.
New features in CLI tools:
* redis-cli RESP3 push support (#7609)
* redis-cli cluster import support source and target that require auth (#7994)
* redis-cli URIs able to provide user name in addition to password (#8048)
* redis-cli/redis-benchmark allow specifying the prefered ciphers/ciphersuites (#8005)
* redis-cli add -e option to exit with code when command execution fails (#8136)
Command behavior changes:
* EXISTS should not alter LRU (#8016)
In Redis 5.0 and 6.0 it would have touched the LRU/LFU of the key.
* OBJECT should not reveal logically expired keys (#8016)
Will now behave the same TYPE or any other non-DEBUG command.
* Improve db id range check for SELECT and MOVE (#8085)
Changes the error message text on a wrong db index.
* Modify AUTH / HELLO error message (#7648)
Changes the error message text when the user isn't found or is disabled.
* BITOPS length limited to proto_max_bulk_len rather than 512MB (#8096)
The limit is now configurable like in SETRANGE, and APPEND.
* GEORADIUS[BYMEMBER] can fail with -OOM if Redis is over the memory limit (#8107)
Other behavior changes:
* Optionally (default) fail to start if requested bind address is not available (#7936)
If you rely on Redis starting successfully even if one of the bind addresses
is not available, you'll need to tune the new config.
* Limit the main db dictionaries expansion to prevent key eviction (#7954)
In the past big dictionary rehashing could result in massive data eviction.
Now this rehashing is delayed (up to a limit), which can result in performance
loss due to hash collisions.
* CONFIG REWRITE is atomic and safer, but requires write access to the config file's folder (#7824, #8051)
This change was already present in 6.0.9, but was missing from the release
notes.
* A new incremental eviction mechanism that reduces latency on eviction spikes (#7653)
In pathological cases this can cause memory to grow uncontrolled and may require
specific tuning.
* Not resetting "save" config when Redis is started with command line arguments. (#7092)
In case you provide command line arguments without "save" and count on it
being disabled, Now the defaults "save" config will kick in.
* Update memory metrics for INFO during loading (#7690)
* When "supervised" config is enabled, it takes precedence over "daemonize". (#8036)
* Assertion and panic, print crash log without generating SIGSEGV (#7585)
* Added crash log report on SIGABRT, instead of silently exiting (#8004)
* Disable THP (Transparent Huge Pages) if enabled (#7381)
If you deliberately enabled it, you'll need to config Redis to keep it.
Bug fixes:
* Handle output buffer limits for module blocked clients (#8141)
Could result in a module sending reply to a blocked client to go beyond the
limit.
* Fix setproctitle related crashes. (#8150, #8088)
Caused various crashes on startup, mainly on Apple M1 chips or under
instrumentation.
* A module doing RM_Call could cause replicas to get nested MULTI (#8097).
* Backup/restore cluster mode keys to slots map for repl-diskless-load=swapdb (#8108)
In cluster mode with repl-diskless-load, when loading failed, slot map
wouldn't have been restored.
* Fix oom-score-adj-values range, and bug when used in config file (#8046)
Enabling setting this in the config file in a line after enabling it, would
have been buggy.
* Reset average ttl when empty databases (#8106)
Just causing misleading metric in INFO
* Disable rehash when Redis has child process (#8007)
This could have caused excessive CoW during BGSAVE, replication or AOFRW.
* Further improved ACL algorithm for picking categories (#7966)
Output of ACL GETUSER is now more similar to the one provided by ACL SETUSER.
* Fix bug with module GIL being released prematurely (#8061)
Could in theory (and rarely) cause multi-threaded modules to corrupt memory.
* Fix cluster redirect for module command with no firstkey. (#7539)
* Reduce effect of client tracking causing feedback loop in key eviction (#8100)
* Kill disk-based fork child when all replicas drop and 'save' is not enabled (#7819)
* Rewritten commands (modified for propagation) are logged as their original command (#8006)
* Fix cluster access to unaligned memory (SIGBUS on old ARM) #7958
* If diskless repl child is killed, make sure to reap the child pid (#7742)
* Broadcast a PONG message when slot's migration is over, may reduce MOVED responses (#7571)
Other improvements:
* TLS Support in redis-benchmark (#7959)
* Accelerate diskless master connections, and general re-connections (#6271)
* Run active defrag while blocked / loading (#7726)
* Performance and memory reporting improvement - sds take control of its internal fragmentation (#7875)
* Speedup cluster failover. (#7948)
Platform / toolchain support related improvements:
* Optionally (not by default) use H/W Monotonic clock for faster time sampling (#7644)
* Remove the requirements for C11 and _Atomic supporting compiler (#7707)
This would allow to more easily build and use Redis on older systems and
compilers again.
* Fix crash log registers output on ARM. (#8020)
* Raspberry build fix. (#8095)
* Setting process title support for Haiku. (#8060)
* DragonFlyBSD RSS memory sampling support. (#8023)
New configuration options:
* Enable configuring OpenSSL using the standard openssl.cnf (#8143)
* oom-score-adj-values config can now take absolute values (besides relative ones) (#8046)
* TLS: Add different client cert support. (#8076)
* Note that a few other changes listed above added their config options.
Info fields and introspection changes:
* Add INFO fields to track diskless and disk-based replication progress (#7981)
* Add INFO field for main thread cpu time, and scrape system time. (#8132)
* Add total_forks to INFO STATS (#8155)
* Add maxclients and cluster_connections to INFO CLIENTS (#7979)
* Add tracking bcast flag and client redirection in client list (#7995)
* Fixed INFO client_recent_max_input_buffer includes argv array (#8065, see #7874)
* Note that a few other changes listed above added their info fields.
Module API changes:
* Add CTX_FLAGS_DENY_BLOCKING as a unified the way to know if blocking is allowed (#8025)
* Add data type callbacks for lazy free effort, and unlink (#7912)
* Add data type callback for COPY command (#8112)
* Add callbacks for defrag support. (#8149)
* Add module event for repl-diskless-load swapdb (#8153)
Module related fixes:
* Moved RMAPI_FUNC_SUPPORTED so that it's usable (#8037)
* Improve timer accuracy (#7987)
* Allow '\0' inside of result of RM_CreateStringPrintf (#6260)
Thanks to all the users and developers who made this release possible.
We'll follow up with more RC releases, until the code looks production ready
and we don't get reports of serious issues for a while.
A special thank you for the amount of work put into this release by:
- Oran Agra
- Yossi Gottlieb
- Viktor Söderqvist
- Yang Bodong
- Filipe Oliveira
- Guy Benoish
- Itamar Haber
- Madelyn Olson
- Wang Yuan
- Felipe Machado
- Wen Hui
- Tatsuya Arisawa
- Jonah H. Harris
- Raghav Muddur
- Jim Brunner
- Yaacov Hazan
- Allen Farris
- Chen Yang
- Nitai Caro
- sundb
- Meir Shpilraien
- maohuazhu
- Valentino Geron
- Zhao Zhao
- Qu Chen
- George Prekas
- Tyson Andre
- Uri Yagelnik
- Michael Grunder
- Huang Zw
- alexronke-channeladvisor
- Andy Pan
- Wu Yunlong
- Wei Kukey
- Yoav Steinberg
- Greg Femec
- Uri Shachar
- Nykolas Laurentino de Lima
- xhe
- zhenwei pi
- David CARLIER
Migrating from 6.0 to 6.2
=========================
Redis 6.2 is mostly a strict superset of 6.0, you should not have any problem
upgrading your application from 6.0 to 6.2. However there are some small changes
of behavior listed above, please make sure you are not badly affected by any of
them.
Specifically these sections:
* Command behavior changes
* Other behavior changes
--------------------------------------------------------------------------------
Cheers,
The Redis team
================================================
FILE: BUGS
================================================
Please check https://github.com/redis/redis/issues
================================================
FILE: CONDUCT
================================================
Contributor Covenant Code of Conduct
Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others’ private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
this email address: redis@redis.io.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
1. Correction
Community Impact: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
Consequence: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
2. Warning
Community Impact: A violation through a single incident or series
of actions.
Consequence: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
3. Temporary Ban
Community Impact: A serious violation of community standards, including
sustained inappropriate behavior.
Consequence: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
4. Permanent Ban
Community Impact: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
Consequence: A permanent ban from any sort of public interaction within
the community.
Attribution
This Code of Conduct is adapted from the Contributor Covenant,
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by Mozilla’s code of conduct
enforcement ladder.
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.
================================================
FILE: COPYING
================================================
Copyright (c) 2006-2020, Salvatore Sanfilippo
Copyright (C) 2019-2021, John Sully
Copyright (C) 2020-2021, EQ Alpha Technology Ltd.
Copyright (C) 2022 Snap Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Redis 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 OWNER 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: INSTALL
================================================
See README
================================================
FILE: Makefile
================================================
# Top level makefile, this just calls into src/Makefile where the real work is done. Changes should be made there.
default: all
.DEFAULT:
cd src && $(MAKE) $@
install:
cd src && $(MAKE) $@
.PHONY: install
================================================
FILE: README.md
================================================
[](https://stackshare.io/eq-alpha-technology-inc/eq-alpha-technology-inc)
##### KeyDB is now a part of Snap Inc! Check out the announcement [here](https://docs.keydb.dev/news/2022/05/12/keydb-joins-snap)
##### [Release v6.3.0](https://github.com/EQ-Alpha/KeyDB/releases/tag/v6.3.0) is here with major improvements as we consolidate our Open Source and Enterprise offerings into a single BSD-3 licensed project. See our [roadmap](https://docs.keydb.dev/docs/coming-soon) for details.
##### Want to extend KeyDB with Javascript? Try [ModJS](https://github.com/JohnSully/ModJS)
##### Need Help? Check out our extensive [documentation](https://docs.keydb.dev).
##### KeyDB is on Slack. Click [here](https://docs.keydb.dev/slack/) to learn more and join the KeyDB Community Slack workspace.
What is KeyDB?
--------------
KeyDB is a high performance fork of Redis with a focus on multithreading, memory efficiency, and high throughput. In addition to performance improvements, KeyDB offers features such as Active Replication, FLASH Storage and Subkey Expires. KeyDB has a MVCC architecture that allows you to execute queries such as KEYS and SCAN without blocking the database and degrading performance.
KeyDB maintains full compatibility with the Redis protocol, modules, and scripts. This includes the atomicity guarantees for scripts and transactions. Because KeyDB keeps in sync with Redis development KeyDB is a superset of Redis functionality, making KeyDB a drop in replacement for existing Redis deployments.
On the same hardware KeyDB can achieve significantly higher throughput than Redis. Active-Replication simplifies hot-spare failover allowing you to easily distribute writes over replicas and use simple TCP based load balancing/failover. KeyDB's higher performance allows you to do more on less hardware which reduces operation costs and complexity.
The chart below compares several KeyDB and Redis setups, including the latest Redis6 io-threads option, and TLS benchmarks.
<img src="https://docs.keydb.dev/img/blog/2020-09-15/ops_comparison.png"/>
See the full benchmark results and setup information here: https://docs.keydb.dev/blog/2020/09/29/blog-post/
Why fork Redis?
---------------
KeyDB has a different philosophy on how the codebase should evolve. We feel that ease of use, high performance, and a "batteries included" approach is the best way to create a good user experience. While we have great respect for the Redis maintainers it is our opinion that the Redis approach focuses too much on simplicity of the code base at the expense of complexity for the user. This results in the need for external components and workarounds to solve common problems - resulting in more complexity overall.
Because of this difference of opinion features which are right for KeyDB may not be appropriate for Redis. A fork allows us to explore this new development path and implement features which may never be a part of Redis. KeyDB keeps in sync with upstream Redis changes, and where applicable we upstream bug fixes and changes. It is our hope that the two projects can continue to grow and learn from each other.
Project Support
-------------------
The KeyDB team maintains this project as part of Snap Inc. KeyDB is used by Snap as part of its caching infrastructure and is fully open sourced. There is no separate commercial product and no paid support options available. We really value collaborating with the open source community and welcome PRs, bug reports, and open discussion. For community support or to get involved further with the project check out our community support options [here](https://docs.keydb.dev/docs/support) (slack, forum, meetup, github issues). Our team monitors these channels regularly.
Additional Resources
--------------------
Try the KeyDB [Docker Image](https://hub.docker.com/r/eqalpha/keydb)
Join us on [Slack](https://docs.keydb.dev/slack/)
Learn more using KeyDB's extensive [documentation](https://docs.keydb.dev)
See the [KeyDB Roadmap](https://docs.keydb.dev/docs/coming-soon) to see what's in store
Benchmarking KeyDB
------------------
Please note keydb-benchmark and redis-benchmark are currently single threaded and too slow to properly benchmark KeyDB. We recommend using a redis cluster benchmark tool such as [memtier](https://github.com/RedisLabs/memtier_benchmark). Please ensure your machine has enough cores for both KeyDB and memtier if testing locally. KeyDB expects exclusive use of any cores assigned to it.
New Configuration Options
-------------------------
With new features comes new options. All other configuration options behave as you'd expect. Your existing configuration files should continue to work unchanged.
```
server-threads N
server-thread-affinity [true/false]
```
The number of threads used to serve requests. This should be related to the number of queues available in your network hardware, *not* the number of cores on your
machine. Because KeyDB uses spinlocks to reduce latency; making this too high will reduce performance. We recommend using 4 here. By default this is set to two.
```
min-clients-per-thread 50
```
The minimum number of clients on a thread before KeyDB assigns new connections to a different thread. Tuning this parameter is a tradeoff between locking overhead and distributing the workload over multiple cores
```
replica-weighting-factor 2
```
KeyDB will attempt to balance clients across threads evenly; However, replica clients are usually much more expensive than a normal client, and so KeyDB will try to assign fewer clients to threads with a replica. The weighting factor below is intended to help tune this behavior. A replica weighting factor of 2 means we treat a replica as the equivalent of two normal clients. Adjusting this value may improve performance when replication is used. The best weighting is workload specific - e.g. read heavy workloads should set this to 1. Very write heavy workloads may benefit from higher numbers.
```
active-client-balancing yes
```
Should KeyDB make active attempts at balancing clients across threads? This can impact performance accepting new clients. By default this is enabled. If disabled there is still a best effort from the kernel to distribute across threads with SO_REUSEPORT but it will not be as fair. By default this is enabled
```
active-replica yes
```
If you are using active-active replication set `active-replica` option to “yes”. This will enable both instances to accept reads and writes while remaining synced. [Click here](https://docs.keydb.dev/docs/active-rep/) to see more on active-rep in our docs section. There are also [docker examples]( https://docs.keydb.dev/docs/docker-active-rep/) on docs.
```
multi-master-no-forward no
```
Avoid forwarding RREPLAY messages to other masters? WARNING: This setting is dangerous! You must be certain all masters are connected to eachother in a true mesh topology or data loss will occur! This command can be used to reduce multimaster bus traffic
```
db-s3-object /path/to/bucket
```
If you would like KeyDB to dump and load directly to AWS S3 this option specifies the bucket. Using this option with the traditional RDB options will result in KeyDB backing up twice to both locations. If both are specified KeyDB will first attempt to load from the local dump file and if that fails load from S3. This requires the AWS CLI tools to be installed and configured which are used under the hood to transfer the data.
```
storage-provider flash /path/to/flash
```
If you would like to use KeyDB FLASH storage, specify the storage medium followed by the directory path on your local SSD volume. Note that this feature is still considered experimental and should be used with discretion. See [FLASH Documentation](https://docs.keydb.dev/docs/flash) for more details on configuration and setting up your FLASH volume.
Building KeyDB
--------------
KeyDB can be compiled and is tested for use on Linux. KeyDB currently relies on SO_REUSEPORT's load balancing behavior which is available only in Linux. When we support marshalling connections across threads we plan to support other operating systems such as FreeBSD.
More on CentOS/Archlinux/Alpine/Debian/Ubuntu dependencies and builds can be found here: https://docs.keydb.dev/docs/build/
Init and clone submodule dependencies:
% git submodule init && git submodule update
Install dependencies:
% sudo apt install build-essential nasm autotools-dev autoconf libjemalloc-dev tcl tcl-dev uuid-dev libcurl4-openssl-dev libbz2-dev libzstd-dev liblz4-dev libsnappy-dev libssl-dev
Compiling is as simple as:
% make
To build with systemd support, you'll need systemd development libraries (such
as libsystemd-dev on Debian/Ubuntu or systemd-devel on CentOS) and run:
% make USE_SYSTEMD=yes
To append a suffix to KeyDB program names, use:
% make PROG_SUFFIX="-alt"
***Note that the following dependencies may be needed:
% sudo apt-get install autoconf autotools-dev libnuma-dev libtool
KeyDB by default is built with TLS enabled. To build without TLS support, use:
% make BUILD_TLS=no
Running the tests with TLS enabled (you will need `tcl-tls`
installed):
% ./utils/gen-test-certs.sh
% ./runtest --tls
To build with KeyDB FLASH support, use:
% make ENABLE_FLASH=yes
***Note that the KeyDB FLASH feature is considered experimental (beta) and should used with discretion
Fixing build problems with dependencies or cached build options
---------
KeyDB has some dependencies which are included in the `deps` directory.
`make` does not automatically rebuild dependencies even if something in
the source code of dependencies changes.
When you update the source code with `git pull` or when code inside the
dependencies tree is modified in any other way, make sure to use the following
command in order to really clean everything and rebuild from scratch:
make distclean
This will clean: jemalloc, lua, hiredis, linenoise.
Also if you force certain build options like 32bit target, no C compiler
optimizations (for debugging purposes), and other similar build time options,
those options are cached indefinitely until you issue a `make distclean`
command.
Fixing problems building 32 bit binaries
---------
If after building KeyDB with a 32 bit target you need to rebuild it
with a 64 bit target, or the other way around, you need to perform a
`make distclean` in the root directory of the KeyDB distribution.
In case of build errors when trying to build a 32 bit binary of KeyDB, try
the following steps:
* Install the package libc6-dev-i386 (also try g++-multilib).
* Try using the following command line instead of `make 32bit`:
`make CFLAGS="-m32 -march=native" LDFLAGS="-m32"`
Allocator
---------
Selecting a non-default memory allocator when building KeyDB is done by setting
the `MALLOC` environment variable. KeyDB is compiled and linked against libc
malloc by default, with the exception of jemalloc being the default on Linux
systems. This default was picked because jemalloc has proven to have fewer
fragmentation problems than libc malloc.
To force compiling against libc malloc, use:
% make MALLOC=libc
To compile against jemalloc on Mac OS X systems, use:
% make MALLOC=jemalloc
Monotonic clock
---------------
By default, KeyDB will build using the POSIX clock_gettime function as the
monotonic clock source. On most modern systems, the internal processor clock
can be used to improve performance. Cautions can be found here:
http://oliveryang.net/2015/09/pitfalls-of-TSC-usage/
To build with support for the processor's internal instruction clock, use:
% make CFLAGS="-DUSE_PROCESSOR_CLOCK"
Verbose build
-------------
KeyDB will build with a user friendly colorized output by default.
If you want to see a more verbose output, use the following:
% make V=1
Running KeyDB
-------------
To run KeyDB with the default configuration, just type:
% cd src
% ./keydb-server
If you want to provide your keydb.conf, you have to run it using an additional
parameter (the path of the configuration file):
% cd src
% ./keydb-server /path/to/keydb.conf
It is possible to alter the KeyDB configuration by passing parameters directly
as options using the command line. Examples:
% ./keydb-server --port 9999 --replicaof 127.0.0.1 6379
% ./keydb-server /etc/keydb/6379.conf --loglevel debug
All the options in keydb.conf are also supported as options using the command
line, with exactly the same name.
Running KeyDB with TLS:
------------------
Please consult the [TLS.md](TLS.md) file for more information on
how to use KeyDB with TLS.
Playing with KeyDB
------------------
You can use keydb-cli to play with KeyDB. Start a keydb-server instance,
then in another terminal try the following:
% cd src
% ./keydb-cli
keydb> ping
PONG
keydb> set foo bar
OK
keydb> get foo
"bar"
keydb> incr mycounter
(integer) 1
keydb> incr mycounter
(integer) 2
keydb>
You can find the list of all the available commands at https://docs.keydb.dev/docs/commands/
Installing KeyDB
-----------------
In order to install KeyDB binaries into /usr/local/bin, just use:
% make install
You can use `make PREFIX=/some/other/directory install` if you wish to use a
different destination.
Make install will just install binaries in your system, but will not configure
init scripts and configuration files in the appropriate place. This is not
needed if you just want to play a bit with KeyDB, but if you are installing
it the proper way for a production system, we have a script that does this
for Ubuntu and Debian systems:
% cd utils
% ./install_server.sh
_Note_: `install_server.sh` will not work on Mac OSX; it is built for Linux only.
The script will ask you a few questions and will setup everything you need
to run KeyDB properly as a background daemon that will start again on
system reboots.
You'll be able to stop and start KeyDB using the script named
`/etc/init.d/keydb_<portnumber>`, for instance `/etc/init.d/keydb_6379`.
Multithreading Architecture
---------------------------
KeyDB works by running the normal Redis event loop on multiple threads. Network IO, and query parsing are done concurrently. Each connection is assigned a thread on accept(). Access to the core hash table is guarded by spinlock. Because the hashtable access is extremely fast this lock has low contention. Transactions hold the lock for the duration of the EXEC command. Modules work in concert with the GIL which is only acquired when all server threads are paused. This maintains the atomicity guarantees modules expect.
Unlike most databases the core data structure is the fastest part of the system. Most of the query time comes from parsing the REPL protocol and copying data to/from the network.
Code contributions
-----------------
Note: by contributing code to the KeyDB project in any form, including sending
a pull request via Github, a code fragment or patch via private email or
public discussion groups, you agree to release your code under the terms
of the BSD license that you can find in the COPYING file included in the KeyDB
source distribution.
Please see the CONTRIBUTING file in this source distribution for more
information.
================================================
FILE: TLS.md
================================================
TLS Support
===========
Getting Started
---------------
### Building
TLS support is enabled in the default build. To build without TLS, run `make BUILD_TLS=no`.
### Tests
To run KeyDB test suite with TLS, you'll need TLS support for TCL (i.e.
`tcl-tls` package on Debian/Ubuntu).
1. Run `./utils/gen-test-certs.sh` to generate a root CA and a server
certificate.
2. Run `./runtest --tls` or `./runtest-cluster --tls` to run KeyDB and KeyDB
Cluster tests in TLS mode.
### Running manually
To manually run a Redis server with TLS mode (assuming `gen-test-certs.sh` was
invoked so sample certificates/keys are available):
./src/keydb-server --tls-port 6379 --port 0 \
--tls-cert-file ./tests/tls/client.crt \
--tls-key-file ./tests/tls/client.key \
--tls-ca-cert-file ./tests/tls/ca.crt
To connect to this Redis server with `keydb-cli`:
./src/keydb-cli --tls \
--cert ./tests/tls/keydb.crt \
--key ./tests/tls/keydb.key \
--cacert ./tests/tls/ca.crt
This will disable TCP and enable TLS on port 6379. It's also possible to have
both TCP and TLS available, but you'll need to assign different ports.
To make a Replica connect to the master using TLS, use `--tls-replication yes`,
and to make KeyDB Cluster use TLS across nodes use `--tls-cluster yes`.
Connections
-----------
All socket operations now go through a connection abstraction layer that hides
I/O and read/write event handling from the caller.
Note that unlike Redis, KeyDB fully supports multithreading of TLS connections.
To-Do List
----------
- [ ] keydb-benchmark support. The current implementation is a mix of using
hiredis for parsing and basic networking (establishing connections), but
directly manipulating sockets for most actions. This will need to be cleaned
up for proper TLS support. The best approach is probably to migrate to hiredis
async mode.
- [ ] keydb-cli `--slave` and `--rdb` support.
Multi-port
----------
Consider the implications of allowing TLS to be configured on a separate port,
making KeyDB listening on multiple ports:
1. Startup banner port notification
2. Proctitle
3. How slaves announce themselves
4. Cluster bus port calculation
================================================
FILE: build.yaml
================================================
# Doc: https://wiki.sc-corp.net/pages/viewpage.action?pageId=121500284
version: 1
machamp:
keydb-build:
# Optional - build counter is linked to the build def
tag_template: "0.0.%build.counter%-%sha%"
# Optional - value in seconds before a build is terminated, default is 3600 seconds
timeout: 3600
# Optional - update ghe or not, default to true
update_ghe: true
code_coverage: false
# Required
steps:
make-build:
type: cmd
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./machamp_scripts/build.sh
tls-test:
type: cmd
parent: make-build
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./runtest --clients 4 --verbose --tls
cluster-test:
type: cmd
parent: make-build
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./runtest-cluster --tls
sentinel-test:
type: cmd
parent: make-build
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./runtest-sentinel
module-test:
type: cmd
parent: make-build
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./runtest-moduleapi
rotation-test:
type: cmd
parent: make-build
# https://github.sc-corp.net/Snapchat/img/tree/master/keydb/ubuntu-20-04
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/keydb/keydb-ubuntu-20-04@sha256:cf869a3f5d1de1e1d976bb906689c37b7031938eb68661b844a38c532f27248c
command: ./runtest-rotation
keydb-docker-build:
# Optional - build counter is linked to the build def
tag_template: "%sha%"
# Optional - value in seconds before a build is terminated, default is 3600 seconds
timeout: 3600
# Optional - update ghe or not, default to true
update_ghe: true
code_coverage: false
# Required
steps:
# to ensure a clearer docker build env
code-checkout:
type: cmd
command: echo checkout
# default machamp builder image does not work for multi arch
builder_image: us.gcr.io/snapchat-build-artifacts/prod/snapchat/img/ubuntu/ubuntu-23-04@sha256:bd43177a80e6ce1c3583e8ea959b88a9081c0f56b765ec9c5a157c27a637c23b
docker:
parent: code-checkout
type: docker # published images can be found in https://console.cloud.google.com/gcr/images/machamp-prod/global/keydb
dockerfile: machamp_scripts/Dockerfile
image_name: keydb # git commit sha will be deafult tag in the final image
workspace_context: ./ # This is the workspace context that your Dockerfile will use to move files around. <Root of checkout repository>/<Workspace Context>/<Dockerfile> If the workspace context is just the root of the repository, you can just use "./".
================================================
FILE: ci.yaml
================================================
# Doc: https://wiki.sc-corp.net/display/TOOL/ci.yaml+User+Guide
version: 1
on:
# https://wiki.sc-corp.net/display/TOOL/Onboard+Machamp+Build+By+ci.yaml+Configuration
# on pull_request is used for any pr build
pull_request:
- branches: ['!!main', '*'] # this branch pattern means any branch but not main branch will trigger this pr build
workflows:
# All builds that use machamp should use the defined `backend_workflow`
- workflow_type: backend_workflow
# references a build defined in build.yaml
build_name: keydb-build
arch_types: ["amd64", "arm64"]
- workflow_type: backend_workflow
# references a build defined in build.yaml
build_name: keydb-docker-build
arch_types: ["amd64", "arm64"]
# on push is used for release branch, meaning: trigger this build when there is commit pushed to this branch
push:
- branches: [main]
workflows:
- workflow_type: backend_workflow
build_name: keydb-build
arch_types: ["amd64", "arm64"]
- workflow_type: backend_workflow
# references a build defined in build.yaml
build_name: keydb-docker-build
arch_types: ["amd64", "arm64"]
# below defines which branch is release branch / release tag
machamp:
releases:
# Note: machamp will only respect the ci.yaml file from default branch for "release branch" definition (most repositories using master/main as default branch)
# https://wiki.sc-corp.net/display/TOOL/Onboard+Machamp+Build+By+ci.yaml+Configuration
- branch_name: ^main$
================================================
FILE: deps/Makefile
================================================
# Redis dependency Makefile
uname_S:= $(shell sh -c 'uname -s 2>/dev/null || echo not')
uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
CCCOLOR="\033[34m"
LINKCOLOR="\033[34;1m"
SRCCOLOR="\033[33m"
BINCOLOR="\033[37;1m"
MAKECOLOR="\033[32;1m"
ENDCOLOR="\033[0m"
default:
@echo "Explicit target required"
.PHONY: default
# Prerequisites target
.make-prerequisites:
@touch $@
# Clean everything when CFLAGS is different
ifneq ($(shell sh -c '[ -f .make-cflags ] && cat .make-cflags || echo none'), $(CFLAGS))
.make-cflags: distclean
-(echo "$(CFLAGS)" > .make-cflags)
.make-prerequisites: .make-cflags
endif
# Clean everything when LDFLAGS is different
ifneq ($(shell sh -c '[ -f .make-ldflags ] && cat .make-ldflags || echo none'), $(LDFLAGS))
.make-ldflags: distclean
-(echo "$(LDFLAGS)" > .make-ldflags)
.make-prerequisites: .make-ldflags
endif
distclean:
ifneq ($(USE_SYSTEM_HIREDIS),yes)
-(cd hiredis && $(MAKE) clean) > /dev/null || true
endif
-(cd linenoise && $(MAKE) clean) > /dev/null || true
-(cd lua && $(MAKE) clean) > /dev/null || true
ifneq ($(USE_SYSTEM_JEMALLOC),yes)
-(cd jemalloc && [ -f Makefile ] && $(MAKE) distclean) > /dev/null || true
endif
ifneq ($(USE_SYSTEM_ROCKSDB),yes)
-(cd rocksdb && $(MAKE) clean) > /dev/null || true
endif
-(cd hdr_histogram && $(MAKE) clean) > /dev/null || true
-(rm -f .make-*)
.PHONY: distclean
ifeq ($(BUILD_TLS),yes)
HIREDIS_MAKE_FLAGS = USE_SSL=1
endif
hiredis: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
cd hiredis && $(MAKE) static $(HIREDIS_MAKE_FLAGS)
.PHONY: hiredis
linenoise: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
cd linenoise && $(MAKE)
.PHONY: linenoise
.PHONY: memkind
memkind:
cd memkind && $(MAKE)
hdr_histogram: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
cd hdr_histogram && $(MAKE)
.PHONY: hdr_histogram
ifeq ($(uname_S),SunOS)
# Make isinf() available
LUA_CFLAGS= -D__C99FEATURES__=1
endif
LUA_CFLAGS+= -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC='' -DLUA_USE_MKSTEMP $(CFLAGS)
LUA_LDFLAGS+= $(LDFLAGS)
# lua's Makefile defines AR="ar rcu", which is unusual, and makes it more
# challenging to cross-compile lua (and redis). These defines make it easier
# to fit redis into cross-compilation environments, which typically set AR.
AR=ar
ARFLAGS=rc
lua: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
cd lua/src && $(MAKE) all CFLAGS="$(LUA_CFLAGS)" MYLDFLAGS="$(LUA_LDFLAGS)" AR="$(AR) $(ARFLAGS)"
.PHONY: lua
JEMALLOC_CFLAGS= -std=gnu99 -Wall -pipe -g3 -O3 -funroll-loops $(CFLAGS)
JEMALLOC_LDFLAGS= $(LDFLAGS)
jemalloc: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
cd jemalloc && ./configure --with-version=5.2.1-0-g0 --with-lg-quantum=3 --disable-cxx CFLAGS="$(JEMALLOC_CFLAGS)" LDFLAGS="$(JEMALLOC_LDFLAGS)"
cd jemalloc && $(MAKE) CFLAGS="$(JEMALLOC_CFLAGS)" LDFLAGS="$(JEMALLOC_LDFLAGS)" lib/libjemalloc.a
.PHONY: jemalloc
rocksdb: .make-prerequisites
@printf '%b %b\n' $(MAKECOLOR)MAKE$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR)
ifeq ($(uname_M),x86_64)
cd rocksdb && CFLAGS=-Wno-error PORTABLE=1 USE_SSE=1 FORCE_SSE42=1 $(MAKE) static_lib
else
cd rocksdb && PORTABLE=1 $(MAKE) static_lib
endif
.PHONY: rocksdb
================================================
FILE: deps/README.md
================================================
This directory contains all Redis dependencies, except for the libc that
should be provided by the operating system.
* **Jemalloc** is our memory allocator, used as replacement for libc malloc on Linux by default. It has good performances and excellent fragmentation behavior. This component is upgraded from time to time.
* **hiredis** is the official C client library for Redis. It is used by redis-cli, redis-benchmark and Redis Sentinel. It is part of the Redis official ecosystem but is developed externally from the Redis repository, so we just upgrade it as needed.
* **linenoise** is a readline replacement. It is developed by the same authors of Redis but is managed as a separated project and updated as needed.
* **lua** is Lua 5.1 with minor changes for security and additional libraries.
How to upgrade the above dependencies
===
Jemalloc
---
Jemalloc is modified with changes that allow us to implement the Redis
active defragmentation logic. However this feature of Redis is not mandatory
and Redis is able to understand if the Jemalloc version it is compiled
against supports such Redis-specific modifications. So in theory, if you
are not interested in the active defragmentation, you can replace Jemalloc
just following these steps:
1. Remove the jemalloc directory.
2. Substitute it with the new jemalloc source tree.
3. Edit the Makefile located in the same directory as the README you are
reading, and change the --with-version in the Jemalloc configure script
options with the version you are using. This is required because otherwise
Jemalloc configuration script is broken and will not work nested in another
git repository.
However note that we change Jemalloc settings via the `configure` script of Jemalloc using the `--with-lg-quantum` option, setting it to the value of 3 instead of 4. This provides us with more size classes that better suit the Redis data structures, in order to gain memory efficiency.
If you want to upgrade Jemalloc while also providing support for
active defragmentation, in addition to the above steps you need to perform
the following additional steps:
5. In Jemalloc tree, file `include/jemalloc/jemalloc_macros.h.in`, make sure
to add `#define JEMALLOC_FRAG_HINT`.
6. Implement the function `je_get_defrag_hint()` inside `src/jemalloc.c`. You
can see how it is implemented in the current Jemalloc source tree shipped
with Redis, and rewrite it according to the new Jemalloc internals, if they
changed, otherwise you could just copy the old implementation if you are
upgrading just to a similar version of Jemalloc.
Hiredis
---
Hiredis uses the SDS string library, that must be the same version used inside Redis itself. Hiredis is also very critical for Sentinel. Historically Redis often used forked versions of hiredis in a way or the other. In order to upgrade it is advised to take a lot of care:
1. Check with diff if hiredis API changed and what impact it could have in Redis.
2. Make sure that the SDS library inside Hiredis and inside Redis are compatible.
3. After the upgrade, run the Redis Sentinel test.
4. Check manually that redis-cli and redis-benchmark behave as expected, since we have no tests for CLI utilities currently.
Linenoise
---
Linenoise is rarely upgraded as needed. The upgrade process is trivial since
Redis uses a non modified version of linenoise, so to upgrade just do the
following:
1. Remove the linenoise directory.
2. Substitute it with the new linenoise source tree.
Lua
---
We use Lua 5.1 and no upgrade is planned currently, since we don't want to break
Lua scripts for new Lua features: in the context of Redis Lua scripts the
capabilities of 5.1 are usually more than enough, the release is rock solid,
and we definitely don't want to break old scripts.
So upgrading of Lua is up to the Redis project maintainers and should be a
manual procedure performed by taking a diff between the different versions.
Currently we have at least the following differences between official Lua 5.1
and our version:
1. Makefile is modified to allow a different compiler than GCC.
2. We have the implementation source code, and directly link to the following external libraries: `lua_cjson.o`, `lua_struct.o`, `lua_cmsgpack.o` and `lua_bit.o`.
3. There is a security fix in `ldo.c`, line 498: The check for `LUA_SIGNATURE[0]` is removed in order to avoid direct bytecode execution.
================================================
FILE: deps/concurrentqueue/blockingconcurrentqueue.h
================================================
// Provides an efficient blocking version of moodycamel::ConcurrentQueue.
// ©2015-2020 Cameron Desrochers. Distributed under the terms of the simplified
// BSD license, available at the top of concurrentqueue.h.
// Also dual-licensed under the Boost Software License (see LICENSE.md)
// Uses Jeff Preshing's semaphore implementation (under the terms of its
// separate zlib license, see lightweightsemaphore.h).
#pragma once
#include "concurrentqueue.h"
#include "lightweightsemaphore.h"
#include <type_traits>
#include <cerrno>
#include <memory>
#include <chrono>
#include <ctime>
namespace moodycamel
{
// This is a blocking version of the queue. It has an almost identical interface to
// the normal non-blocking version, with the addition of various wait_dequeue() methods
// and the removal of producer-specific dequeue methods.
template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
class BlockingConcurrentQueue
{
private:
typedef ::moodycamel::ConcurrentQueue<T, Traits> ConcurrentQueue;
typedef ::moodycamel::LightweightSemaphore LightweightSemaphore;
public:
typedef typename ConcurrentQueue::producer_token_t producer_token_t;
typedef typename ConcurrentQueue::consumer_token_t consumer_token_t;
typedef typename ConcurrentQueue::index_t index_t;
typedef typename ConcurrentQueue::size_t size_t;
typedef typename std::make_signed<size_t>::type ssize_t;
static const size_t BLOCK_SIZE = ConcurrentQueue::BLOCK_SIZE;
static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = ConcurrentQueue::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD;
static const size_t EXPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::EXPLICIT_INITIAL_INDEX_SIZE;
static const size_t IMPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::IMPLICIT_INITIAL_INDEX_SIZE;
static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = ConcurrentQueue::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = ConcurrentQueue::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE;
static const size_t MAX_SUBQUEUE_SIZE = ConcurrentQueue::MAX_SUBQUEUE_SIZE;
public:
// Creates a queue with at least `capacity` element slots; note that the
// actual number of elements that can be inserted without additional memory
// allocation depends on the number of producers and the block size (e.g. if
// the block size is equal to `capacity`, only a single block will be allocated
// up-front, which means only a single producer will be able to enqueue elements
// without an extra allocation -- blocks aren't shared between producers).
// This method is not thread safe -- it is up to the user to ensure that the
// queue is fully constructed before it starts being used by other threads (this
// includes making the memory effects of construction visible, possibly with a
// memory barrier).
explicit BlockingConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
: inner(capacity), sema(create<LightweightSemaphore, ssize_t, int>(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
{
assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
if (!sema) {
MOODYCAMEL_THROW(std::bad_alloc());
}
}
BlockingConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
: inner(minCapacity, maxExplicitProducers, maxImplicitProducers), sema(create<LightweightSemaphore, ssize_t, int>(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
{
assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
if (!sema) {
MOODYCAMEL_THROW(std::bad_alloc());
}
}
// Disable copying and copy assignment
BlockingConcurrentQueue(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
BlockingConcurrentQueue& operator=(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
// Moving is supported, but note that it is *not* a thread-safe operation.
// Nobody can use the queue while it's being moved, and the memory effects
// of that move must be propagated to other threads before they can use it.
// Note: When a queue is moved, its tokens are still valid but can only be
// used with the destination queue (i.e. semantically they are moved along
// with the queue itself).
BlockingConcurrentQueue(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
: inner(std::move(other.inner)), sema(std::move(other.sema))
{ }
inline BlockingConcurrentQueue& operator=(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
{
return swap_internal(other);
}
// Swaps this queue's state with the other's. Not thread-safe.
// Swapping two queues does not invalidate their tokens, however
// the tokens that were created for one queue must be used with
// only the swapped queue (i.e. the tokens are tied to the
// queue's movable state, not the object itself).
inline void swap(BlockingConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
{
swap_internal(other);
}
private:
BlockingConcurrentQueue& swap_internal(BlockingConcurrentQueue& other)
{
if (this == &other) {
return *this;
}
inner.swap(other.inner);
sema.swap(other.sema);
return *this;
}
public:
// Enqueues a single item (by copying it).
// Allocates memory if required. Only fails if memory allocation fails (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(T const& item)
{
if ((details::likely)(inner.enqueue(item))) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by moving it, if possible).
// Allocates memory if required. Only fails if memory allocation fails (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(T&& item)
{
if ((details::likely)(inner.enqueue(std::move(item)))) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by copying it) using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails (or
// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(producer_token_t const& token, T const& item)
{
if ((details::likely)(inner.enqueue(token, item))) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by moving it, if possible) using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails (or
// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(producer_token_t const& token, T&& item)
{
if ((details::likely)(inner.enqueue(token, std::move(item)))) {
sema->signal();
return true;
}
return false;
}
// Enqueues several items.
// Allocates memory if required. Only fails if memory allocation fails (or
// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
// Thread-safe.
template<typename It>
inline bool enqueue_bulk(It itemFirst, size_t count)
{
if ((details::likely)(inner.enqueue_bulk(std::forward<It>(itemFirst), count))) {
sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
return true;
}
return false;
}
// Enqueues several items using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails
// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
inline bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
{
if ((details::likely)(inner.enqueue_bulk(token, std::forward<It>(itemFirst), count))) {
sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
return true;
}
return false;
}
// Enqueues a single item (by copying it).
// Does not allocate memory. Fails if not enough room to enqueue (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
// is 0).
// Thread-safe.
inline bool try_enqueue(T const& item)
{
if (inner.try_enqueue(item)) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by moving it, if possible).
// Does not allocate memory (except for one-time implicit producer).
// Fails if not enough room to enqueue (or implicit production is
// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
// Thread-safe.
inline bool try_enqueue(T&& item)
{
if (inner.try_enqueue(std::move(item))) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by copying it) using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Thread-safe.
inline bool try_enqueue(producer_token_t const& token, T const& item)
{
if (inner.try_enqueue(token, item)) {
sema->signal();
return true;
}
return false;
}
// Enqueues a single item (by moving it, if possible) using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Thread-safe.
inline bool try_enqueue(producer_token_t const& token, T&& item)
{
if (inner.try_enqueue(token, std::move(item))) {
sema->signal();
return true;
}
return false;
}
// Enqueues several items.
// Does not allocate memory (except for one-time implicit producer).
// Fails if not enough room to enqueue (or implicit production is
// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
inline bool try_enqueue_bulk(It itemFirst, size_t count)
{
if (inner.try_enqueue_bulk(std::forward<It>(itemFirst), count)) {
sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
return true;
}
return false;
}
// Enqueues several items using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
inline bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
{
if (inner.try_enqueue_bulk(token, std::forward<It>(itemFirst), count)) {
sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
return true;
}
return false;
}
// Attempts to dequeue from the queue.
// Returns false if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename U>
inline bool try_dequeue(U& item)
{
if (sema->tryWait()) {
while (!inner.try_dequeue(item)) {
continue;
}
return true;
}
return false;
}
// Attempts to dequeue from the queue using an explicit consumer token.
// Returns false if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename U>
inline bool try_dequeue(consumer_token_t& token, U& item)
{
if (sema->tryWait()) {
while (!inner.try_dequeue(token, item)) {
continue;
}
return true;
}
return false;
}
// Attempts to dequeue several elements from the queue.
// Returns the number of items actually dequeued.
// Returns 0 if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename It>
inline size_t try_dequeue_bulk(It itemFirst, size_t max)
{
size_t count = 0;
max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
}
return count;
}
// Attempts to dequeue several elements from the queue using an explicit consumer token.
// Returns the number of items actually dequeued.
// Returns 0 if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename It>
inline size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
{
size_t count = 0;
max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
}
return count;
}
// Blocks the current thread until there's something to dequeue, then
// dequeues it.
// Never allocates. Thread-safe.
template<typename U>
inline void wait_dequeue(U& item)
{
while (!sema->wait()) {
continue;
}
while (!inner.try_dequeue(item)) {
continue;
}
}
// Blocks the current thread until either there's something to dequeue
// or the timeout (specified in microseconds) expires. Returns false
// without setting `item` if the timeout expires, otherwise assigns
// to `item` and returns true.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue.
// Never allocates. Thread-safe.
template<typename U>
inline bool wait_dequeue_timed(U& item, std::int64_t timeout_usecs)
{
if (!sema->wait(timeout_usecs)) {
return false;
}
while (!inner.try_dequeue(item)) {
continue;
}
return true;
}
// Blocks the current thread until either there's something to dequeue
// or the timeout expires. Returns false without setting `item` if the
// timeout expires, otherwise assigns to `item` and returns true.
// Never allocates. Thread-safe.
template<typename U, typename Rep, typename Period>
inline bool wait_dequeue_timed(U& item, std::chrono::duration<Rep, Period> const& timeout)
{
return wait_dequeue_timed(item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
}
// Blocks the current thread until there's something to dequeue, then
// dequeues it using an explicit consumer token.
// Never allocates. Thread-safe.
template<typename U>
inline void wait_dequeue(consumer_token_t& token, U& item)
{
while (!sema->wait()) {
continue;
}
while (!inner.try_dequeue(token, item)) {
continue;
}
}
// Blocks the current thread until either there's something to dequeue
// or the timeout (specified in microseconds) expires. Returns false
// without setting `item` if the timeout expires, otherwise assigns
// to `item` and returns true.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue.
// Never allocates. Thread-safe.
template<typename U>
inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::int64_t timeout_usecs)
{
if (!sema->wait(timeout_usecs)) {
return false;
}
while (!inner.try_dequeue(token, item)) {
continue;
}
return true;
}
// Blocks the current thread until either there's something to dequeue
// or the timeout expires. Returns false without setting `item` if the
// timeout expires, otherwise assigns to `item` and returns true.
// Never allocates. Thread-safe.
template<typename U, typename Rep, typename Period>
inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::chrono::duration<Rep, Period> const& timeout)
{
return wait_dequeue_timed(token, item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
}
// Attempts to dequeue several elements from the queue.
// Returns the number of items actually dequeued, which will
// always be at least one (this method blocks until the queue
// is non-empty) and at most max.
// Never allocates. Thread-safe.
template<typename It>
inline size_t wait_dequeue_bulk(It itemFirst, size_t max)
{
size_t count = 0;
max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
}
return count;
}
// Attempts to dequeue several elements from the queue.
// Returns the number of items actually dequeued, which can
// be 0 if the timeout expires while waiting for elements,
// and at most max.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue_bulk.
// Never allocates. Thread-safe.
template<typename It>
inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::int64_t timeout_usecs)
{
size_t count = 0;
max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
}
return count;
}
// Attempts to dequeue several elements from the queue.
// Returns the number of items actually dequeued, which can
// be 0 if the timeout expires while waiting for elements,
// and at most max.
// Never allocates. Thread-safe.
template<typename It, typename Rep, typename Period>
inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
{
return wait_dequeue_bulk_timed<It&>(itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
}
// Attempts to dequeue several elements from the queue using an explicit consumer token.
// Returns the number of items actually dequeued, which will
// always be at least one (this method blocks until the queue
// is non-empty) and at most max.
// Never allocates. Thread-safe.
template<typename It>
inline size_t wait_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
{
size_t count = 0;
max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
}
return count;
}
// Attempts to dequeue several elements from the queue using an explicit consumer token.
// Returns the number of items actually dequeued, which can
// be 0 if the timeout expires while waiting for elements,
// and at most max.
// Using a negative timeout indicates an indefinite timeout,
// and is thus functionally equivalent to calling wait_dequeue_bulk.
// Never allocates. Thread-safe.
template<typename It>
inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::int64_t timeout_usecs)
{
size_t count = 0;
max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
while (count != max) {
count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
}
return count;
}
// Attempts to dequeue several elements from the queue using an explicit consumer token.
// Returns the number of items actually dequeued, which can
// be 0 if the timeout expires while waiting for elements,
// and at most max.
// Never allocates. Thread-safe.
template<typename It, typename Rep, typename Period>
inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
{
return wait_dequeue_bulk_timed<It&>(token, itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
}
// Returns an estimate of the total number of elements currently in the queue. This
// estimate is only accurate if the queue has completely stabilized before it is called
// (i.e. all enqueue and dequeue operations have completed and their memory effects are
// visible on the calling thread, and no further operations start while this method is
// being called).
// Thread-safe.
inline size_t size_approx() const
{
return (size_t)sema->availableApprox();
}
// Returns true if the underlying atomic variables used by
// the queue are lock-free (they should be on most platforms).
// Thread-safe.
static bool is_lock_free()
{
return ConcurrentQueue::is_lock_free();
}
private:
template<typename U, typename A1, typename A2>
static inline U* create(A1&& a1, A2&& a2)
{
void* p = (Traits::malloc)(sizeof(U));
return p != nullptr ? new (p) U(std::forward<A1>(a1), std::forward<A2>(a2)) : nullptr;
}
template<typename U>
static inline void destroy(U* p)
{
if (p != nullptr) {
p->~U();
}
(Traits::free)(p);
}
private:
ConcurrentQueue inner;
std::unique_ptr<LightweightSemaphore, void (*)(LightweightSemaphore*)> sema;
};
template<typename T, typename Traits>
inline void swap(BlockingConcurrentQueue<T, Traits>& a, BlockingConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
{
a.swap(b);
}
} // end namespace moodycamel
================================================
FILE: deps/concurrentqueue/concurrentqueue.h
================================================
// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.
// An overview, including benchmark results, is provided here:
// http://moodycamel.com/blog/2014/a-fast-general-purpose-lock-free-queue-for-c++
// The full design is also described in excruciating detail at:
// http://moodycamel.com/blog/2014/detailed-design-of-a-lock-free-queue
// Simplified BSD license:
// Copyright (c) 2013-2020, Cameron Desrochers.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// - Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// - Redistributions in binary form must reproduce the above copyright notice, this list of
// conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
// TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Also dual-licensed under the Boost Software License (see LICENSE.md)
#pragma once
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
// Disable -Wconversion warnings (spuriously triggered when Traits::size_t and
// Traits::index_t are set to < 32 bits, causing integer promotion, causing warnings
// upon assigning any computed values)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wconversion"
#ifdef MCDBGQ_USE_RELACY
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
#endif
#endif
#if defined(_MSC_VER) && (!defined(_HAS_CXX17) || !_HAS_CXX17)
// VS2019 with /W4 warns about constant conditional expressions but unless /std=c++17 or higher
// does not support `if constexpr`, so we have no choice but to simply disable the warning
#pragma warning(push)
#pragma warning(disable: 4127) // conditional expression is constant
#endif
#if defined(__APPLE__)
#include "TargetConditionals.h"
#endif
#ifdef MCDBGQ_USE_RELACY
#include "relacy/relacy_std.hpp"
#include "relacy_shims.h"
// We only use malloc/free anyway, and the delete macro messes up `= delete` method declarations.
// We'll override the default trait malloc ourselves without a macro.
#undef new
#undef delete
#undef malloc
#undef free
#else
#include <atomic> // Requires C++11. Sorry VS2010.
#include <cassert>
#endif
#include <cstddef> // for max_align_t
#include <cstdint>
#include <cstdlib>
#include <type_traits>
#include <algorithm>
#include <utility>
#include <limits>
#include <climits> // for CHAR_BIT
#include <array>
#include <thread> // partly for __WINPTHREADS_VERSION if on MinGW-w64 w/ POSIX threading
// Platform-specific definitions of a numeric thread ID type and an invalid value
namespace moodycamel { namespace details {
template<typename thread_id_t> struct thread_id_converter {
typedef thread_id_t thread_id_numeric_size_t;
typedef thread_id_t thread_id_hash_t;
static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
};
} }
#if defined(MCDBGQ_USE_RELACY)
namespace moodycamel { namespace details {
typedef std::uint32_t thread_id_t;
static const thread_id_t invalid_thread_id = 0xFFFFFFFFU;
static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
static inline thread_id_t thread_id() { return rl::thread_index(); }
} }
#elif defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
// No sense pulling in windows.h in a header, we'll manually declare the function
// we use and rely on backwards-compatibility for this not to break
extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(void);
namespace moodycamel { namespace details {
static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
typedef std::uint32_t thread_id_t;
static const thread_id_t invalid_thread_id = 0; // See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU; // Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
} }
#elif defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || (defined(__APPLE__) && TARGET_OS_IPHONE) || defined(MOODYCAMEL_NO_THREAD_LOCAL)
namespace moodycamel { namespace details {
static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
typedef std::thread::id thread_id_t;
static const thread_id_t invalid_thread_id; // Default ctor creates invalid ID
// Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
// only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
// be.
static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
template<std::size_t> struct thread_id_size { };
template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
template<> struct thread_id_converter<thread_id_t> {
typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
#ifndef __APPLE__
typedef std::size_t thread_id_hash_t;
#else
typedef thread_id_numeric_size_t thread_id_hash_t;
#endif
static thread_id_hash_t prehash(thread_id_t const& x)
{
#ifndef __APPLE__
return std::hash<std::thread::id>()(x);
#else
return *reinterpret_cast<thread_id_hash_t const*>(&x);
#endif
}
};
} }
#else
// Use a nice trick from this answer: http://stackoverflow.com/a/8438730/21475
// In order to get a numeric thread ID in a platform-independent way, we use a thread-local
// static variable's address as a thread identifier :-)
#if defined(__GNUC__) || defined(__INTEL_COMPILER)
#define MOODYCAMEL_THREADLOCAL __thread
#elif defined(_MSC_VER)
#define MOODYCAMEL_THREADLOCAL __declspec(thread)
#else
// Assume C++11 compliant compiler
#define MOODYCAMEL_THREADLOCAL thread_local
#endif
namespace moodycamel { namespace details {
typedef std::uintptr_t thread_id_t;
static const thread_id_t invalid_thread_id = 0; // Address can't be nullptr
static const thread_id_t invalid_thread_id2 = 1; // Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
} }
#endif
// Constexpr if
#ifndef MOODYCAMEL_CONSTEXPR_IF
#if (defined(_MSC_VER) && defined(_HAS_CXX17) && _HAS_CXX17) || __cplusplus > 201402L
#define MOODYCAMEL_CONSTEXPR_IF if constexpr
#define MOODYCAMEL_MAYBE_UNUSED [[maybe_unused]]
#else
#define MOODYCAMEL_CONSTEXPR_IF if
#define MOODYCAMEL_MAYBE_UNUSED
#endif
#endif
// Exceptions
#ifndef MOODYCAMEL_EXCEPTIONS_ENABLED
#if (defined(_MSC_VER) && defined(_CPPUNWIND)) || (defined(__GNUC__) && defined(__EXCEPTIONS)) || (!defined(_MSC_VER) && !defined(__GNUC__))
#define MOODYCAMEL_EXCEPTIONS_ENABLED
#endif
#endif
#ifdef MOODYCAMEL_EXCEPTIONS_ENABLED
#define MOODYCAMEL_TRY try
#define MOODYCAMEL_CATCH(...) catch(__VA_ARGS__)
#define MOODYCAMEL_RETHROW throw
#define MOODYCAMEL_THROW(expr) throw (expr)
#else
#define MOODYCAMEL_TRY MOODYCAMEL_CONSTEXPR_IF (true)
#define MOODYCAMEL_CATCH(...) else MOODYCAMEL_CONSTEXPR_IF (false)
#define MOODYCAMEL_RETHROW
#define MOODYCAMEL_THROW(expr)
#endif
#ifndef MOODYCAMEL_NOEXCEPT
#if !defined(MOODYCAMEL_EXCEPTIONS_ENABLED)
#define MOODYCAMEL_NOEXCEPT
#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) true
#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) true
#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1800
// VS2012's std::is_nothrow_[move_]constructible is broken and returns true when it shouldn't :-(
// We have to assume *all* non-trivial constructors may throw on VS2012!
#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value)
#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
#elif defined(_MSC_VER) && defined(_NOEXCEPT) && _MSC_VER < 1900
#define MOODYCAMEL_NOEXCEPT _NOEXCEPT
#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) (std::is_rvalue_reference<valueType>::value && std::is_move_constructible<type>::value ? std::is_trivially_move_constructible<type>::value || std::is_nothrow_move_constructible<type>::value : std::is_trivially_copy_constructible<type>::value || std::is_nothrow_copy_constructible<type>::value)
#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) ((std::is_rvalue_reference<valueType>::value && std::is_move_assignable<type>::value ? std::is_trivially_move_assignable<type>::value || std::is_nothrow_move_assignable<type>::value : std::is_trivially_copy_assignable<type>::value || std::is_nothrow_copy_assignable<type>::value) && MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr))
#else
#define MOODYCAMEL_NOEXCEPT noexcept
#define MOODYCAMEL_NOEXCEPT_CTOR(type, valueType, expr) noexcept(expr)
#define MOODYCAMEL_NOEXCEPT_ASSIGN(type, valueType, expr) noexcept(expr)
#endif
#endif
#ifndef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
#ifdef MCDBGQ_USE_RELACY
#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
#else
// VS2013 doesn't support `thread_local`, and MinGW-w64 w/ POSIX threading has a crippling bug: http://sourceforge.net/p/mingw-w64/bugs/445
// g++ <=4.7 doesn't support thread_local either.
// Finally, iOS/ARM doesn't have support for it either, and g++/ARM allows it to compile but it's unconfirmed to actually work
#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && (!defined(__MINGW32__) && !defined(__MINGW64__) || !defined(__WINPTHREADS_VERSION)) && (!defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) && (!defined(__APPLE__) || !TARGET_OS_IPHONE) && !defined(__arm__) && !defined(_M_ARM) && !defined(__aarch64__)
// Assume `thread_local` is fully supported in all other C++11 compilers/platforms
//#define MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED // always disabled for now since several users report having problems with it on
#endif
#endif
#endif
// VS2012 doesn't support deleted functions.
// In this case, we declare the function normally but don't define it. A link error will be generated if the function is called.
#ifndef MOODYCAMEL_DELETE_FUNCTION
#if defined(_MSC_VER) && _MSC_VER < 1800
#define MOODYCAMEL_DELETE_FUNCTION
#else
#define MOODYCAMEL_DELETE_FUNCTION = delete
#endif
#endif
namespace moodycamel { namespace details {
#ifndef MOODYCAMEL_ALIGNAS
// VS2013 doesn't support alignas or alignof, and align() requires a constant literal
#if defined(_MSC_VER) && _MSC_VER <= 1800
#define MOODYCAMEL_ALIGNAS(alignment) __declspec(align(alignment))
#define MOODYCAMEL_ALIGNOF(obj) __alignof(obj)
#define MOODYCAMEL_ALIGNED_TYPE_LIKE(T, obj) typename details::Vs2013Aligned<std::alignment_of<obj>::value, T>::type
template<int Align, typename T> struct Vs2013Aligned { }; // default, unsupported alignment
template<typename T> struct Vs2013Aligned<1, T> { typedef __declspec(align(1)) T type; };
template<typename T> struct Vs2013Aligned<2, T> { typedef __declspec(align(2)) T type; };
template<typename T> struct Vs2013Aligned<4, T> { typedef __declspec(align(4)) T type; };
template<typename T> struct Vs2013Aligned<8, T> { typedef __declspec(align(8)) T type; };
template<typename T> struct Vs2013Aligned<16, T> { typedef __declspec(align(16)) T type; };
template<typename T> struct Vs2013Aligned<32, T> { typedef __declspec(align(32)) T type; };
template<typename T> struct Vs2013Aligned<64, T> { typedef __declspec(align(64)) T type; };
template<typename T> struct Vs2013Aligned<128, T> { typedef __declspec(align(128)) T type; };
template<typename T> struct Vs2013Aligned<256, T> { typedef __declspec(align(256)) T type; };
#else
template<typename T> struct identity { typedef T type; };
#define MOODYCAMEL_ALIGNAS(alignment) alignas(alignment)
#define MOODYCAMEL_ALIGNOF(obj) alignof(obj)
#define MOODYCAMEL_ALIGNED_TYPE_LIKE(T, obj) alignas(alignof(obj)) typename details::identity<T>::type
#endif
#endif
} }
// TSAN can false report races in lock-free code. To enable TSAN to be used from projects that use this one,
// we can apply per-function compile-time suppression.
// See https://clang.llvm.org/docs/ThreadSanitizer.html#has-feature-thread-sanitizer
#define MOODYCAMEL_NO_TSAN
#if defined(__has_feature)
#if __has_feature(thread_sanitizer)
#undef MOODYCAMEL_NO_TSAN
#define MOODYCAMEL_NO_TSAN __attribute__((no_sanitize("thread")))
#endif // TSAN
#endif // TSAN
// Compiler-specific likely/unlikely hints
namespace moodycamel { namespace details {
#if defined(__GNUC__)
static inline bool (likely)(bool x) { return __builtin_expect((x), true); }
static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); }
#else
static inline bool (likely)(bool x) { return x; }
static inline bool (unlikely)(bool x) { return x; }
#endif
} }
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
#include "internal/concurrentqueue_internal_debug.h"
#endif
namespace moodycamel {
namespace details {
template<typename T>
struct const_numeric_max {
static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
static const T value = std::numeric_limits<T>::is_signed
? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
: static_cast<T>(-1);
};
#if defined(__GLIBCXX__)
typedef ::max_align_t std_max_align_t; // libstdc++ forgot to add it to std:: for a while
#else
typedef std::max_align_t std_max_align_t; // Others (e.g. MSVC) insist it can *only* be accessed via std::
#endif
// Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
// 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
typedef union {
std_max_align_t x;
long long y;
void* z;
} max_align_t;
}
// Default traits for the ConcurrentQueue. To change some of the
// traits without re-implementing all of them, inherit from this
// struct and shadow the declarations you wish to be different;
// since the traits are used as a template type parameter, the
// shadowed declarations will be used where defined, and the defaults
// otherwise.
struct ConcurrentQueueDefaultTraits
{
// General-purpose size type. std::size_t is strongly recommended.
typedef std::size_t size_t;
// The type used for the enqueue and dequeue indices. Must be at least as
// large as size_t. Should be significantly larger than the number of elements
// you expect to hold at once, especially if you have a high turnover rate;
// for example, on 32-bit x86, if you expect to have over a hundred million
// elements or pump several million elements through your queue in a very
// short space of time, using a 32-bit type *may* trigger a race condition.
// A 64-bit int type is recommended in that case, and in practice will
// prevent a race condition no matter the usage of the queue. Note that
// whether the queue is lock-free with a 64-int type depends on the whether
// std::atomic<std::uint64_t> is lock-free, which is platform-specific.
typedef std::size_t index_t;
// Internally, all elements are enqueued and dequeued from multi-element
// blocks; this is the smallest controllable unit. If you expect few elements
// but many producers, a smaller block size should be favoured. For few producers
// and/or many elements, a larger block size is preferred. A sane default
// is provided. Must be a power of 2.
static const size_t BLOCK_SIZE = 32;
// For explicit producers (i.e. when using a producer token), the block is
// checked for being empty by iterating through a list of flags, one per element.
// For large block sizes, this is too inefficient, and switching to an atomic
// counter-based approach is faster. The switch is made for block sizes strictly
// larger than this threshold.
static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
// How many full blocks can be expected for a single explicit producer? This should
// reflect that number's maximum for optimal performance. Must be a power of 2.
static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
// How many full blocks can be expected for a single implicit producer? This should
// reflect that number's maximum for optimal performance. Must be a power of 2.
static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
// The initial size of the hash table mapping thread IDs to implicit producers.
// Note that the hash is resized every time it becomes half full.
// Must be a power of two, and either 0 or at least 1. If 0, implicit production
// (using the enqueue methods without an explicit producer token) is disabled.
static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
// Controls the number of items that an explicit consumer (i.e. one with a token)
// must consume before it causes all consumers to rotate and move on to the next
// internal queue.
static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
// The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
// Enqueue operations that would cause this limit to be surpassed will fail. Note
// that this limit is enforced at the block level (for performance reasons), i.e.
// it's rounded up to the nearest block size.
static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
// The number of times to spin before sleeping when waiting on a semaphore.
// Recommended values are on the order of 1000-10000 unless the number of
// consumer threads exceeds the number of idle cores (in which case try 0-100).
// Only affects instances of the BlockingConcurrentQueue.
static const int MAX_SEMA_SPINS = 10000;
#ifndef MCDBGQ_USE_RELACY
// Memory allocation can be customized if needed.
// malloc should return nullptr on failure, and handle alignment like std::malloc.
#if defined(malloc) || defined(free)
// Gah, this is 2015, stop defining macros that break standard code already!
// Work around malloc/free being special macros:
static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
#else
static inline void* malloc(size_t size) { return std::malloc(size); }
static inline void free(void* ptr) { return std::free(ptr); }
#endif
#else
// Debug versions when running under the Relacy race detector (ignore
// these in user code)
static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
#endif
};
// When producing or consuming many elements, the most efficient way is to:
// 1) Use one of the bulk-operation methods of the queue with a token
// 2) Failing that, use the bulk-operation methods without a token
// 3) Failing that, create a token and use that with the single-item methods
// 4) Failing that, use the single-parameter methods of the queue
// Having said that, don't create tokens willy-nilly -- ideally there should be
// a maximum of one token per thread (of each kind).
struct ProducerToken;
struct ConsumerToken;
template<typename T, typename Traits> class ConcurrentQueue;
template<typename T, typename Traits> class BlockingConcurrentQueue;
class ConcurrentQueueTests;
namespace details
{
struct ConcurrentQueueProducerTypelessBase
{
ConcurrentQueueProducerTypelessBase* next;
std::atomic<bool> inactive;
ProducerToken* token;
ConcurrentQueueProducerTypelessBase()
: next(nullptr), inactive(false), token(nullptr)
{
}
};
template<bool use32> struct _hash_32_or_64 {
static inline std::uint32_t hash(std::uint32_t h)
{
// MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
// Since the thread ID is already unique, all we really want to do is propagate that
// uniqueness evenly across all the bits, so that we can use a subset of the bits while
// reducing collisions significantly
h ^= h >> 16;
h *= 0x85ebca6b;
h ^= h >> 13;
h *= 0xc2b2ae35;
return h ^ (h >> 16);
}
};
template<> struct _hash_32_or_64<1> {
static inline std::uint64_t hash(std::uint64_t h)
{
h ^= h >> 33;
h *= 0xff51afd7ed558ccd;
h ^= h >> 33;
h *= 0xc4ceb9fe1a85ec53;
return h ^ (h >> 33);
}
};
template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> { };
static inline size_t hash_thread_id(thread_id_t id)
{
static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
thread_id_converter<thread_id_t>::prehash(id)));
}
template<typename T>
static inline bool circular_less_than(T a, T b)
{
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4554)
#endif
static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << static_cast<T>(sizeof(T) * CHAR_BIT - 1));
#ifdef _MSC_VER
#pragma warning(pop)
#endif
}
template<typename U>
static inline char* align_for(char* ptr)
{
const std::size_t alignment = std::alignment_of<U>::value;
return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
}
template<typename T>
static inline T ceil_to_pow_2(T x)
{
static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
x |= x >> (i << 3);
}
++x;
return x;
}
template<typename T>
static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
{
T temp = std::move(left.load(std::memory_order_relaxed));
left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
right.store(std::move(temp), std::memory_order_relaxed);
}
template<typename T>
static inline T const& nomove(T const& x)
{
return x;
}
template<bool Enable>
struct nomove_if
{
template<typename T>
static inline T const& eval(T const& x)
{
return x;
}
};
template<>
struct nomove_if<false>
{
template<typename U>
static inline auto eval(U&& x)
-> decltype(std::forward<U>(x))
{
return std::forward<U>(x);
}
};
template<typename It>
static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
{
return *it;
}
#if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
#else
template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
#endif
#ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
#ifdef MCDBGQ_USE_RELACY
typedef RelacyThreadExitListener ThreadExitListener;
typedef RelacyThreadExitNotifier ThreadExitNotifier;
#else
struct ThreadExitListener
{
typedef void (*callback_t)(void*);
callback_t callback;
void* userData;
ThreadExitListener* next; // reserved for use by the ThreadExitNotifier
};
class ThreadExitNotifier
{
public:
static void subscribe(ThreadExitListener* listener)
{
auto& tlsInst = instance();
listener->next = tlsInst.tail;
tlsInst.tail = listener;
}
static void unsubscribe(ThreadExitListener* listener)
{
auto& tlsInst = instance();
ThreadExitListener** prev = &tlsInst.tail;
for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
if (ptr == listener) {
*prev = ptr->next;
break;
}
prev = &ptr->next;
}
}
private:
ThreadExitNotifier() : tail(nullptr) { }
ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
~ThreadExitNotifier()
{
// This thread is about to exit, let everyone know!
assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
ptr->callback(ptr->userData);
}
}
// Thread-local
static inline ThreadExitNotifier& instance()
{
static thread_local ThreadExitNotifier notifier;
return notifier;
}
private:
ThreadExitListener* tail;
};
#endif
#endif
template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> { };
template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
}
struct ProducerToken
{
template<typename T, typename Traits>
explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
template<typename T, typename Traits>
explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
: producer(other.producer)
{
other.producer = nullptr;
if (producer != nullptr) {
producer->token = this;
}
}
inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
{
swap(other);
return *this;
}
void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
{
std::swap(producer, other.producer);
if (producer != nullptr) {
producer->token = this;
}
if (other.producer != nullptr) {
other.producer->token = &other;
}
}
// A token is always valid unless:
// 1) Memory allocation failed during construction
// 2) It was moved via the move constructor
// (Note: assignment does a swap, leaving both potentially valid)
// 3) The associated queue was destroyed
// Note that if valid() returns true, that only indicates
// that the token is valid for use with a specific queue,
// but not which one; that's up to the user to track.
inline bool valid() const { return producer != nullptr; }
~ProducerToken()
{
if (producer != nullptr) {
producer->token = nullptr;
producer->inactive.store(true, std::memory_order_release);
}
}
// Disable copying and assignment
ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
private:
template<typename T, typename Traits> friend class ConcurrentQueue;
friend class ConcurrentQueueTests;
protected:
details::ConcurrentQueueProducerTypelessBase* producer;
};
struct ConsumerToken
{
template<typename T, typename Traits>
explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
template<typename T, typename Traits>
explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
: initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
{
}
inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
{
swap(other);
return *this;
}
void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
{
std::swap(initialOffset, other.initialOffset);
std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
std::swap(currentProducer, other.currentProducer);
std::swap(desiredProducer, other.desiredProducer);
}
// Disable copying and assignment
ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
private:
template<typename T, typename Traits> friend class ConcurrentQueue;
friend class ConcurrentQueueTests;
private: // but shared with ConcurrentQueue
std::uint32_t initialOffset;
std::uint32_t lastKnownGlobalOffset;
std::uint32_t itemsConsumedFromCurrent;
details::ConcurrentQueueProducerTypelessBase* currentProducer;
details::ConcurrentQueueProducerTypelessBase* desiredProducer;
};
// Need to forward-declare this swap because it's in a namespace.
// See http://stackoverflow.com/questions/4492062/why-does-a-c-friend-class-need-a-forward-declaration-only-in-other-namespaces
template<typename T, typename Traits>
inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT;
template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
class ConcurrentQueue
{
public:
typedef ::moodycamel::ProducerToken producer_token_t;
typedef ::moodycamel::ConsumerToken consumer_token_t;
typedef typename Traits::index_t index_t;
typedef typename Traits::size_t size_t;
static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4307) // + integral constant overflow (that's what the ternary expression is for!)
#pragma warning(disable: 4309) // static_cast: Truncation of constant value
#endif
static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
#ifdef _MSC_VER
#pragma warning(pop)
#endif
static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
public:
// Creates a queue with at least `capacity` element slots; note that the
// actual number of elements that can be inserted without additional memory
// allocation depends on the number of producers and the block size (e.g. if
// the block size is equal to `capacity`, only a single block will be allocated
// up-front, which means only a single producer will be able to enqueue elements
// without an extra allocation -- blocks aren't shared between producers).
// This method is not thread safe -- it is up to the user to ensure that the
// queue is fully constructed before it starts being used by other threads (this
// includes making the memory effects of construction visible, possibly with a
// memory barrier).
explicit ConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
: producerListTail(nullptr),
producerCount(0),
initialBlockPoolIndex(0),
nextExplicitConsumerId(0),
globalExplicitConsumerOffset(0)
{
implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
populate_initial_implicit_producer_hash();
populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
// Track all the producers using a fully-resolved typed list for
// each kind; this makes it possible to debug them starting from
// the root queue object (otherwise wacky casts are needed that
// don't compile in the debugger's expression evaluator).
explicitProducers.store(nullptr, std::memory_order_relaxed);
implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
}
// Computes the correct amount of pre-allocated blocks for you based
// on the minimum number of elements you want available at any given
// time, and the maximum concurrent number of each type of producer.
ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
: producerListTail(nullptr),
producerCount(0),
initialBlockPoolIndex(0),
nextExplicitConsumerId(0),
globalExplicitConsumerOffset(0)
{
implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
populate_initial_implicit_producer_hash();
size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
populate_initial_block_list(blocks);
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
explicitProducers.store(nullptr, std::memory_order_relaxed);
implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
}
// Note: The queue should not be accessed concurrently while it's
// being deleted. It's up to the user to synchronize this.
// This method is not thread safe.
~ConcurrentQueue()
{
// Destroy producers
auto ptr = producerListTail.load(std::memory_order_relaxed);
while (ptr != nullptr) {
auto next = ptr->next_prod();
if (ptr->token != nullptr) {
ptr->token->producer = nullptr;
}
destroy(ptr);
ptr = next;
}
// Destroy implicit producer hash tables
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
auto hash = implicitProducerHash.load(std::memory_order_relaxed);
while (hash != nullptr) {
auto prev = hash->prev;
if (prev != nullptr) { // The last hash is part of this object and was not allocated dynamically
for (size_t i = 0; i != hash->capacity; ++i) {
hash->entries[i].~ImplicitProducerKVP();
}
hash->~ImplicitProducerHash();
(Traits::free)(hash);
}
hash = prev;
}
}
// Destroy global free list
auto block = freeList.head_unsafe();
while (block != nullptr) {
auto next = block->freeListNext.load(std::memory_order_relaxed);
if (block->dynamicallyAllocated) {
destroy(block);
}
block = next;
}
// Destroy initial free list
destroy_array(initialBlockPool, initialBlockPoolSize);
}
// Disable copying and copy assignment
ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
// Moving is supported, but note that it is *not* a thread-safe operation.
// Nobody can use the queue while it's being moved, and the memory effects
// of that move must be propagated to other threads before they can use it.
// Note: When a queue is moved, its tokens are still valid but can only be
// used with the destination queue (i.e. semantically they are moved along
// with the queue itself).
ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
: producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
producerCount(other.producerCount.load(std::memory_order_relaxed)),
initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
initialBlockPool(other.initialBlockPool),
initialBlockPoolSize(other.initialBlockPoolSize),
freeList(std::move(other.freeList)),
nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
{
// Move the other one into this, and leave the other one as an empty queue
implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
populate_initial_implicit_producer_hash();
swap_implicit_producer_hashes(other);
other.producerListTail.store(nullptr, std::memory_order_relaxed);
other.producerCount.store(0, std::memory_order_relaxed);
other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
other.explicitProducers.store(nullptr, std::memory_order_relaxed);
implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
other.implicitProducers.store(nullptr, std::memory_order_relaxed);
#endif
other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
other.initialBlockPoolSize = 0;
other.initialBlockPool = nullptr;
reown_producers();
}
inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
{
return swap_internal(other);
}
// Swaps this queue's state with the other's. Not thread-safe.
// Swapping two queues does not invalidate their tokens, however
// the tokens that were created for one queue must be used with
// only the swapped queue (i.e. the tokens are tied to the
// queue's movable state, not the object itself).
inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
{
swap_internal(other);
}
private:
ConcurrentQueue& swap_internal(ConcurrentQueue& other)
{
if (this == &other) {
return *this;
}
details::swap_relaxed(producerListTail, other.producerListTail);
details::swap_relaxed(producerCount, other.producerCount);
details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
std::swap(initialBlockPool, other.initialBlockPool);
std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
freeList.swap(other.freeList);
details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
swap_implicit_producer_hashes(other);
reown_producers();
other.reown_producers();
#ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
details::swap_relaxed(explicitProducers, other.explicitProducers);
details::swap_relaxed(implicitProducers, other.implicitProducers);
#endif
return *this;
}
public:
// Enqueues a single item (by copying it).
// Allocates memory if required. Only fails if memory allocation fails (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(T const& item)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue<CanAlloc>(item);
}
// Enqueues a single item (by moving it, if possible).
// Allocates memory if required. Only fails if memory allocation fails (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(T&& item)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue<CanAlloc>(std::move(item));
}
// Enqueues a single item (by copying it) using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails (or
// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(producer_token_t const& token, T const& item)
{
return inner_enqueue<CanAlloc>(token, item);
}
// Enqueues a single item (by moving it, if possible) using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails (or
// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Thread-safe.
inline bool enqueue(producer_token_t const& token, T&& item)
{
return inner_enqueue<CanAlloc>(token, std::move(item));
}
// Enqueues several items.
// Allocates memory if required. Only fails if memory allocation fails (or
// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
// Thread-safe.
template<typename It>
bool enqueue_bulk(It itemFirst, size_t count)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
}
// Enqueues several items using an explicit producer token.
// Allocates memory if required. Only fails if memory allocation fails
// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
{
return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
}
// Enqueues a single item (by copying it).
// Does not allocate memory. Fails if not enough room to enqueue (or implicit
// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
// is 0).
// Thread-safe.
inline bool try_enqueue(T const& item)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue<CannotAlloc>(item);
}
// Enqueues a single item (by moving it, if possible).
// Does not allocate memory (except for one-time implicit producer).
// Fails if not enough room to enqueue (or implicit production is
// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
// Thread-safe.
inline bool try_enqueue(T&& item)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue<CannotAlloc>(std::move(item));
}
// Enqueues a single item (by copying it) using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Thread-safe.
inline bool try_enqueue(producer_token_t const& token, T const& item)
{
return inner_enqueue<CannotAlloc>(token, item);
}
// Enqueues a single item (by moving it, if possible) using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Thread-safe.
inline bool try_enqueue(producer_token_t const& token, T&& item)
{
return inner_enqueue<CannotAlloc>(token, std::move(item));
}
// Enqueues several items.
// Does not allocate memory (except for one-time implicit producer).
// Fails if not enough room to enqueue (or implicit production is
// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
bool try_enqueue_bulk(It itemFirst, size_t count)
{
MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
else return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
}
// Enqueues several items using an explicit producer token.
// Does not allocate memory. Fails if not enough room to enqueue.
// Note: Use std::make_move_iterator if the elements should be moved
// instead of copied.
// Thread-safe.
template<typename It>
bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
{
return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
}
// Attempts to dequeue from the queue.
// Returns false if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename U>
bool try_dequeue(U& item)
{
// Instead of simply trying each producer in turn (which could cause needless contention on the first
// producer), we score them heuristically.
size_t nonEmptyCount = 0;
ProducerBase* best = nullptr;
size_t bestSize = 0;
for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
auto size = ptr->size_approx();
if (size > 0) {
if (size > bestSize) {
bestSize = size;
best = ptr;
}
++nonEmptyCount;
}
}
// If there was at least one non-empty queue but it appears empty at the time
// we try to dequeue from it, we need to make sure every queue's been tried
if (nonEmptyCount > 0) {
if ((details::likely)(best->dequeue(item))) {
return true;
}
for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
if (ptr != best && ptr->dequeue(item)) {
return true;
}
}
}
return false;
}
// Attempts to dequeue from the queue.
// Returns false if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// This differs from the try_dequeue(item) method in that this one does
// not attempt to reduce contention by interleaving the order that producer
// streams are dequeued from. So, using this method can reduce overall throughput
// under contention, but will give more predictable results in single-threaded
// consumer scenarios. This is mostly only useful for internal unit tests.
// Never allocates. Thread-safe.
template<typename U>
bool try_dequeue_non_interleaved(U& item)
{
for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
if (ptr->dequeue(item)) {
return true;
}
}
return false;
}
// Attempts to dequeue from the queue using an explicit consumer token.
// Returns false if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename U>
bool try_dequeue(consumer_token_t& token, U& item)
{
// The idea is roughly as follows:
// Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
// If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
// If there's no items where you're supposed to be, keep moving until you find a producer with some items
// If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
if (!update_current_producer_after_rotation(token)) {
return false;
}
}
// If there was at least one non-empty queue but it appears empty at the time
// we try to dequeue from it, we need to make sure every queue's been tried
if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
}
return true;
}
auto tail = producerListTail.load(std::memory_order_acquire);
auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
if (ptr == nullptr) {
ptr = tail;
}
while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
if (ptr->dequeue(item)) {
token.currentProducer = ptr;
token.itemsConsumedFromCurrent = 1;
return true;
}
ptr = ptr->next_prod();
if (ptr == nullptr) {
ptr = tail;
}
}
return false;
}
// Attempts to dequeue several elements from the queue.
// Returns the number of items actually dequeued.
// Returns 0 if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename It>
size_t try_dequeue_bulk(It itemFirst, size_t max)
{
size_t count = 0;
for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
count += ptr->dequeue_bulk(itemFirst, max - count);
if (count == max) {
break;
}
}
return count;
}
// Attempts to dequeue several elements from the queue using an explicit consumer token.
// Returns the number of items actually dequeued.
// Returns 0 if all producer streams appeared empty at the time they
// were checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename It>
size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
{
if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
if (!update_current_producer_after_rotation(token)) {
return 0;
}
}
size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
if (count == max) {
if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
}
return max;
}
token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
max -= count;
auto tail = producerListTail.load(std::memory_order_acquire);
auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
if (ptr == nullptr) {
ptr = tail;
}
while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
auto dequeued = ptr->dequeue_bulk(itemFirst, max);
count += dequeued;
if (dequeued != 0) {
token.currentProducer = ptr;
token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
}
if (dequeued == max) {
break;
}
max -= dequeued;
ptr = ptr->next_prod();
if (ptr == nullptr) {
ptr = tail;
}
}
return count;
}
// Attempts to dequeue from a specific producer's inner queue.
// If you happen to know which producer you want to dequeue from, this
// is significantly faster than using the general-case try_dequeue methods.
// Returns false if the producer's queue appeared empty at the time it
// was checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename U>
inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
{
return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
}
// Attempts to dequeue several elements from a specific producer's inner queue.
// Returns the number of items actually dequeued.
// If you happen to know which producer you want to dequeue from, this
// is significantly faster than using the general-case try_dequeue methods.
// Returns 0 if the producer's queue appeared empty at the time it
// was checked (so, the queue is likely but not guaranteed to be empty).
// Never allocates. Thread-safe.
template<typename It>
inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
{
return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
}
// Returns an estimate of the total number of elements currently in the queue. This
// estimate is only accurate if the queue has completely stabilized before it is called
// (i.e. all enqueue and dequeue operations have completed and their memory effects are
// visible on the calling thread, and no further operations start while this method is
// being called).
// Thread-safe.
size_t size_approx() const
{
size_t size = 0;
for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
size += ptr->size_approx();
}
return size;
}
// Returns true if the underlying atomic variables used by
// the queue are lock-free (they should be on most platforms).
// Thread-safe.
static bool is_lock_free()
{
return
details::static_is_lock_free<bool>::value == 2 &&
details::static_is_lock_free<size_t>::value == 2 &&
details::static_is_lock_free<std::uint32_t>::value == 2 &&
details::static_is_lock_free<index_t>::value == 2 &&
details::static_is_lock_free<void*>::value == 2 &&
details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
}
private:
friend struct ProducerToken;
friend struct ConsumerToken;
struct ExplicitProducer;
friend struct ExplicitProducer;
struct ImplicitProducer;
friend struct ImplicitProducer;
friend class ConcurrentQueueTests;
enum AllocationMode { CanAlloc, CannotAlloc };
///////////////////////////////
// Queue methods
///////////////////////////////
template<AllocationMode canAlloc, typename U>
inline bool inner_enqueue(producer_token_t const& token, U&& element)
{
return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
}
template<AllocationMode canAlloc, typename U>
inline bool inner_enqueue(U&& element)
{
auto producer = get_or_add_implicit_producer();
return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
}
template<AllocationMode canAlloc, typename It>
inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
{
return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
}
template<AllocationMode canAlloc, typename It>
inline bool inner_enqueue_bulk(It itemFirst, size_t count)
{
auto producer = get_or_add_implicit_producer();
return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
}
inline bool update_current_producer_after_rotation(consumer_token_t& token)
{
// Ah, there's been a rotation, figure out where we should be!
auto tail = producerListTail.load(std::memory_order_acquire);
if (token.desiredProducer == nullptr && tail == nullptr) {
return false;
}
auto prodCount = producerCount.load(std::memory_order_relaxed);
auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
if ((details::unlikely)(token.desiredProducer == nullptr)) {
// Aha, first time we're dequeueing anything.
// Figure out our local position
// Note: offset is from start, not end, but we're traversing from end -- subtract from count first
std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
token.desiredProducer = tail;
for (std::uint32_t i = 0; i != offset; ++i) {
token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
if (token.desiredProducer == nullptr) {
token.desiredProducer = tail;
}
}
}
std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
if (delta >= prodCount) {
delta = delta % prodCount;
}
for (std::uint32_t i = 0; i != delta; ++i) {
token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
if (token.desiredProducer == nullptr) {
token.desiredProducer = tail;
}
}
token.lastKnownGlobalOffset = globalOffset;
token.currentProducer = token.desiredProducer;
token.itemsConsumedFromCurrent = 0;
return true;
}
///////////////////////////
// Free list
///////////////////////////
template <typename N>
struct FreeListNode
{
FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
std::atomic<std::uint32_t> freeListRefs;
std::atomic<N*> freeListNext;
};
// A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
// simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
// speedy under low contention.
template<typename N> // N must inherit FreeListNode or have the same fields (and initialization of them)
struct FreeList
{
FreeList() : freeListHead(nullptr) { }
FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
inline void add(N* node)
{
#ifdef MCDBGQ_NOLOCKFREE_FREELIST
debug::DebugLock lock(mutex);
#endif
// We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
// set it using a fetch_add
if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
// Oh look! We were the last ones referencing this node, and we know
// we want to add it to the free list, so let's do it!
add_knowing_refcount_is_zero(node);
}
}
inline N* try_get()
{
#ifdef MCDBGQ_NOLOCKFREE_FREELIST
debug::DebugLock lock(mutex);
#endif
auto head = freeListHead.load(std::memory_order_acquire);
while (head != nullptr) {
auto prevHead = head;
auto refs = head->freeListRefs.load(std::memory_order_relaxed);
if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
head = freeListHead.load(std::memory_order_acquire);
continue;
}
// Good, reference count has been incremented (it wasn't at zero), which means we can read the
// next and not worry about it changing between now and the time we do the CAS
auto next = head->freeListNext.load(std::memory_order_relaxed);
if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
// Decrease refcount twice, once for our ref, and once for the list's ref
head->freeListRefs.fetch_sub(2, std::memory_order_release);
return head;
}
// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
// Note that we don't need to release any memory effects, but we do need to ensure that the reference
// count decrement happens-after the CAS on the head.
refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
if (refs == SHOULD_BE_ON_FREELIST + 1) {
add_knowing_refcount_is_zero(prevHead);
}
}
return nullptr;
}
// Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
private:
inline void add_knowing_refcount_is_zero(N* node)
{
// Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
// only one copy of this method per node at a time, i.e. the single thread case), then we know
// we can safely change the next pointer of the node; however, once the refcount is back above
// zero, then other threads could increase it (happens under heavy contention, when the refcount
// goes to zero in between a load and a refcount increment of a node in try_get, then back up to
// something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
// to add the node to the actual list fails, decrease the refcount and leave the add operation to
// the next thread who puts the refcount back at zero (which could be us, hence the loop).
auto head = freeListHead.load(std::memory_order_relaxed);
while (true) {
node->freeListNext.store(head, std::memory_order_relaxed);
node->freeListRefs.store(1, std::memory_order_release);
if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
// Hmm, the add failed, but we can only try again when the refcount goes back to zero
if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
continue;
}
}
return;
}
}
private:
// Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
std::atomic<N*> freeListHead;
static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
#ifdef MCDBGQ_NOLOCKFREE_FREELIST
debug::DebugMutex mutex;
#endif
};
///////////////////////////
// Block
///////////////////////////
enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
struct Block
{
Block()
: next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), shouldBeOnFreeList(false), dynamicallyAllocated(true)
{
#ifdef MCDBGQ_TRACKMEM
owner = nullptr;
#endif
}
template<InnerQueueContext context>
inline bool is_empty() const
{
MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
// Check flags
for (size_t i = 0; i < BLOCK_SIZE; ++i) {
if (!emptyFlags[i].load(std::memory_order_relaxed)) {
return false;
}
}
// Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
std::atomic_thread_fence(std::memory_order_acquire);
return true;
}
else {
// Check counter
if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
std::atomic_thread_fence(std::memory_order_acquire);
return true;
}
assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
return false;
}
}
// Returns true if the block is now empty (does not apply in explicit context)
template<InnerQueueContext context>
inline bool set_empty(MOODYCAMEL_MAYBE_UNUSED index_t i)
{
MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
// Set flag
assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
return false;
}
else {
// Increment counter
auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
assert(prevVal < BLOCK_SIZE);
return prevVal == BLOCK_SIZE - 1;
}
}
// Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
// Returns true if the block is now empty (does not apply in explicit context).
template<InnerQueueContext context>
inline bool set_many_empty(MOODYCAMEL_MAYBE_UNUSED index_t i, size_t count)
{
MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
// Set flags
std::atomic_thread_fence(std::memory_order_release);
i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
for (size_t j = 0; j != count; ++j) {
assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
emptyFlags[i + j].store(true, std::memory_order_relaxed);
}
return false;
}
else {
// Increment counter
auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
assert(prevVal + count <= BLOCK_SIZE);
return prevVal + count == BLOCK_SIZE;
}
}
template<InnerQueueContext context>
inline void set_all_empty()
{
MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
// Set all flags
for (size_t i = 0; i != BLOCK_SIZE; ++i) {
emptyFlags[i].store(true, std::memory_order_relaxed);
}
}
else {
// Reset counter
elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
}
}
template<InnerQueueContext context>
inline void reset_empty()
{
MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
// Reset flags
for (size_t i = 0; i != BLOCK_SIZE; ++i) {
emptyFlags[i].store(false, std::memory_order_relaxed);
}
}
else {
// Reset counter
elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
}
}
inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
private:
static_assert(std::alignment_of<T>::value <= sizeof(T), "The queue does not support types with an alignment greater than their size at this time");
MOODYCAMEL_ALIGNED_TYPE_LIKE(char[sizeof(T) * BLOCK_SIZE], T) elements;
public:
Block* next;
std::atomic<size_t> elementsCompletelyDequeued;
std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
public:
std::atomic<std::uint32_t> freeListRefs;
std::atomic<Block*> freeListNext;
std::atomic<bool> shouldBeOnFreeList;
bool dynamicallyAllocated; // Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
#ifdef MCDBGQ_TRACKMEM
void* owner;
#endif
};
static_assert(std::alignment_of<Block>::value >= std::alignment_of<T>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
#ifdef MCDBGQ_TRACKMEM
public:
struct MemStats;
private:
#endif
///////////////////////////
// Producer base
///////////////////////////
struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
{
ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
tailIndex(0),
headIndex(0),
dequeueOptimisticCount(0),
dequeueOvercommit(0),
tailBlock(nullptr),
isExplicit(isExplicit_),
parent(parent_)
{
}
virtual ~ProducerBase() { }
template<typename U>
inline bool dequeue(U& element)
{
if (isExplicit) {
return static_cast<ExplicitProducer*>(this)->dequeue(element);
}
else {
return static_cast<ImplicitProducer*>(this)->dequeue(element);
}
}
template<typename It>
inline size_t dequeue_bulk(It& itemFirst, size_t max)
{
if (isExplicit) {
return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
}
else {
return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
}
}
inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
inline size_t size_approx() const
{
auto tail = tailIndex.load(std::memory_order_relaxed);
auto head = headIndex.load(std::memory_order_relaxed);
return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
}
inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
protected:
std::atomic<index_t> tailIndex; // Where to enqueue to next
std::atomic<index_t> headIndex; // Where to dequeue from next
std::atomic<index_t> dequeueOptimisticCount;
std::atomic<index_t> dequeueOvercommit;
Block* tailBlock;
public:
bool isExplicit;
ConcurrentQueue* parent;
protected:
#ifdef MCDBGQ_TRACKMEM
friend struct MemStats;
#endif
};
///////////////////////////
// Explicit queue
///////////////////////////
struct ExplicitProducer : public ProducerBase
{
explicit ExplicitProducer(ConcurrentQueue* parent_) :
ProducerBase(parent_, true),
blockIndex(nullptr),
pr_blockIndexSlotsUsed(0),
pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
pr_blockIndexFront(0),
pr_blockIndexEntries(nullptr),
pr_blockIndexRaw(nullptr)
{
size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
if (poolBasedIndexSize > pr_blockIndexSize) {
pr_blockIndexSize = poolBasedIndexSize;
}
new_block_index(0); // This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
}
~ExplicitProducer()
{
// Destruct any elements not yet dequeued.
// Since we're in the destructor, we can assume all elements
// are either completely dequeued or completely not (no halfways).
if (this->tailBlock != nullptr) { // Note this means there must be a block index too
// First find the block that's partially dequeued, if any
Block* halfDequeuedBlock = nullptr;
if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
// The head's not on a block boundary, meaning a block somewhere is partially dequeued
// (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
i = (i + 1) & (pr_blockIndexSize - 1);
}
assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
halfDequeuedBlock = pr_blockIndexEntries[i].block;
}
// Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
auto block = this->tailBlock;
do {
block = block->next;
if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
continue;
}
size_t i = 0; // Offset into block
if (block == halfDequeuedBlock) {
i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
}
// Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
(*block)[i++]->~T();
}
} while (block != this->tailBlock);
}
// Destroy all blocks that we own
if (this->tailBlock != nullptr) {
auto block = this->tailBlock;
do {
auto nextBlock = block->next;
if (block->dynamicallyAllocated) {
destroy(block);
}
else {
this->parent->add_block_to_free_list(block);
}
block = nextBlock;
} while (block != this->tailBlock);
}
// Destroy the block indices
auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
while (header != nullptr) {
auto prev = static_cast<BlockIndexHeader*>(header->prev);
header->~BlockIndexHeader();
(Traits::free)(header);
header = prev;
}
}
template<AllocationMode allocMode, typename U>
inline bool enqueue(U&& element)
{
index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
index_t newTailIndex = 1 + currentTailIndex;
if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
// We reached the end of a block, start a new one
auto startBlock = this->tailBlock;
auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
// We can re-use the block ahead of us, it's empty!
this->tailBlock = this->tailBlock->next;
this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
// We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
// last block from it first -- except instead of removing then adding, we can just overwrite).
// Note that there must be a valid block index here, since even if allocation failed in the ctor,
// it would have been re-attempted when adding the first block to the queue; since there is such
// a block, a block index must have been successfully allocated.
}
else {
// Whatever head value we see here is >= the last value we saw here (relatively),
// and <= its current value. Since we have the most recent tail, the head must be
// <= to it.
auto head = this->headIndex.load(std::memory_order_relaxed);
assert(!details::circular_less_than<index_t>(currentTailIndex, head));
if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
|| (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
// We can't enqueue in another block because there's not enough leeway -- the
// tail could surpass the head by the time the block fills up! (Or we'll exceed
// the size limit, if the second part of the condition was true.)
return false;
}
// We're going to need a new block; check that the block index has room
if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
// Hmm, the circular block index is already full -- we'll need
// to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
// the initial allocation failed in the constructor.
MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
return false;
}
else if (!new_block_index(pr_blockIndexSlotsUsed)) {
return false;
}
}
// Insert a new block in the circular linked list
auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
if (newBlock == nullptr) {
return false;
}
#ifdef MCDBGQ_TRACKMEM
newBlock->owner = this;
#endif
newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
if (this->tailBlock == nullptr) {
newBlock->next = newBlock;
}
else {
newBlock->next = this->tailBlock->next;
this->tailBlock->next = newBlock;
}
this->tailBlock = newBlock;
++pr_blockIndexSlotsUsed;
}
MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
// The constructor may throw. We want the element not to appear in the queue in
// that case (without corrupting the queue):
MOODYCAMEL_TRY {
new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
}
MOODYCAMEL_CATCH (...) {
// Revert change to the current block, but leave the new block available
// for next time
pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
MOODYCAMEL_RETHROW;
}
}
else {
(void)startBlock;
(void)originalBlockIndexSlotsUsed;
}
// Add block to block index
auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
entry.base = currentTailIndex;
entry.block = this->tailBlock;
blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
this->tailIndex.store(newTailIndex, std::memory_order_release);
return true;
}
}
// Enqueue
new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
this->tailIndex.store(newTailIndex, std::memory_order_release);
return true;
}
template<typename U>
bool dequeue(U& element)
{
auto tail = this->tailIndex.load(std::memory_order_relaxed);
auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
// Might be something to dequeue, let's give it a try
// Note that this if is purely for performance purposes in the common case when the queue is
// empty and the values are eventually consistent -- we may enter here spuriously.
// Note that whatever the values of overcommit and tail are, they are not going to change (unless we
// change them) and must be the same value at this point (inside the if) as when the if condition was
// evaluated.
// We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
// This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
// the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
// Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
// read-modify-write operations are guaranteed to work on the latest value in the modification order), but
// unfortunately that can't be shown to be correct using only the C++11 standard.
// See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
std::atomic_thread_fence(std::memory_order_acquire);
// Increment optimistic counter, then check if it went over the boundary
auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
// Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
// incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
// have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
// incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
// However, we can't assert this since both dequeueOptimisticCount and dequeueOvercommit may (independently)
// overflow; in such a case, though, the logic still holds since the difference between the two is maintained.
// Note that we reload tail here in case it changed; it will be the same value as before or greater, since
// this load is sequenced after (happens after) the earlier load above. This is supported by read-read
// coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
tail = this->tailIndex.load(std::memory_order_acquire);
if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
// Guaranteed to be at least one element to dequeue!
// Get the index. Note that since there's guaranteed to be at least one element, this
// will never exceed tail. We need to do an acquire-release fence here since it's possible
// that whatever condition got us to this point was for an earlier enqueued element (that
// we already see the memory effects for), but that by the time we increment somebody else
// has incremented it, and we need to see the memory effects for *that* element, which is
// in such a case is necessarily visible on the thread that incremented it in the first
// place with the more current condition (they must have acquired a tail that is at least
// as recent).
auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
// Determine which block the element is in
auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
// We need to be careful here about subtracting and dividing because of index wrap-around.
// When an index wraps, we need to preserve the sign of the offset when dividing it by the
// block size (in order to get a correct signed block count offset in all cases):
auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / BLOCK_SIZE);
auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
// Dequeue
auto& el = *((*block)[index]);
if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
// Make sure the element is still fully dequeued and destroyed even if the assignment
// throws
struct Guard {
Block* block;
index_t index;
~Guard()
{
(*block)[index]->~T();
block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
}
} guard = { block, index };
element = std::move(el); // NOLINT
}
else {
element = std::move(el); // NOLINT
el.~T(); // NOLINT
block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
}
return true;
}
else {
// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
this->dequeueOvercommit.fetch_add(1, std::memory_order_release); // Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
}
}
return false;
}
template<AllocationMode allocMode, typename It>
bool MOODYCAMEL_NO_TSAN enqueue_bulk(It itemFirst, size_t count)
{
// First, we need to make sure we have enough room to enqueue all of the elements;
// this means pre-allocating blocks and putting them in the block index (but only if
// all the allocations succeeded).
index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
auto startBlock = this->tailBlock;
auto originalBlockIndexFront = pr_blockIndexFront;
auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
Block* firstAllocatedBlock = nullptr;
// Figure out how many blocks we'll need to allocate, and do so
size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
if (blockBaseDiff > 0) {
// Allocate as many blocks as possible from ahead
while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
this->tailBlock = this->tailBlock->next;
firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
entry.base = currentTailIndex;
entry.block = this->tailBlock;
pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
}
// Now allocate as many blocks as necessary from the block pool
while (blockBaseDiff > 0) {
blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
auto head = this->headIndex.load(std::memory_order_relaxed);
assert(!details::circular_less_than<index_t>(currentTailIndex, head));
bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
// Failed to allocate, undo changes (but keep injected blocks)
pr_blockIndexFront = originalBlockIndexFront;
pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
return false;
}
else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
// Failed to allocate, undo changes (but keep injected blocks)
pr_blockIndexFront = originalBlockIndexFront;
pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
return false;
}
// pr_blockIndexFront is updated inside new_block_index, so we need to
// update our fallback value too (since we keep the new index even if we
// later fail)
originalBlockIndexFront = originalBlockIndexSlotsUsed;
}
// Insert a new block in the circular linked list
auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
if (newBlock == nullptr) {
pr_blockIndexFront = originalBlockIndexFront;
pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
return false;
}
#ifdef MCDBGQ_TRACKMEM
newBlock->owner = this;
#endif
newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
if (this->tailBlock == nullptr) {
newBlock->next = newBlock;
}
else {
newBlock->next = this->tailBlock->next;
this->tailBlock->next = newBlock;
}
this->tailBlock = newBlock;
firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
++pr_blockIndexSlotsUsed;
auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
entry.base = currentTailIndex;
entry.block = this->tailBlock;
pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
}
// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
// publish the new block index front
auto block = firstAllocatedBlock;
while (true) {
block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
if (block == this->tailBlock) {
break;
}
block = block->next;
}
MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
}
}
// Enqueue, one block at a time
index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
currentTailIndex = startTailIndex;
auto endBlock = this->tailBlock;
this->tailBlock = startBlock;
assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
this->tailBlock = firstAllocatedBlock;
}
while (true) {
index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
stopIndex = newTailIndex;
}
MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
while (currentTailIndex != stopIndex) {
new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
}
}
else {
MOODYCAMEL_TRY {
while (currentTailIndex != stopIndex) {
// Must use copy constructor even if move constructor is available
// because we may have to revert if there's an exception.
// Sorry about the horrible templated next line, but it was the only way
// to disable moving *at compile time*, which is important because a type
// may only define a (noexcept) move constructor, and so calls to the
// cctor will not compile, even if they are in an if branch that will never
// be executed
new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
++currentTailIndex;
++itemFirst;
}
}
MOODYCAMEL_CATCH (...) {
// Oh dear, an exception's been thrown -- destroy the elements that
// were enqueued so far and revert the entire bulk operation (we'll keep
// any allocated blocks in our linked list for later, though).
auto constructedStopIndex = currentTailIndex;
auto lastBlockEnqueued = this->tailBlock;
pr_blockIndexFront = originalBlockIndexFront;
pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
if (!details::is_trivially_destructible<T>::value) {
auto block = startBlock;
if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
block = firstAllocatedBlock;
}
currentTailIndex = startTailIndex;
while (true) {
stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
stopIndex = constructedStopIndex;
}
while (currentTailIndex != stopIndex) {
(*block)[currentTailIndex++]->~T();
}
if (block == lastBlockEnqueued) {
break;
}
block = block->next;
}
}
MOODYCAMEL_RETHROW;
}
}
if (this->tailBlock == endBlock) {
assert(currentTailIndex == newTailIndex);
break;
}
this->tailBlock = this->tailBlock->next;
}
MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
if (firstAllocatedBlock != nullptr)
blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
}
this->tailIndex.store(newTailIndex, std::memory_order_release);
return true;
}
template<typename It>
size_t dequeue_bulk(It& itemFirst, size_t max)
{
auto tail = this->tailIndex.load(std::memory_order_relaxed);
auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
if (details::circular_less_than<size_t>(0, desiredCount)) {
desiredCount = desiredCount < max ? desiredCount : max;
std::atomic_thread_fence(std::memory_order_acquire);
auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
tail = this->tailIndex.load(std::memory_order_acquire);
auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
if (details::circular_less_than<size_t>(0, actualCount)) {
actualCount = desiredCount < actualCount ? desiredCount : actualCount;
if (actualCount < desiredCount) {
this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
}
// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
// will never exceed tail.
auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
// Determine which block the first element is in
auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / BLOCK_SIZE);
auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
// Iterate the blocks and dequeue
auto index = firstIndex;
do {
auto firstIndexInBlock = index;
index_t endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
auto block = localBlockIndex->entries[indexIndex].block;
if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
while (index != endIndex) {
auto& el = *((*block)[index]);
*itemFirst++ = std::move(el);
el.~T();
++index;
}
}
else {
MOODYCAMEL_TRY {
while (index != endIndex) {
auto& el = *((*block)[index]);
*itemFirst = std::move(el);
++itemFirst;
el.~T();
++index;
}
}
MOODYCAMEL_CATCH (...) {
// It's too late to revert the dequeue, but we can make sure that all
// the dequeued objects are properly destroyed and the block index
// (and empty count) are properly updated before we propagate the exception
do {
block = localBlockIndex->entries[indexIndex].block;
while (index != endIndex) {
(*block)[index++]->~T();
}
block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
firstIndexInBlock = index;
endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
} while (index != firstIndex + actualCount);
MOODYCAMEL_RETHROW;
}
}
block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
} while (index != firstIndex + actualCount);
return actualCount;
}
else {
// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
}
}
return 0;
}
private:
struct BlockIndexEntry
{
index_t base;
Block* block;
};
struct BlockIndexHeader
{
size_t size;
std::atomic<size_t> front; // Current slot (not next, like pr_blockIndexFront)
B
gitextract__91v1dat/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── crash_report.md
│ │ ├── feature_request.md
│ │ └── other_stuff.md
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── .gitmodules
├── 00-RELEASENOTES
├── BUGS
├── CONDUCT
├── COPYING
├── INSTALL
├── Makefile
├── README.md
├── TLS.md
├── build.yaml
├── ci.yaml
├── deps/
│ ├── Makefile
│ ├── README.md
│ ├── concurrentqueue/
│ │ ├── blockingconcurrentqueue.h
│ │ ├── concurrentqueue.h
│ │ └── lightweightsemaphore.h
│ ├── cpp-statsd-client/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ ├── coverage.yml
│ │ │ ├── lint.yml
│ │ │ ├── linux.yml
│ │ │ └── windows.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── cmake/
│ │ │ ├── CodeCoverage.cmake
│ │ │ ├── Config.cmake.in
│ │ │ └── cpp-statsd-clientConfig.cmake.in
│ │ ├── include/
│ │ │ └── cpp-statsd-client/
│ │ │ ├── StatsdClient.hpp
│ │ │ └── UDPSender.hpp
│ │ └── tests/
│ │ ├── StatsdServer.hpp
│ │ └── testStatsdClient.cpp
│ ├── hdr_histogram/
│ │ ├── COPYING.txt
│ │ ├── LICENSE.txt
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── hdr_atomic.h
│ │ ├── hdr_histogram.c
│ │ └── hdr_histogram.h
│ ├── hiredis/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CHANGELOG.md
│ │ ├── CMakeLists.txt
│ │ ├── COPYING
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── adapters/
│ │ │ ├── ae.h
│ │ │ ├── glib.h
│ │ │ ├── ivykis.h
│ │ │ ├── libev.h
│ │ │ ├── libevent.h
│ │ │ ├── libuv.h
│ │ │ ├── macosx.h
│ │ │ └── qt.h
│ │ ├── alloc.c
│ │ ├── alloc.h
│ │ ├── appveyor.yml
│ │ ├── async.c
│ │ ├── async.h
│ │ ├── async_private.h
│ │ ├── dict.c
│ │ ├── dict.h
│ │ ├── examples/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── example-ae.c
│ │ │ ├── example-glib.c
│ │ │ ├── example-ivykis.c
│ │ │ ├── example-libev.c
│ │ │ ├── example-libevent-ssl.c
│ │ │ ├── example-libevent.c
│ │ │ ├── example-libuv.c
│ │ │ ├── example-macosx.c
│ │ │ ├── example-push.c
│ │ │ ├── example-qt.cpp
│ │ │ ├── example-qt.h
│ │ │ ├── example-ssl.c
│ │ │ └── example.c
│ │ ├── fmacros.h
│ │ ├── hiredis-config.cmake.in
│ │ ├── hiredis.c
│ │ ├── hiredis.h
│ │ ├── hiredis.pc.in
│ │ ├── hiredis_ssl-config.cmake.in
│ │ ├── hiredis_ssl.h
│ │ ├── hiredis_ssl.pc.in
│ │ ├── net.c
│ │ ├── net.h
│ │ ├── read.c
│ │ ├── read.h
│ │ ├── sds.c
│ │ ├── sds.h
│ │ ├── sdsalloc.h
│ │ ├── sockcompat.c
│ │ ├── sockcompat.h
│ │ ├── ssl.c
│ │ ├── test.c
│ │ ├── test.sh
│ │ └── win32.h
│ ├── jemalloc/
│ │ ├── .appveyor.yml
│ │ ├── .autom4te.cfg
│ │ ├── .cirrus.yml
│ │ ├── .gitattributes
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── COPYING
│ │ ├── ChangeLog
│ │ ├── INSTALL.md
│ │ ├── Makefile.in
│ │ ├── README
│ │ ├── TUNING.md
│ │ ├── VERSION
│ │ ├── autogen.sh
│ │ ├── bin/
│ │ │ ├── jemalloc-config.in
│ │ │ ├── jemalloc.sh.in
│ │ │ └── jeprof.in
│ │ ├── build-aux/
│ │ │ ├── config.guess
│ │ │ ├── config.sub
│ │ │ └── install-sh
│ │ ├── config.stamp.in
│ │ ├── configure
│ │ ├── configure.ac
│ │ ├── doc/
│ │ │ ├── html.xsl.in
│ │ │ ├── jemalloc.xml.in
│ │ │ ├── manpages.xsl.in
│ │ │ └── stylesheet.xsl
│ │ ├── include/
│ │ │ ├── jemalloc/
│ │ │ │ ├── internal/
│ │ │ │ │ ├── arena_externs.h
│ │ │ │ │ ├── arena_inlines_a.h
│ │ │ │ │ ├── arena_inlines_b.h
│ │ │ │ │ ├── arena_stats.h
│ │ │ │ │ ├── arena_structs_a.h
│ │ │ │ │ ├── arena_structs_b.h
│ │ │ │ │ ├── arena_types.h
│ │ │ │ │ ├── assert.h
│ │ │ │ │ ├── atomic.h
│ │ │ │ │ ├── atomic_c11.h
│ │ │ │ │ ├── atomic_gcc_atomic.h
│ │ │ │ │ ├── atomic_gcc_sync.h
│ │ │ │ │ ├── atomic_msvc.h
│ │ │ │ │ ├── background_thread_externs.h
│ │ │ │ │ ├── background_thread_inlines.h
│ │ │ │ │ ├── background_thread_structs.h
│ │ │ │ │ ├── base_externs.h
│ │ │ │ │ ├── base_inlines.h
│ │ │ │ │ ├── base_structs.h
│ │ │ │ │ ├── base_types.h
│ │ │ │ │ ├── bin.h
│ │ │ │ │ ├── bin_stats.h
│ │ │ │ │ ├── bin_types.h
│ │ │ │ │ ├── bit_util.h
│ │ │ │ │ ├── bitmap.h
│ │ │ │ │ ├── cache_bin.h
│ │ │ │ │ ├── ckh.h
│ │ │ │ │ ├── ctl.h
│ │ │ │ │ ├── div.h
│ │ │ │ │ ├── emitter.h
│ │ │ │ │ ├── extent_dss.h
│ │ │ │ │ ├── extent_externs.h
│ │ │ │ │ ├── extent_inlines.h
│ │ │ │ │ ├── extent_mmap.h
│ │ │ │ │ ├── extent_structs.h
│ │ │ │ │ ├── extent_types.h
│ │ │ │ │ ├── hash.h
│ │ │ │ │ ├── hook.h
│ │ │ │ │ ├── jemalloc_internal_decls.h
│ │ │ │ │ ├── jemalloc_internal_defs.h.in
│ │ │ │ │ ├── jemalloc_internal_externs.h
│ │ │ │ │ ├── jemalloc_internal_includes.h
│ │ │ │ │ ├── jemalloc_internal_inlines_a.h
│ │ │ │ │ ├── jemalloc_internal_inlines_b.h
│ │ │ │ │ ├── jemalloc_internal_inlines_c.h
│ │ │ │ │ ├── jemalloc_internal_macros.h
│ │ │ │ │ ├── jemalloc_internal_types.h
│ │ │ │ │ ├── jemalloc_preamble.h.in
│ │ │ │ │ ├── large_externs.h
│ │ │ │ │ ├── log.h
│ │ │ │ │ ├── malloc_io.h
│ │ │ │ │ ├── mutex.h
│ │ │ │ │ ├── mutex_pool.h
│ │ │ │ │ ├── mutex_prof.h
│ │ │ │ │ ├── nstime.h
│ │ │ │ │ ├── pages.h
│ │ │ │ │ ├── ph.h
│ │ │ │ │ ├── private_namespace.sh
│ │ │ │ │ ├── private_symbols.sh
│ │ │ │ │ ├── prng.h
│ │ │ │ │ ├── prof_externs.h
│ │ │ │ │ ├── prof_inlines_a.h
│ │ │ │ │ ├── prof_inlines_b.h
│ │ │ │ │ ├── prof_structs.h
│ │ │ │ │ ├── prof_types.h
│ │ │ │ │ ├── public_namespace.sh
│ │ │ │ │ ├── public_unnamespace.sh
│ │ │ │ │ ├── ql.h
│ │ │ │ │ ├── qr.h
│ │ │ │ │ ├── quantum.h
│ │ │ │ │ ├── rb.h
│ │ │ │ │ ├── rtree.h
│ │ │ │ │ ├── rtree_tsd.h
│ │ │ │ │ ├── safety_check.h
│ │ │ │ │ ├── sc.h
│ │ │ │ │ ├── seq.h
│ │ │ │ │ ├── smoothstep.h
│ │ │ │ │ ├── smoothstep.sh
│ │ │ │ │ ├── spin.h
│ │ │ │ │ ├── stats.h
│ │ │ │ │ ├── sz.h
│ │ │ │ │ ├── tcache_externs.h
│ │ │ │ │ ├── tcache_inlines.h
│ │ │ │ │ ├── tcache_structs.h
│ │ │ │ │ ├── tcache_types.h
│ │ │ │ │ ├── test_hooks.h
│ │ │ │ │ ├── ticker.h
│ │ │ │ │ ├── tsd.h
│ │ │ │ │ ├── tsd_generic.h
│ │ │ │ │ ├── tsd_malloc_thread_cleanup.h
│ │ │ │ │ ├── tsd_tls.h
│ │ │ │ │ ├── tsd_types.h
│ │ │ │ │ ├── tsd_win.h
│ │ │ │ │ ├── util.h
│ │ │ │ │ └── witness.h
│ │ │ │ ├── jemalloc.sh
│ │ │ │ ├── jemalloc_defs.h.in
│ │ │ │ ├── jemalloc_macros.h.in
│ │ │ │ ├── jemalloc_mangle.sh
│ │ │ │ ├── jemalloc_protos.h.in
│ │ │ │ ├── jemalloc_rename.sh
│ │ │ │ └── jemalloc_typedefs.h.in
│ │ │ └── msvc_compat/
│ │ │ ├── C99/
│ │ │ │ ├── stdbool.h
│ │ │ │ └── stdint.h
│ │ │ ├── strings.h
│ │ │ └── windows_extra.h
│ │ ├── jemalloc.pc.in
│ │ ├── m4/
│ │ │ └── ax_cxx_compile_stdcxx.m4
│ │ ├── msvc/
│ │ │ ├── ReadMe.txt
│ │ │ ├── jemalloc_vc2015.sln
│ │ │ ├── jemalloc_vc2017.sln
│ │ │ ├── projects/
│ │ │ │ ├── vc2015/
│ │ │ │ │ ├── jemalloc/
│ │ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ │ └── test_threads/
│ │ │ │ │ ├── test_threads.vcxproj
│ │ │ │ │ └── test_threads.vcxproj.filters
│ │ │ │ └── vc2017/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ └── test_threads/
│ │ │ │ ├── test_threads.vcxproj
│ │ │ │ └── test_threads.vcxproj.filters
│ │ │ └── test_threads/
│ │ │ ├── test_threads.cpp
│ │ │ ├── test_threads.h
│ │ │ └── test_threads_main.cpp
│ │ ├── run_tests.sh
│ │ ├── scripts/
│ │ │ ├── gen_run_tests.py
│ │ │ └── gen_travis.py
│ │ ├── src/
│ │ │ ├── arena.c
│ │ │ ├── background_thread.c
│ │ │ ├── base.c
│ │ │ ├── bin.c
│ │ │ ├── bitmap.c
│ │ │ ├── ckh.c
│ │ │ ├── ctl.c
│ │ │ ├── div.c
│ │ │ ├── extent.c
│ │ │ ├── extent_dss.c
│ │ │ ├── extent_mmap.c
│ │ │ ├── hash.c
│ │ │ ├── hook.c
│ │ │ ├── jemalloc.c
│ │ │ ├── jemalloc_cpp.cpp
│ │ │ ├── large.c
│ │ │ ├── log.c
│ │ │ ├── malloc_io.c
│ │ │ ├── mutex.c
│ │ │ ├── mutex_pool.c
│ │ │ ├── nstime.c
│ │ │ ├── pages.c
│ │ │ ├── prng.c
│ │ │ ├── prof.c
│ │ │ ├── rtree.c
│ │ │ ├── safety_check.c
│ │ │ ├── sc.c
│ │ │ ├── stats.c
│ │ │ ├── sz.c
│ │ │ ├── tcache.c
│ │ │ ├── test_hooks.c
│ │ │ ├── ticker.c
│ │ │ ├── tsd.c
│ │ │ ├── witness.c
│ │ │ └── zone.c
│ │ └── test/
│ │ ├── include/
│ │ │ └── test/
│ │ │ ├── SFMT-alti.h
│ │ │ ├── SFMT-params.h
│ │ │ ├── SFMT-params11213.h
│ │ │ ├── SFMT-params1279.h
│ │ │ ├── SFMT-params132049.h
│ │ │ ├── SFMT-params19937.h
│ │ │ ├── SFMT-params216091.h
│ │ │ ├── SFMT-params2281.h
│ │ │ ├── SFMT-params4253.h
│ │ │ ├── SFMT-params44497.h
│ │ │ ├── SFMT-params607.h
│ │ │ ├── SFMT-params86243.h
│ │ │ ├── SFMT-sse2.h
│ │ │ ├── SFMT.h
│ │ │ ├── btalloc.h
│ │ │ ├── extent_hooks.h
│ │ │ ├── jemalloc_test.h.in
│ │ │ ├── jemalloc_test_defs.h.in
│ │ │ ├── math.h
│ │ │ ├── mq.h
│ │ │ ├── mtx.h
│ │ │ ├── test.h
│ │ │ ├── thd.h
│ │ │ └── timer.h
│ │ ├── integration/
│ │ │ ├── MALLOCX_ARENA.c
│ │ │ ├── aligned_alloc.c
│ │ │ ├── allocated.c
│ │ │ ├── cpp/
│ │ │ │ └── basic.cpp
│ │ │ ├── extent.c
│ │ │ ├── extent.sh
│ │ │ ├── malloc.c
│ │ │ ├── mallocx.c
│ │ │ ├── mallocx.sh
│ │ │ ├── overflow.c
│ │ │ ├── posix_memalign.c
│ │ │ ├── rallocx.c
│ │ │ ├── sdallocx.c
│ │ │ ├── slab_sizes.c
│ │ │ ├── slab_sizes.sh
│ │ │ ├── smallocx.c
│ │ │ ├── smallocx.sh
│ │ │ ├── thread_arena.c
│ │ │ ├── thread_tcache_enabled.c
│ │ │ ├── xallocx.c
│ │ │ └── xallocx.sh
│ │ ├── src/
│ │ │ ├── SFMT.c
│ │ │ ├── btalloc.c
│ │ │ ├── btalloc_0.c
│ │ │ ├── btalloc_1.c
│ │ │ ├── math.c
│ │ │ ├── mq.c
│ │ │ ├── mtx.c
│ │ │ ├── test.c
│ │ │ ├── thd.c
│ │ │ └── timer.c
│ │ ├── stress/
│ │ │ ├── hookbench.c
│ │ │ └── microbench.c
│ │ ├── test.sh.in
│ │ └── unit/
│ │ ├── SFMT.c
│ │ ├── a0.c
│ │ ├── arena_reset.c
│ │ ├── arena_reset_prof.c
│ │ ├── arena_reset_prof.sh
│ │ ├── atomic.c
│ │ ├── background_thread.c
│ │ ├── background_thread_enable.c
│ │ ├── base.c
│ │ ├── binshard.c
│ │ ├── binshard.sh
│ │ ├── bit_util.c
│ │ ├── bitmap.c
│ │ ├── ckh.c
│ │ ├── decay.c
│ │ ├── decay.sh
│ │ ├── div.c
│ │ ├── emitter.c
│ │ ├── extent_quantize.c
│ │ ├── extent_util.c
│ │ ├── fork.c
│ │ ├── hash.c
│ │ ├── hook.c
│ │ ├── huge.c
│ │ ├── junk.c
│ │ ├── junk.sh
│ │ ├── junk_alloc.c
│ │ ├── junk_alloc.sh
│ │ ├── junk_free.c
│ │ ├── junk_free.sh
│ │ ├── log.c
│ │ ├── mallctl.c
│ │ ├── malloc_io.c
│ │ ├── math.c
│ │ ├── mq.c
│ │ ├── mtx.c
│ │ ├── nstime.c
│ │ ├── pack.c
│ │ ├── pack.sh
│ │ ├── pages.c
│ │ ├── ph.c
│ │ ├── prng.c
│ │ ├── prof_accum.c
│ │ ├── prof_accum.sh
│ │ ├── prof_active.c
│ │ ├── prof_active.sh
│ │ ├── prof_gdump.c
│ │ ├── prof_gdump.sh
│ │ ├── prof_idump.c
│ │ ├── prof_idump.sh
│ │ ├── prof_log.c
│ │ ├── prof_log.sh
│ │ ├── prof_reset.c
│ │ ├── prof_reset.sh
│ │ ├── prof_tctx.c
│ │ ├── prof_tctx.sh
│ │ ├── prof_thread_name.c
│ │ ├── prof_thread_name.sh
│ │ ├── ql.c
│ │ ├── qr.c
│ │ ├── rb.c
│ │ ├── retained.c
│ │ ├── rtree.c
│ │ ├── safety_check.c
│ │ ├── safety_check.sh
│ │ ├── sc.c
│ │ ├── seq.c
│ │ ├── size_classes.c
│ │ ├── slab.c
│ │ ├── smoothstep.c
│ │ ├── spin.c
│ │ ├── stats.c
│ │ ├── stats_print.c
│ │ ├── test_hooks.c
│ │ ├── ticker.c
│ │ ├── tsd.c
│ │ ├── witness.c
│ │ ├── zero.c
│ │ └── zero.sh
│ ├── license/
│ │ ├── arm64/
│ │ │ └── libkey.a
│ │ ├── keycheck.h
│ │ └── x64/
│ │ └── libkey.a
│ ├── linenoise/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── README.markdown
│ │ ├── example.c
│ │ ├── linenoise.c
│ │ └── linenoise.h
│ ├── lua/
│ │ ├── COPYRIGHT
│ │ ├── HISTORY
│ │ ├── INSTALL
│ │ ├── Makefile
│ │ ├── README
│ │ ├── doc/
│ │ │ ├── contents.html
│ │ │ ├── lua.1
│ │ │ ├── lua.css
│ │ │ ├── lua.html
│ │ │ ├── luac.1
│ │ │ ├── luac.html
│ │ │ ├── manual.css
│ │ │ ├── manual.html
│ │ │ └── readme.html
│ │ ├── etc/
│ │ │ ├── Makefile
│ │ │ ├── README
│ │ │ ├── all.c
│ │ │ ├── lua.hpp
│ │ │ ├── lua.pc
│ │ │ ├── luavs.bat
│ │ │ ├── min.c
│ │ │ ├── noparser.c
│ │ │ └── strict.lua
│ │ ├── src/
│ │ │ ├── Makefile
│ │ │ ├── fpconv.c
│ │ │ ├── fpconv.h
│ │ │ ├── lapi.c
│ │ │ ├── lapi.h
│ │ │ ├── lauxlib.c
│ │ │ ├── lauxlib.h
│ │ │ ├── lbaselib.c
│ │ │ ├── lcode.c
│ │ │ ├── lcode.h
│ │ │ ├── ldblib.c
│ │ │ ├── ldebug.c
│ │ │ ├── ldebug.h
│ │ │ ├── ldo.c
│ │ │ ├── ldo.h
│ │ │ ├── ldump.c
│ │ │ ├── lfunc.c
│ │ │ ├── lfunc.h
│ │ │ ├── lgc.c
│ │ │ ├── lgc.h
│ │ │ ├── linit.c
│ │ │ ├── liolib.c
│ │ │ ├── llex.c
│ │ │ ├── llex.h
│ │ │ ├── llimits.h
│ │ │ ├── lmathlib.c
│ │ │ ├── lmem.c
│ │ │ ├── lmem.h
│ │ │ ├── loadlib.c
│ │ │ ├── lobject.c
│ │ │ ├── lobject.h
│ │ │ ├── lopcodes.c
│ │ │ ├── lopcodes.h
│ │ │ ├── loslib.c
│ │ │ ├── lparser.c
│ │ │ ├── lparser.h
│ │ │ ├── lstate.c
│ │ │ ├── lstate.h
│ │ │ ├── lstring.c
│ │ │ ├── lstring.h
│ │ │ ├── lstrlib.c
│ │ │ ├── ltable.c
│ │ │ ├── ltable.h
│ │ │ ├── ltablib.c
│ │ │ ├── ltm.c
│ │ │ ├── ltm.h
│ │ │ ├── lua.c
│ │ │ ├── lua.h
│ │ │ ├── lua_bit.c
│ │ │ ├── lua_cjson.c
│ │ │ ├── lua_cmsgpack.c
│ │ │ ├── lua_struct.c
│ │ │ ├── luac.c
│ │ │ ├── luaconf.h
│ │ │ ├── lualib.h
│ │ │ ├── lundump.c
│ │ │ ├── lundump.h
│ │ │ ├── lvm.c
│ │ │ ├── lvm.h
│ │ │ ├── lzio.c
│ │ │ ├── lzio.h
│ │ │ ├── print.c
│ │ │ ├── strbuf.c
│ │ │ └── strbuf.h
│ │ └── test/
│ │ ├── README
│ │ ├── bisect.lua
│ │ ├── cf.lua
│ │ ├── echo.lua
│ │ ├── env.lua
│ │ ├── factorial.lua
│ │ ├── fib.lua
│ │ ├── fibfor.lua
│ │ ├── globals.lua
│ │ ├── hello.lua
│ │ ├── life.lua
│ │ ├── luac.lua
│ │ ├── printf.lua
│ │ ├── readonly.lua
│ │ ├── sieve.lua
│ │ ├── sort.lua
│ │ ├── table.lua
│ │ ├── trace-calls.lua
│ │ ├── trace-globals.lua
│ │ └── xd.lua
│ ├── memkind/
│ │ ├── Makefile
│ │ └── src/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── AUTHORS
│ │ ├── CONTRIBUTING
│ │ ├── COPYING
│ │ ├── ChangeLog
│ │ ├── INSTALL
│ │ ├── MANIFEST
│ │ ├── Makefile.am
│ │ ├── NEWS
│ │ ├── PULL_REQUEST_TEMPLATE.md
│ │ ├── README
│ │ ├── astyle.sh
│ │ ├── autogen.sh
│ │ ├── autohbw/
│ │ │ ├── Makefile.mk
│ │ │ ├── autohbw.c
│ │ │ ├── autohbw_README
│ │ │ ├── autohbw_api.h
│ │ │ ├── autohbw_get_src_lines.pl
│ │ │ └── autohbw_test.sh
│ │ ├── build.sh
│ │ ├── build_jemalloc.sh
│ │ ├── config.h.in~
│ │ ├── configure.ac
│ │ ├── copying_headers/
│ │ │ ├── MANIFEST.EXEMPT
│ │ │ ├── MANIFEST.freeBSD
│ │ │ ├── MANIFEST.freeBSD3
│ │ │ ├── header.freeBSD
│ │ │ ├── header.freeBSD3
│ │ │ └── header.intel-acpi
│ │ ├── debian/
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ └── rules
│ │ ├── examples/
│ │ │ ├── Makefile.mk
│ │ │ ├── README
│ │ │ ├── autohbw_candidates.c
│ │ │ ├── filter_example.c
│ │ │ ├── hello_hbw_example.c
│ │ │ ├── hello_memkind_example.c
│ │ │ ├── memkind_allocated.hpp
│ │ │ ├── memkind_allocated_example.cpp
│ │ │ ├── memkind_decorator_debug.c
│ │ │ ├── pmem_alignment.c
│ │ │ ├── pmem_and_default_kind.c
│ │ │ ├── pmem_cpp_allocator.cpp
│ │ │ ├── pmem_free_with_unknown_kind.c
│ │ │ ├── pmem_kinds.c
│ │ │ ├── pmem_malloc.c
│ │ │ ├── pmem_malloc_unlimited.c
│ │ │ ├── pmem_multithreads.c
│ │ │ ├── pmem_multithreads_onekind.c
│ │ │ └── pmem_usable_size.c
│ │ ├── include/
│ │ │ ├── hbw_allocator.h
│ │ │ ├── hbwmalloc.h
│ │ │ ├── memkind/
│ │ │ │ └── internal/
│ │ │ │ ├── heap_manager.h
│ │ │ │ ├── memkind_arena.h
│ │ │ │ ├── memkind_default.h
│ │ │ │ ├── memkind_gbtlb.h
│ │ │ │ ├── memkind_hbw.h
│ │ │ │ ├── memkind_hugetlb.h
│ │ │ │ ├── memkind_interleave.h
│ │ │ │ ├── memkind_log.h
│ │ │ │ ├── memkind_pmem.h
│ │ │ │ ├── memkind_private.h
│ │ │ │ ├── memkind_regular.h
│ │ │ │ ├── tbb_mem_pool_policy.h
│ │ │ │ └── tbb_wrapper.h
│ │ │ ├── memkind.h
│ │ │ ├── memkind_deprecated.h
│ │ │ └── pmem_allocator.h
│ │ ├── install_astyle.sh
│ │ ├── jemalloc/
│ │ │ ├── .appveyor.yml
│ │ │ ├── .autom4te.cfg
│ │ │ ├── .gitattributes
│ │ │ ├── .gitignore
│ │ │ ├── .travis.yml
│ │ │ ├── COPYING
│ │ │ ├── ChangeLog
│ │ │ ├── INSTALL.md
│ │ │ ├── Makefile.in
│ │ │ ├── README
│ │ │ ├── autogen.sh
│ │ │ ├── bin/
│ │ │ │ ├── jemalloc-config.in
│ │ │ │ ├── jemalloc.sh.in
│ │ │ │ └── jeprof.in
│ │ │ ├── build-aux/
│ │ │ │ ├── config.guess
│ │ │ │ ├── config.sub
│ │ │ │ └── install-sh
│ │ │ ├── config.stamp.in
│ │ │ ├── configure.ac
│ │ │ ├── doc/
│ │ │ │ ├── html.xsl.in
│ │ │ │ ├── jemalloc.xml.in
│ │ │ │ ├── manpages.xsl.in
│ │ │ │ └── stylesheet.xsl
│ │ │ ├── include/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── arena_externs.h
│ │ │ │ │ │ ├── arena_inlines_a.h
│ │ │ │ │ │ ├── arena_inlines_b.h
│ │ │ │ │ │ ├── arena_structs_a.h
│ │ │ │ │ │ ├── arena_structs_b.h
│ │ │ │ │ │ ├── arena_types.h
│ │ │ │ │ │ ├── assert.h
│ │ │ │ │ │ ├── atomic.h
│ │ │ │ │ │ ├── atomic_c11.h
│ │ │ │ │ │ ├── atomic_gcc_atomic.h
│ │ │ │ │ │ ├── atomic_gcc_sync.h
│ │ │ │ │ │ ├── atomic_msvc.h
│ │ │ │ │ │ ├── background_thread_externs.h
│ │ │ │ │ │ ├── background_thread_inlines.h
│ │ │ │ │ │ ├── background_thread_structs.h
│ │ │ │ │ │ ├── base_externs.h
│ │ │ │ │ │ ├── base_inlines.h
│ │ │ │ │ │ ├── base_structs.h
│ │ │ │ │ │ ├── base_types.h
│ │ │ │ │ │ ├── bit_util.h
│ │ │ │ │ │ ├── bitmap.h
│ │ │ │ │ │ ├── ckh.h
│ │ │ │ │ │ ├── ctl.h
│ │ │ │ │ │ ├── extent_dss.h
│ │ │ │ │ │ ├── extent_externs.h
│ │ │ │ │ │ ├── extent_inlines.h
│ │ │ │ │ │ ├── extent_mmap.h
│ │ │ │ │ │ ├── extent_structs.h
│ │ │ │ │ │ ├── extent_types.h
│ │ │ │ │ │ ├── hash.h
│ │ │ │ │ │ ├── hooks.h
│ │ │ │ │ │ ├── jemalloc_internal_decls.h
│ │ │ │ │ │ ├── jemalloc_internal_defs.h.in
│ │ │ │ │ │ ├── jemalloc_internal_externs.h
│ │ │ │ │ │ ├── jemalloc_internal_includes.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_a.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_b.h
│ │ │ │ │ │ ├── jemalloc_internal_inlines_c.h
│ │ │ │ │ │ ├── jemalloc_internal_macros.h
│ │ │ │ │ │ ├── jemalloc_internal_types.h
│ │ │ │ │ │ ├── jemalloc_preamble.h.in
│ │ │ │ │ │ ├── large_externs.h
│ │ │ │ │ │ ├── malloc_io.h
│ │ │ │ │ │ ├── mutex.h
│ │ │ │ │ │ ├── mutex_pool.h
│ │ │ │ │ │ ├── mutex_prof.h
│ │ │ │ │ │ ├── nstime.h
│ │ │ │ │ │ ├── pages.h
│ │ │ │ │ │ ├── ph.h
│ │ │ │ │ │ ├── private_namespace.sh
│ │ │ │ │ │ ├── private_symbols.sh
│ │ │ │ │ │ ├── prng.h
│ │ │ │ │ │ ├── prof_externs.h
│ │ │ │ │ │ ├── prof_inlines_a.h
│ │ │ │ │ │ ├── prof_inlines_b.h
│ │ │ │ │ │ ├── prof_structs.h
│ │ │ │ │ │ ├── prof_types.h
│ │ │ │ │ │ ├── public_namespace.sh
│ │ │ │ │ │ ├── public_unnamespace.sh
│ │ │ │ │ │ ├── ql.h
│ │ │ │ │ │ ├── qr.h
│ │ │ │ │ │ ├── rb.h
│ │ │ │ │ │ ├── rtree.h
│ │ │ │ │ │ ├── rtree_tsd.h
│ │ │ │ │ │ ├── size_classes.sh
│ │ │ │ │ │ ├── smoothstep.h
│ │ │ │ │ │ ├── smoothstep.sh
│ │ │ │ │ │ ├── spin.h
│ │ │ │ │ │ ├── stats.h
│ │ │ │ │ │ ├── stats_tsd.h
│ │ │ │ │ │ ├── sz.h
│ │ │ │ │ │ ├── tcache_externs.h
│ │ │ │ │ │ ├── tcache_inlines.h
│ │ │ │ │ │ ├── tcache_structs.h
│ │ │ │ │ │ ├── tcache_types.h
│ │ │ │ │ │ ├── ticker.h
│ │ │ │ │ │ ├── tsd.h
│ │ │ │ │ │ ├── tsd_generic.h
│ │ │ │ │ │ ├── tsd_malloc_thread_cleanup.h
│ │ │ │ │ │ ├── tsd_tls.h
│ │ │ │ │ │ ├── tsd_types.h
│ │ │ │ │ │ ├── tsd_win.h
│ │ │ │ │ │ ├── util.h
│ │ │ │ │ │ └── witness.h
│ │ │ │ │ ├── jemalloc.sh
│ │ │ │ │ ├── jemalloc_defs.h.in
│ │ │ │ │ ├── jemalloc_macros.h.in
│ │ │ │ │ ├── jemalloc_mangle.sh
│ │ │ │ │ ├── jemalloc_protos.h.in
│ │ │ │ │ ├── jemalloc_rename.sh
│ │ │ │ │ └── jemalloc_typedefs.h.in
│ │ │ │ └── msvc_compat/
│ │ │ │ ├── C99/
│ │ │ │ │ ├── stdbool.h
│ │ │ │ │ └── stdint.h
│ │ │ │ ├── strings.h
│ │ │ │ └── windows_extra.h
│ │ │ ├── jemalloc.pc.in
│ │ │ ├── m4/
│ │ │ │ └── ax_cxx_compile_stdcxx.m4
│ │ │ ├── msvc/
│ │ │ │ ├── ReadMe.txt
│ │ │ │ ├── jemalloc_vc2015.sln
│ │ │ │ └── projects/
│ │ │ │ └── vc2015/
│ │ │ │ ├── jemalloc/
│ │ │ │ │ ├── jemalloc.vcxproj
│ │ │ │ │ └── jemalloc.vcxproj.filters
│ │ │ │ └── test_threads/
│ │ │ │ ├── test_threads.cpp
│ │ │ │ ├── test_threads.h
│ │ │ │ ├── test_threads.vcxproj
│ │ │ │ ├── test_threads.vcxproj.filters
│ │ │ │ └── test_threads_main.cpp
│ │ │ ├── run_tests.sh
│ │ │ ├── scripts/
│ │ │ │ ├── gen_run_tests.py
│ │ │ │ └── gen_travis.py
│ │ │ ├── src/
│ │ │ │ ├── arena.c
│ │ │ │ ├── background_thread.c
│ │ │ │ ├── base.c
│ │ │ │ ├── bitmap.c
│ │ │ │ ├── ckh.c
│ │ │ │ ├── ctl.c
│ │ │ │ ├── extent.c
│ │ │ │ ├── extent_dss.c
│ │ │ │ ├── extent_mmap.c
│ │ │ │ ├── hash.c
│ │ │ │ ├── hooks.c
│ │ │ │ ├── jemalloc.c
│ │ │ │ ├── jemalloc_cpp.cpp
│ │ │ │ ├── large.c
│ │ │ │ ├── malloc_io.c
│ │ │ │ ├── mutex.c
│ │ │ │ ├── mutex_pool.c
│ │ │ │ ├── nstime.c
│ │ │ │ ├── pages.c
│ │ │ │ ├── prng.c
│ │ │ │ ├── prof.c
│ │ │ │ ├── rtree.c
│ │ │ │ ├── spin.c
│ │ │ │ ├── stats.c
│ │ │ │ ├── sz.c
│ │ │ │ ├── tcache.c
│ │ │ │ ├── ticker.c
│ │ │ │ ├── tsd.c
│ │ │ │ ├── witness.c
│ │ │ │ └── zone.c
│ │ │ └── test/
│ │ │ ├── include/
│ │ │ │ └── test/
│ │ │ │ ├── SFMT-alti.h
│ │ │ │ ├── SFMT-params.h
│ │ │ │ ├── SFMT-params11213.h
│ │ │ │ ├── SFMT-params1279.h
│ │ │ │ ├── SFMT-params132049.h
│ │ │ │ ├── SFMT-params19937.h
│ │ │ │ ├── SFMT-params216091.h
│ │ │ │ ├── SFMT-params2281.h
│ │ │ │ ├── SFMT-params4253.h
│ │ │ │ ├── SFMT-params44497.h
│ │ │ │ ├── SFMT-params607.h
│ │ │ │ ├── SFMT-params86243.h
│ │ │ │ ├── SFMT-sse2.h
│ │ │ │ ├── SFMT.h
│ │ │ │ ├── btalloc.h
│ │ │ │ ├── extent_hooks.h
│ │ │ │ ├── jemalloc_test.h.in
│ │ │ │ ├── jemalloc_test_defs.h.in
│ │ │ │ ├── math.h
│ │ │ │ ├── mq.h
│ │ │ │ ├── mtx.h
│ │ │ │ ├── test.h
│ │ │ │ ├── thd.h
│ │ │ │ └── timer.h
│ │ │ ├── integration/
│ │ │ │ ├── MALLOCX_ARENA.c
│ │ │ │ ├── aligned_alloc.c
│ │ │ │ ├── allocated.c
│ │ │ │ ├── extent.c
│ │ │ │ ├── extent.sh
│ │ │ │ ├── mallocx.c
│ │ │ │ ├── mallocx.sh
│ │ │ │ ├── overflow.c
│ │ │ │ ├── posix_memalign.c
│ │ │ │ ├── rallocx.c
│ │ │ │ ├── sdallocx.c
│ │ │ │ ├── thread_arena.c
│ │ │ │ ├── thread_tcache_enabled.c
│ │ │ │ ├── xallocx.c
│ │ │ │ └── xallocx.sh
│ │ │ ├── src/
│ │ │ │ ├── SFMT.c
│ │ │ │ ├── btalloc.c
│ │ │ │ ├── btalloc_0.c
│ │ │ │ ├── btalloc_1.c
│ │ │ │ ├── math.c
│ │ │ │ ├── mq.c
│ │ │ │ ├── mtx.c
│ │ │ │ ├── test.c
│ │ │ │ ├── thd.c
│ │ │ │ └── timer.c
│ │ │ ├── stress/
│ │ │ │ └── microbench.c
│ │ │ ├── test.sh.in
│ │ │ └── unit/
│ │ │ ├── SFMT.c
│ │ │ ├── a0.c
│ │ │ ├── arena_reset.c
│ │ │ ├── arena_reset_prof.c
│ │ │ ├── arena_reset_prof.sh
│ │ │ ├── atomic.c
│ │ │ ├── background_thread.c
│ │ │ ├── base.c
│ │ │ ├── bit_util.c
│ │ │ ├── bitmap.c
│ │ │ ├── ckh.c
│ │ │ ├── decay.c
│ │ │ ├── decay.sh
│ │ │ ├── extent_quantize.c
│ │ │ ├── fork.c
│ │ │ ├── hash.c
│ │ │ ├── hooks.c
│ │ │ ├── junk.c
│ │ │ ├── junk.sh
│ │ │ ├── junk_alloc.c
│ │ │ ├── junk_alloc.sh
│ │ │ ├── junk_free.c
│ │ │ ├── junk_free.sh
│ │ │ ├── mallctl.c
│ │ │ ├── malloc_io.c
│ │ │ ├── math.c
│ │ │ ├── mq.c
│ │ │ ├── mtx.c
│ │ │ ├── nstime.c
│ │ │ ├── pack.c
│ │ │ ├── pack.sh
│ │ │ ├── pages.c
│ │ │ ├── ph.c
│ │ │ ├── prng.c
│ │ │ ├── prof_accum.c
│ │ │ ├── prof_accum.sh
│ │ │ ├── prof_active.c
│ │ │ ├── prof_active.sh
│ │ │ ├── prof_gdump.c
│ │ │ ├── prof_gdump.sh
│ │ │ ├── prof_idump.c
│ │ │ ├── prof_idump.sh
│ │ │ ├── prof_reset.c
│ │ │ ├── prof_reset.sh
│ │ │ ├── prof_tctx.c
│ │ │ ├── prof_tctx.sh
│ │ │ ├── prof_thread_name.c
│ │ │ ├── prof_thread_name.sh
│ │ │ ├── ql.c
│ │ │ ├── qr.c
│ │ │ ├── rb.c
│ │ │ ├── retained.c
│ │ │ ├── rtree.c
│ │ │ ├── size_classes.c
│ │ │ ├── slab.c
│ │ │ ├── smoothstep.c
│ │ │ ├── spin.c
│ │ │ ├── stats.c
│ │ │ ├── stats_print.c
│ │ │ ├── ticker.c
│ │ │ ├── tsd.c
│ │ │ ├── witness.c
│ │ │ ├── zero.c
│ │ │ └── zero.sh
│ │ ├── m4/
│ │ │ ├── ax_cxx_compile_stdcxx.m4
│ │ │ ├── ax_cxx_compile_stdcxx_11.m4
│ │ │ └── ax_pthread.m4
│ │ ├── make_rpm.mk
│ │ ├── man/
│ │ │ ├── autohbw.7
│ │ │ ├── hbwallocator.3
│ │ │ ├── hbwmalloc.3
│ │ │ ├── memkind-hbw-nodes.1
│ │ │ ├── memkind.3
│ │ │ ├── memkind_arena.3
│ │ │ ├── memkind_default.3
│ │ │ ├── memkind_hbw.3
│ │ │ ├── memkind_hugetlb.3
│ │ │ ├── memkind_interleave.3
│ │ │ ├── memkind_pmem.3
│ │ │ └── pmemallocator.3
│ │ ├── memkind.spec.mk
│ │ ├── src/
│ │ │ ├── Makefile.mk
│ │ │ ├── hbwmalloc.c
│ │ │ ├── heap_manager.c
│ │ │ ├── memkind-hbw-nodes.c
│ │ │ ├── memkind.c
│ │ │ ├── memkind_arena.c
│ │ │ ├── memkind_default.c
│ │ │ ├── memkind_gbtlb.c
│ │ │ ├── memkind_hbw.c
│ │ │ ├── memkind_hugetlb.c
│ │ │ ├── memkind_interleave.c
│ │ │ ├── memkind_log.c
│ │ │ ├── memkind_pmem.c
│ │ │ ├── memkind_regular.c
│ │ │ └── tbb_wrapper.c
│ │ └── test/
│ │ ├── Allocator.hpp
│ │ ├── Makefile.mk
│ │ ├── README
│ │ ├── TestPolicy.hpp
│ │ ├── alloc_benchmark.c
│ │ ├── alloc_performance_tests.cpp
│ │ ├── allocate_to_max_stress_test.cpp
│ │ ├── allocator_perf_tool/
│ │ │ ├── AllocationSizes.hpp
│ │ │ ├── Allocation_info.cpp
│ │ │ ├── Allocation_info.hpp
│ │ │ ├── Allocator.hpp
│ │ │ ├── AllocatorFactory.hpp
│ │ │ ├── CSVLogger.hpp
│ │ │ ├── CommandLine.hpp
│ │ │ ├── Configuration.hpp
│ │ │ ├── ConsoleLog.hpp
│ │ │ ├── FunctionCalls.hpp
│ │ │ ├── FunctionCallsPerformanceTask.cpp
│ │ │ ├── FunctionCallsPerformanceTask.h
│ │ │ ├── GTestAdapter.hpp
│ │ │ ├── HBWmallocAllocatorWithTimer.hpp
│ │ │ ├── HugePageOrganizer.hpp
│ │ │ ├── HugePageUnmap.hpp
│ │ │ ├── Iterator.hpp
│ │ │ ├── JemallocAllocatorWithTimer.hpp
│ │ │ ├── Makefile
│ │ │ ├── MemkindAllocatorWithTimer.hpp
│ │ │ ├── Numastat.hpp
│ │ │ ├── PmemMockup.cpp
│ │ │ ├── PmemMockup.hpp
│ │ │ ├── Runnable.hpp
│ │ │ ├── ScenarioWorkload.cpp
│ │ │ ├── ScenarioWorkload.h
│ │ │ ├── StandardAllocatorWithTimer.hpp
│ │ │ ├── Stats.hpp
│ │ │ ├── StressIncreaseToMax.cpp
│ │ │ ├── StressIncreaseToMax.h
│ │ │ ├── Task.hpp
│ │ │ ├── TaskFactory.hpp
│ │ │ ├── Tests.hpp
│ │ │ ├── Thread.hpp
│ │ │ ├── TimerSysTime.hpp
│ │ │ ├── VectorIterator.hpp
│ │ │ ├── Workload.hpp
│ │ │ ├── WrappersMacros.hpp
│ │ │ └── main.cpp
│ │ ├── autohbw_test.py
│ │ ├── autohbw_test_helper.c
│ │ ├── bat_tests.cpp
│ │ ├── check.cpp
│ │ ├── check.h
│ │ ├── common.h
│ │ ├── decorator_test.cpp
│ │ ├── decorator_test.h
│ │ ├── dlopen_test.cpp
│ │ ├── draw_plots.py
│ │ ├── environ_err_hbw_malloc_test.cpp
│ │ ├── error_message_tests.cpp
│ │ ├── freeing_memory_segfault_test.cpp
│ │ ├── gb_page_tests_bind_policy.cpp
│ │ ├── get_arena_test.cpp
│ │ ├── gtest_fused/
│ │ │ └── gtest/
│ │ │ ├── gtest-all.cc
│ │ │ └── gtest.h
│ │ ├── hbw_allocator_tests.cpp
│ │ ├── hbw_detection_test.py
│ │ ├── hbw_verify_function_test.cpp
│ │ ├── heap_manager_init_perf_test.cpp
│ │ ├── huge_page_test.cpp
│ │ ├── load_tbbmalloc_symbols.c
│ │ ├── locality_test.cpp
│ │ ├── main.cpp
│ │ ├── memkind-afts-ext.ts
│ │ ├── memkind-afts.ts
│ │ ├── memkind-perf-ext.ts
│ │ ├── memkind-perf.ts
│ │ ├── memkind-pytests.ts
│ │ ├── memkind-slts.ts
│ │ ├── memkind_pmem_long_time_tests.cpp
│ │ ├── memkind_pmem_tests.cpp
│ │ ├── memkind_versioning_tests.cpp
│ │ ├── memory_footprint_test.cpp
│ │ ├── memory_manager.h
│ │ ├── multithreaded_tests.cpp
│ │ ├── negative_tests.cpp
│ │ ├── performance/
│ │ │ ├── framework.cpp
│ │ │ ├── framework.hpp
│ │ │ ├── operations.hpp
│ │ │ ├── perf_tests.cpp
│ │ │ └── perf_tests.hpp
│ │ ├── pmem_allocator_tests.cpp
│ │ ├── proc_stat.h
│ │ ├── python_framework/
│ │ │ ├── __init__.py
│ │ │ ├── cmd_helper.py
│ │ │ └── huge_page_organizer.py
│ │ ├── random_sizes_allocator.h
│ │ ├── run_alloc_benchmark.sh
│ │ ├── static_kinds_list.h
│ │ ├── static_kinds_tests.cpp
│ │ ├── tbbmalloc.h
│ │ ├── test.sh
│ │ ├── trace_mechanism_test.py
│ │ ├── trace_mechanism_test_helper.c
│ │ ├── trial_generator.cpp
│ │ └── trial_generator.h
│ └── update-jemalloc.sh
├── fuzz/
│ └── rdb/
│ ├── dict.txt
│ └── testcases/
│ ├── empty.rdb
│ ├── expire.rdb
│ ├── expireonload.rdb
│ ├── integer.rdb
│ ├── integer_shared.rdb
│ ├── multidb.rdb
│ ├── replica.rdb
│ ├── set.rdb
│ └── string.rdb
├── keydb.conf
├── machamp_scripts/
│ ├── Dockerfile
│ └── build.sh
├── monkey/
│ └── monkey.py
├── pkg/
│ ├── README.md
│ ├── deb/
│ │ ├── README.md
│ │ ├── conf/
│ │ │ ├── keydb.conf
│ │ │ └── sentinel.conf
│ │ ├── deb-buildsource.sh
│ │ ├── deb_files_generated/
│ │ │ └── .gitkeep
│ │ ├── debian/
│ │ │ ├── bash_completion.d/
│ │ │ │ └── keydb-cli
│ │ │ ├── bin/
│ │ │ │ └── generate-systemd-service-files
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ ├── copyright
│ │ │ ├── keydb-benchmark.1
│ │ │ ├── keydb-check-aof.1
│ │ │ ├── keydb-check-rdb.1
│ │ │ ├── keydb-cli.1
│ │ │ ├── keydb-sentinel.1
│ │ │ ├── keydb-sentinel.install
│ │ │ ├── keydb-sentinel.logrotate
│ │ │ ├── keydb-sentinel.manpages
│ │ │ ├── keydb-sentinel.postinst
│ │ │ ├── keydb-sentinel.postrm
│ │ │ ├── keydb-server.1
│ │ │ ├── keydb-server.docs
│ │ │ ├── keydb-server.install
│ │ │ ├── keydb-server.logrotate
│ │ │ ├── keydb-server.manpages
│ │ │ ├── keydb-server.postinst
│ │ │ ├── keydb-server.postrm
│ │ │ ├── keydb-tools.examples
│ │ │ ├── keydb-tools.install
│ │ │ ├── keydb-tools.manpages
│ │ │ ├── keydb-tools.postinst
│ │ │ ├── keydb-tools.postrm
│ │ │ ├── rules
│ │ │ ├── source/
│ │ │ │ ├── format
│ │ │ │ └── lintian-overrides
│ │ │ ├── tests/
│ │ │ │ ├── 0001-keydb-cli
│ │ │ │ ├── 0002-benchmark
│ │ │ │ ├── 0003-keydb-check-aof
│ │ │ │ ├── 0004-keydb-check-rdb
│ │ │ │ └── control
│ │ │ ├── watch
│ │ │ └── zsh-completion/
│ │ │ └── _keydb-cli
│ │ ├── debian_dh9/
│ │ │ ├── NEWS
│ │ │ ├── bash_completion.d/
│ │ │ │ └── keydb-cli
│ │ │ ├── bin/
│ │ │ │ └── generate-systemd-service-files
│ │ │ ├── changelog
│ │ │ ├── compat
│ │ │ ├── control
│ │ │ ├── copyright
│ │ │ ├── files
│ │ │ ├── gbp.conf
│ │ │ ├── keydb-benchmark.1
│ │ │ ├── keydb-check-aof.1
│ │ │ ├── keydb-check-rdb.1
│ │ │ ├── keydb-cli.1
│ │ │ ├── keydb-sentinel.1
│ │ │ ├── keydb-sentinel.default
│ │ │ ├── keydb-sentinel.init
│ │ │ ├── keydb-sentinel.install
│ │ │ ├── keydb-sentinel.logrotate
│ │ │ ├── keydb-sentinel.maintscript
│ │ │ ├── keydb-sentinel.manpages
│ │ │ ├── keydb-sentinel.postinst
│ │ │ ├── keydb-sentinel.postrm
│ │ │ ├── keydb-server.1
│ │ │ ├── keydb-server.default
│ │ │ ├── keydb-server.docs
│ │ │ ├── keydb-server.init
│ │ │ ├── keydb-server.install
│ │ │ ├── keydb-server.logrotate
│ │ │ ├── keydb-server.maintscript
│ │ │ ├── keydb-server.manpages
│ │ │ ├── keydb-server.postinst
│ │ │ ├── keydb-server.postrm
│ │ │ ├── keydb-tools.examples
│ │ │ ├── keydb-tools.install
│ │ │ ├── keydb-tools.manpages
│ │ │ ├── keydb-tools.postinst
│ │ │ ├── keydb-tools.postrm
│ │ │ ├── patches/
│ │ │ │ ├── 0001-fix-ftbfs-on-kfreebsd.patch
│ │ │ │ ├── 0010-Use-get_current_dir_name-over-PATHMAX-etc.patch
│ │ │ │ ├── 0011-Add-support-for-a-USE_SYSTEM_LUA-flag.patch
│ │ │ │ ├── debian-packaging/
│ │ │ │ │ ├── 0003-dpkg-buildflags.patch
│ │ │ │ │ └── 0007-Set-Debian-configuration-defaults.patch
│ │ │ │ ├── series
│ │ │ │ └── test
│ │ │ ├── rules
│ │ │ ├── source/
│ │ │ │ ├── format
│ │ │ │ ├── include-binaries
│ │ │ │ ├── lintian-overrides
│ │ │ │ └── options
│ │ │ ├── tests/
│ │ │ │ ├── 0001-keydb-cli
│ │ │ │ ├── 0002-benchmark
│ │ │ │ ├── 0003-keydb-check-aof
│ │ │ │ ├── 0004-keydb-check-rdb
│ │ │ │ └── control
│ │ │ └── watch
│ │ └── master_changelog
│ ├── docker/
│ │ ├── Dockerfile
│ │ ├── Dockerfile_Alpine
│ │ └── README.md
│ └── rpm/
│ ├── README.md
│ ├── generate_rpms.sh
│ ├── keydb_build/
│ │ ├── keydb.spec
│ │ └── keydb_rpm/
│ │ ├── etc/
│ │ │ ├── keydb/
│ │ │ │ ├── keydb.conf
│ │ │ │ └── sentinel.conf
│ │ │ ├── logrotate.d/
│ │ │ │ └── keydb
│ │ │ └── systemd/
│ │ │ └── system/
│ │ │ ├── keydb-sentinel.service.d/
│ │ │ │ └── limit.conf
│ │ │ └── keydb.service.d/
│ │ │ └── limit.conf
│ │ └── usr/
│ │ ├── lib/
│ │ │ └── systemd/
│ │ │ └── system/
│ │ │ ├── keydb-sentinel.service
│ │ │ └── keydb.service
│ │ ├── libexec/
│ │ │ └── keydb-shutdown
│ │ └── share/
│ │ └── licenses/
│ │ └── keydb/
│ │ ├── COPYING
│ │ ├── COPYING-hiredis
│ │ ├── COPYING-jemalloc
│ │ └── COPYRIGHT-lua
│ └── rpm_files_generated/
│ └── .gitkeep
├── runtest
├── runtest-cluster
├── runtest-moduleapi
├── runtest-rotation
├── runtest-sentinel
├── sentinel.conf
├── src/
│ ├── .gitignore
│ ├── AsyncWorkQueue.cpp
│ ├── AsyncWorkQueue.h
│ ├── IStorage.h
│ ├── Makefile
│ ├── SnapshotPayloadParseState.cpp
│ ├── SnapshotPayloadParseState.h
│ ├── StorageCache.cpp
│ ├── StorageCache.h
│ ├── acl.cpp
│ ├── adlist.c
│ ├── adlist.h
│ ├── ae.cpp
│ ├── ae.h
│ ├── ae_epoll.cpp
│ ├── ae_evport.c
│ ├── ae_kqueue.c
│ ├── ae_select.c
│ ├── aelocker.h
│ ├── anet.c
│ ├── anet.h
│ ├── aof.cpp
│ ├── asciilogo.h
│ ├── atomicvar.h
│ ├── bio.cpp
│ ├── bio.h
│ ├── bitops.cpp
│ ├── blocked.cpp
│ ├── childinfo.cpp
│ ├── cli_common.c
│ ├── cli_common.h
│ ├── cluster.cpp
│ ├── cluster.h
│ ├── compactvector.h
│ ├── config.cpp
│ ├── config.h
│ ├── connection.cpp
│ ├── connection.h
│ ├── connhelpers.h
│ ├── cowptr.h
│ ├── crc16.c
│ ├── crc16_slottable.h
│ ├── crc64.c
│ ├── crc64.h
│ ├── crcspeed.c
│ ├── crcspeed.h
│ ├── cron.cpp
│ ├── cron.h
│ ├── db.cpp
│ ├── debug.cpp
│ ├── debugmacro.h
│ ├── defrag.cpp
│ ├── dict.cpp
│ ├── dict.h
│ ├── endianconv.c
│ ├── endianconv.h
│ ├── evict.cpp
│ ├── expire.cpp
│ ├── expire.h
│ ├── fastlock.cpp
│ ├── fastlock.h
│ ├── fastlock_x64.asm
│ ├── fmacros.h
│ ├── gc.h
│ ├── geo.cpp
│ ├── geo.h
│ ├── geohash.c
│ ├── geohash.h
│ ├── geohash_helper.cpp
│ ├── geohash_helper.h
│ ├── help.h
│ ├── hyperloglog.cpp
│ ├── intset.c
│ ├── intset.h
│ ├── keydb-diagnostic-tool.cpp
│ ├── keydbutils.cpp
│ ├── latency.cpp
│ ├── latency.h
│ ├── lazyfree.cpp
│ ├── listpack.c
│ ├── listpack.h
│ ├── listpack_malloc.h
│ ├── localtime.c
│ ├── lolwut.c
│ ├── lolwut.h
│ ├── lolwut5.c
│ ├── lolwut6.c
│ ├── lzf.h
│ ├── lzfP.h
│ ├── lzf_c.c
│ ├── lzf_d.c
│ ├── meminfo.cpp
│ ├── memtest.c
│ ├── mkreleasehdr.sh
│ ├── module.cpp
│ ├── modules/
│ │ ├── .gitignore
│ │ ├── Makefile
│ │ ├── gendoc.rb
│ │ ├── helloacl.c
│ │ ├── helloblock.c
│ │ ├── hellocluster.c
│ │ ├── hellodict.c
│ │ ├── hellohook.c
│ │ ├── hellotimer.c
│ │ ├── hellotype.c
│ │ ├── helloworld.c
│ │ └── keydb_modstatsd/
│ │ ├── Makefile
│ │ ├── modmain.cpp
│ │ └── redismodule.h
│ ├── monotonic.c
│ ├── monotonic.h
│ ├── motd.cpp
│ ├── motd.h
│ ├── mt19937-64.c
│ ├── mt19937-64.h
│ ├── multi.cpp
│ ├── networking.cpp
│ ├── new.cpp
│ ├── new.h
│ ├── notify.cpp
│ ├── object.cpp
│ ├── pqsort.c
│ ├── pqsort.h
│ ├── pubsub.cpp
│ ├── quicklist.c
│ ├── quicklist.h
│ ├── rand.c
│ ├── rand.h
│ ├── rax.c
│ ├── rax.h
│ ├── rax_malloc.h
│ ├── rdb-s3.cpp
│ ├── rdb.cpp
│ ├── rdb.h
│ ├── readwritelock.h
│ ├── redis-benchmark.cpp
│ ├── redis-check-aof.cpp
│ ├── redis-check-rdb.cpp
│ ├── redis-cli-cpphelper.cpp
│ ├── redis-cli.c
│ ├── redis-cli.h
│ ├── redis-trib.rb
│ ├── redisassert.h
│ ├── redismodule.h
│ ├── release.c
│ ├── replication.cpp
│ ├── rio.cpp
│ ├── rio.h
│ ├── scripting.cpp
│ ├── sds.c
│ ├── sds.h
│ ├── sdsalloc.h
│ ├── sdscompat.h
│ ├── semiorderedset.h
│ ├── sentinel.cpp
│ ├── server.cpp
│ ├── server.h
│ ├── serverassert.h
│ ├── setcpuaffinity.c
│ ├── setproctitle.c
│ ├── sha1.c
│ ├── sha1.h
│ ├── sha256.c
│ ├── sha256.h
│ ├── siphash.c
│ ├── slowlog.cpp
│ ├── slowlog.h
│ ├── snapshot.cpp
│ ├── solarisfixes.h
│ ├── sort.cpp
│ ├── sparkline.cpp
│ ├── sparkline.h
│ ├── storage/
│ │ ├── rocksdb.cpp
│ │ ├── rocksdb.h
│ │ ├── rocksdbfactor_internal.h
│ │ ├── rocksdbfactory.cpp
│ │ ├── rocksdbfactory.h
│ │ ├── teststorageprovider.cpp
│ │ └── teststorageprovider.h
│ ├── storage-lite.c
│ ├── storage.cpp
│ ├── storage.h
│ ├── stream.h
│ ├── syncio.cpp
│ ├── t_hash.cpp
│ ├── t_list.cpp
│ ├── t_nhash.cpp
│ ├── t_nhash.h
│ ├── t_set.cpp
│ ├── t_stream.cpp
│ ├── t_string.cpp
│ ├── t_zset.cpp
│ ├── testhelp.h
│ ├── timeout.cpp
│ ├── tls.cpp
│ ├── tracking.cpp
│ ├── util.c
│ ├── util.h
│ ├── uuid.h
│ ├── valgrind.sup
│ ├── version.h
│ ├── ziplist.c
│ ├── ziplist.h
│ ├── zipmap.c
│ ├── zipmap.h
│ ├── zmalloc.cpp
│ └── zmalloc.h
├── tests/
│ ├── assets/
│ │ ├── corrupt_empty_keys.rdb
│ │ ├── corrupt_ziplist.rdb
│ │ ├── default.conf
│ │ ├── encodings.rdb
│ │ ├── hash-zipmap.rdb
│ │ ├── minimal.conf
│ │ ├── nodefaultuser.acl
│ │ ├── redis-module-save.rdb
│ │ ├── redis-save.rdb
│ │ └── user.acl
│ ├── cluster/
│ │ ├── cluster.tcl
│ │ ├── run.tcl
│ │ ├── tests/
│ │ │ ├── 00-base.tcl
│ │ │ ├── 01-faildet.tcl
│ │ │ ├── 02-failover.tcl
│ │ │ ├── 03-failover-loop.tcl
│ │ │ ├── 04-resharding.tcl
│ │ │ ├── 05-slave-selection.tcl
│ │ │ ├── 06-slave-stop-cond.tcl
│ │ │ ├── 07-replica-migration.tcl
│ │ │ ├── 08-update-msg.tcl
│ │ │ ├── 09-pubsub.tcl
│ │ │ ├── 10-manual-failover.tcl
│ │ │ ├── 11-manual-takeover.tcl
│ │ │ ├── 12-replica-migration-2.tcl
│ │ │ ├── 12.1-replica-migration-3.tcl
│ │ │ ├── 13-no-failover-option.tcl
│ │ │ ├── 14-consistency-check.tcl
│ │ │ ├── 15-cluster-slots.tcl
│ │ │ ├── 16-transactions-on-replica.tcl
│ │ │ ├── 17-diskless-load-swapdb.tcl
│ │ │ ├── 18-info.tcl
│ │ │ ├── 19-cluster-nodes-slots.tcl
│ │ │ ├── 20-half-migrated-slot.tcl
│ │ │ ├── 21-many-slot-migration.tcl
│ │ │ ├── helpers/
│ │ │ │ └── onlydots.tcl
│ │ │ └── includes/
│ │ │ ├── init-tests.tcl
│ │ │ └── utils.tcl
│ │ └── tmp/
│ │ └── .gitignore
│ ├── helpers/
│ │ ├── bg_block_op.tcl
│ │ ├── bg_complex_data.tcl
│ │ ├── fake_redis_node.tcl
│ │ ├── gen_climbing_load.tcl
│ │ └── gen_write_load.tcl
│ ├── instances.tcl
│ ├── integration/
│ │ ├── aof-race.tcl
│ │ ├── aof.tcl
│ │ ├── block-repl.tcl
│ │ ├── convert-zipmap-hash-on-load.tcl
│ │ ├── corrupt-dump-fuzzer.tcl
│ │ ├── corrupt-dump.tcl
│ │ ├── failover.tcl
│ │ ├── keydb-benchmark.tcl
│ │ ├── keydb-cli.tcl
│ │ ├── logging.tcl
│ │ ├── multimaster-psync.tcl
│ │ ├── psync2-pingoff.tcl
│ │ ├── psync2-reg-multimaster.tcl
│ │ ├── psync2-reg.tcl
│ │ ├── psync2.tcl
│ │ ├── rdb-repl-tests
│ │ ├── rdb.tcl
│ │ ├── replication-2.tcl
│ │ ├── replication-3.tcl
│ │ ├── replication-4.tcl
│ │ ├── replication-active.tcl
│ │ ├── replication-fast.tcl
│ │ ├── replication-multimaster-connect.tcl
│ │ ├── replication-multimaster.tcl
│ │ ├── replication-psync-flash.tcl
│ │ ├── replication-psync-multimaster.tcl
│ │ ├── replication-psync.tcl
│ │ └── replication.tcl
│ ├── modules/
│ │ ├── Makefile
│ │ ├── auth.c
│ │ ├── basics.c
│ │ ├── blockedclient.c
│ │ ├── blockonbackground.c
│ │ ├── blockonkeys.c
│ │ ├── commandfilter.c
│ │ ├── datatype.c
│ │ ├── defragtest.c
│ │ ├── fork.c
│ │ ├── getkeys.c
│ │ ├── hash.c
│ │ ├── hooks.c
│ │ ├── infotest.c
│ │ ├── keyspace_events.c
│ │ ├── load.c
│ │ ├── misc.c
│ │ ├── propagate.c
│ │ ├── scan.c
│ │ ├── stream.c
│ │ ├── test_lazyfree.c
│ │ ├── testrdb.c
│ │ ├── timer.c
│ │ ├── timers.c
│ │ └── zset.c
│ ├── sentinel/
│ │ ├── run.tcl
│ │ ├── tests/
│ │ │ ├── 00-base.tcl
│ │ │ ├── 01-conf-update.tcl
│ │ │ ├── 02-slaves-reconf.tcl
│ │ │ ├── 03-runtime-reconf.tcl
│ │ │ ├── 04-slave-selection.tcl
│ │ │ ├── 05-manual.tcl
│ │ │ ├── 06-ckquorum.tcl
│ │ │ ├── 07-down-conditions.tcl
│ │ │ ├── 08-hostname-conf.tcl
│ │ │ ├── 09-acl-support.tcl
│ │ │ ├── 10-replica-priority.tcl
│ │ │ ├── helpers/
│ │ │ │ └── check_leaked_fds.tcl
│ │ │ └── includes/
│ │ │ ├── init-tests.tcl
│ │ │ ├── sentinel.conf
│ │ │ └── start-init-tests.tcl
│ │ └── tmp/
│ │ └── .gitignore
│ ├── support/
│ │ ├── benchmark.tcl
│ │ ├── cli.tcl
│ │ ├── cluster.tcl
│ │ ├── keydb.tcl
│ │ ├── server.tcl
│ │ ├── test.tcl
│ │ ├── tmpfile.tcl
│ │ └── util.tcl
│ ├── test_helper.tcl
│ └── unit/
│ ├── acl.tcl
│ ├── aofrw.tcl
│ ├── auth.tcl
│ ├── bitfield.tcl
│ ├── bitops.tcl
│ ├── cron.tcl
│ ├── dump.tcl
│ ├── expire.tcl
│ ├── flash.tcl
│ ├── flash.tcl.save
│ ├── geo.tcl
│ ├── hyperloglog.tcl
│ ├── info.tcl
│ ├── introspection-2.tcl
│ ├── introspection.tcl
│ ├── keyspace.tcl
│ ├── latency-monitor.tcl
│ ├── lazyfree.tcl
│ ├── limits.tcl
│ ├── loadsave.tcl
│ ├── maxmemory.tcl
│ ├── memefficiency.tcl
│ ├── moduleapi/
│ │ ├── auth.tcl
│ │ ├── basics.tcl
│ │ ├── blockedclient.tcl
│ │ ├── blockonbackground.tcl
│ │ ├── blockonkeys.tcl
│ │ ├── commandfilter.tcl
│ │ ├── datatype.tcl
│ │ ├── defrag.tcl
│ │ ├── fork.tcl
│ │ ├── getkeys.tcl
│ │ ├── hash.tcl
│ │ ├── hooks.tcl
│ │ ├── infotest.tcl
│ │ ├── keyspace_events.tcl
│ │ ├── load.tcl
│ │ ├── misc.tcl
│ │ ├── moduleloadsave.tcl
│ │ ├── propagate.tcl
│ │ ├── scan.tcl
│ │ ├── stream.tcl
│ │ ├── test_lazyfree.tcl
│ │ ├── testrdb.tcl
│ │ ├── timer.tcl
│ │ └── zset.tcl
│ ├── multi.tcl
│ ├── networking.tcl
│ ├── obuf-limits.tcl
│ ├── oom-score-adj.tcl
│ ├── other.tcl
│ ├── pause.tcl
│ ├── pendingquerybuf.tcl
│ ├── printver.tcl
│ ├── protocol.tcl
│ ├── pubsub.tcl
│ ├── quit.tcl
│ ├── replication.tcl
│ ├── rreplay.tcl
│ ├── scan.tcl
│ ├── scripting.tcl
│ ├── shutdown.tcl
│ ├── slowlog.tcl
│ ├── soft_shutdown.tcl
│ ├── sort.tcl
│ ├── tls-auditlog.tcl
│ ├── tls-name-validation.tcl
│ ├── tls-rotation.tcl
│ ├── tls.tcl
│ ├── tracking.tcl
│ ├── type/
│ │ ├── hash.tcl
│ │ ├── incr.tcl
│ │ ├── list-2.tcl
│ │ ├── list-3.tcl
│ │ ├── list-common.tcl
│ │ ├── list.tcl
│ │ ├── nestedhash.tcl
│ │ ├── set.tcl
│ │ ├── stream-cgroups.tcl
│ │ ├── stream.tcl
│ │ ├── string.tcl
│ │ └── zset.tcl
│ ├── violations.tcl
│ └── wait.tcl
└── utils/
├── build-static-symbols.tcl
├── cluster_fail_time.tcl
├── compare_config.sh
├── corrupt_rdb.c
├── create-cluster/
│ ├── .gitignore
│ ├── README
│ └── create-cluster
├── gen-test-certs.sh
├── generate-command-help.rb
├── graphs/
│ └── commits-over-time/
│ ├── README.md
│ └── genhtml.tcl
├── hashtable/
│ ├── README
│ └── rehashing.c
├── hyperloglog/
│ ├── .gitignore
│ ├── hll-err.rb
│ └── hll-gnuplot-graph.rb
├── install_server.sh
├── lru/
│ ├── README
│ ├── lfu-simulation.c
│ └── test-lru.rb
├── redis-copy.rb
├── redis-sha1.rb
├── redis_init_script
├── redis_init_script.tpl
├── releasetools/
│ ├── 01_create_tarball.sh
│ ├── 02_upload_tarball.sh
│ ├── 03_test_release.sh
│ ├── 04_release_hash.sh
│ └── changelog.tcl
├── speed-regression.tcl
├── srandmember/
│ ├── README.md
│ ├── showdist.rb
│ └── showfreq.rb
├── systemd-redis_multiple_servers@.service
├── systemd-redis_server.service
├── tracking_collisions.c
└── whatisdoing.sh
Showing preview only (1,586K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (11352 symbols across 761 files)
FILE: deps/concurrentqueue/blockingconcurrentqueue.h
function namespace (line 19) | namespace moodycamel
function swap (line 100) | inline void swap(BlockingConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
function enqueue (line 137) | inline bool enqueue(T&& item)
function enqueue (line 150) | inline bool enqueue(producer_token_t const& token, T const& item)
function enqueue (line 163) | inline bool enqueue(producer_token_t const& token, T&& item)
function try_enqueue (line 209) | inline bool try_enqueue(T const& item)
function try_enqueue (line 223) | inline bool try_enqueue(T&& item)
function try_enqueue (line 235) | inline bool try_enqueue(producer_token_t const& token, T const& item)
function try_enqueue (line 247) | inline bool try_enqueue(producer_token_t const& token, T&& item)
function is_lock_free (line 547) | static bool is_lock_free()
function destroy (line 562) | void destroy(U* p)
FILE: deps/concurrentqueue/concurrentqueue.h
function namespace (line 82) | namespace moodycamel { namespace details {
function namespace (line 90) | namespace moodycamel { namespace details {
function namespace (line 100) | namespace moodycamel { namespace details {
function namespace (line 108) | namespace moodycamel { namespace details {
function namespace (line 153) | namespace moodycamel { namespace details {
function namespace (line 236) | namespace moodycamel { namespace details {
function namespace (line 275) | namespace moodycamel { namespace details {
function namespace (line 289) | namespace moodycamel {
type ConsumerToken (line 695) | struct ConsumerToken
function swap (line 934) | inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
function enqueue (line 985) | inline bool enqueue(T&& item)
function enqueue (line 995) | inline bool enqueue(producer_token_t const& token, T const& item)
function enqueue (line 1004) | inline bool enqueue(producer_token_t const& token, T&& item)
function try_enqueue (line 1039) | inline bool try_enqueue(T const& item)
function try_enqueue (line 1050) | inline bool try_enqueue(T&& item)
function try_enqueue (line 1059) | inline bool try_enqueue(producer_token_t const& token, T const& item)
function try_enqueue (line 1067) | inline bool try_enqueue(producer_token_t const& token, T&& item)
function size_approx (line 1304) | size_t size_approx() const
type ExplicitProducer (line 1332) | struct ExplicitProducer
type ImplicitProducer (line 1334) | struct ImplicitProducer
type AllocationMode (line 1338) | enum AllocationMode { CanAlloc, CannotAlloc }
function update_current_producer_after_rotation (line 1371) | inline bool update_current_producer_after_rotation(consumer_token_t& token)
function freeListHead (line 1431) | freeListHead(nullptr) { }
function swap (line 1433) | void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.f...
function add (line 1438) | inline void add(N* node)
function N (line 1452) | inline N* try_get()
function N (line 1492) | N* head_unsafe() const { return freeListHead.load(std::memory_order_rela...
type InnerQueueContext (line 1536) | enum InnerQueueContext { implicit_context = 0, explicit_context = 1 }
function else (line 1538) | struct Block
function T (line 1645) | inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_ca...
function T (line 1646) | inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { retu...
type MemStats (line 1670) | struct MemStats
type ProducerBase (line 1678) | struct ProducerBase
function virtual (line 1691) | virtual ~ProducerBase() { }
function ProducerBase (line 1715) | inline ProducerBase* next_prod() const { return static_cast<ProducerBase...
function size_approx (line 1717) | inline size_t size_approx() const
function ProducerBase (line 1749) | struct ExplicitProducer : public ProducerBase
function else (line 1875) | else if (!new_block_index(pr_blockIndexSlotsUsed)) {
type Guard (line 2009) | struct Guard {
function else (line 2086) | else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
function else (line 2166) | else {
type BlockIndexEntry (line 2326) | struct BlockIndexEntry
type BlockIndexHeader (line 2332) | struct BlockIndexHeader
function new_block_index (line 2341) | bool new_block_index(size_t numberOfFilledSlotsToExpose)
function ProducerBase (line 2406) | struct ImplicitProducer : public ProducerBase
function else (line 2705) | else {
type BlockIndexEntry (line 2870) | struct BlockIndexEntry
type BlockIndexHeader (line 2876) | struct BlockIndexHeader
function else (line 2906) | else if (!new_block_index()) {
function rewind_block_index_tail (line 2918) | inline void rewind_block_index_tail()
function BlockIndexEntry (line 2924) | inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) c...
function get_block_index_index_for_index (line 2931) | inline size_t get_block_index_index_for_index(index_t index, BlockIndexH...
function new_block_index (line 2949) | bool new_block_index()
function populate_initial_block_list (line 3022) | void populate_initial_block_list(size_t blockCount)
function Block (line 3039) | inline Block* try_get_block_from_initial_pool()
function add_block_to_free_list (line 3050) | inline void add_block_to_free_list(Block* block)
function add_blocks_to_free_list (line 3058) | inline void add_blocks_to_free_list(Block* block)
function Block (line 3067) | inline Block* try_get_block_from_free_list()
type MemStats (line 3097) | struct MemStats {
function MemStats (line 3192) | MemStats getMemStats()
function ProducerBase (line 3205) | ProducerBase* recycle_or_create_producer(bool isExplicit)
function ProducerBase (line 3211) | ProducerBase* recycle_or_create_producer(bool isExplicit, bool& recycled)
function ProducerBase (line 3232) | ProducerBase* add_producer(ProducerBase* producer)
function reown_producers (line 3265) | void reown_producers()
type ImplicitProducerKVP (line 3280) | struct ImplicitProducerKVP
function swap (line 3299) | inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
type ImplicitProducerHash (line 3311) | struct ImplicitProducerHash
function populate_initial_implicit_producer_hash (line 3318) | inline void populate_initial_implicit_producer_hash()
function swap_implicit_producer_hashes (line 3336) | void swap_implicit_producer_hashes(ConcurrentQueue& other)
function ImplicitProducer (line 3374) | ImplicitProducer* get_or_add_implicit_producer()
function swap (line 3718) | inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
function swap (line 3723) | inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
FILE: deps/concurrentqueue/lightweightsemaphore.h
type _SECURITY_ATTRIBUTES (line 19) | struct _SECURITY_ATTRIBUTES
function namespace (line 31) | namespace moodycamel
function tryWait (line 341) | bool tryWait()
function wait (line 352) | bool wait()
function wait (line 357) | bool wait(std::int64_t timeout_usecs)
function tryWaitMany (line 363) | ssize_t tryWaitMany(ssize_t max)
function waitMany (line 377) | ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
function waitMany (line 386) | ssize_t waitMany(ssize_t max)
FILE: deps/cpp-statsd-client/include/cpp-statsd-client/StatsdClient.hpp
type Statsd (line 14) | namespace Statsd {
class StatsdClient (line 58) | class StatsdClient {
method StatsdClient (line 71) | StatsdClient(const StatsdClient&) = delete;
method StatsdClient (line 72) | StatsdClient& operator=(const StatsdClient&) = delete;
type detail (line 164) | namespace detail {
function sanitizePrefix (line 165) | inline std::string sanitizePrefix(std::string prefix) {
FILE: deps/cpp-statsd-client/include/cpp-statsd-client/UDPSender.hpp
type Statsd (line 25) | namespace Statsd {
class UDPSender (line 46) | class UDPSender final {
method UDPSender (line 60) | UDPSender(const UDPSender&) = delete;
method UDPSender (line 61) | UDPSender& operator=(const UDPSender&) = delete;
method UDPSender (line 62) | UDPSender(UDPSender&&) = delete;
type sockaddr_in (line 117) | struct sockaddr_in
type detail (line 148) | namespace detail {
function isValidSocket (line 150) | inline bool isValidSocket(const SOCKET_TYPE socket) {
type WinSockSingleton (line 155) | struct WinSockSingleton {
method WinSockSingleton (line 156) | inline static const WinSockSingleton& getInstance() {
method ok (line 160) | inline bool ok() const {
method WinSockSingleton (line 168) | WinSockSingleton() {
type addrinfo (line 283) | struct addrinfo
type addrinfo (line 289) | struct addrinfo
type sockaddr_in (line 300) | struct sockaddr_in
type sockaddr_in (line 300) | struct sockaddr_in
type in_addr (line 301) | struct in_addr
type sockaddr (line 320) | struct sockaddr
FILE: deps/cpp-statsd-client/tests/StatsdServer.hpp
type Statsd (line 11) | namespace Statsd {
class StatsdServer (line 13) | class StatsdServer {
method StatsdServer (line 15) | StatsdServer(unsigned short port = 8125) noexcept {
method receive (line 53) | std::string receive() noexcept {
FILE: deps/cpp-statsd-client/tests/testStatsdClient.cpp
function mock (line 12) | void mock(StatsdServer& server, std::vector<std::string>& messages) {
function throwOnError (line 35) | void throwOnError(const SocketWrapper& wrapped, bool expectEmpty = true,...
function throwOnWrongMessage (line 42) | void throwOnWrongMessage(StatsdServer& server, const std::string& expect...
function testErrorConditions (line 50) | void testErrorConditions() {
function testReconfigure (line 56) | void testReconfigure() {
function testSendRecv (line 79) | void testSendRecv(uint64_t batchSize, uint64_t sendInterval) {
function main (line 169) | int main() {
FILE: deps/hdr_histogram/hdr_atomic.h
function hdr_atomic_store_pointer (line 23) | static void hdr_atomic_store_pointer(void** pointer, void* value)
function hdr_atomic_load_64 (line 29) | static int64_t __inline hdr_atomic_load_64(int64_t* field)
function hdr_atomic_store_64 (line 35) | static void __inline hdr_atomic_store_64(int64_t* field, int64_t value)
function hdr_atomic_exchange_64 (line 41) | static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, ...
function hdr_atomic_add_fetch_64 (line 59) | static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field,...
function hdr_atomic_compare_exchange_64 (line 77) | static bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* fi...
function hdr_atomic_store_pointer (line 104) | static inline void hdr_atomic_store_pointer(void** pointer, void* value)
function hdr_atomic_load_64 (line 109) | static inline int64_t hdr_atomic_load_64(int64_t* field)
function hdr_atomic_store_64 (line 116) | static inline void hdr_atomic_store_64(int64_t* field, int64_t value)
function hdr_atomic_exchange_64 (line 121) | static inline int64_t hdr_atomic_exchange_64(volatile int64_t* field, in...
function hdr_atomic_add_fetch_64 (line 128) | static inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, i...
function hdr_atomic_compare_exchange_64 (line 133) | static inline bool hdr_atomic_compare_exchange_64(volatile int64_t* fiel...
FILE: deps/hdr_histogram/hdr_histogram.c
function normalize_index (line 27) | static int32_t normalize_index(const struct hdr_histogram* h, int32_t in...
function counts_get_direct (line 50) | static int64_t counts_get_direct(const struct hdr_histogram* h, int32_t ...
function counts_get_normalised (line 55) | static int64_t counts_get_normalised(const struct hdr_histogram* h, int3...
function counts_inc_normalised (line 60) | static void counts_inc_normalised(
function counts_inc_normalised_atomic (line 68) | static void counts_inc_normalised_atomic(
function update_min_max (line 77) | static void update_min_max(struct hdr_histogram* h, int64_t value)
function update_min_max_atomic (line 83) | static void update_min_max_atomic(struct hdr_histogram* h, int64_t value)
function power (line 119) | static int64_t power(int64_t base, int64_t exp)
function count_leading_zeros_64 (line 137) | static int32_t count_leading_zeros_64(int64_t value)
function get_bucket_index (line 161) | static int32_t get_bucket_index(const struct hdr_histogram* h, int64_t v...
function get_sub_bucket_index (line 167) | static int32_t get_sub_bucket_index(int64_t value, int32_t bucket_index,...
function counts_index (line 172) | static int32_t counts_index(const struct hdr_histogram* h, int32_t bucke...
function value_from_index (line 183) | static int64_t value_from_index(int32_t bucket_index, int32_t sub_bucket...
function counts_index_for (line 188) | int32_t counts_index_for(const struct hdr_histogram* h, int64_t value)
function hdr_value_at_index (line 196) | int64_t hdr_value_at_index(const struct hdr_histogram *h, int32_t index)
function hdr_size_of_equivalent_value_range (line 210) | int64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h...
function lowest_equivalent_value (line 218) | static int64_t lowest_equivalent_value(const struct hdr_histogram* h, in...
function hdr_next_non_equivalent_value (line 225) | int64_t hdr_next_non_equivalent_value(const struct hdr_histogram *h, int...
function highest_equivalent_value (line 230) | static int64_t highest_equivalent_value(const struct hdr_histogram* h, i...
function hdr_median_equivalent_value (line 235) | int64_t hdr_median_equivalent_value(const struct hdr_histogram *h, int64...
function non_zero_min (line 240) | static int64_t non_zero_min(const struct hdr_histogram* h)
function hdr_reset_internal_counters (line 250) | void hdr_reset_internal_counters(struct hdr_histogram* h)
function buckets_needed_to_cover_value (line 294) | static int32_t buckets_needed_to_cover_value(int64_t value, int32_t sub_...
function hdr_calculate_bucket_config (line 319) | int hdr_calculate_bucket_config(
function hdr_init_preallocated (line 360) | void hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram...
function hdr_init (line 379) | int hdr_init(
function hdr_close (line 416) | void hdr_close(struct hdr_histogram* h)
function hdr_alloc (line 424) | int hdr_alloc(int64_t highest_trackable_value, int significant_figures, ...
function hdr_reset (line 430) | void hdr_reset(struct hdr_histogram *h)
function hdr_get_memory_size (line 438) | size_t hdr_get_memory_size(struct hdr_histogram *h)
function hdr_record_value (line 452) | bool hdr_record_value(struct hdr_histogram* h, int64_t value)
function hdr_record_value_atomic (line 457) | bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value)
function hdr_record_values (line 462) | bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t c...
function hdr_record_values_atomic (line 484) | bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, in...
function hdr_record_corrected_value (line 506) | bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, ...
function hdr_record_corrected_value_atomic (line 511) | bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t ...
function hdr_record_corrected_values (line 516) | bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value,...
function hdr_record_corrected_values_atomic (line 542) | bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t...
function hdr_add (line 568) | int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from)
function hdr_add_while_correcting_for_coordinated_omission (line 588) | int64_t hdr_add_while_correcting_for_coordinated_omission(
function hdr_max (line 620) | int64_t hdr_max(const struct hdr_histogram* h)
function hdr_min (line 630) | int64_t hdr_min(const struct hdr_histogram* h)
function hdr_value_at_percentile (line 640) | int64_t hdr_value_at_percentile(const struct hdr_histogram* h, double pe...
function hdr_mean (line 665) | double hdr_mean(const struct hdr_histogram* h)
function hdr_stddev (line 683) | double hdr_stddev(const struct hdr_histogram* h)
function hdr_values_are_equivalent (line 703) | bool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a,...
function hdr_lowest_equivalent_value (line 708) | int64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64...
function hdr_count_at_value (line 713) | int64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value)
function hdr_count_at_index (line 718) | int64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index)
function has_buckets (line 733) | static bool has_buckets(struct hdr_iter* iter)
function has_next (line 738) | static bool has_next(struct hdr_iter* iter)
function move_next (line 743) | static bool move_next(struct hdr_iter* iter)
function peek_next_value_from_index (line 763) | static int64_t peek_next_value_from_index(struct hdr_iter* iter)
function next_value_greater_than_reporting_level_upper_bound (line 768) | static bool next_value_greater_than_reporting_level_upper_bound(
function basic_iter_next (line 779) | static bool basic_iter_next(struct hdr_iter *iter)
function update_iterated_values (line 791) | static void update_iterated_values(struct hdr_iter* iter, int64_t new_va...
function all_values_iter_next (line 797) | static bool all_values_iter_next(struct hdr_iter* iter)
function hdr_iter_init (line 809) | void hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h)
function hdr_iter_next (line 825) | bool hdr_iter_next(struct hdr_iter* iter)
function percentile_iter_next (line 838) | static bool percentile_iter_next(struct hdr_iter* iter)
function hdr_iter_percentile_init (line 884) | void hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_hi...
function format_line_string (line 898) | static void format_line_string(char* str, size_t len, int significant_fi...
function recorded_iter_next (line 934) | static bool recorded_iter_next(struct hdr_iter* iter)
function hdr_iter_recorded_init (line 950) | void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_hist...
function iter_linear_next (line 968) | static bool iter_linear_next(struct hdr_iter* iter)
function hdr_iter_linear_init (line 1005) | void hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histog...
function hdr_iter_linear_set_value_units_per_bucket (line 1017) | void hdr_iter_linear_set_value_units_per_bucket(struct hdr_iter* iter, i...
function log_iter_next (line 1030) | static bool log_iter_next(struct hdr_iter *iter)
function hdr_iter_log_init (line 1065) | void hdr_iter_log_init(
function hdr_percentiles_print (line 1099) | int hdr_percentiles_print(
FILE: deps/hdr_histogram/hdr_histogram.h
type hdr_histogram (line 17) | struct hdr_histogram
type hdr_histogram (line 65) | struct hdr_histogram
type hdr_histogram (line 72) | struct hdr_histogram
type hdr_histogram (line 80) | struct hdr_histogram
type hdr_histogram (line 92) | struct hdr_histogram
type hdr_histogram (line 100) | struct hdr_histogram
type hdr_histogram (line 111) | struct hdr_histogram
type hdr_histogram (line 126) | struct hdr_histogram
type hdr_histogram (line 139) | struct hdr_histogram
type hdr_histogram (line 156) | struct hdr_histogram
type hdr_histogram (line 173) | struct hdr_histogram
type hdr_histogram (line 194) | struct hdr_histogram
type hdr_histogram (line 207) | struct hdr_histogram
type hdr_histogram (line 224) | struct hdr_histogram
type hdr_histogram (line 236) | struct hdr_histogram
type hdr_histogram (line 236) | struct hdr_histogram
type hdr_histogram (line 249) | struct hdr_histogram
type hdr_histogram (line 249) | struct hdr_histogram
type hdr_histogram (line 257) | struct hdr_histogram
type hdr_histogram (line 265) | struct hdr_histogram
type hdr_histogram (line 273) | struct hdr_histogram
type hdr_histogram (line 281) | struct hdr_histogram
type hdr_histogram (line 289) | struct hdr_histogram
type hdr_histogram (line 301) | struct hdr_histogram
type hdr_histogram (line 312) | struct hdr_histogram
type hdr_histogram (line 323) | struct hdr_histogram
type hdr_histogram (line 325) | struct hdr_histogram
type hdr_histogram (line 327) | struct hdr_histogram
type hdr_iter_percentiles (line 329) | struct hdr_iter_percentiles
type hdr_iter_recorded (line 337) | struct hdr_iter_recorded
type hdr_iter_linear (line 342) | struct hdr_iter_linear
type hdr_iter_log (line 350) | struct hdr_iter_log
type hdr_iter (line 366) | struct hdr_iter
type hdr_iter (line 403) | struct hdr_iter
type hdr_histogram (line 403) | struct hdr_histogram
type hdr_iter (line 408) | struct hdr_iter
type hdr_histogram (line 408) | struct hdr_histogram
type hdr_iter (line 413) | struct hdr_iter
type hdr_histogram (line 413) | struct hdr_histogram
type hdr_iter (line 419) | struct hdr_iter
type hdr_histogram (line 420) | struct hdr_histogram
type hdr_iter (line 426) | struct hdr_iter
type hdr_iter (line 432) | struct hdr_iter
type hdr_histogram (line 433) | struct hdr_histogram
type hdr_iter (line 444) | struct hdr_iter
type format_type (line 446) | typedef enum
type hdr_histogram (line 465) | struct hdr_histogram
type hdr_histogram_bucket_config (line 471) | struct hdr_histogram_bucket_config
type hdr_histogram_bucket_config (line 489) | struct hdr_histogram_bucket_config
type hdr_histogram (line 491) | struct hdr_histogram
type hdr_histogram_bucket_config (line 491) | struct hdr_histogram_bucket_config
type hdr_histogram (line 493) | struct hdr_histogram
type hdr_histogram (line 495) | struct hdr_histogram
type hdr_histogram (line 497) | struct hdr_histogram
type hdr_histogram (line 503) | struct hdr_histogram
FILE: deps/hiredis/adapters/ae.h
type redisAeEvents (line 38) | typedef struct redisAeEvents {
function redisAeReadEvent (line 45) | static void redisAeReadEvent(aeEventLoop *el, int fd, void *privdata, in...
function redisAeWriteEvent (line 52) | static void redisAeWriteEvent(aeEventLoop *el, int fd, void *privdata, i...
function redisAeAddRead (line 59) | static void redisAeAddRead(void *privdata) {
function redisAeDelRead (line 68) | static void redisAeDelRead(void *privdata) {
function redisAeAddWrite (line 77) | static void redisAeAddWrite(void *privdata) {
function redisAeDelWrite (line 86) | static void redisAeDelWrite(void *privdata) {
function redisAeCleanup (line 95) | static void redisAeCleanup(void *privdata) {
function redisAeAttach (line 102) | static int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) {
FILE: deps/hiredis/adapters/glib.h
type RedisSource (line 9) | typedef struct
function redis_source_add_read (line 16) | static void
function redis_source_del_read (line 25) | static void
function redis_source_add_write (line 34) | static void
function redis_source_del_write (line 43) | static void
function redis_source_cleanup (line 52) | static void
function gboolean (line 71) | static gboolean
function gboolean (line 80) | static gboolean
function gboolean (line 87) | static gboolean
function redis_source_finalize (line 111) | static void
function GSource (line 122) | static GSource *
FILE: deps/hiredis/adapters/ivykis.h
type redisIvykisEvents (line 7) | typedef struct redisIvykisEvents {
function redisIvykisReadEvent (line 12) | static void redisIvykisReadEvent(void *arg) {
function redisIvykisWriteEvent (line 17) | static void redisIvykisWriteEvent(void *arg) {
function redisIvykisAddRead (line 22) | static void redisIvykisAddRead(void *privdata) {
function redisIvykisDelRead (line 27) | static void redisIvykisDelRead(void *privdata) {
function redisIvykisAddWrite (line 32) | static void redisIvykisAddWrite(void *privdata) {
function redisIvykisDelWrite (line 37) | static void redisIvykisDelWrite(void *privdata) {
function redisIvykisCleanup (line 42) | static void redisIvykisCleanup(void *privdata) {
function redisIvykisAttach (line 49) | static int redisIvykisAttach(redisAsyncContext *ac) {
FILE: deps/hiredis/adapters/libev.h
type redisLibevEvents (line 39) | typedef struct redisLibevEvents {
function redisLibevReadEvent (line 47) | static void redisLibevReadEvent(EV_P_ ev_io *watcher, int revents) {
function redisLibevWriteEvent (line 57) | static void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) {
function redisLibevAddRead (line 67) | static void redisLibevAddRead(void *privdata) {
function redisLibevDelRead (line 77) | static void redisLibevDelRead(void *privdata) {
function redisLibevAddWrite (line 87) | static void redisLibevAddWrite(void *privdata) {
function redisLibevDelWrite (line 97) | static void redisLibevDelWrite(void *privdata) {
function redisLibevStopTimer (line 107) | static void redisLibevStopTimer(void *privdata) {
function redisLibevCleanup (line 114) | static void redisLibevCleanup(void *privdata) {
function redisLibevTimeout (line 122) | static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {
function redisLibevSetTimeout (line 128) | static void redisLibevSetTimeout(void *privdata, struct timeval tv) {
function redisLibevAttach (line 142) | static int redisLibevAttach(EV_P_ redisAsyncContext *ac) {
FILE: deps/hiredis/adapters/libevent.h
type redisLibeventEvents (line 40) | typedef struct redisLibeventEvents {
function redisLibeventDestroy (line 49) | static void redisLibeventDestroy(redisLibeventEvents *e) {
function redisLibeventHandler (line 53) | static void redisLibeventHandler(int fd, short event, void *arg) {
function redisLibeventUpdate (line 82) | static void redisLibeventUpdate(void *privdata, short flag, int isRemove) {
function redisLibeventAddRead (line 106) | static void redisLibeventAddRead(void *privdata) {
function redisLibeventDelRead (line 110) | static void redisLibeventDelRead(void *privdata) {
function redisLibeventAddWrite (line 114) | static void redisLibeventAddWrite(void *privdata) {
function redisLibeventDelWrite (line 118) | static void redisLibeventDelWrite(void *privdata) {
function redisLibeventCleanup (line 122) | static void redisLibeventCleanup(void *privdata) {
function redisLibeventSetTimeout (line 138) | static void redisLibeventSetTimeout(void *privdata, struct timeval tv) {
function redisLibeventAttach (line 146) | static int redisLibeventAttach(redisAsyncContext *ac, struct event_base ...
FILE: deps/hiredis/adapters/libuv.h
type redisLibuvEvents (line 9) | typedef struct redisLibuvEvents {
function redisLibuvPoll (line 16) | static void redisLibuvPoll(uv_poll_t* handle, int status, int events) {
function redisLibuvAddRead (line 29) | static void redisLibuvAddRead(void *privdata) {
function redisLibuvDelRead (line 38) | static void redisLibuvDelRead(void *privdata) {
function redisLibuvAddWrite (line 51) | static void redisLibuvAddWrite(void *privdata) {
function redisLibuvDelWrite (line 60) | static void redisLibuvDelWrite(void *privdata) {
function on_close (line 73) | static void on_close(uv_handle_t* handle) {
function redisLibuvCleanup (line 80) | static void redisLibuvCleanup(void *privdata) {
function redisLibuvAttach (line 88) | static int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) {
FILE: deps/hiredis/adapters/macosx.h
type RedisRunLoop (line 14) | typedef struct {
function freeRedisRunLoop (line 20) | static int freeRedisRunLoop(RedisRunLoop* redisRunLoop) {
function redisMacOSAddRead (line 35) | static void redisMacOSAddRead(void *privdata) {
function redisMacOSDelRead (line 40) | static void redisMacOSDelRead(void *privdata) {
function redisMacOSAddWrite (line 45) | static void redisMacOSAddWrite(void *privdata) {
function redisMacOSDelWrite (line 50) | static void redisMacOSDelWrite(void *privdata) {
function redisMacOSCleanup (line 55) | static void redisMacOSCleanup(void *privdata) {
function redisMacOSAsyncCallback (line 60) | static void redisMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCall...
function redisMacOSAttach (line 77) | static int redisMacOSAttach(redisAsyncContext *redisAsyncCtx, CFRunLoopR...
FILE: deps/hiredis/adapters/qt.h
function class (line 37) | class RedisQtAdapter : public QObject {
FILE: deps/hiredis/alloc.c
function hiredisAllocFuncs (line 45) | hiredisAllocFuncs hiredisSetAllocators(hiredisAllocFuncs *override) {
function hiredisResetAllocators (line 54) | void hiredisResetAllocators(void) {
function hi_free (line 82) | void hi_free(void *ptr) {
FILE: deps/hiredis/alloc.h
type hiredisAllocFuncs (line 41) | typedef struct hiredisAllocFuncs {
function hi_free (line 73) | static inline void hi_free(void *ptr) {
FILE: deps/hiredis/async.c
function callbackHash (line 55) | static unsigned int callbackHash(const void *key) {
function callbackKeyCompare (line 72) | static int callbackKeyCompare(void *privdata, const void *key1, const vo...
function callbackKeyDestructor (line 82) | static void callbackKeyDestructor(void *privdata, void *key) {
function callbackValDestructor (line 87) | static void callbackValDestructor(void *privdata, void *val) {
function redisAsyncContext (line 101) | static redisAsyncContext *redisAsyncInitialize(redisContext *c) {
function __redisAsyncCopyError (line 156) | static void __redisAsyncCopyError(redisAsyncContext *ac) {
function redisAsyncContext (line 165) | redisAsyncContext *redisAsyncConnectWithOptions(const redisOptions *opti...
function redisAsyncContext (line 194) | redisAsyncContext *redisAsyncConnect(const char *ip, int port) {
function redisAsyncContext (line 200) | redisAsyncContext *redisAsyncConnectBind(const char *ip, int port,
function redisAsyncContext (line 208) | redisAsyncContext *redisAsyncConnectBindWithReuse(const char *ip, int port,
function redisAsyncContext (line 217) | redisAsyncContext *redisAsyncConnectUnix(const char *path) {
function redisAsyncSetConnectCallback (line 223) | int redisAsyncSetConnectCallback(redisAsyncContext *ac, redisConnectCall...
function redisAsyncSetDisconnectCallback (line 236) | int redisAsyncSetDisconnectCallback(redisAsyncContext *ac, redisDisconne...
function __redisPushCallback (line 245) | static int __redisPushCallback(redisCallbackList *list, redisCallback *s...
function __redisShiftCallback (line 267) | static int __redisShiftCallback(redisCallbackList *list, redisCallback *...
function __redisRunCallback (line 283) | static void __redisRunCallback(redisAsyncContext *ac, redisCallback *cb,...
function __redisRunPushCallback (line 292) | static void __redisRunPushCallback(redisAsyncContext *ac, redisReply *re...
function __redisAsyncFree (line 301) | static void __redisAsyncFree(redisAsyncContext *ac) {
function redisAsyncFree (line 363) | void redisAsyncFree(redisAsyncContext *ac) {
function __redisAsyncDisconnect (line 371) | void __redisAsyncDisconnect(redisAsyncContext *ac) {
function redisAsyncDisconnect (line 404) | void redisAsyncDisconnect(redisAsyncContext *ac) {
function __redisGetSubscribeCallback (line 414) | static int __redisGetSubscribeCallback(redisAsyncContext *ac, redisReply...
function redisIsSubscribeReply (line 483) | static int redisIsSubscribeReply(redisReply *reply) {
function redisProcessCallbacks (line 504) | void redisProcessCallbacks(redisAsyncContext *ac) {
function __redisAsyncHandleConnectFailure (line 594) | static void __redisAsyncHandleConnectFailure(redisAsyncContext *ac) {
function __redisAsyncHandleConnect (line 602) | static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
function redisAsyncRead (line 627) | void redisAsyncRead(redisAsyncContext *ac) {
function redisAsyncHandleRead (line 642) | void redisAsyncHandleRead(redisAsyncContext *ac) {
function redisAsyncWrite (line 657) | void redisAsyncWrite(redisAsyncContext *ac) {
function redisAsyncHandleWrite (line 675) | void redisAsyncHandleWrite(redisAsyncContext *ac) {
function redisAsyncHandleTimeout (line 690) | void redisAsyncHandleTimeout(redisAsyncContext *ac) {
function __redisAsyncCommand (line 737) | static int __redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *f...
function redisvAsyncCommand (line 823) | int redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void ...
function redisAsyncCommand (line 838) | int redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *...
function redisAsyncCommandArgv (line 847) | int redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, vo...
function redisAsyncFormattedCommand (line 859) | int redisAsyncFormattedCommand(redisAsyncContext *ac, redisCallbackFn *f...
function redisAsyncPushFn (line 864) | redisAsyncPushFn *redisAsyncSetPushCallback(redisAsyncContext *ac, redis...
function redisAsyncSetTimeout (line 870) | int redisAsyncSetTimeout(redisAsyncContext *ac, struct timeval tv) {
FILE: deps/hiredis/async.h
type redisAsyncContext (line 40) | struct redisAsyncContext
type dict (line 41) | struct dict
type redisAsyncContext (line 44) | struct redisAsyncContext
type redisCallback (line 45) | typedef struct redisCallback {
type redisCallbackList (line 53) | typedef struct redisCallbackList {
type redisAsyncContext (line 58) | struct redisAsyncContext
type redisAsyncContext (line 59) | struct redisAsyncContext
type redisAsyncContext (line 63) | typedef struct redisAsyncContext {
type timeval (line 125) | struct timeval
FILE: deps/hiredis/async_private.h
function refreshTimeout (line 56) | static inline void refreshTimeout(redisAsyncContext *ctx) {
FILE: deps/hiredis/dict.c
function dictGenHashFunction (line 54) | static unsigned int dictGenHashFunction(const unsigned char *buf, int le...
function _dictReset (line 66) | static void _dictReset(dict *ht) {
function dict (line 74) | static dict *dictCreate(dictType *type, void *privDataPtr) {
function _dictInit (line 84) | static int _dictInit(dict *ht, dictType *type, void *privDataPtr) {
function dictExpand (line 92) | static int dictExpand(dict *ht, unsigned long size) {
function dictAdd (line 141) | static int dictAdd(dict *ht, void *key, void *val) {
function dictReplace (line 169) | static int dictReplace(dict *ht, void *key, void *val) {
function dictDelete (line 194) | static int dictDelete(dict *ht, const void *key) {
function _dictClear (line 225) | static int _dictClear(dict *ht) {
function dictRelease (line 250) | static void dictRelease(dict *ht) {
function dictEntry (line 255) | static dictEntry *dictFind(dict *ht, const void *key) {
function dictIterator (line 270) | static dictIterator *dictGetIterator(dict *ht) {
function dictEntry (line 282) | static dictEntry *dictNext(dictIterator *iter) {
function dictReleaseIterator (line 302) | static void dictReleaseIterator(dictIterator *iter) {
function _dictExpandIfNeeded (line 309) | static int _dictExpandIfNeeded(dict *ht) {
function _dictNextPower (line 320) | static unsigned long _dictNextPower(unsigned long size) {
function _dictKeyIndex (line 334) | static int _dictKeyIndex(dict *ht, const void *key) {
FILE: deps/hiredis/dict.h
type dictEntry (line 45) | typedef struct dictEntry {
type dictType (line 51) | typedef struct dictType {
type dict (line 60) | typedef struct dict {
type dictIterator (line 69) | typedef struct dictIterator {
FILE: deps/hiredis/examples/example-ae.c
function getCallback (line 13) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 22) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 32) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 43) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-glib.c
function connect_cb (line 9) | static void
function disconnect_cb (line 21) | static void
function command_cb (line 33) | static void
function gint (line 47) | gint
FILE: deps/hiredis/examples/example-ivykis.c
function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 19) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 27) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 35) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-libev.c
function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 19) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 27) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 35) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-libevent-ssl.c
function getCallback (line 11) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 20) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 28) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 36) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-libevent.c
function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 24) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 32) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 40) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-libuv.c
function getCallback (line 10) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 19) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 27) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 35) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-macosx.c
function getCallback (line 12) | void getCallback(redisAsyncContext *c, void *r, void *privdata) {
function connectCallback (line 21) | void connectCallback(const redisAsyncContext *c, int status) {
function disconnectCallback (line 29) | void disconnectCallback(const redisAsyncContext *c, int status) {
function main (line 38) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-push.c
function assertReplyAndFree (line 44) | static void assertReplyAndFree(redisContext *context, redisReply *reply,...
function enableClientTracking (line 59) | static void enableClientTracking(redisContext *c) {
function pushReplyHandler (line 79) | void pushReplyHandler(void *privdata, void *r) {
function privdata_dtor (line 102) | void privdata_dtor(void *privdata) {
function main (line 107) | int main(int argc, char **argv) {
FILE: deps/hiredis/examples/example-qt.cpp
function getCallback (line 9) | void getCallback(redisAsyncContext *, void * r, void * privdata) {
function main (line 36) | int main (int argc, char **argv) {
FILE: deps/hiredis/examples/example-qt.h
function class (line 6) | class ExampleQt : public QObject {
FILE: deps/hiredis/examples/example-ssl.c
function main (line 9) | int main(int argc, char **argv) {
FILE: deps/hiredis/examples/example.c
function main (line 7) | int main(int argc, char **argv) {
FILE: deps/hiredis/hiredis.c
type timeval (line 47) | struct timeval
type timeval (line 48) | struct timeval
function redisReply (line 79) | static redisReply *createReplyObject(int type) {
function freeReplyObject (line 90) | void freeReplyObject(void *reply) {
function countDigits (line 289) | static uint32_t countDigits(uint64_t v) {
function bulklen (line 302) | static size_t bulklen(size_t len) {
function redisvFormatCommand (line 306) | int redisvFormatCommand(char **target, const char *format, va_list ap) {
function redisFormatCommand (line 548) | int redisFormatCommand(char **target, const char *format, ...) {
function redisFormatSdsCommandArgv (line 569) | int redisFormatSdsCommandArgv(hisds *target, int argc, const char **argv,
function redisFreeSdsCommand (line 617) | void redisFreeSdsCommand(hisds cmd) {
function redisFormatCommandArgv (line 626) | int redisFormatCommandArgv(char **target, int argc, const char **argv, c...
function redisFreeCommand (line 664) | void redisFreeCommand(char *cmd) {
function __redisSetError (line 668) | void __redisSetError(redisContext *c, int type, const char *str) {
function redisReader (line 684) | redisReader *redisReaderCreate(void) {
function redisPushAutoFree (line 688) | static void redisPushAutoFree(void *privdata, void *reply) {
function redisContext (line 693) | static redisContext *redisContextInit(void) {
function redisFree (line 714) | void redisFree(redisContext *c) {
function redisFD (line 738) | redisFD redisFreeKeepFd(redisContext *c) {
function redisReconnect (line 745) | int redisReconnect(redisContext *c) {
function redisContext (line 787) | redisContext *redisConnectWithOptions(const redisOptions *options) {
function redisContext (line 843) | redisContext *redisConnect(const char *ip, int port) {
function redisContext (line 849) | redisContext *redisConnectWithTimeout(const char *ip, int port, const st...
function redisContext (line 856) | redisContext *redisConnectNonBlock(const char *ip, int port) {
function redisContext (line 863) | redisContext *redisConnectBindNonBlock(const char *ip, int port,
function redisContext (line 872) | redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
function redisContext (line 881) | redisContext *redisConnectUnix(const char *path) {
function redisContext (line 887) | redisContext *redisConnectUnixWithTimeout(const char *path, const struct...
function redisContext (line 894) | redisContext *redisConnectUnixNonBlock(const char *path) {
function redisContext (line 901) | redisContext *redisConnectFd(redisFD fd) {
function redisSetTimeout (line 909) | int redisSetTimeout(redisContext *c, const struct timeval tv) {
function redisEnableKeepAlive (line 916) | int redisEnableKeepAlive(redisContext *c) {
function redisPushFn (line 923) | redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) {
function redisBufferRead (line 934) | int redisBufferRead(redisContext *c) {
function redisBufferWrite (line 964) | int redisBufferWrite(redisContext *c, int *done) {
function redisGetReplyFromReader (line 995) | int redisGetReplyFromReader(redisContext *c, void **reply) {
function redisHandledPushReply (line 1006) | static int redisHandledPushReply(redisContext *c, void *reply) {
function redisGetReply (line 1015) | int redisGetReply(redisContext *c, void **reply) {
function __redisAppendCommand (line 1062) | int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) {
function redisAppendFormattedCommand (line 1075) | int redisAppendFormattedCommand(redisContext *c, const char *cmd, size_t...
function redisvAppendCommand (line 1084) | int redisvAppendCommand(redisContext *c, const char *format, va_list ap) {
function redisAppendCommand (line 1106) | int redisAppendCommand(redisContext *c, const char *format, ...) {
function redisAppendCommandArgv (line 1116) | int redisAppendCommandArgv(redisContext *c, int argc, const char **argv,...
FILE: deps/hiredis/hiredis.h
type timeval (line 41) | struct timeval
type redisAsyncContext (line 96) | struct redisAsyncContext
type redisContext (line 97) | struct redisContext
type redisAsyncContext (line 102) | struct redisAsyncContext
type redisReply (line 109) | typedef struct redisReply {
type redisConnectionType (line 135) | enum redisConnectionType {
type redisSsl (line 141) | struct redisSsl
type redisFD (line 160) | typedef int redisFD;
type redisFD (line 164) | typedef unsigned long long redisFD;
type redisFD (line 166) | typedef unsigned long redisFD;
type redisOptions (line 171) | typedef struct {
type redisContextFuncs (line 224) | typedef struct redisContextFuncs {
type redisContext (line 233) | typedef struct redisContext {
type timeval (line 276) | struct timeval
type timeval (line 283) | struct timeval
type timeval (line 299) | struct timeval
FILE: deps/hiredis/hiredis_ssl.h
type ssl_st (line 42) | struct ssl_st
type redisSSLContext (line 47) | typedef struct redisSSLContext redisSSLContext;
type redisSSLContextError (line 53) | typedef enum {
type ssl_st (line 121) | struct ssl_st
FILE: deps/hiredis/net.c
function redisNetClose (line 53) | void redisNetClose(redisContext *c) {
function redisNetRead (line 60) | ssize_t redisNetRead(redisContext *c, char *buf, size_t bufcap) {
function redisNetWrite (line 82) | ssize_t redisNetWrite(redisContext *c) {
function __redisSetErrorFromErrno (line 95) | static void __redisSetErrorFromErrno(redisContext *c, int type, const ch...
function redisSetReuseAddr (line 106) | static int redisSetReuseAddr(redisContext *c) {
function redisCreateSocket (line 116) | static int redisCreateSocket(redisContext *c, int type) {
function redisSetBlocking (line 131) | static int redisSetBlocking(redisContext *c, int blocking) {
function redisKeepAlive (line 165) | int redisKeepAlive(redisContext *c, int interval) {
function redisSetTcpNoDelay (line 206) | int redisSetTcpNoDelay(redisContext *c) {
function redisContextTimeoutMsec (line 218) | static int redisContextTimeoutMsec(redisContext *c, long *result)
function redisContextWaitReady (line 241) | static int redisContextWaitReady(redisContext *c, long msec) {
function redisCheckConnectDone (line 274) | int redisCheckConnectDone(redisContext *c, int *completed) {
function redisCheckSocketError (line 294) | int redisCheckSocketError(redisContext *c) {
function redisContextSetTimeout (line 316) | int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
function redisContextUpdateConnectTimeout (line 331) | int redisContextUpdateConnectTimeout(redisContext *c, const struct timev...
function redisContextUpdateCommandTimeout (line 347) | int redisContextUpdateCommandTimeout(redisContext *c, const struct timev...
function _redisContextConnectTcp (line 363) | static int _redisContextConnectTcp(redisContext *c, const char *addr, in...
function redisContextConnectTcp (line 536) | int redisContextConnectTcp(redisContext *c, const char *addr, int port,
function redisContextConnectBindTcp (line 541) | int redisContextConnectBindTcp(redisContext *c, const char *addr, int port,
function redisContextConnectUnix (line 547) | int redisContextConnectUnix(redisContext *c, const char *path, const str...
FILE: deps/hiredis/net.h
type timeval (line 45) | struct timeval
type timeval (line 46) | struct timeval
type timeval (line 48) | struct timeval
type timeval (line 50) | struct timeval
FILE: deps/hiredis/read.c
function __redisReaderSetError (line 53) | static void __redisReaderSetError(redisReader *r, int type, const char *...
function chrtos (line 77) | static size_t chrtos(char *buf, size_t size, char byte) {
function __redisReaderSetErrorProtocolByte (line 101) | static void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {
function __redisReaderSetErrorOOM (line 110) | static void __redisReaderSetErrorOOM(redisReader *r) {
function string2ll (line 163) | static int string2ll(const char *s, size_t slen, long long *value) {
function moveToNextTask (line 241) | static void moveToNextTask(redisReader *r) {
function processLineItem (line 269) | static int processLineItem(redisReader *r) {
function processBulkItem (line 351) | static int processBulkItem(redisReader *r) {
function redisReaderGrow (line 423) | static int redisReaderGrow(redisReader *r) {
function processAggregateItem (line 449) | static int processAggregateItem(redisReader *r) {
function processItem (line 528) | static int processItem(redisReader *r) {
function redisReader (line 605) | redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *f...
function redisReaderFree (line 637) | void redisReaderFree(redisReader *r) {
function redisReaderFeed (line 657) | int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
function redisReaderGetReply (line 688) | int redisReaderGetReply(redisReader *r, void **reply) {
FILE: deps/hiredis/read.h
type redisReadTask (line 76) | typedef struct redisReadTask {
type redisReplyObjectFunctions (line 85) | typedef struct redisReplyObjectFunctions {
type redisReader (line 95) | typedef struct redisReader {
FILE: deps/hiredis/sds.c
function hi_sdsHdrSize (line 43) | static inline int hi_sdsHdrSize(char type) {
function hi_sdsReqType (line 59) | static inline char hi_sdsReqType(size_t string_size) {
function hisds (line 83) | hisds hi_sdsnewlen(const void *init, size_t initlen) {
function hisds (line 141) | hisds hi_sdsempty(void) {
function hisds (line 146) | hisds hi_sdsnew(const char *init) {
function hisds (line 152) | hisds hi_sdsdup(const hisds s) {
function hi_sdsfree (line 157) | void hi_sdsfree(hisds s) {
function hi_sdsupdatelen (line 176) | void hi_sdsupdatelen(hisds s) {
function hi_sdsclear (line 185) | void hi_sdsclear(hisds s) {
function hisds (line 196) | hisds hi_sdsMakeRoomFor(hisds s, size_t addlen) {
function hisds (line 247) | hisds hi_sdsRemoveFreeSpace(hisds s) {
function hi_sdsAllocSize (line 280) | size_t hi_sdsAllocSize(hisds s) {
function hi_sdsIncrLen (line 314) | void hi_sdsIncrLen(hisds s, int incr) {
function hisds (line 360) | hisds hi_sdsgrowzero(hisds s, size_t len) {
function hisds (line 378) | hisds hi_sdscatlen(hisds s, const void *t, size_t len) {
function hisds (line 393) | hisds hi_sdscat(hisds s, const char *t) {
function hisds (line 401) | hisds hi_sdscatsds(hisds s, const hisds t) {
function hisds (line 407) | hisds hi_sdscpylen(hisds s, const char *t, size_t len) {
function hisds (line 420) | hisds hi_sdscpy(hisds s, const char *t) {
function hi_sdsll2str (line 431) | int hi_sdsll2str(char *s, long long value) {
function hi_sdsull2str (line 463) | int hi_sdsull2str(char *s, unsigned long long v) {
function hisds (line 495) | hisds hi_sdsfromlonglong(long long value) {
function hisds (line 503) | hisds hi_sdscatvprintf(hisds s, const char *fmt, va_list ap) {
function hisds (line 556) | hisds hi_sdscatprintf(hisds s, const char *fmt, ...) {
function hisds (line 581) | hisds hi_sdscatfmt(hisds s, char const *fmt, ...) {
function hisds (line 691) | hisds hi_sdstrim(hisds s, const char *cset) {
function hi_sdsrange (line 726) | int hi_sdsrange(hisds s, ssize_t start, ssize_t end) {
function hi_sdstolower (line 757) | void hi_sdstolower(hisds s) {
function hi_sdstoupper (line 764) | void hi_sdstoupper(hisds s) {
function hi_sdscmp (line 781) | int hi_sdscmp(const hisds s1, const hisds s2) {
function hisds (line 809) | hisds *hi_sdssplitlen(const char *s, int len, const char *sep, int seple...
function hi_sdsfreesplitres (line 859) | void hi_sdsfreesplitres(hisds *tokens, int count) {
function hisds (line 872) | hisds hi_sdscatrepr(hisds s, const char *p, size_t len) {
function hi_hex_digit_to_int (line 899) | static int hi_hex_digit_to_int(char c) {
function hisds (line 940) | hisds *hi_sdssplitargs(const char *line, int *argc) {
function hisds (line 1067) | hisds hi_sdsmapchars(hisds s, const char *from, const char *to, size_t s...
function hisds (line 1083) | hisds hi_sdsjoin(char **argv, int argc, char *sep) {
function hisds (line 1095) | hisds hi_sdsjoinsds(hisds *argv, int argc, const char *sep, size_t seple...
function hi_sds_free (line 1113) | void hi_sds_free(void *ptr) { hi_s_free(ptr); }
function hi_sdsTest (line 1121) | int hi_sdsTest(void) {
function main (line 1286) | int main(void) {
FILE: deps/hiredis/sds.h
type hisdshdr5 (line 51) | struct __attribute__ ((__packed__)) hisdshdr5 {
type hisdshdr8 (line 57) | struct __attribute__ ((__packed__)) hisdshdr8 {
type hisdshdr16 (line 65) | struct __attribute__ ((__packed__)) hisdshdr16 {
type hisdshdr32 (line 73) | struct __attribute__ ((__packed__)) hisdshdr32 {
type hisdshdr64 (line 81) | struct __attribute__ ((__packed__)) hisdshdr64 {
function hi_sdslen (line 101) | static inline size_t hi_sdslen(const hisds s) {
function hi_sdsavail (line 119) | static inline size_t hi_sdsavail(const hisds s) {
function hi_sdssetlen (line 145) | static inline void hi_sdssetlen(hisds s, size_t newlen) {
function hi_sdsinclen (line 169) | static inline void hi_sdsinclen(hisds s, size_t inc) {
function hi_sdsalloc (line 195) | static inline size_t hi_sdsalloc(const hisds s) {
function hi_sdssetalloc (line 212) | static inline void hi_sdssetalloc(hisds s, size_t newlen) {
FILE: deps/hiredis/sockcompat.c
function _wsaErrorToErrno (line 35) | static int _wsaErrorToErrno(int err) {
function _updateErrno (line 97) | static void _updateErrno(int success) {
function _initWinsock (line 101) | static int _initWinsock() {
function win32_getaddrinfo (line 115) | int win32_getaddrinfo(const char *node, const char *service, const struc...
function win32_freeaddrinfo (line 149) | void win32_freeaddrinfo(struct addrinfo *res) {
function SOCKET (line 153) | SOCKET win32_socket(int domain, int type, int protocol) {
function win32_ioctl (line 165) | int win32_ioctl(SOCKET fd, unsigned long request, unsigned long *argp) {
function win32_bind (line 171) | int win32_bind(SOCKET sockfd, const struct sockaddr *addr, socklen_t add...
function win32_connect (line 177) | int win32_connect(SOCKET sockfd, const struct sockaddr *addr, socklen_t ...
function win32_getsockopt (line 191) | int win32_getsockopt(SOCKET sockfd, int level, int optname, void *optval...
function win32_setsockopt (line 212) | int win32_setsockopt(SOCKET sockfd, int level, int optname, const void *...
function win32_close (line 225) | int win32_close(SOCKET fd) {
function win32_recv (line 231) | ssize_t win32_recv(SOCKET sockfd, void *buf, size_t len, int flags) {
function win32_send (line 237) | ssize_t win32_send(SOCKET sockfd, const void *buf, size_t len, int flags) {
function win32_poll (line 243) | int win32_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
FILE: deps/hiredis/sockcompat.h
type addrinfo (line 59) | struct addrinfo
type addrinfo (line 59) | struct addrinfo
type addrinfo (line 61) | struct addrinfo
type sockaddr (line 64) | struct sockaddr
type sockaddr (line 65) | struct sockaddr
type ULONG (line 71) | typedef ULONG nfds_t;
type pollfd (line 72) | struct pollfd
FILE: deps/hiredis/ssl.c
type redisSSLContext (line 54) | struct redisSSLContext {
type redisSSL (line 63) | typedef struct redisSSL {
type CRITICAL_SECTION (line 99) | typedef CRITICAL_SECTION sslLockType;
function sslLockInit (line 100) | static void sslLockInit(sslLockType* l) {
function sslLockAcquire (line 103) | static void sslLockAcquire(sslLockType* l) {
function sslLockRelease (line 106) | static void sslLockRelease(sslLockType* l) {
type pthread_mutex_t (line 110) | typedef pthread_mutex_t sslLockType;
function sslLockInit (line 111) | static void sslLockInit(sslLockType *l) {
function sslLockAcquire (line 114) | static void sslLockAcquire(sslLockType *l) {
function sslLockRelease (line 117) | static void sslLockRelease(sslLockType *l) {
function opensslDoLock (line 124) | static void opensslDoLock(int mode, int lkid, const char *f, int line) {
function initOpensslLocks (line 137) | static int initOpensslLocks(void) {
function redisInitOpenSSL (line 156) | int redisInitOpenSSL(void)
function redisFreeSSLContext (line 190) | void redisFreeSSLContext(redisSSLContext *ctx)
function redisSSLContext (line 213) | redisSSLContext *redisCreateSSLContext(const char *cacert_filename, cons...
function redisSSLConnect (line 269) | static int redisSSLConnect(redisContext *c, SSL *ssl) {
function redisInitiateSSL (line 323) | int redisInitiateSSL(redisContext *c, SSL *ssl) {
function redisInitiateSSLWithContext (line 332) | int redisInitiateSSLWithContext(redisContext *c, redisSSLContext *redis_...
function maybeCheckWant (line 364) | static int maybeCheckWant(redisSSL *rssl, int rv) {
function redisSSLFree (line 384) | static void redisSSLFree(void *privctx){
function redisSSLRead (line 395) | static ssize_t redisSSLRead(redisContext *c, char *buf, size_t bufcap) {
function redisSSLWrite (line 437) | static ssize_t redisSSLWrite(redisContext *c) {
function redisSSLAsyncRead (line 459) | static void redisSSLAsyncRead(redisAsyncContext *ac) {
function redisSSLAsyncWrite (line 489) | static void redisSSLAsyncWrite(redisAsyncContext *ac) {
FILE: deps/hiredis/test.c
type connection_type (line 23) | enum connection_type {
type config (line 30) | struct config {
type privdata (line 52) | struct privdata {
type pushCounters (line 56) | struct pushCounters {
function usec (line 71) | static long long usec(void) {
function get_redis_version (line 92) | void get_redis_version(redisContext *c, int *majorptr, int *minorptr) {
function redisContext (line 127) | static redisContext *select_database(redisContext *c) {
function send_hello (line 150) | static void send_hello(redisContext *c, int version) {
function send_client_tracking (line 161) | static void send_client_tracking(redisContext *c, const char *str) {
function disconnect (line 169) | static int disconnect(redisContext *c, int keep_fd) {
function do_ssl_handshake (line 187) | static void do_ssl_handshake(redisContext *c) {
function redisContext (line 200) | static redisContext *do_connect(struct config config) {
function do_reconnect (line 237) | static void do_reconnect(redisContext *c, struct config config) {
function test_format_commands (line 245) | static void test_format_commands(void) {
function test_append_formatted_commands (line 365) | static void test_append_formatted_commands(struct config config) {
function test_reply_reader (line 387) | static void test_reply_reader(void) {
function test_free_null (line 602) | static void test_free_null(void) {
function test_allocator_injection (line 632) | static void test_allocator_injection(void) {
function test_blocking_connection_errors (line 657) | static void test_blocking_connection_errors(void) {
function push_handler (line 700) | void push_handler(void *privdata, void *r) {
function push_handler_async (line 721) | void push_handler_async(redisAsyncContext *ac, void *reply) {
function test_resp3_push_handler (line 726) | static void test_resp3_push_handler(redisContext *c) {
function redisOptions (line 786) | redisOptions get_redis_tcp_options(struct config config) {
function test_resp3_push_options (line 792) | static void test_resp3_push_options(struct config config) {
function free_privdata (line 831) | void free_privdata(void *privdata) {
function test_privdata_hooks (line 836) | static void test_privdata_hooks(struct config config) {
function test_blocking_connection (line 852) | static void test_blocking_connection(struct config config) {
function detect_debug_sleep (line 943) | static int detect_debug_sleep(redisContext *c) {
function test_blocking_connection_timeouts (line 959) | static void test_blocking_connection_timeouts(struct config config) {
function test_blocking_io_errors (line 1016) | static void test_blocking_io_errors(struct config config) {
function test_invalid_timeout_errors (line 1062) | static void test_invalid_timeout_errors(struct config config) {
function test_throughput (line 1098) | static void test_throughput(struct config config) {
function main (line 1286) | int main(int argc, char **argv) {
FILE: deps/hiredis/win32.h
function c99_vsnprintf (line 26) | __inline int c99_vsnprintf(char* str, size_t size, const char* format, v...
function c99_snprintf (line 38) | __inline int c99_snprintf(char* str, size_t size, const char* format, ...)
FILE: deps/jemalloc/include/jemalloc/internal/arena_inlines_a.h
function arena_ind_get (line 4) | static inline unsigned
function arena_internal_add (line 9) | static inline void
function arena_internal_sub (line 14) | static inline void
function arena_internal_get (line 19) | static inline size_t
function arena_prof_accum (line 24) | static inline bool
function percpu_arena_update (line 35) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/arena_inlines_b.h
function JEMALLOC_ALWAYS_INLINE (line 11) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 16) | JEMALLOC_ALWAYS_INLINE arena_t *
function JEMALLOC_ALWAYS_INLINE (line 37) | JEMALLOC_ALWAYS_INLINE prof_tctx_t *
function JEMALLOC_ALWAYS_INLINE (line 56) | JEMALLOC_ALWAYS_INLINE void
function arena_prof_tctx_reset (line 75) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 86) | JEMALLOC_ALWAYS_INLINE nstime_t
function JEMALLOC_ALWAYS_INLINE (line 101) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 112) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 130) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 139) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 158) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 179) | JEMALLOC_ALWAYS_INLINE arena_t *
function JEMALLOC_ALWAYS_INLINE (line 184) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 198) | JEMALLOC_ALWAYS_INLINE size_t
function arena_dalloc_large_no_tcache (line 231) | static inline void
function arena_dalloc_no_tcache (line 241) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 269) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 285) | JEMALLOC_ALWAYS_INLINE void
function arena_sdalloc_no_tcache (line 327) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 370) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/arena_stats.h
type atomic_u64_t (line 17) | typedef atomic_u64_t arena_stats_u64_t;
type arena_stats_u64_t (line 20) | typedef uint64_t arena_stats_u64_t;
type arena_stats_large_t (line 23) | typedef struct arena_stats_large_s arena_stats_large_t;
type arena_stats_large_s (line 24) | struct arena_stats_large_s {
type arena_stats_decay_t (line 50) | typedef struct arena_stats_decay_s arena_stats_decay_t;
type arena_stats_decay_s (line 51) | struct arena_stats_decay_s {
type arena_stats_extents_t (line 60) | typedef struct arena_stats_extents_s arena_stats_extents_t;
type arena_stats_extents_s (line 61) | struct arena_stats_extents_s {
type arena_stats_t (line 81) | typedef struct arena_stats_s arena_stats_t;
type arena_stats_s (line 82) | struct arena_stats_s {
function arena_stats_init (line 130) | static inline bool
function arena_stats_lock (line 147) | static inline void
function arena_stats_unlock (line 154) | static inline void
function arena_stats_read_u64 (line 161) | static inline uint64_t
function arena_stats_add_u64 (line 172) | static inline void
function arena_stats_sub_u64 (line 183) | static inline void
function arena_stats_accum_u64 (line 201) | static inline void
function arena_stats_read_zu (line 211) | static inline size_t
function arena_stats_add_zu (line 222) | static inline void
function arena_stats_sub_zu (line 234) | static inline void
function arena_stats_accum_zu (line 248) | static inline void
function arena_stats_large_flush_nrequests_add (line 254) | static inline void
function arena_stats_mapped_add (line 264) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/arena_structs_a.h
type arena_slab_data_s (line 6) | struct arena_slab_data_s {
FILE: deps/jemalloc/include/jemalloc/internal/arena_structs_b.h
type arena_decay_s (line 17) | struct arena_decay_s {
type arena_s (line 77) | struct arena_s {
type arena_tdata_s (line 222) | struct arena_tdata_s {
type alloc_ctx_s (line 227) | struct alloc_ctx_s {
FILE: deps/jemalloc/include/jemalloc/internal/arena_types.h
type arena_slab_data_t (line 16) | typedef struct arena_slab_data_s arena_slab_data_t;
type arena_decay_t (line 17) | typedef struct arena_decay_s arena_decay_t;
type arena_t (line 18) | typedef struct arena_s arena_t;
type arena_tdata_t (line 19) | typedef struct arena_tdata_s arena_tdata_t;
type alloc_ctx_t (line 20) | typedef struct alloc_ctx_s alloc_ctx_t;
type percpu_arena_mode_t (line 22) | typedef enum {
FILE: deps/jemalloc/include/jemalloc/internal/atomic_gcc_atomic.h
type atomic_memory_order_t (line 8) | typedef enum {
function ATOMIC_INLINE (line 16) | ATOMIC_INLINE int
function ATOMIC_INLINE (line 34) | ATOMIC_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/atomic_gcc_sync.h
type atomic_memory_order_t (line 6) | typedef enum {
function ATOMIC_INLINE (line 14) | ATOMIC_INLINE void
function ATOMIC_INLINE (line 65) | ATOMIC_INLINE void
function ATOMIC_INLINE (line 75) | ATOMIC_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/atomic_msvc.h
type atomic_memory_order_t (line 6) | typedef enum {
type atomic_repr_0_t (line 14) | typedef char atomic_repr_0_t;
type atomic_repr_1_t (line 15) | typedef short atomic_repr_1_t;
type atomic_repr_2_t (line 16) | typedef long atomic_repr_2_t;
type __int64 (line 17) | typedef __int64 atomic_repr_3_t;
function ATOMIC_INLINE (line 19) | ATOMIC_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/background_thread_inlines.h
function JEMALLOC_ALWAYS_INLINE (line 4) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 9) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 15) | JEMALLOC_ALWAYS_INLINE background_thread_info_t *
function JEMALLOC_ALWAYS_INLINE (line 21) | JEMALLOC_ALWAYS_INLINE background_thread_info_t *
function JEMALLOC_ALWAYS_INLINE (line 26) | JEMALLOC_ALWAYS_INLINE uint64_t
function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 43) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 48) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/background_thread_structs.h
type background_thread_state_t (line 14) | typedef enum {
type background_thread_info_s (line 21) | struct background_thread_info_s {
type background_thread_info_t (line 45) | typedef struct background_thread_info_s background_thread_info_t;
type background_thread_stats_s (line 47) | struct background_thread_stats_s {
type background_thread_stats_t (line 52) | typedef struct background_thread_stats_s background_thread_stats_t;
FILE: deps/jemalloc/include/jemalloc/internal/base_inlines.h
function base_ind_get (line 4) | static inline unsigned
function metadata_thp_enabled (line 9) | static inline bool
FILE: deps/jemalloc/include/jemalloc/internal/base_structs.h
type base_block_s (line 9) | struct base_block_s {
type base_s (line 20) | struct base_s {
FILE: deps/jemalloc/include/jemalloc/internal/base_types.h
type base_block_t (line 4) | typedef struct base_block_s base_block_t;
type base_t (line 5) | typedef struct base_s base_t;
type metadata_thp_mode_t (line 18) | typedef enum {
FILE: deps/jemalloc/include/jemalloc/internal/bin.h
type bin_info_t (line 35) | typedef struct bin_info_s bin_info_t;
type bin_info_s (line 36) | struct bin_info_s {
type bin_t (line 58) | typedef struct bin_s bin_t;
type bin_s (line 59) | struct bin_s {
type bins_t (line 86) | typedef struct bins_s bins_t;
type bins_s (line 87) | struct bins_s {
function bin_stats_merge (line 106) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/bin_stats.h
type bin_stats_t (line 6) | typedef struct bin_stats_s bin_stats_t;
type bin_stats_s (line 7) | struct bin_stats_s {
FILE: deps/jemalloc/include/jemalloc/internal/bin_types.h
type tsd_binshards_t (line 12) | typedef struct tsd_binshards_s tsd_binshards_t;
type tsd_binshards_s (line 13) | struct tsd_binshards_s {
FILE: deps/jemalloc/include/jemalloc/internal/bit_util.h
function ffs_llu (line 15) | BIT_UTIL_INLINE unsigned
function ffs_lu (line 20) | BIT_UTIL_INLINE unsigned
function ffs_u (line 25) | BIT_UTIL_INLINE unsigned
function popcount_lu (line 31) | BIT_UTIL_INLINE unsigned
function BIT_UTIL_INLINE (line 42) | BIT_UTIL_INLINE size_t
function ffs_zu (line 49) | BIT_UTIL_INLINE unsigned
function ffs_u64 (line 62) | BIT_UTIL_INLINE unsigned
function ffs_u32 (line 73) | BIT_UTIL_INLINE unsigned
function BIT_UTIL_INLINE (line 83) | BIT_UTIL_INLINE uint64_t
function BIT_UTIL_INLINE (line 113) | BIT_UTIL_INLINE uint32_t
function BIT_UTIL_INLINE (line 143) | BIT_UTIL_INLINE size_t
function lg_floor (line 153) | BIT_UTIL_INLINE unsigned
function lg_floor (line 166) | BIT_UTIL_INLINE unsigned
function lg_floor (line 183) | BIT_UTIL_INLINE unsigned
function lg_floor (line 196) | BIT_UTIL_INLINE unsigned
function lg_ceil (line 216) | BIT_UTIL_INLINE unsigned
FILE: deps/jemalloc/include/jemalloc/internal/bitmap.h
type bitmap_t (line 8) | typedef unsigned long bitmap_t;
type bitmap_info_t (line 152) | typedef struct bitmap_info_s {
function bitmap_full (line 175) | static inline bool
function bitmap_get (line 194) | static inline bool
function bitmap_set (line 205) | static inline void
function bitmap_ffu (line 241) | static inline size_t
function bitmap_sfu (line 300) | static inline size_t
function bitmap_unset (line 330) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/cache_bin.h
type cache_bin_sz_t (line 22) | typedef int32_t cache_bin_sz_t;
type cache_bin_stats_t (line 24) | typedef struct cache_bin_stats_s cache_bin_stats_t;
type cache_bin_stats_s (line 25) | struct cache_bin_stats_s {
type cache_bin_info_t (line 37) | typedef struct cache_bin_info_s cache_bin_info_t;
type cache_bin_info_s (line 38) | struct cache_bin_info_s {
type cache_bin_t (line 43) | typedef struct cache_bin_s cache_bin_t;
type cache_bin_s (line 44) | struct cache_bin_s {
type cache_bin_array_descriptor_t (line 67) | typedef struct cache_bin_array_descriptor_s cache_bin_array_descriptor_t;
type cache_bin_array_descriptor_s (line 68) | struct cache_bin_array_descriptor_s {
function cache_bin_array_descriptor_init (line 79) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 87) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 119) | JEMALLOC_ALWAYS_INLINE bool
FILE: deps/jemalloc/include/jemalloc/internal/ckh.h
type ckhc_t (line 28) | typedef struct {
type ckh_t (line 34) | typedef struct {
FILE: deps/jemalloc/include/jemalloc/internal/ctl.h
type ctl_node_t (line 14) | typedef struct ctl_node_s {
type ctl_named_node_t (line 18) | typedef struct ctl_named_node_s {
type ctl_indexed_node_t (line 28) | typedef struct ctl_indexed_node_s {
type ctl_arena_stats_t (line 34) | typedef struct ctl_arena_stats_s {
type ctl_stats_t (line 50) | typedef struct ctl_stats_s {
type ctl_arena_t (line 63) | typedef struct ctl_arena_s ctl_arena_t;
type ctl_arena_s (line 64) | struct ctl_arena_s {
type ctl_arenas_t (line 82) | typedef struct ctl_arenas_s {
FILE: deps/jemalloc/include/jemalloc/internal/div.h
type div_info_t (line 15) | typedef struct div_info_s div_info_t;
type div_info_s (line 16) | struct div_info_s {
function div_compute (line 25) | static inline size_t
FILE: deps/jemalloc/include/jemalloc/internal/emitter.h
type emitter_output_t (line 6) | typedef enum emitter_output_e emitter_output_t;
type emitter_output_e (line 7) | enum emitter_output_e {
type emitter_justify_t (line 12) | typedef enum emitter_justify_e emitter_justify_t;
type emitter_justify_e (line 13) | enum emitter_justify_e {
type emitter_type_t (line 20) | typedef enum emitter_type_e emitter_type_t;
type emitter_type_e (line 21) | enum emitter_type_e {
type emitter_col_t (line 37) | typedef struct emitter_col_s emitter_col_t;
type emitter_col_s (line 38) | struct emitter_col_s {
type emitter_row_t (line 60) | typedef struct emitter_row_s emitter_row_t;
type emitter_row_s (line 61) | struct emitter_row_s {
type emitter_t (line 65) | typedef struct emitter_s emitter_t;
type emitter_s (line 66) | struct emitter_s {
function emitter_printf (line 80) | static inline void
function emitter_print_value (line 116) | static inline void
function emitter_nest_inc (line 183) | static inline void
function emitter_nest_dec (line 189) | static inline void
function emitter_indent (line 195) | static inline void
function emitter_json_key_prefix (line 210) | static inline void
function emitter_init (line 223) | static inline void
function emitter_json_key (line 241) | static inline void
function emitter_json_value (line 250) | static inline void
function emitter_json_kv (line 262) | static inline void
function emitter_json_array_begin (line 269) | static inline void
function emitter_json_array_kv_begin (line 279) | static inline void
function emitter_json_array_end (line 285) | static inline void
function emitter_json_object_begin (line 296) | static inline void
function emitter_json_object_kv_begin (line 306) | static inline void
function emitter_json_object_end (line 312) | static inline void
function emitter_table_dict_begin (line 327) | static inline void
function emitter_table_dict_end (line 336) | static inline void
function emitter_table_kv_note (line 343) | static inline void
function emitter_table_kv (line 364) | static inline void
function emitter_table_printf (line 374) | static inline void
function emitter_table_row (line 384) | static inline void
function emitter_row_init (line 397) | static inline void
function emitter_col_init (line 402) | static inline void
function emitter_kv_note (line 418) | static inline void
function emitter_kv (line 433) | static inline void
function emitter_dict_begin (line 440) | static inline void
function emitter_dict_end (line 451) | static inline void
function emitter_begin (line 460) | static inline void
function emitter_end (line 477) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/extent_dss.h
type dss_prec_t (line 4) | typedef enum {
FILE: deps/jemalloc/include/jemalloc/internal/extent_inlines.h
function extent_lock (line 12) | static inline void
function extent_unlock (line 18) | static inline void
function extent_lock2 (line 24) | static inline void
function extent_unlock2 (line 31) | static inline void
function extent_arena_ind_get (line 38) | static inline unsigned
function arena_t (line 47) | static inline arena_t *
function szind_t (line 54) | static inline szind_t
function szind_t (line 62) | static inline szind_t
function extent_usize_get (line 69) | static inline size_t
function extent_binshard_get (line 74) | static inline unsigned
function extent_sn_get (line 82) | static inline size_t
function extent_state_t (line 88) | static inline extent_state_t
function extent_zeroed_get (line 94) | static inline bool
function extent_committed_get (line 100) | static inline bool
function extent_dumpable_get (line 106) | static inline bool
function extent_slab_get (line 112) | static inline bool
function extent_nfree_get (line 118) | static inline unsigned
function extent_size_get (line 139) | static inline size_t
function extent_esn_get (line 144) | static inline size_t
function extent_bsize_get (line 149) | static inline size_t
function arena_slab_data_t (line 171) | static inline arena_slab_data_t *
function arena_slab_data_t (line 177) | static inline const arena_slab_data_t *
function prof_tctx_t (line 183) | static inline prof_tctx_t *
function nstime_t (line 189) | static inline nstime_t
function extent_arena_set (line 194) | static inline void
function extent_binshard_set (line 202) | static inline void
function extent_addr_set (line 210) | static inline void
function extent_addr_randomize (line 215) | static inline void
function extent_size_set (line 241) | static inline void
function extent_esn_set (line 247) | static inline void
function extent_bsize_set (line 253) | static inline void
function extent_szind_set (line 258) | static inline void
function extent_nfree_set (line 265) | static inline void
function extent_nfree_binshard_set (line 272) | static inline void
function extent_nfree_inc (line 282) | static inline void
function extent_nfree_dec (line 288) | static inline void
function extent_nfree_sub (line 294) | static inline void
function extent_sn_set (line 300) | static inline void
function extent_state_set (line 306) | static inline void
function extent_zeroed_set (line 312) | static inline void
function extent_committed_set (line 318) | static inline void
function extent_dumpable_set (line 324) | static inline void
function extent_slab_set (line 330) | static inline void
function extent_prof_tctx_set (line 336) | static inline void
function extent_prof_alloc_time_set (line 341) | static inline void
function extent_is_head_get (line 346) | static inline bool
function extent_is_head_set (line 356) | static inline void
function extent_init (line 366) | static inline void
function extent_binit (line 392) | static inline void
function extent_list_init (line 406) | static inline void
function extent_t (line 411) | static inline extent_t *
function extent_t (line 416) | static inline extent_t *
function extent_list_append (line 421) | static inline void
function extent_list_prepend (line 426) | static inline void
function extent_list_replace (line 431) | static inline void
function extent_list_remove (line 438) | static inline void
function extent_sn_comp (line 443) | static inline int
function extent_esn_comp (line 451) | static inline int
function extent_ad_comp (line 459) | static inline int
function extent_ead_comp (line 467) | static inline int
function extent_snad_comp (line 475) | static inline int
function extent_esnead_comp (line 488) | static inline int
FILE: deps/jemalloc/include/jemalloc/internal/extent_structs.h
type extent_state_t (line 12) | typedef enum {
type extent_s (line 20) | struct extent_s {
type extent_list_t (line 184) | typedef ql_head(extent_t) extent_list_t;
type extent_tree_t (line 185) | typedef ph(extent_t) extent_tree_t;
type extent_heap_t (line 186) | typedef ph(extent_t) extent_heap_t;
type extents_s (line 189) | struct extents_s {
type extent_util_stats_s (line 241) | struct extent_util_stats_s {
type extent_util_stats_verbose_s (line 247) | struct extent_util_stats_verbose_s {
FILE: deps/jemalloc/include/jemalloc/internal/extent_types.h
type extent_t (line 4) | typedef struct extent_s extent_t;
type extents_t (line 5) | typedef struct extents_s extents_t;
type extent_util_stats_t (line 7) | typedef struct extent_util_stats_s extent_util_stats_t;
type extent_util_stats_verbose_t (line 8) | typedef struct extent_util_stats_verbose_s extent_util_stats_verbose_t;
type extent_head_state_t (line 18) | typedef enum {
FILE: deps/jemalloc/include/jemalloc/internal/hash.h
function hash_rotl_32 (line 14) | static inline uint32_t
function hash_rotl_64 (line 19) | static inline uint64_t
function hash_get_block_32 (line 24) | static inline uint32_t
function hash_get_block_64 (line 37) | static inline uint64_t
function hash_fmix_32 (line 50) | static inline uint32_t
function hash_fmix_64 (line 61) | static inline uint64_t
function hash_x86_32 (line 72) | static inline uint32_t
function hash_x86_128 (line 122) | static inline void
function hash_x64_128 (line 224) | static inline void
function hash (line 303) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/hook.h
type hook_alloc_e (line 51) | enum hook_alloc_e {
type hook_alloc_t (line 68) | typedef enum hook_alloc_e hook_alloc_t;
type hook_dalloc_e (line 70) | enum hook_dalloc_e {
type hook_dalloc_t (line 82) | typedef enum hook_dalloc_e hook_dalloc_t;
type hook_expand_e (line 85) | enum hook_expand_e {
type hook_expand_t (line 90) | typedef enum hook_expand_e hook_expand_t;
type hooks_t (line 103) | typedef struct hooks_s hooks_t;
type hooks_s (line 104) | struct hooks_s {
type hook_ralloc_args_t (line 130) | typedef struct hook_ralloc_args_s hook_ralloc_args_t;
type hook_ralloc_args_s (line 131) | struct hook_ralloc_args_s {
FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_decls.h
function isblank (line 84) | static int
FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_a.h
function malloc_getcpu (line 11) | malloc_getcpu(void) {
function percpu_arena_choose (line 24) | JEMALLOC_ALWAYS_INLINE unsigned
function percpu_arena_ind_limit (line 45) | JEMALLOC_ALWAYS_INLINE unsigned
function arena_tdata_t (line 59) | static inline arena_tdata_t *
function arena_t (line 84) | static inline arena_t *
function ticker_t (line 100) | static inline ticker_t *
function JEMALLOC_ALWAYS_INLINE (line 111) | JEMALLOC_ALWAYS_INLINE cache_bin_t *
function JEMALLOC_ALWAYS_INLINE (line 117) | JEMALLOC_ALWAYS_INLINE cache_bin_t *
function JEMALLOC_ALWAYS_INLINE (line 123) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 141) | JEMALLOC_ALWAYS_INLINE tcache_t *
function pre_reentrancy (line 150) | static inline void
function post_reentrancy (line 165) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_b.h
function arena_t (line 7) | static inline arena_t *
function arena_t (line 61) | static inline arena_t *
function arena_t (line 66) | static inline arena_t *
function arena_is_auto (line 71) | static inline bool
function JEMALLOC_ALWAYS_INLINE (line 78) | JEMALLOC_ALWAYS_INLINE extent_t *
FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h
function JEMALLOC_ALWAYS_INLINE (line 27) | JEMALLOC_ALWAYS_INLINE arena_t *
function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 41) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 60) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 66) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 86) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 92) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 98) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 103) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 121) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 126) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 134) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 173) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 196) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 203) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 222) | JEMALLOC_ALWAYS_INLINE int
FILE: deps/jemalloc/include/jemalloc/internal/jemalloc_internal_types.h
type pszind_t (line 7) | typedef unsigned pszind_t;
type szind_t (line 10) | typedef unsigned szind_t;
type malloc_cpuid_t (line 13) | typedef int malloc_cpuid_t;
FILE: deps/jemalloc/include/jemalloc/internal/log.h
type log_var_t (line 41) | typedef struct log_var_s log_var_t;
type log_var_s (line 42) | struct log_var_s {
function log_impl_varargs (line 88) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/malloc_io.h
function malloc_write_fd (line 66) | static inline ssize_t
function malloc_read_fd (line 88) | static inline ssize_t
FILE: deps/jemalloc/include/jemalloc/internal/mutex.h
type malloc_mutex_lock_order_t (line 9) | typedef enum {
type malloc_mutex_t (line 19) | typedef struct malloc_mutex_s malloc_mutex_t;
type malloc_mutex_s (line 20) | struct malloc_mutex_s {
function malloc_mutex_lock_final (line 153) | static inline void
function malloc_mutex_trylock_final (line 159) | static inline bool
function mutex_owner_stats_update (line 164) | static inline void
function malloc_mutex_trylock (line 177) | static inline bool
function malloc_mutex_prof_merge (line 193) | static inline void
function malloc_mutex_lock (line 216) | static inline void
function malloc_mutex_unlock (line 229) | static inline void
function malloc_mutex_assert_owner (line 238) | static inline void
function malloc_mutex_assert_not_owner (line 243) | static inline void
function malloc_mutex_prof_read (line 249) | static inline void
function malloc_mutex_prof_accum (line 266) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/mutex_pool.h
type mutex_pool_t (line 11) | typedef struct mutex_pool_s mutex_pool_t;
type mutex_pool_s (line 12) | struct mutex_pool_s {
function malloc_mutex_t (line 19) | static inline malloc_mutex_t *
function mutex_pool_assert_not_held (line 26) | static inline void
function mutex_pool_lock (line 40) | static inline void
function mutex_pool_unlock (line 48) | static inline void
function mutex_pool_lock2 (line 56) | static inline void
function mutex_pool_unlock2 (line 74) | static inline void
function mutex_pool_assert_owner (line 89) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/mutex_prof.h
type mutex_prof_global_ind_t (line 13) | typedef enum {
type mutex_prof_arena_ind_t (line 31) | typedef enum {
type mutex_prof_data_t (line 76) | typedef struct {
FILE: deps/jemalloc/include/jemalloc/internal/nstime.h
type nstime_t (line 8) | typedef struct {
FILE: deps/jemalloc/include/jemalloc/internal/pages.h
type thp_mode_t (line 61) | typedef enum {
FILE: deps/jemalloc/include/jemalloc/internal/prng.h
function JEMALLOC_ALWAYS_INLINE (line 35) | JEMALLOC_ALWAYS_INLINE uint32_t
function JEMALLOC_ALWAYS_INLINE (line 40) | JEMALLOC_ALWAYS_INLINE uint64_t
function JEMALLOC_ALWAYS_INLINE (line 45) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 66) | JEMALLOC_ALWAYS_INLINE uint32_t
function JEMALLOC_ALWAYS_INLINE (line 89) | JEMALLOC_ALWAYS_INLINE uint64_t
function JEMALLOC_ALWAYS_INLINE (line 103) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 131) | JEMALLOC_ALWAYS_INLINE uint32_t
function JEMALLOC_ALWAYS_INLINE (line 149) | JEMALLOC_ALWAYS_INLINE uint64_t
function JEMALLOC_ALWAYS_INLINE (line 167) | JEMALLOC_ALWAYS_INLINE size_t
FILE: deps/jemalloc/include/jemalloc/internal/prof_inlines_a.h
function prof_accum_add (line 6) | static inline bool
function prof_accum_cancel (line 45) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 74) | JEMALLOC_ALWAYS_INLINE bool
FILE: deps/jemalloc/include/jemalloc/internal/prof_inlines_b.h
function JEMALLOC_ALWAYS_INLINE (line 7) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 17) | JEMALLOC_ALWAYS_INLINE prof_tdata_t *
function JEMALLOC_ALWAYS_INLINE (line 40) | JEMALLOC_ALWAYS_INLINE prof_tctx_t *
function JEMALLOC_ALWAYS_INLINE (line 48) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 57) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 65) | JEMALLOC_ALWAYS_INLINE nstime_t
function JEMALLOC_ALWAYS_INLINE (line 73) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 82) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 100) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 145) | JEMALLOC_ALWAYS_INLINE prof_tctx_t *
function JEMALLOC_ALWAYS_INLINE (line 165) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 180) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 238) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/prof_structs.h
type prof_bt_s (line 9) | struct prof_bt_s {
type prof_unwind_data_t (line 17) | typedef struct {
type prof_accum_s (line 23) | struct prof_accum_s {
type prof_cnt_s (line 32) | struct prof_cnt_s {
type prof_tctx_state_t (line 40) | typedef enum {
type prof_tctx_s (line 47) | struct prof_tctx_s {
type prof_tctx_tree_t (line 97) | typedef rb_tree(prof_tctx_t) prof_tctx_tree_t;
type prof_gctx_s (line 99) | struct prof_gctx_s {
type prof_gctx_tree_t (line 133) | typedef rb_tree(prof_gctx_t) prof_gctx_tree_t;
type prof_tdata_s (line 135) | struct prof_tdata_s {
type prof_tdata_tree_t (line 198) | typedef rb_tree(prof_tdata_t) prof_tdata_tree_t;
FILE: deps/jemalloc/include/jemalloc/internal/prof_types.h
type prof_bt_t (line 4) | typedef struct prof_bt_s prof_bt_t;
type prof_accum_t (line 5) | typedef struct prof_accum_s prof_accum_t;
type prof_cnt_t (line 6) | typedef struct prof_cnt_s prof_cnt_t;
type prof_tctx_t (line 7) | typedef struct prof_tctx_s prof_tctx_t;
type prof_gctx_t (line 8) | typedef struct prof_gctx_s prof_gctx_t;
type prof_tdata_t (line 9) | typedef struct prof_tdata_s prof_tdata_t;
FILE: deps/jemalloc/include/jemalloc/internal/rtree.h
type rtree_node_elm_t (line 41) | typedef struct rtree_node_elm_s rtree_node_elm_t;
type rtree_node_elm_s (line 42) | struct rtree_node_elm_s {
type rtree_leaf_elm_s (line 46) | struct rtree_leaf_elm_s {
type rtree_level_t (line 68) | typedef struct rtree_level_s rtree_level_t;
type rtree_level_s (line 69) | struct rtree_level_s {
type rtree_t (line 79) | typedef struct rtree_s rtree_t;
type rtree_s (line 80) | struct rtree_s {
type rtree_node_elm_t (line 114) | typedef rtree_node_elm_t *(rtree_node_alloc_t)(tsdn_t *, rtree_t *, size...
type rtree_leaf_elm_t (line 117) | typedef rtree_leaf_elm_t *(rtree_leaf_alloc_t)(tsdn_t *, rtree_t *, size...
function JEMALLOC_ALWAYS_INLINE (line 131) | JEMALLOC_ALWAYS_INLINE uintptr_t
function JEMALLOC_ALWAYS_INLINE (line 141) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 150) | JEMALLOC_ALWAYS_INLINE uintptr_t
function JEMALLOC_ALWAYS_INLINE (line 172) | JEMALLOC_ALWAYS_INLINE uintptr_t
function JEMALLOC_ALWAYS_INLINE (line 179) | JEMALLOC_ALWAYS_INLINE extent_t *
function JEMALLOC_ALWAYS_INLINE (line 198) | JEMALLOC_ALWAYS_INLINE szind_t
function JEMALLOC_ALWAYS_INLINE (line 203) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 210) | JEMALLOC_ALWAYS_INLINE extent_t *
function JEMALLOC_ALWAYS_INLINE (line 223) | JEMALLOC_ALWAYS_INLINE szind_t
function JEMALLOC_ALWAYS_INLINE (line 235) | JEMALLOC_ALWAYS_INLINE bool
function rtree_leaf_elm_extent_write (line 247) | static inline void
function rtree_leaf_elm_szind_write (line 261) | static inline void
function rtree_leaf_elm_slab_write (line 279) | static inline void
function rtree_leaf_elm_write (line 294) | static inline void
function rtree_leaf_elm_szind_slab_update (line 313) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 326) | JEMALLOC_ALWAYS_INLINE rtree_leaf_elm_t *
function rtree_write (line 385) | static inline bool
function JEMALLOC_ALWAYS_INLINE (line 403) | JEMALLOC_ALWAYS_INLINE rtree_leaf_elm_t *
function JEMALLOC_ALWAYS_INLINE (line 415) | JEMALLOC_ALWAYS_INLINE extent_t *
function JEMALLOC_ALWAYS_INLINE (line 426) | JEMALLOC_ALWAYS_INLINE szind_t
function JEMALLOC_ALWAYS_INLINE (line 442) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 462) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 491) | JEMALLOC_ALWAYS_INLINE bool
function rtree_szind_slab_update (line 510) | static inline void
function rtree_clear (line 519) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/rtree_tsd.h
type rtree_leaf_elm_t (line 32) | typedef struct rtree_leaf_elm_s rtree_leaf_elm_t;
type rtree_ctx_cache_elm_t (line 34) | typedef struct rtree_ctx_cache_elm_s rtree_ctx_cache_elm_t;
type rtree_ctx_cache_elm_s (line 35) | struct rtree_ctx_cache_elm_s {
type rtree_ctx_t (line 40) | typedef struct rtree_ctx_s rtree_ctx_t;
type rtree_ctx_s (line 41) | struct rtree_ctx_s {
FILE: deps/jemalloc/include/jemalloc/internal/safety_check.h
function JEMALLOC_ALWAYS_INLINE (line 8) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 16) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/sc.h
type sc_t (line 267) | typedef struct sc_s sc_t;
type sc_s (line 268) | struct sc_s {
type sc_data_t (line 292) | typedef struct sc_data_s sc_data_t;
type sc_data_s (line 293) | struct sc_data_s {
FILE: deps/jemalloc/include/jemalloc/internal/spin.h
type spin_t (line 6) | typedef struct {
function spin_cpu_spinwait (line 10) | static inline void
function spin_adaptive (line 20) | static inline void
FILE: deps/jemalloc/include/jemalloc/internal/sz.h
function JEMALLOC_ALWAYS_INLINE (line 52) | JEMALLOC_ALWAYS_INLINE pszind_t
function sz_pind2sz_compute (line 73) | static inline size_t
function sz_pind2sz_lookup (line 93) | static inline size_t
function sz_pind2sz (line 100) | static inline size_t
function sz_psz2u (line 106) | static inline size_t
function szind_t (line 120) | static inline szind_t
function JEMALLOC_ALWAYS_INLINE (line 154) | JEMALLOC_ALWAYS_INLINE szind_t
function JEMALLOC_ALWAYS_INLINE (line 163) | JEMALLOC_ALWAYS_INLINE szind_t
function sz_index2size_compute (line 171) | static inline size_t
function JEMALLOC_ALWAYS_INLINE (line 197) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 204) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 210) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 238) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 250) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_ALWAYS_INLINE (line 262) | JEMALLOC_ALWAYS_INLINE size_t
FILE: deps/jemalloc/include/jemalloc/internal/tcache_inlines.h
function tcache_enabled_get (line 11) | static inline bool
function tcache_enabled_set (line 16) | static inline void
function JEMALLOC_ALWAYS_INLINE (line 30) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 41) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 103) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 163) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 188) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 215) | JEMALLOC_ALWAYS_INLINE tcache_t *
FILE: deps/jemalloc/include/jemalloc/internal/tcache_structs.h
type tsd_link_t (line 11) | typedef ql_elm(tsd_t) tsd_link_t;
type tcache_s (line 13) | struct tcache_s {
type tcaches_s (line 63) | struct tcaches_s {
FILE: deps/jemalloc/include/jemalloc/internal/tcache_types.h
type tcache_t (line 6) | typedef struct tcache_s tcache_t;
type tcaches_t (line 7) | typedef struct tcaches_s tcaches_t;
FILE: deps/jemalloc/include/jemalloc/internal/ticker.h
type ticker_t (line 14) | typedef struct {
function ticker_init (line 19) | static inline void
function ticker_copy (line 25) | static inline void
function ticker_read (line 30) | static inline int32_t
function ticker_fixup (line 58) | static bool
function ticker_ticks (line 64) | static inline bool
function ticker_tick (line 73) | static inline bool
function ticker_trytick (line 82) | static inline bool
FILE: deps/jemalloc/include/jemalloc/internal/tsd.h
type tsd_s (line 185) | struct tsd_s {
function JEMALLOC_ALWAYS_INLINE (line 203) | JEMALLOC_ALWAYS_INLINE uint8_t
type tsdn_s (line 219) | struct tsdn_s {
function JEMALLOC_ALWAYS_INLINE (line 223) | JEMALLOC_ALWAYS_INLINE tsdn_t *
function JEMALLOC_ALWAYS_INLINE (line 228) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 233) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 323) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 334) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 344) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 363) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 369) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 378) | JEMALLOC_ALWAYS_INLINE tsd_t *
function tsd_nominal (line 383) | static inline bool
function JEMALLOC_ALWAYS_INLINE (line 388) | JEMALLOC_ALWAYS_INLINE tsdn_t *
function JEMALLOC_ALWAYS_INLINE (line 397) | JEMALLOC_ALWAYS_INLINE rtree_ctx_t *
function JEMALLOC_ALWAYS_INLINE (line 402) | JEMALLOC_ALWAYS_INLINE rtree_ctx_t *
FILE: deps/jemalloc/include/jemalloc/internal/tsd_generic.h
type tsd_init_block_t (line 6) | typedef struct tsd_init_block_s tsd_init_block_t;
type tsd_init_block_s (line 7) | struct tsd_init_block_s {
type tsd_init_head_t (line 14) | typedef struct tsd_init_head_s tsd_init_head_t;
type tsd_wrapper_t (line 16) | typedef struct {
function JEMALLOC_ALWAYS_INLINE (line 31) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 53) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 61) | JEMALLOC_ALWAYS_INLINE tsd_wrapper_t *
function JEMALLOC_ALWAYS_INLINE (line 92) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 102) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 121) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 130) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 135) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 141) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 153) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/tsd_malloc_thread_cleanup.h
function JEMALLOC_ALWAYS_INLINE (line 13) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 22) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 29) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 34) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 39) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 44) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 50) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 54) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/tsd_tls.h
function JEMALLOC_ALWAYS_INLINE (line 13) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 22) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 27) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 32) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 37) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 43) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 48) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/tsd_types.h
type tsd_t (line 6) | typedef struct tsd_s tsd_t;
type tsdn_t (line 7) | typedef struct tsdn_s tsdn_t;
FILE: deps/jemalloc/include/jemalloc/internal/tsd_win.h
type tsd_wrapper_t (line 6) | typedef struct {
function JEMALLOC_ALWAYS_INLINE (line 16) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 38) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 46) | JEMALLOC_ALWAYS_INLINE tsd_wrapper_t *
function JEMALLOC_ALWAYS_INLINE (line 69) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 81) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 97) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 106) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 111) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 117) | JEMALLOC_ALWAYS_INLINE tsd_t *
function JEMALLOC_ALWAYS_INLINE (line 129) | JEMALLOC_ALWAYS_INLINE void
FILE: deps/jemalloc/include/jemalloc/internal/util.h
function UTIL_INLINE (line 46) | UTIL_INLINE void
function UTIL_INLINE (line 56) | UTIL_INLINE int
FILE: deps/jemalloc/include/jemalloc/internal/witness.h
type witness_t (line 74) | typedef struct witness_s witness_t;
type witness_rank_t (line 75) | typedef unsigned witness_rank_t;
type witness_list_t (line 76) | typedef ql_head(witness_t) witness_list_t;
type witness_s (line 80) | struct witness_s {
type witness_tsd_t (line 107) | typedef struct witness_tsd_s witness_tsd_t;
type witness_tsd_s (line 108) | struct witness_tsd_s {
type witness_tsdn_t (line 119) | typedef struct witness_tsdn_s witness_tsdn_t;
type witness_tsdn_s (line 120) | struct witness_tsdn_s {
function JEMALLOC_ALWAYS_INLINE (line 124) | JEMALLOC_ALWAYS_INLINE witness_tsdn_t *
function JEMALLOC_ALWAYS_INLINE (line 129) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 134) | JEMALLOC_ALWAYS_INLINE witness_tsd_t *
function witness_owner (line 165) | static inline bool
function witness_assert_owner (line 182) | static inline void
function witness_assert_not_owner (line 204) | static inline void
function witness_assert_depth_to_rank (line 231) | static inline void
function witness_assert_depth (line 264) | static inline void
function witness_assert_lockless (line 269) | static inline void
function witness_lock (line 274) | static inline void
function witness_unlock (line 317) | static inline void
FILE: deps/jemalloc/include/msvc_compat/C99/stdbool.h
type BOOL (line 11) | typedef BOOL _Bool;
FILE: deps/jemalloc/include/msvc_compat/C99/stdint.h
type int_least8_t (line 94) | typedef int8_t int_least8_t;
type int_least16_t (line 95) | typedef int16_t int_least16_t;
type int_least32_t (line 96) | typedef int32_t int_least32_t;
type int_least64_t (line 97) | typedef int64_t int_least64_t;
type uint_least8_t (line 98) | typedef uint8_t uint_least8_t;
type uint_least16_t (line 99) | typedef uint16_t uint_least16_t;
type uint_least32_t (line 100) | typedef uint32_t uint_least32_t;
type uint_least64_t (line 101) | typedef uint64_t uint_least64_t;
type int_fast8_t (line 104) | typedef int8_t int_fast8_t;
type int_fast16_t (line 105) | typedef int16_t int_fast16_t;
type int_fast32_t (line 106) | typedef int32_t int_fast32_t;
type int_fast64_t (line 107) | typedef int64_t int_fast64_t;
type uint_fast8_t (line 108) | typedef uint8_t uint_fast8_t;
type uint_fast16_t (line 109) | typedef uint16_t uint_fast16_t;
type uint_fast32_t (line 110) | typedef uint32_t uint_fast32_t;
type uint_fast64_t (line 111) | typedef uint64_t uint_fast64_t;
type intmax_t (line 123) | typedef int64_t intmax_t;
type uintmax_t (line 124) | typedef uint64_t uintmax_t;
FILE: deps/jemalloc/include/msvc_compat/strings.h
function ffsl (line 9) | static __forceinline int ffsl(long x) {
function ffs (line 18) | static __forceinline int ffs(int x) {
function ffsll (line 26) | static __forceinline int ffsll(unsigned __int64 x) {
FILE: deps/jemalloc/msvc/test_threads/test_threads.cpp
function test_threads (line 19) | int test_threads() {
FILE: deps/jemalloc/msvc/test_threads/test_threads_main.cpp
function main (line 8) | int main(int argc, char** argv) {
FILE: deps/jemalloc/scripts/gen_run_tests.py
function powerset (line 22) | def powerset(items):
FILE: deps/jemalloc/scripts/gen_travis.py
function format_job (line 70) | def format_job(combination):
FILE: deps/jemalloc/src/arena.c
function arena_basic_stats_merge (line 69) | void
function arena_stats_merge (line 82) | void
function arena_extents_dirty_dalloc (line 255) | void
function arena_slab_reg_alloc_batch (line 286) | static void
function arena_slab_regind (line 335) | static
function arena_slab_reg_dalloc (line 358) | static void
function arena_nactive_add (line 372) | static void
function arena_nactive_sub (line 377) | static void
function arena_large_malloc_stats_update (line 383) | static void
function arena_large_dalloc_stats_update (line 399) | static void
function arena_large_ralloc_stats_update (line 415) | static void
function arena_may_have_muzzy (line 422) | static bool
function extent_t (line 427) | extent_t *
function arena_extent_dalloc_large_prep (line 479) | void
function arena_extent_ralloc_large_shrink (line 490) | void
function arena_extent_ralloc_large_expand (line 504) | void
function arena_decay_ms_read (line 518) | static ssize_t
function arena_decay_ms_write (line 523) | static void
function arena_decay_deadline_init (line 528) | static void
function arena_decay_deadline_reached (line 545) | static bool
function arena_decay_backlog_npages_limit (line 550) | static size_t
function arena_decay_backlog_update_last (line 570) | static void
function arena_decay_backlog_update (line 588) | static void
function arena_decay_try_purge (line 610) | static void
function arena_decay_epoch_advance_helper (line 621) | static void
function arena_decay_epoch_advance (line 645) | static void
function arena_decay_reinit (line 662) | static void
function arena_decay_init (line 679) | static bool
function arena_decay_ms_valid (line 701) | static bool
function arena_maybe_decay (line 713) | static bool
function arena_decay_ms_get (line 771) | static ssize_t
function arena_dirty_decay_ms_get (line 776) | ssize_t
function arena_muzzy_decay_ms_get (line 781) | ssize_t
function arena_decay_ms_set (line 786) | static bool
function arena_dirty_decay_ms_set (line 809) | bool
function arena_muzzy_decay_ms_set (line 816) | bool
function arena_stash_decayed (line 823) | static size_t
function arena_decay_stashed (line 842) | static size_t
function arena_decay_to_limit (line 915) | static void
function arena_decay_impl (line 947) | static bool
function arena_decay_dirty (line 982) | static bool
function arena_decay_muzzy (line 989) | static bool
function arena_decay (line 996) | void
function arena_slab_dalloc (line 1004) | static void
function arena_bin_slabs_nonfull_insert (line 1012) | static void
function arena_bin_slabs_nonfull_remove (line 1021) | static void
function extent_t (line 1029) | static extent_t *
function arena_bin_slabs_full_insert (line 1042) | static void
function arena_bin_slabs_full_remove (line 1056) | static void
function arena_bin_reset (line 1064) | static void
function arena_reset (line 1095) | void
function arena_destroy_retained (line 1150) | static void
function arena_destroy (line 1169) | void
function extent_t (line 1205) | static extent_t *
function extent_t (line 1228) | static extent_t *
function extent_t (line 1265) | static extent_t *
function bin_t (line 1364) | bin_t *
function arena_tcache_fill_small (line 1380) | void
function arena_alloc_junk_small (line 1445) | void
function arena_dalloc_junk_small_impl (line 1452) | static void
function arena_prof_promote (line 1552) | void
function arena_prof_demote (line 1580) | static size_t
function arena_dalloc_promoted (line 1596) | void
function arena_dissociate_bin_slab (line 1621) | static void
function arena_dalloc_bin_slab (line 1643) | static void
function arena_bin_lower_slab (line 1658) | static void
function arena_dalloc_bin_locked_impl (line 1685) | static void
function arena_dalloc_bin_junked_locked (line 1711) | void
function arena_dalloc_bin (line 1718) | static void
function arena_dalloc_small (line 1730) | void
function arena_ralloc_no_move (line 1739) | bool
function dss_prec_t (line 1853) | dss_prec_t
function arena_dss_prec_set (line 1858) | bool
function arena_dirty_decay_ms_default_get (line 1867) | ssize_t
function arena_dirty_decay_ms_default_set (line 1872) | bool
function arena_muzzy_decay_ms_default_get (line 1881) | ssize_t
function arena_muzzy_decay_ms_default_set (line 1886) | bool
function arena_retain_grow_limit_get_set (line 1895) | bool
function arena_nthreads_get (line 1921) | unsigned
function arena_nthreads_inc (line 1926) | void
function arena_nthreads_dec (line 1931) | void
function arena_extent_sn_next (line 1936) | size_t
function arena_t (line 1941) | arena_t *
function arena_t (line 2110) | arena_t *
function arena_init_huge (line 2142) | bool
function arena_is_huge (line 2162) | bool
function arena_boot (line 2170) | void
function arena_prefork0 (line 2181) | void
function arena_prefork1 (line 2187) | void
function arena_prefork2 (line 2194) | void
function arena_prefork3 (line 2199) | void
function arena_prefork4 (line 2206) | void
function arena_prefork5 (line 2211) | void
function arena_prefork6 (line 2216) | void
function arena_prefork7 (line 2221) | void
function arena_postfork_parent (line 2230) | void
function arena_postfork_child (line 2254) | void
FILE: deps/jemalloc/src/background_thread.c
function pthread_create_wrapper_init (line 34) | static void
function pthread_create_wrapper (line 43) | int
function background_thread_info_init (line 71) | static void
function set_current_thread_affinity (line 81) | static inline bool
function decay_npurge_after_interval (line 101) | static inline size_t
function arena_decay_compute_purge_interval_impl (line 115) | static uint64_t
function arena_decay_compute_purge_interval (line 201) | static uint64_t
function background_thread_sleep (line 215) | static void
function background_thread_pause_check (line 271) | static bool
function background_work_sleep_once (line 285) | static inline void
function background_threads_disable_single (line 310) | static bool
function background_thread_create_signals_masked (line 351) | static int
function check_background_thread_creation (line 383) | static bool
function background_thread0_work (line 433) | static void
function background_work (line 482) | static void
function background_thread_init (line 529) | static void
function background_thread_create_locked (line 537) | static bool
function background_thread_create (line 592) | bool
function background_threads_enable (line 604) | bool
function background_threads_disable (line 640) | bool
function background_thread_interval_check (line 656) | void
function background_thread_prefork0 (line 739) | void
function background_thread_prefork1 (line 745) | void
function background_thread_postfork_parent (line 752) | void
function background_thread_postfork_child (line 761) | void
function background_thread_stats_read (line 788) | bool
function pthread_create_fptr_init (line 832) | static bool
function background_thread_ctl_init (line 867) | void
function background_thread_boot0 (line 878) | bool
function background_thread_boot1 (line 894) | bool
FILE: deps/jemalloc/src/base.c
function metadata_thp_madvise (line 25) | static inline bool
function base_unmap (line 54) | static void
function base_extent_init (line 118) | static void
function base_get_num_blocks (line 129) | static size_t
function base_auto_thp_switch (line 143) | static void
function base_extent_bump_alloc_post (line 197) | static void
function base_block_t (line 247) | static base_block_t *
function extent_t (line 307) | static extent_t *
function base_t (line 344) | base_t *
function base_t (line 349) | base_t *
function base_delete (line 395) | void
function extent_hooks_t (line 407) | extent_hooks_t *
function extent_hooks_t (line 413) | extent_hooks_t *
function extent_t (line 468) | extent_t *
function base_stats_get (line 480) | void
function base_prefork (line 495) | void
function base_postfork_parent (line 500) | void
function base_postfork_child (line 505) | void
function base_boot (line 510) | bool
FILE: deps/jemalloc/src/bin.c
function bin_infos_init (line 11) | static void
function bin_update_shard_size (line 29) | bool
function bin_shard_sizes_boot (line 53) | void
function bin_boot (line 61) | void
function bin_init (line 67) | bool
function bin_prefork (line 82) | void
function bin_postfork_parent (line 87) | void
function bin_postfork_child (line 92) | void
FILE: deps/jemalloc/src/bitmap.c
function bitmap_info_init (line 11) | void
function bitmap_info_ngroups (line 39) | static size_t
function bitmap_init (line 44) | void
function bitmap_info_init (line 85) | void
function bitmap_info_ngroups (line 94) | static size_t
function bitmap_init (line 99) | void
function bitmap_size (line 118) | size_t
FILE: deps/jemalloc/src/ckh.c
function ckh_bucket_search (line 62) | static size_t
function ckh_isearch (line 80) | static size_t
function ckh_try_bucket_insert (line 101) | static bool
function ckh_evict_reloc_insert (line 133) | static bool
function ckh_try_insert (line 204) | static bool
function ckh_rebuild (line 234) | static bool
function ckh_grow (line 256) | static bool
function ckh_shrink (line 311) | static void
function ckh_new (line 359) | bool
function ckh_delete (line 416) | void
function ckh_count (line 438) | size_t
function ckh_iter (line 445) | bool
function ckh_insert (line 466) | bool
function ckh_remove (line 489) | bool
function ckh_search (line 522) | bool
function ckh_string_hash (line 542) | void
function ckh_string_keycomp (line 547) | bool
function ckh_pointer_hash (line 555) | void
function ckh_pointer_keycomp (line 567) | bool
FILE: deps/jemalloc/src/ctl.c
function ctl_named_node_t (line 29) | static const ctl_named_node_t *
function ctl_named_node_t (line 34) | static const ctl_named_node_t *
function ctl_indexed_node_t (line 41) | static const ctl_indexed_node_t *
function MUTEX_PROF_GLOBAL_MUTEXES (line 575) | MUTEX_PROF_GLOBAL_MUTEXES
function thread_prof_name_ctl (line 1910) | static int
function thread_prof_active_ctl (line 1942) | static int
function tcache_create_ctl (line 1973) | static int
function tcache_flush_ctl (line 1991) | static int
function tcache_destroy_ctl (line 2011) | static int
function arena_i_initialized_ctl (line 2033) | static int
function arena_i_decay (line 2055) | static void
function arena_i_decay_ctl (line 2102) | static int
function arena_i_purge_ctl (line 2118) | static int
function arena_i_reset_destroy_helper (line 2134) | static int
function arena_reset_prepare_background_thread (line 2155) | static void
function arena_reset_finish_background_thread (line 2171) | static void
function arena_i_reset_ctl (line 2186) | static int
function arena_i_destroy_ctl (line 2206) | static int
function arena_i_dss_ctl (line 2247) | static int
function arena_i_decay_ms_ctl_impl (line 2308) | static int
function arena_i_dirty_decay_ms_ctl (line 2356) | static int
function arena_i_muzzy_decay_ms_ctl (line 2363) | static int
function arena_i_extent_hooks_ctl (line 2370) | static int
function arena_i_retain_grow_limit_ctl (line 2425) | static int
function ctl_named_node_t (line 2462) | static const ctl_named_node_t *
function arenas_narenas_ctl (line 2488) | static int
function arenas_decay_ms_ctl_impl (line 2509) | static int
function arenas_dirty_decay_ms_ctl (line 2537) | static int
function arenas_muzzy_decay_ms_ctl (line 2544) | static int
function ctl_named_node_t (line 2560) | static const ctl_named_node_t *
function ctl_named_node_t (line 2572) | static const ctl_named_node_t *
function arenas_create_ctl (line 2581) | static int
function arenas_lookup_ctl (line 2604) | static int
function prof_thread_active_init_ctl (line 2637) | static int
function prof_active_ctl (line 2665) | static int
function prof_dump_ctl (line 2691) | static int
function prof_gdump_ctl (line 2714) | static int
function prof_reset_ctl (line 2740) | static int
function prof_log_start_ctl (line 2766) | static int
function prof_log_stop_ctl (line 2790) | static int
function stats_mutexes_reset_ctl (line 2953) | static int
function ctl_named_node_t (line 3028) | static const ctl_named_node_t *
function ctl_named_node_t (line 3049) | static const ctl_named_node_t *
function ctl_named_node_t (line 3083) | static const ctl_named_node_t *
function ctl_arenas_i_verify (line 3092) | static bool
function ctl_named_node_t (line 3102) | static const ctl_named_node_t *
function experimental_hooks_install_ctl (line 3119) | static int
function experimental_hooks_remove_ctl (line 3147) | static int
function experimental_utilization_query_ctl (line 3230) | static int
function experimental_utilization_batch_query_ctl (line 3355) | static int
function ctl_named_node_t (line 3384) | static const ctl_named_node_t *
function experimental_arenas_i_pactivep_ctl (line 3400) | static int
FILE: deps/jemalloc/src/div.c
function div_init (line 29) | void
FILE: deps/jemalloc/src/extent.c
type lock_result_t (line 123) | typedef enum {
function lock_result_t (line 129) | static lock_result_t
function extent_t (line 162) | static extent_t *
function extent_t (line 179) | extent_t *
function extent_dalloc (line 193) | void
function extent_hooks_t (line 201) | extent_hooks_t *
function extent_hooks_t (line 206) | extent_hooks_t *
function extent_hooks_assure_initialized (line 221) | static void
function extent_size_quantize_floor (line 232) | size_t
function extent_size_quantize_ceil (line 256) | static
function extents_init (line 285) | bool
function extent_state_t (line 303) | extent_state_t
function extents_npages_get (line 308) | size_t
function extents_nextents_get (line 313) | size_t
function extents_nbytes_get (line 318) | size_t
function extents_stats_add (line 323) | static void
function extents_stats_sub (line 331) | static void
function extents_insert_locked (line 339) | static void
function extents_remove_locked (line 370) | static void
function extent_t (line 405) | static extent_t *
function extent_t (line 442) | static extent_t *
function extent_t (line 492) | static extent_t *
function extent_try_delayed_coalesce (line 519) | static bool
function extent_t (line 536) | extent_t *
function extents_dalloc (line 551) | void
function extent_t (line 566) | extent_t *
function extents_abandon_vm (line 634) | static void
function extents_prefork (line 656) | void
function extents_postfork_parent (line 661) | void
function extents_postfork_child (line 666) | void
function extent_deactivate_locked (line 671) | static void
function extent_deactivate (line 681) | static void
function extent_activate_locked (line 689) | static void
function extent_rtree_leaf_elms_lookup (line 699) | static bool
function extent_rtree_write_acquired (line 720) | static void
function extent_interior_register (line 730) | static void
function extent_gdump_add (line 743) | static void
function extent_gdump_sub (line 769) | static void
function extent_register_impl (line 780) | static bool
function extent_register (line 814) | static bool
function extent_register_no_gdump_add (line 819) | static bool
function extent_reregister (line 824) | static void
function extent_interior_deregister (line 837) | static void
function extent_deregister_impl (line 854) | static void
function extent_deregister (line 877) | static void
function extent_deregister_no_gdump_sub (line 882) | static void
function extent_t (line 891) | static extent_t *
type extent_split_interior_result_t (line 960) | typedef enum {
function extent_split_interior_result_t (line 979) | static extent_split_interior_result_t
function extent_t (line 1056) | static extent_t *
function extent_need_manual_zero (line 1112) | static bool
function extent_t (line 1127) | static extent_t *
function extent_hook_pre_reentrancy (line 1268) | static void
function extent_hook_post_reentrancy (line 1285) | static void
function extent_t (line 1296) | static extent_t *
function extent_t (line 1462) | static extent_t *
function extent_t (line 1491) | static extent_t *
function extent_t (line 1530) | extent_t *
function extent_can_coalesce (line 1559) | static bool
function extent_coalesce (line 1579) | static bool
function extent_t (line 1599) | static extent_t *
function extent_t (line 1671) | static extent_t *
function extent_t (line 1679) | static extent_t *
function extent_record (line 1691) | static void
function extent_dalloc_gap (line 1738) | void
function extent_may_dalloc (line 1752) | static bool
function extent_dalloc_default_impl (line 1758) | static bool
function extent_dalloc_default (line 1766) | static bool
function extent_dalloc_wrapper_try (line 1772) | static bool
function extent_dalloc_wrapper (line 1806) | void
function extent_destroy_default_impl (line 1864) | static void
function extent_destroy_default (line 1871) | static void
function extent_destroy_wrapper (line 1877) | void
function extent_commit_default (line 1907) | static bool
function extent_commit_impl (line 1914) | static bool
function extent_commit_wrapper (line 1935) | bool
function extent_decommit_default (line 1943) | static bool
function extent_decommit_wrapper (line 1950) | bool
function extent_purge_lazy_default (line 1974) | static bool
function extent_purge_lazy_impl (line 1987) | static bool
function extent_purge_lazy_wrapper (line 2012) | bool
function extent_purge_forced_default (line 2021) | static bool
function extent_purge_forced_impl (line 2034) | static bool
function extent_purge_forced_wrapper (line 2058) | bool
function extent_split_default (line 2066) | static bool
function extent_t (line 2088) | static extent_t *
function extent_t (line 2172) | extent_t *
function extent_merge_default_impl (line 2180) | static bool
function extent_head_no_merge (line 2196) | static bool
function extent_merge_default (line 2224) | static bool
function extent_merge_impl (line 2238) | static bool
function extent_merge_wrapper (line 2312) | bool
function extent_boot (line 2318) | bool
function extent_util_stats_get (line 2336) | void
function extent_util_stats_verbose_get (line 2359) | void
FILE: deps/jemalloc/src/extent_dss.c
function dss_prec_t (line 51) | dss_prec_t
function extent_dss_prec_set (line 62) | bool
function extent_dss_extending_start (line 71) | static void
function extent_dss_extending_finish (line 84) | static void
function extent_in_dss_helper (line 231) | static bool
function extent_in_dss (line 237) | bool
function extent_dss_mergeable (line 245) | bool
function extent_dss_boot (line 261) | void
FILE: deps/jemalloc/src/extent_mmap.c
function extent_dalloc_mmap (line 36) | bool
FILE: deps/jemalloc/src/hook.c
type hooks_internal_t (line 9) | typedef struct hooks_internal_s hooks_internal_t;
type hooks_internal_s (line 10) | struct hooks_internal_s {
function hook_boot (line 21) | bool
function hook_remove_locked (line 58) | static void
function hook_remove (line 72) | void
function hook_invoke_alloc (line 153) | void
function hook_invoke_dalloc (line 169) | void
function hook_invoke_expand (line 182) | void
FILE: deps/jemalloc/src/jemalloc.c
type malloc_init_t (line 97) | typedef enum {
function WINAPI (line 140) | WINAPI
type malloc_utrace_t (line 169) | typedef struct {
function malloc_initialized (line 208) | bool
function JEMALLOC_ALWAYS_INLINE (line 213) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 221) | JEMALLOC_ALWAYS_INLINE bool
function a0idalloc (line 244) | static void
function a0dalloc (line 254) | void
function bootstrap_free (line 287) | void
function arena_set (line 296) | void
function narenas_total_set (line 301) | static void
function narenas_total_inc (line 306) | static void
function narenas_total_get (line 311) | unsigned
function arena_t (line 317) | static arena_t *
function arena_new_create_background_thread (line 345) | static void
function arena_t (line 363) | arena_t *
function arena_bind (line 376) | static void
function arena_migrate (line 396) | void
function arena_unbind (line 407) | static void
function arena_tdata_t (line 421) | arena_tdata_t *
function arena_t (line 498) | arena_t *
function iarena_cleanup (line 612) | void
function arena_cleanup (line 622) | void
function arenas_tdata_cleanup (line 632) | void
function stats_print_atexit (line 646) | static void
function JEMALLOC_ALWAYS_INLINE (line 683) | JEMALLOC_ALWAYS_INLINE void
function malloc_ncpus (line 725) | static unsigned
function init_opt_stats_print_opts (line 753) | static void
function malloc_conf_multi_sizes_next (line 779) | static bool
function malloc_conf_next (line 822) | static bool
function malloc_abort_invalid_conf (line 897) | static void
function malloc_conf_error (line 905) | static void
function malloc_slow_flag_init (line 919) | static void
function malloc_conf_init_helper (line 1020) | static void
function malloc_conf_init (line 1439) | static void
function malloc_init_hard_needed (line 1452) | static bool
function malloc_init_hard_a0_locked (line 1478) | static bool
function malloc_init_hard_a0 (line 1563) | static bool
function malloc_init_hard_recursible (line 1574) | static bool
function malloc_narenas_default (line 1601) | static unsigned
function percpu_arena_mode_t (line 1615) | static percpu_arena_mode_t
function malloc_init_narenas (line 1627) | static bool
function malloc_init_percpu (line 1703) | static void
function malloc_init_hard_finish (line 1708) | static bool
function malloc_init_hard_cleanup (line 1720) | static void
function malloc_init_hard (line 1732) | static bool
type static_opts_t (line 1815) | typedef struct static_opts_s static_opts_t;
type static_opts_s (line 1816) | struct static_opts_s {
function JEMALLOC_ALWAYS_INLINE (line 1863) | JEMALLOC_ALWAYS_INLINE void
type dynamic_opts_t (line 1886) | typedef struct dynamic_opts_s dynamic_opts_t;
type dynamic_opts_s (line 1887) | struct dynamic_opts_s {
function JEMALLOC_ALWAYS_INLINE (line 1898) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 1911) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 1953) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 1989) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 2027) | JEMALLOC_ALWAYS_INLINE int
function JEMALLOC_ALWAYS_INLINE (line 2227) | JEMALLOC_ALWAYS_INLINE bool
function JEMALLOC_ALWAYS_INLINE (line 2245) | JEMALLOC_ALWAYS_INLINE int
function JEMALLOC_NOINLINE (line 2269) | JEMALLOC_NOINLINE
function JEMALLOC_ALWAYS_INLINE (line 2528) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 2555) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_ALWAYS_INLINE (line 2594) | JEMALLOC_ALWAYS_INLINE void
function JEMALLOC_NOINLINE (line 2769) | JEMALLOC_NOINLINE
function JEMALLOC_ALWAYS_INLINE (line 2805) | JEMALLOC_ALWAYS_INLINE
function JEMALLOC_NOTHROW (line 2862) | JEMALLOC_NOTHROW
type smallocx_return_t (line 3025) | typedef struct {
function JEMALLOC_NOTHROW (line 3031) | JEMALLOC_NOTHROW
function JEMALLOC_ALWAYS_INLINE (line 3173) | JEMALLOC_ALWAYS_INLINE void *
function JEMALLOC_ALWAYS_INLINE (line 3311) | JEMALLOC_ALWAYS_INLINE size_t
function ixallocx_prof_sample (line 3324) | static size_t
function JEMALLOC_ALWAYS_INLINE (line 3338) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_NOTHROW (line 3389) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3486) | JEMALLOC_NOTHROW
function JEMALLOC_ALWAYS_INLINE (line 3533) | JEMALLOC_ALWAYS_INLINE size_t
function JEMALLOC_NOINLINE (line 3547) | JEMALLOC_NOINLINE void
function JEMALLOC_NOTHROW (line 3593) | JEMALLOC_NOTHROW
function je_sdallocx_noflags (line 3605) | void JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3617) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3644) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3666) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3686) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3707) | JEMALLOC_NOTHROW
function JEMALLOC_NOTHROW (line 3721) | JEMALLOC_NOTHROW
function jemalloc_constructor (line 3772) | JEMALLOC_ATTR(constructor)
function jemalloc_prefork (line 3780) | void
function jemalloc_postfork_parent (line 3854) | void
function jemalloc_postfork_child (line 3893) | void
function JEMALLOC_NOTHROW (line 3927) | JEMALLOC_NOTHROW
FILE: deps/jemalloc/src/jemalloc_cpp.cpp
function JEMALLOC_NOINLINE (line 42) | JEMALLOC_NOINLINE
function JEMALLOC_ALWAYS_INLINE (line 75) | JEMALLOC_ALWAYS_INLINE
FILE: deps/jemalloc/src/large.c
function large_dalloc_junk_impl (line 74) | static void
function large_dalloc_maybe_junk_impl (line 80) | static void
function large_ralloc_no_move_shrink (line 95) | static bool
function large_ralloc_no_move_expand (line 130) | static bool
function large_ralloc_no_move (line 218) | bool
function large_dalloc_prep_impl (line 321) | static void
function large_dalloc_finish_impl (line 343) | static void
function large_dalloc_prep_junked_locked (line 349) | void
function large_dalloc_finish (line 354) | void
function large_dalloc (line 359) | void
function large_salloc (line 367) | size_t
function prof_tctx_t (line 372) | prof_tctx_t *
function large_prof_tctx_set (line 377) | void
function large_prof_tctx_reset (line 382) | void
function nstime_t (line 387) | nstime_t
function large_prof_alloc_time_set (line 392) | void
FILE: deps/jemalloc/src/log.c
function log_var_matches_segment (line 21) | static bool
function log_var_update_state (line 43) | unsigned
FILE: deps/jemalloc/src/malloc_io.c
function wrtmessage (line 71) | static void
function malloc_write (line 82) | void
function buferror (line 95) | int
function uintmax_t (line 113) | uintmax_t
function malloc_vsnprintf (line 326) | size_t
function malloc_cprintf (line 646) | void
function malloc_printf (line 658) | void
FILE: deps/jemalloc/src/mutex.c
function JEMALLOC_EXPORT (line 31) | JEMALLOC_EXPORT int
function malloc_mutex_lock_slow (line 46) | void
function mutex_prof_data_init (line 104) | static void
function malloc_mutex_prof_data_reset (line 112) | void
function mutex_addr_comp (line 118) | static int
function malloc_mutex_init (line 134) | bool
function malloc_mutex_prefork (line 184) | void
function malloc_mutex_postfork_parent (line 189) | void
function malloc_mutex_postfork_child (line 194) | void
function malloc_mutex_boot (line 210) | bool
FILE: deps/jemalloc/src/mutex_pool.c
function mutex_pool_init (line 9) | bool
FILE: deps/jemalloc/src/nstime.c
function nstime_init (line 11) | void
function nstime_init2 (line 16) | void
function nstime_ns (line 21) | uint64_t
function nstime_msec (line 26) | uint64_t
function nstime_sec (line 31) | uint64_t
function nstime_nsec (line 36) | uint64_t
function nstime_copy (line 41) | void
function nstime_compare (line 46) | int
function nstime_add (line 51) | void
function nstime_iadd (line 58) | void
function nstime_subtract (line 65) | void
function nstime_isubtract (line 72) | void
function nstime_imultiply (line 79) | void
function nstime_idivide (line 87) | void
function nstime_divide (line 94) | uint64_t
function nstime_get (line 103) | static void
function nstime_get (line 115) | static void
function nstime_get (line 124) | static void
function nstime_get (line 133) | static void
function nstime_get (line 139) | static void
function nstime_monotonic_impl (line 148) | static bool
function nstime_update_impl (line 155) | static bool
FILE: deps/jemalloc/src/pages.c
function pages_unmap (line 240) | void
function pages_commit_impl (line 248) | static bool
function pages_commit (line 281) | bool
function pages_decommit (line 286) | bool
function pages_purge_lazy (line 291) | bool
function pages_purge_forced (line 326) | bool
function pages_huge_impl (line 346) | static bool
function pages_huge (line 359) | bool
function pages_huge_unaligned (line 364) | static bool
function pages_nohuge_impl (line 369) | static bool
function pages_nohuge (line 383) | bool
function pages_nohuge_unaligned (line 388) | static bool
function pages_dontdump (line 393) | bool
function pages_dodump (line 404) | bool
function os_page_detect (line 416) | static size_t
function os_overcommits_sysctl (line 438) | static bool
function os_overcommits_proc (line 468) | static bool
function pages_set_thp_state (line 529) | void
function init_thp_state (line 548) | static void
function pages_boot (line 598) | bool
FILE: deps/jemalloc/src/prof.c
type prof_logging_state_t (line 75) | typedef enum prof_logging_state_e prof_logging_state_t;
type prof_logging_state_e (line 76) | enum prof_logging_state_e {
type prof_bt_node_t (line 110) | typedef struct prof_bt_node_s prof_bt_node_t;
type prof_bt_node_s (line 112) | struct prof_bt_node_s {
type prof_thr_node_t (line 120) | typedef struct prof_thr_node_s prof_thr_node_t;
type prof_thr_node_s (line 122) | struct prof_thr_node_s {
type prof_alloc_node_t (line 130) | typedef struct prof_alloc_node_s prof_alloc_node_t;
type prof_alloc_node_s (line 133) | struct prof_alloc_node_s {
function prof_tctx_comp (line 253) | static int
function prof_malloc_sample_object (line 342) | void
function prof_log_bt_index (line 364) | static size_t
function prof_log_thr_index (line 406) | static size_t
function prof_try_log (line 443) | static void
function prof_free_sampled_object (line 520) | void
function bt_init (line 539) | void
function prof_enter (line 547) | static void
function prof_leave (line 560) | static void
function prof_backtrace (line 587) | void
function _Unwind_Reason_Code (line 602) | static _Unwind_Reason_Code
function _Unwind_Reason_Code (line 609) | static _Unwind_Reason_Code
function prof_backtrace (line 629) | void
function prof_backtrace (line 638) | void
function prof_backtrace (line 801) | void
function malloc_mutex_t (line 808) | static malloc_mutex_t *
function malloc_mutex_t (line 815) | static malloc_mutex_t *
function prof_gctx_t (line 820) | static prof_gctx_t *
function prof_gctx_try_destroy (line 846) | static void
function prof_tctx_should_destroy (line 881) | static bool
function prof_gctx_should_destroy (line 897) | static bool
function prof_tctx_destroy (line 911) | static void
function prof_lookup_global (line 987) | static bool
function prof_tctx_t (line 1052) | prof_tctx_t *
function prof_sample_threshold_update (line 1139) | void
function prof_tdata_t (line 1183) | static prof_tdata_t *
function prof_tdata_count (line 1193) | size_t
function prof_bt_count (line 1207) | size_t
function prof_dump_open_impl (line 1227) | static int
function prof_dump_flush (line 1244) | static bool
function prof_dump_close (line 1267) | static bool
function prof_dump_write (line 1279) | static bool
function prof_dump_printf (line 1312) | static bool
function prof_tctx_merge_tdata (line 1326) | static void
function prof_tctx_merge_gctx (line 1357) | static void
function prof_tctx_t (line 1369) | static prof_tctx_t *
type prof_tctx_dump_iter_arg_s (line 1390) | struct prof_tctx_dump_iter_arg_s {
function prof_tctx_t (line 1395) | static prof_tctx_t *
function prof_tctx_t (line 1423) | static prof_tctx_t *
function prof_dump_gctx_prep (line 1449) | static void
type prof_gctx_merge_iter_arg_s (line 1468) | struct prof_gctx_merge_iter_arg_s {
function prof_gctx_t (line 1473) | static prof_gctx_t *
function prof_gctx_finish (line 1489) | static void
type prof_tdata_merge_iter_arg_s (line 1535) | struct prof_tdata_merge_iter_arg_s {
function prof_tdata_t (line 1540) | static prof_tdata_t *
function prof_tdata_t (line 1575) | static prof_tdata_t *
function prof_dump_header_impl (line 1596) | static bool
function prof_dump_gctx (line 1617) | static bool
function prof_open_maps (line 1674) | static int
function prof_getpid (line 1697) | static int
function prof_dump_maps (line 1706) | static bool
function prof_leakcheck (line 1766) | static void
type prof_gctx_dump_iter_arg_s (line 1797) | struct prof_gctx_dump_iter_arg_s {
function prof_gctx_t (line 1802) | static prof_gctx_t *
function prof_dump_prep (line 1822) | static void
function prof_dump_file (line 1864) | static bool
function prof_dump (line 1905) | static bool
function prof_cnt_all (line 1945) | void
function prof_dump_filename (line 1993) | static void
function prof_fdump (line 2011) | static void
function prof_accum_init (line 2032) | bool
function prof_idump (line 2048) | void
function prof_mdump (line 2082) | bool
function prof_gdump (line 2105) | void
function prof_bt_hash (line 2139) | static void
function prof_bt_keycomp (line 2148) | static bool
function prof_bt_node_hash (line 2161) | static void
function prof_bt_node_keycomp (line 2167) | static bool
function prof_thr_node_hash (line 2175) | static void
function prof_thr_node_keycomp (line 2181) | static bool
function prof_thr_uid_alloc (line 2188) | static uint64_t
function prof_tdata_t (line 2200) | static prof_tdata_t *
function prof_tdata_t (line 2246) | prof_tdata_t *
function prof_tdata_should_destroy_unlocked (line 2252) | static bool
function prof_tdata_should_destroy (line 2263) | static bool
function prof_tdata_destroy_locked (line 2271) | static void
function prof_tdata_destroy (line 2288) | static void
function prof_tdata_detach (line 2295) | static void
function prof_tdata_t (line 2320) | prof_tdata_t *
function prof_tdata_expire (line 2333) | static bool
function prof_tdata_t (line 2350) | static prof_tdata_t *
function prof_reset (line 2358) | void
function prof_tdata_cleanup (line 2385) | void
function prof_active_get (line 2399) | bool
function prof_active_set (line 2409) | bool
function prof_log_bt_count (line 2421) | size_t
function prof_log_alloc_count (line 2432) | size_t
function prof_log_thr_count (line 2443) | size_t
function prof_log_is_logging (line 2454) | bool
function prof_log_rep_check (line 2459) | bool
function prof_log_dummy_set (line 2510) | void
function prof_log_start (line 2516) | bool
function prof_log_stop_final (line 2552) | static void
type prof_emitter_cb_arg_s (line 2558) | struct prof_emitter_cb_arg_s {
function prof_emitter_write_cb (line 2563) | static void
function prof_log_emit_threads (line 2580) | static void
function prof_log_emit_traces (line 2604) | static void
function prof_log_emit_allocs (line 2633) | static void
function prof_log_emit_metadata (line 2671) | static void
function prof_log_stop (line 2695) | bool
function prof_thread_name_set (line 2816) | int
function prof_thread_active_get (line 2854) | bool
function prof_thread_active_set (line 2865) | bool
function prof_thread_active_init_get (line 2877) | bool
function prof_thread_active_init_set (line 2887) | bool
function prof_gdump_get (line 2898) | bool
function prof_gdump_set (line 2908) | bool
function prof_boot0 (line 2919) | void
function prof_boot1 (line 2927) | void
function prof_boot2 (line 2951) | bool
function prof_prefork0 (line 3087) | void
function prof_prefork1 (line 3104) | void
function prof_postfork_parent (line 3115) | void
function prof_postfork_child (line 3138) | void
FILE: deps/jemalloc/src/rtree.c
function rtree_new (line 12) | bool
function rtree_node_elm_t (line 30) | static rtree_node_elm_t *
function rtree_node_dalloc_impl (line 37) | static void
function rtree_leaf_elm_t (line 45) | static rtree_leaf_elm_t *
function rtree_leaf_dalloc_impl (line 52) | static void
function rtree_delete_subtree (line 62) | static void
function rtree_delete (line 93) | void
function rtree_node_elm_t (line 101) | static rtree_node_elm_t *
function rtree_leaf_elm_t (line 128) | static rtree_leaf_elm_t *
function rtree_node_valid (line 154) | static bool
function rtree_leaf_valid (line 159) | static bool
function rtree_node_elm_t (line 164) | static rtree_node_elm_t *
function rtree_node_elm_t (line 180) | static rtree_node_elm_t *
function rtree_leaf_elm_t (line 193) | static rtree_leaf_elm_t *
function rtree_leaf_elm_t (line 209) | static rtree_leaf_elm_t *
function rtree_leaf_elm_t (line 222) | rtree_leaf_elm_t *
function rtree_ctx_data_init (line 308) | void
FILE: deps/jemalloc/src/safety_check.c
function safety_check_set_abort (line 6) | void safety_check_set_abort(void (*abort_fn)(const char *)) {
function safety_check_fail (line 10) | void safety_check_fail(const char *format, ...) {
FILE: deps/jemalloc/src/sc.c
function reg_size_compute (line 18) | static size_t
function slab_size (line 24) | static int
function size_class (line 55) | static void
function size_classes (line 87) | static void
function sc_data_init (line 258) | void
function sc_data_update_sc_slab_size (line 270) | static void
function sc_data_update_slab_size (line 294) | void
function sc_boot (line 310) | void
FILE: deps/jemalloc/src/stats.c
function rate_per_second (line 55) | static uint64_t
function get_rate_str (line 70) | static bool
function gen_mutex_ctl_str (line 95) | static void
function mutex_stats_init_cols (line 101) | static void
function mutex_stats_read_global (line 136) | static void
function mutex_stats_read_arena (line 165) | static void
function mutex_stats_read_arena_bin (line 195) | static void
function mutex_stats_emit (line 224) | static void
function stats_arena_bins_print (line 269) | static void
function stats_arena_lextents_print (line 469) | static void
function stats_arena_extents_print (line 547) | static void
function stats_arena_mutexes_print (line 635) | static void
function stats_arena_print (line 660) | static void
function stats_general_print (line 984) | static void
function stats_print_helper (line 1232) | static void
function stats_print (line 1395) | void
FILE: deps/jemalloc/src/sz.c
function sz_boot_pind2sz_tab (line 7) | static void
function sz_boot_index2size_tab (line 26) | static void
function sz_boot_size2index_tab (line 42) | static void
function sz_boot (line 59) | void
FILE: deps/jemalloc/src/tcache.c
function tcache_salloc (line 35) | size_t
function tcache_event_hard (line 40) | void
function tbin_extents_lookup_size_check (line 105) | static void
function tcache_bin_flush_small (line 133) | void
function tcache_bin_flush_large (line 229) | void
function tcache_arena_associate (line 340) | void
function tcache_arena_dissociate (line 361) | static void
function tcache_arena_reassociate (line 388) | void
function tsd_tcache_enabled_data_init (line 394) | bool
function tcache_init (line 409) | static void
function tsd_tcache_data_init (line 443) | bool
function tcache_t (line 485) | tcache_t *
function tcache_flush_cache (line 511) | static void
function tcache_flush (line 539) | void
function tcache_destroy (line 545) | static void
function tcache_cleanup (line 581) | void
function tcache_stats_merge (line 600) | void
function tcaches_create_prep (line 624) | static bool
function tcaches_create (line 650) | bool
function tcache_t (line 688) | static tcache_t *
function tcaches_flush (line 708) | void
function tcaches_destroy (line 719) | void
function tcache_boot (line 732) | bool
function tcache_prefork (line 779) | void
function tcache_postfork_parent (line 786) | void
function tcache_postfork_child (line 793) | void
FILE: deps/jemalloc/src/tsd.c
type tsd_init_head_s (line 38) | struct tsd_init_head_s {
function tsd_in_nominal_list (line 68) | static bool
function tsd_add_nominal (line 87) | static void
function tsd_remove_nominal (line 97) | static void
function tsd_force_recompute (line 106) | static void
function tsd_global_slow_inc (line 124) | void
function tsd_global_slow_dec (line 138) | void tsd_global_slow_dec(tsdn_t *tsdn) {
function tsd_local_slow (line 144) | static bool
function tsd_global_slow (line 150) | bool
function tsd_state_compute (line 157) | static uint8_t
function tsd_slow_update (line 170) | void
function tsd_state_set (line 180) | void
function tsd_data_init (line 218) | static bool
function assert_tsd_data_cleanup_done (line 239) | static void
function tsd_data_init_nocleanup (line 251) | static bool
function tsd_t (line 269) | tsd_t *
function malloc_tsd_dalloc (line 323) | void
function _malloc_thread_cleanup (line 332) | void
function malloc_tsd_cleanup_register (line 355) | void
function tsd_do_data_cleanup (line 362) | static void
function tsd_cleanup (line 372) | void
function tsd_t (line 417) | tsd_t *
function malloc_tsd_boot1 (line 434) | void
function BOOL (line 444) | static BOOL WINAPI
function tsd_init_finish (line 508) | void
function tsd_prefork (line 516) | void
function tsd_postfork_parent (line 521) | void
function tsd_postfork_child (line 526) | void
FILE: deps/jemalloc/src/witness.c
function witness_init (line 8) | void
function witness_lock_error_impl (line 17) | static void
function witness_owner_error_impl (line 31) | static void
function witness_not_owner_error_impl (line 40) | static void
function witness_depth_error_impl (line 49) | static void
function witnesses_cleanup (line 65) | void
function witness_prefork (line 72) | void
function witness_postfork_parent (line 80) | void
function witness_postfork_child (line 88) | void
FILE: deps/jemalloc/src/zone.c
type malloc_zone_t (line 14) | typedef struct _malloc_zone_t {
type vm_range_t (line 34) | typedef struct {
type malloc_statistics_t (line 39) | typedef struct malloc_statistics_t {
type kern_return_t (line 46) | typedef kern_return_t memory_reader_t(task_t, vm_address_t, vm_size_t, v...
type malloc_introspection_t (line 50) | typedef struct malloc_introspection_t {
type malloc_introspection_t (line 91) | struct malloc_introspection_t
type _malloc_zone_t (line 108) | struct _malloc_zone_t
type _malloc_zone_t (line 110) | struct _malloc_zone_t
type _malloc_zone_t (line 112) | struct _malloc_zone_t
function zone_size (line 132) | static size_t
function zone_free (line 165) | static void
function zone_free_definite_size (line 193) | static void
function zone_destroy (line 207) | static void
function zone_batch_malloc (line 213) | static unsigned
function zone_batch_free (line 227) | static void
function zone_pressure_relief (line 238) | static size_t
function zone_good_size (line 243) | static size_t
function kern_return_t (line 251) | static kern_return_t
function boolean_t (line 258) | static boolean_t
function zone_print (line 263) | static void
function zone_log (line 267) | static void
function zone_force_lock (line 271) | static void
function zone_force_unlock (line 284) | static void
function zone_statistics (line 309) | static void
function boolean_t (line 318) | static boolean_t
function zone_reinit_lock (line 324) | static void
function zone_init (line 331) | static void
function malloc_zone_t (line 369) | static malloc_zone_t *
function zone_promote (line 400) | static void
function zone_register (line 436) | JEMALLOC_ATTR(constructor)
FILE: deps/jemalloc/test/include/test/SFMT-alti.h
function vec_recursion (line 64) | unsigned int vec_recursion(vector unsigned int a,
function gen_rand_all (line 98) | static inline void gen_rand_all(sfmt_t *ctx) {
function gen_rand_array (line 125) | static inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {
function swap (line 176) | static inline void swap(w128_t *array, int size) {
FILE: deps/jemalloc/test/include/test/SFMT-sse2.h
function JEMALLOC_ALWAYS_INLINE (line 63) | JEMALLOC_ALWAYS_INLINE __m128i mm_recursion(__m128i *a, __m128i *b,
function gen_rand_all (line 84) | static inline void gen_rand_all(sfmt_t *ctx) {
function gen_rand_array (line 114) | static inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {
FILE: deps/jemalloc/test/include/test/SFMT.h
type sfmt_t (line 69) | typedef struct sfmt_s sfmt_t;
function to_real1 (line 86) | static inline double to_real1(uint32_t v) {
function genrand_real1 (line 92) | static inline double genrand_real1(sfmt_t *ctx) {
function to_real2 (line 97) | static inline double to_real2(uint32_t v) {
function genrand_real2 (line 103) | static inline double genrand_real2(sfmt_t *ctx) {
function to_real3 (line 108) | static inline double to_real3(uint32_t v) {
function genrand_real3 (line 114) | static inline double genrand_real3(sfmt_t *ctx) {
function to_res53 (line 120) | static inline double to_res53(uint64_t v) {
function to_res53_mix (line 126) | static inline double to_res53_mix(uint32_t x, uint32_t y) {
function genrand_res53 (line 132) | static inline double genrand_res53(sfmt_t *ctx) {
function genrand_res53_mix (line 139) | static inline double genrand_res53_mix(sfmt_t *ctx) {
FILE: deps/jemalloc/test/include/test/extent_hooks.h
function extent_dalloc_hook (line 103) | static bool
function extent_destroy_hook (line 124) | static void
function extent_commit_hook (line 142) | static bool
function extent_decommit_hook (line 164) | static bool
function extent_purge_lazy_hook (line 186) | static bool
function extent_purge_forced_hook (line 209) | static bool
function extent_split_hook (line 232) | static bool
function extent_merge_hook (line 256) | static bool
function extent_hooks_prep (line 282) | static void
FILE: deps/jemalloc/test/include/test/math.h
function ln_gamma (line 9) | static inline double
function i_gamma (line 44) | static inline double
function pt_norm (line 128) | static inline double
function pt_chi2 (line 216) | static inline double
function pt_gamma (line 303) | static inline double
FILE: deps/jemalloc/test/include/test/mtx.h
type mtx_t (line 8) | typedef struct {
FILE: deps/jemalloc/test/include/test/test.h
type test_status_t (line 289) | typedef enum {
FILE: deps/jemalloc/test/include/test/thd.h
type HANDLE (line 3) | typedef HANDLE thd_t;
type pthread_t (line 5) | typedef pthread_t thd_t;
FILE: deps/jemalloc/test/include/test/timer.h
type timedelta_t (line 3) | typedef struct {
FILE: deps/jemalloc/test/integration/MALLOCX_ARENA.c
function TEST_BEGIN (line 47) | TEST_BEGIN(test_MALLOCX_ARENA) {
function TEST_END (line 60) | TEST_END
FILE: deps/jemalloc/test/integration/aligned_alloc.c
function purge (line 10) | static void
function TEST_BEGIN (line 16) | TEST_BEGIN(test_alignment_errors) {
function JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN (line 46) | JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN
function TEST_BEGIN (line 95) | TEST_BEGIN(test_alignment_and_size) {
function TEST_END (line 139) | TEST_END
function TEST_END (line 148) | TEST_END
FILE: deps/jemalloc/test/integration/allocated.c
function TEST_BEGIN (line 102) | TEST_BEGIN(test_main_thread) {
function TEST_END (line 105) | TEST_END
function TEST_END (line 113) | TEST_END
FILE: deps/jemalloc/test/integration/cpp/basic.cpp
function TEST_BEGIN (line 4) | TEST_BEGIN(test_basic) {
function TEST_END (line 19) | TEST_END
FILE: deps/jemalloc/test/integration/extent.c
function check_background_thread_enabled (line 5) | static bool
function test_extent_body (line 17) | static void
function test_manual_hook_auto_arena (line 101) | static void
function test_manual_hook_body (line 138) | static void
function TEST_BEGIN (line 208) | TEST_BEGIN(test_extent_manual_hook) {
function TEST_END (line 223) | TEST_END
function TEST_END (line 241) | TEST_END
FILE: deps/jemalloc/test/integration/malloc.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_zero_alloc) {
function TEST_END (line 10) | TEST_END
FILE: deps/jemalloc/test/integration/mallocx.c
function get_nsizes_impl (line 3) | static unsigned
function get_nlarge (line 15) | static unsigned
function get_size_impl (line 20) | static size_t
function get_large_size (line 38) | static size_t
function purge (line 48) | static void
function TEST_BEGIN (line 64) | TEST_BEGIN(test_overflow) {
function TEST_END (line 82) | TEST_END
function TEST_BEGIN (line 103) | TEST_BEGIN(test_remote_free) {
function TEST_END (line 114) | TEST_END
function TEST_BEGIN (line 161) | TEST_BEGIN(test_basic) {
function TEST_END (line 196) | TEST_END
function TEST_END (line 264) | TEST_END
FILE: deps/jemalloc/test/integration/overflow.c
function TEST_BEGIN (line 13) | TEST_BEGIN(test_overflow) {
function main (line 55) | int
FILE: deps/jemalloc/test/integration/posix_memalign.c
function purge (line 10) | static void
function TEST_BEGIN (line 16) | TEST_BEGIN(test_alignment_errors) {
function TEST_END (line 33) | TEST_END
function TEST_END (line 71) | TEST_END
function TEST_END (line 120) | TEST_END
FILE: deps/jemalloc/test/integration/rallocx.c
function get_nsizes_impl (line 3) | static unsigned
function get_nlarge (line 15) | static unsigned
function get_size_impl (line 20) | static size_t
function get_large_size (line 38) | static size_t
function TEST_BEGIN (line 43) | TEST_BEGIN(test_grow_and_shrink) {
function TEST_END (line 85) | TEST_END
function TEST_BEGIN (line 106) | TEST_BEGIN(test_zero) {
function TEST_END (line 148) | TEST_END
function TEST_END (line 172) | TEST_END
function JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN (line 219) | JEMALLOC_DIAGNOSTIC_IGNORE_ALLOC_SIZE_LARGER_THAN
function main (line 250) | int
FILE: deps/jemalloc/test/integration/sdallocx.c
function TEST_BEGIN (line 6) | TEST_BEGIN(test_basic) {
function TEST_END (line 10) | TEST_END
function TEST_END (line 48) | TEST_END
FILE: deps/jemalloc/test/integration/slab_sizes.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_slab_sizes) {
function TEST_END (line 74) | TEST_END
FILE: deps/jemalloc/test/integration/smallocx.c
type smallocx_return_t (line 15) | typedef struct {
function get_nsizes_impl (line 23) | static unsigned
function get_nlarge (line 35) | static unsigned
function get_size_impl (line 40) | static size_t
function get_large_size (line 58) | static size_t
function purge (line 68) | static void
function TEST_BEGIN (line 84) | TEST_BEGIN(test_overflow) {
function TEST_END (line 102) | TEST_END
function TEST_BEGIN (line 127) | TEST_BEGIN(test_remote_free) {
function TEST_END (line 138) | TEST_END
function TEST_BEGIN (line 185) | TEST_BEGIN(test_basic) {
function TEST_END (line 229) | TEST_END
function TEST_END (line 302) | TEST_END
FILE: deps/jemalloc/test/integration/thread_arena.c
function mallctl_failure (line 40) | static void
function TEST_BEGIN (line 48) | TEST_BEGIN(test_thread_arena) {
function TEST_END (line 80) | TEST_END
FILE: deps/jemalloc/test/integration/thread_tcache_enabled.c
function TEST_BEGIN (line 65) | TEST_BEGIN(test_main_thread) {
function TEST_END (line 68) | TEST_END
function TEST_END (line 76) | TEST_END
FILE: deps/jemalloc/test/integration/xallocx.c
function arena_ind (line 8) | static unsigned
function TEST_BEGIN (line 21) | TEST_BEGIN(test_same_size) {
function TEST_END (line 34) | TEST_END
function TEST_END (line 49) | TEST_END
function TEST_END (line 64) | TEST_END
function get_nsmall (line 78) | static unsigned
function get_nlarge (line 83) | static unsigned
function get_size_impl (line 88) | static size_t
function get_small_size (line 106) | static size_t
function get_large_size (line 111) | static size_t
function TEST_BEGIN (line 116) | TEST_BEGIN(test_size) {
function TEST_END (line 143) | TEST_END
function TEST_END (line 174) | TEST_END
function TEST_END (line 205) | TEST_END
function TEST_END (line 274) | TEST_END
function validate_fill (line 295) | static bool
function test_zero (line 314) | static void
function TEST_BEGIN (line 362) | TEST_BEGIN(test_zero_large) {
function TEST_END (line 371) | TEST_END
FILE: deps/jemalloc/test/src/SFMT.c
type w128_t (line 77) | typedef union W128_T w128_t;
type w128_t (line 86) | typedef union W128_T w128_t;
type W128_T (line 91) | struct W128_T {
type w128_t (line 95) | typedef struct W128_T w128_t;
type sfmt_s (line 99) | struct sfmt_s {
function idxof (line 145) | static inline int idxof(int i) {
function idxof (line 149) | static inline int idxof(int i) {
function rshift128 (line 163) | static inline void rshift128(w128_t *out, w128_t const *in, int shift) {
function rshift128 (line 178) | static inline void rshift128(w128_t *out, w128_t const *in, int shift) {
function lshift128 (line 202) | static inline void lshift128(w128_t *out, w128_t const *in, int shift) {
function lshift128 (line 217) | static inline void lshift128(w128_t *out, w128_t const *in, int shift) {
function do_recursion (line 244) | static inline void do_recursion(w128_t *r, w128_t *a, w128_t *b, w128_t *c,
function do_recursion (line 261) | static inline void do_recursion(w128_t *r, w128_t *a, w128_t *b, w128_t *c,
function gen_rand_all (line 285) | static inline void gen_rand_all(sfmt_t *ctx) {
function gen_rand_array (line 312) | static inline void gen_rand_array(sfmt_t *ctx, w128_t *array, int size) {
function swap (line 346) | static inline void swap(w128_t *array, int size) {
function func1 (line 366) | static uint32_t func1(uint32_t x) {
function func2 (line 376) | static uint32_t func2(uint32_t x) {
function period_certification (line 383) | static void period_certification(sfmt_t *ctx) {
function get_min_array_size32 (line 428) | int get_min_array_size32(void) {
function get_min_array_size64 (line 437) | int get_min_array_size64(void) {
function gen_rand32 (line 447) | uint32_t gen_rand32(sfmt_t *ctx) {
function gen_rand32_range (line 461) | uint32_t gen_rand32_range(sfmt_t *ctx, uint32_t limit) {
function gen_rand64 (line 482) | uint64_t gen_rand64(sfmt_t *ctx) {
function gen_rand64_range (line 511) | uint64_t gen_rand64_range(sfmt_t *ctx, uint64_t limit) {
function fill_array32 (line 551) | void fill_array32(sfmt_t *ctx, uint32_t *array, int size) {
function fill_array64 (line 587) | void fill_array64(sfmt_t *ctx, uint64_t *array, int size) {
function sfmt_t (line 607) | sfmt_t *init_gen_rand(uint32_t seed) {
function sfmt_t (line 638) | sfmt_t *init_by_array(uint32_t *init_key, int key_length) {
function fini_gen_rand (line 714) | void fini_gen_rand(sfmt_t *ctx) {
FILE: deps/jemalloc/test/src/mq.c
function mq_nanosleep (line 7) | void
FILE: deps/jemalloc/test/src/mtx.c
function mtx_init (line 7) | bool
function mtx_fini (line 32) | void
function mtx_lock (line 41) | void
function mtx_unlock (line 52) | void
FILE: deps/jemalloc/test/src/test.c
type reentrancy_t (line 13) | typedef enum {
function do_hook (line 37) | static void
function libc_reentrancy_hook (line 49) | static void
function arena_new_reentrancy_hook (line 54) | static void
function test_is_reentrant (line 60) | bool
function test_skip (line 66) | void
function test_fail (line 78) | void
function p_test_init (line 99) | void
function p_test_fini (line 106) | void
function check_global_slow (line 113) | static void
function test_status_t (line 127) | static test_status_t
function test_status_t (line 187) | test_status_t
function test_status_t (line 200) | test_status_t
function test_status_t (line 213) | test_status_t
function p_test_fail (line 230) | void
FILE: deps/jemalloc/test/src/thd.c
function thd_create (line 4) | void
function thd_join (line 13) | void
function thd_create (line 23) | void
function thd_join (line 30) | void
FILE: deps/jemalloc/test/src/timer.c
function timer_start (line 3) | void
function timer_stop (line 9) | void
function timer_usec (line 15) | uint64_t
function timer_ratio (line 24) | void
FILE: deps/jemalloc/test/stress/hookbench.c
function noop_alloc_hook (line 3) | static void
function noop_dalloc_hook (line 8) | static void
function noop_expand_hook (line 13) | static void
function malloc_free_loop (line 19) | static void
function test_hooked (line 27) | static void
function test_unhooked (line 55) | static void
function main (line 65) | int
FILE: deps/jemalloc/test/stress/microbench.c
function time_func (line 3) | static inline void
function compare_funcs (line 18) | void
function malloc_free (line 43) | static void
function mallocx_free (line 54) | static void
function TEST_BEGIN (line 64) | TEST_BEGIN(test_malloc_vs_mallocx) {
function TEST_END (line 68) | TEST_END
function malloc_sdallocx (line 80) | static void
function TEST_BEGIN (line 90) | TEST_BEGIN(test_free_vs_dallocx) {
function TEST_END (line 94) | TEST_END
function TEST_END (line 100) | TEST_END
function malloc_sallocx_free (line 115) | static void
function TEST_BEGIN (line 130) | TEST_BEGIN(test_mus_vs_sallocx) {
function TEST_END (line 134) | TEST_END
function TEST_BEGIN (line 151) | TEST_BEGIN(test_sallocx_vs_nallocx) {
function TEST_END (line 155) | TEST_END
FILE: deps/jemalloc/test/unit/SFMT.c
function TEST_BEGIN (line 1452) | TEST_BEGIN(test_gen_rand_32) {
function TEST_END (line 1484) | TEST_END
function TEST_END (line 1519) | TEST_END
function TEST_END (line 1554) | TEST_END
function TEST_END (line 1590) | TEST_END
FILE: deps/jemalloc/test/unit/a0.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_a0) {
function TEST_END (line 10) | TEST_END
FILE: deps/jemalloc/test/unit/arena_reset.c
function get_nsizes_impl (line 10) | static unsigned
function get_nsmall (line 22) | static unsigned
function get_nlarge (line 27) | static unsigned
function get_size_impl (line 32) | static size_t
function get_small_size (line 50) | static size_t
function get_large_size (line 55) | static size_t
function vsalloc (line 61) | static size_t
function do_arena_create (line 87) | static unsigned
function do_arena_reset_pre (line 97) | static void
function do_arena_reset_post (line 136) | static void
function do_arena_reset_destroy (line 160) | static void
function do_arena_reset (line 173) | static void
function do_arena_destroy (line 178) | static void
function TEST_BEGIN (line 183) | TEST_BEGIN(test_arena_reset) {
function TEST_END (line 193) | TEST_END
function TEST_BEGIN (line 218) | TEST_BEGIN(test_arena_destroy_initial) {
function TEST_END (line 222) | TEST_END
function TEST_END (line 262) | TEST_END
function TEST_BEGIN (line 304) | TEST_BEGIN(test_arena_destroy_hooks_unmap) {
function TEST_END (line 340) | TEST_END
FILE: deps/jemalloc/test/unit/atomic.c
function TEST_BEGIN (line 179) | TEST_BEGIN(test_atomic_u64) {
function TEST_BEGIN (line 190) | TEST_BEGIN(test_atomic_u32) {
function TEST_BEGIN (line 196) | TEST_BEGIN(test_atomic_p) {
function TEST_BEGIN (line 202) | TEST_BEGIN(test_atomic_zu) {
function TEST_BEGIN (line 208) | TEST_BEGIN(test_atomic_zd) {
function TEST_BEGIN (line 215) | TEST_BEGIN(test_atomic_u) {
function TEST_END (line 218) | TEST_END
FILE: deps/jemalloc/test/unit/background_thread.c
function test_switch_background_thread_ctl (line 5) | static void
function test_repeat_background_thread_ctl (line 24) | static void
function TEST_BEGIN (line 43) | TEST_BEGIN(test_background_thread_ctl) {
function TEST_END (line 71) | TEST_END
function TEST_END (line 111) | TEST_END
FILE: deps/jemalloc/test/unit/background_thread_enable.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_deferred) {
function TEST_END (line 31) | TEST_END
function TEST_END (line 78) | TEST_END
FILE: deps/jemalloc/test/unit/base.c
function TEST_BEGIN (line 29) | TEST_BEGIN(test_base_hooks_default) {
function TEST_END (line 59) | TEST_END
function TEST_END (line 104) | TEST_END
function TEST_END (line 226) | TEST_END
FILE: deps/jemalloc/test/unit/binshard.c
function TEST_BEGIN (line 30) | TEST_BEGIN(test_producer_consumer) {
function TEST_END (line 51) | TEST_END
function TEST_BEGIN (line 84) | TEST_BEGIN(test_bin_shard_mt) {
function TEST_END (line 103) | TEST_END
function TEST_END (line 146) | TEST_END
FILE: deps/jemalloc/test/unit/bit_util.c
function TEST_BEGIN (line 36) | TEST_BEGIN(test_pow2_ceil_u64) {
function TEST_END (line 39) | TEST_END
function TEST_END (line 44) | TEST_END
function TEST_END (line 49) | TEST_END
function assert_lg_floor_range (line 63) | void
function TEST_BEGIN (line 75) | TEST_BEGIN(test_lg_ceil_floor) {
function TEST_END (line 102) | TEST_END
FILE: deps/jemalloc/test/unit/bitmap.c
function test_bitmap_initializer_body (line 95) | static void
function TEST_BEGIN (line 126) | TEST_BEGIN(test_bitmap_initializer) {
function TEST_END (line 137) | TEST_END
function TEST_BEGIN (line 149) | TEST_BEGIN(test_bitmap_size) {
function TEST_END (line 167) | TEST_END
function TEST_BEGIN (line 189) | TEST_BEGIN(test_bitmap_init) {
function TEST_END (line 204) | TEST_END
function TEST_BEGIN (line 220) | TEST_BEGIN(test_bitmap_set) {
function TEST_END (line 235) | TEST_END
function TEST_BEGIN (line 258) | TEST_BEGIN(test_bitmap_unset) {
function TEST_END (line 273) | TEST_END
function TEST_BEGIN (line 405) | TEST_BEGIN(test_bitmap_xfu) {
function TEST_END (line 420) | TEST_END
FILE: deps/jemalloc/test/unit/ckh.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_new_delete) {
function TEST_END (line 17) | TEST_END
function TEST_END (line 104) | TEST_END
function TEST_END (line 203) | TEST_END
FILE: deps/jemalloc/test/unit/decay.c
function check_background_thread_enabled (line 12) | static bool
function nstime_monotonic_mock (line 24) | static bool
function nstime_update_mock (line 29) | static bool
function do_arena_create (line 38) | static unsigned
function do_arena_destroy (line 64) | static void
function do_epoch (line 75) | void
function do_purge (line 82) | void
function do_decay (line 93) | void
function get_arena_npurge_impl (line 104) | static uint64_t
function get_arena_dirty_npurge (line 118) | static uint64_t
function get_arena_dirty_purged (line 124) | static uint64_t
function get_arena_muzzy_npurge (line 130) | static uint64_t
function get_arena_npurge (line 136) | static uint64_t
function get_arena_pdirty (line 143) | static size_t
function get_arena_pmuzzy (line 158) | static size_t
function generate_dirty (line 180) | static void
function TEST_BEGIN (line 187) | TEST_BEGIN(test_decay_ticks) {
function TEST_END (line 379) | TEST_END
function TEST_BEGIN (line 427) | TEST_BEGIN(test_decay_ticker) {
function TEST_END (line 487) | TEST_END
function TEST_END (line 545) | TEST_END
function TEST_END (line 565) | TEST_END
function TEST_END (line 595) | TEST_END
FILE: deps/jemalloc/test/unit/div.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_div_exhaustive) {
function TEST_END (line 23) | TEST_END
FILE: deps/jemalloc/test/unit/emitter.c
type buf_descriptor_t (line 13) | typedef struct buf_descriptor_s buf_descriptor_t;
type buf_descriptor_s (line 14) | struct buf_descriptor_s {
function forwarding_cb (line 24) | static void
function assert_emit_output (line 67) | static void
function emit_dict (line 93) | static void
function TEST_BEGIN (line 127) | TEST_BEGIN(test_dict) {
function TEST_END (line 130) | TEST_END
function TEST_BEGIN (line 149) | TEST_BEGIN(test_table_printf) {
function TEST_END (line 153) | TEST_END
function TEST_BEGIN (line 194) | TEST_BEGIN(test_nested_dict) {
function TEST_END (line 198) | TEST_END
function TEST_BEGIN (line 249) | TEST_BEGIN(test_types) {
function TEST_END (line 252) | TEST_END
function TEST_BEGIN (line 296) | TEST_BEGIN(test_modal) {
function TEST_END (line 299) | TEST_END
function TEST_BEGIN (line 344) | TEST_BEGIN(test_json_arr) {
function TEST_END (line 347) | TEST_END
function TEST_BEGIN (line 395) | TEST_BEGIN(test_json_nested_arr) {
function TEST_END (line 399) | TEST_END
function TEST_BEGIN (line 453) | TEST_BEGIN(test_table_row) {
function TEST_END (line 456) | TEST_END
FILE: deps/jemalloc/test/unit/extent_quantize.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_small_extent_size) {
function TEST_END (line 35) | TEST_END
function TEST_END (line 99) | TEST_END
function TEST_END (line 133) | TEST_END
FILE: deps/jemalloc/test/unit/extent_util.c
function TEST_BEGIN (line 30) | TEST_BEGIN(test_query) {
function TEST_END (line 160) | TEST_END
function TEST_END (line 262) | TEST_END
FILE: deps/jemalloc/test/unit/fork.c
function wait_for_child_exit (line 8) | static void
function TEST_BEGIN (line 31) | TEST_BEGIN(test_fork) {
function do_test_fork_multithreaded (line 97) | static void
function TEST_BEGIN (line 106) | TEST_BEGIN(test_fork_multithreaded) {
function TEST_END (line 134) | TEST_END
FILE: deps/jemalloc/test/unit/hash.c
type hash_variant_t (line 33) | typedef enum {
function hash_variant_bits (line 39) | static int
function hash_variant_verify_key (line 60) | static void
function hash_variant_verify (line 139) | static void
function TEST_BEGIN (line 152) | TEST_BEGIN(test_hash_x86_32) {
function TEST_END (line 155) | TEST_END
function TEST_END (line 160) | TEST_END
function TEST_END (line 165) | TEST_END
FILE: deps/jemalloc/test/unit/hook.c
function reset_args (line 16) | static void
function alloc_free_size (line 28) | static void
function be_reentrant (line 42) | static void
function set_args_raw (line 67) | static void
function assert_args_raw (line 72) | static void
function reset (line 79) | static void
function test_alloc_hook (line 85) | static void
function test_dalloc_hook (line 97) | static void
function test_expand_hook (line 108) | static void
function TEST_BEGIN (line 123) | TEST_BEGIN(test_hooks_basic) {
function TEST_END (line 166) | TEST_END
function TEST_END (line 204) | TEST_END
function TEST_END (line 221) | TEST_END
function TEST_END (line 332) | TEST_END
function TEST_END (line 379) | TEST_END
function TEST_END (line 407) | TEST_END
function TEST_END (line 456) | TEST_END
function TEST_BEGIN (line 555) | TEST_BEGIN(test_hooks_realloc) {
function TEST_END (line 559) | TEST_END
function TEST_END (line 565) | TEST_END
FILE: deps/jemalloc/test/unit/huge.c
function TEST_BEGIN (line 9) | TEST_BEGIN(huge_bind_thread) {
function TEST_END (line 47) | TEST_END
function TEST_END (line 72) | TEST_END
function TEST_END (line 100) | TEST_END
FILE: deps/jemalloc/test/unit/junk.c
function watch_junking (line 11) | static void
function arena_dalloc_junk_small_intercept (line 17) | static void
function large_dalloc_junk_intercept (line 32) | static void
function large_dalloc_maybe_junk_intercept (line 47) | static void
function test_junk (line 55) | static void
function TEST_BEGIN (line 124) | TEST_BEGIN(test_junk_small) {
function TEST_END (line 128) | TEST_END
function TEST_END (line 134) | TEST_END
FILE: deps/jemalloc/test/unit/mallctl.c
function TEST_BEGIN (line 6) | TEST_BEGIN(test_mallctl_errors) {
function TEST_END (line 31) | TEST_END
function TEST_END (line 41) | TEST_END
function TEST_END (line 77) | TEST_END
function TEST_END (line 104) | TEST_END
function TEST_END (line 118) | TEST_END
function TEST_END (line 144) | TEST_END
function TEST_END (line 193) | TEST_END
function TEST_END (line 217) | TEST_END
function TEST_END (line 240) | TEST_END
function TEST_END (line 333) | TEST_END
function TEST_END (line 372) | TEST_END
function TEST_END (line 410) | TEST_END
function TEST_END (line 442) | TEST_END
function TEST_END (line 474) | TEST_END
function TEST_END (line 497) | TEST_END
function TEST_END (line 520) | TEST_END
function TEST_END (line 565) | TEST_END
function TEST_END (line 613) | TEST_END
function TEST_END (line 645) | TEST_END
function TEST_END (line 677) | TEST_END
function TEST_END (line 695) | TEST_END
function TEST_END (line 714) | TEST_END
function TEST_END (line 730) | TEST_END
function TEST_END (line 747) | TEST_END
function TEST_END (line 763) | TEST_END
function TEST_END (line 782) | TEST_END
function dalloc_hook (line 790) | static void
function TEST_BEGIN (line 796) | TEST_BEGIN(test_hooks) {
function TEST_END (line 819) | TEST_END
function TEST_END (line 855) | TEST_END
FILE: deps/jemalloc/test/unit/malloc_io.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_malloc_strtoumax_no_endptr) {
function TEST_END (line 11) | TEST_END
function TEST_END (line 105) | TEST_END
function TEST_END (line 137) | TEST_END
function TEST_END (line 249) | TEST_END
FILE: deps/jemalloc/test/unit/math.c
function double_eq_rel (line 16) | static bool
function factorial (line 27) | static uint64_t
function TEST_BEGIN (line 39) | TEST_BEGIN(test_ln_gamma_factorial) {
function TEST_BEGIN (line 190) | TEST_BEGIN(test_ln_gamma_misc) {
function TEST_BEGIN (line 240) | TEST_BEGIN(test_pt_norm) {
function TEST_BEGIN (line 289) | TEST_BEGIN(test_pt_chi2) {
function TEST_BEGIN (line 350) | TEST_BEGIN(test_pt_gamma_shape) {
function TEST_END (line 367) | TEST_END
function TEST_END (line 379) | TEST_END
FILE: deps/jemalloc/test/unit/mq.c
type mq_msg_t (line 6) | typedef struct mq_msg_s mq_msg_t;
type mq_msg_s (line 7) | struct mq_msg_s {
function TEST_BEGIN (line 12) | TEST_BEGIN(test_mq_basic) {
function TEST_END (line 30) | TEST_END
function TEST_BEGIN (line 61) | TEST_BEGIN(test_mq_threaded) {
function TEST_END (line 81) | TEST_END
FILE: deps/jemalloc/test/unit/mtx.c
function TEST_BEGIN (line 6) | TEST_BEGIN(test_mtx_basic) {
function TEST_END (line 14) | TEST_END
function TEST_BEGIN (line 34) | TEST_BEGIN(test_mtx_race) {
function TEST_END (line 50) | TEST_END
FILE: deps/jemalloc/test/unit/nstime.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_nstime_init) {
function TEST_END (line 13) | TEST_END
function TEST_END (line 22) | TEST_END
function TEST_END (line 33) | TEST_END
function TEST_END (line 67) | TEST_END
function TEST_END (line 86) | TEST_END
function TEST_END (line 103) | TEST_END
function TEST_END (line 122) | TEST_END
function TEST_END (line 139) | TEST_END
function TEST_END (line 156) | TEST_END
function TEST_END (line 175) | TEST_END
function TEST_END (line 202) | TEST_END
function TEST_END (line 207) | TEST_END
function TEST_END (line 231) | TEST_END
FILE: deps/jemalloc/test/unit/pack.c
function binind_compute (line 19) | static unsigned
function nregs_per_run_compute (line 49) | static size_t
function arenas_create_mallctl (line 66) | static unsigned
function arena_reset_mallctl (line 78) | static void
function TEST_BEGIN (line 90) | TEST_BEGIN(test_pack) {
function TEST_END (line 160) | TEST_END
FILE: deps/jemalloc/test/unit/pages.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_pages_huge) {
function TEST_END (line 23) | TEST_END
FILE: deps/jemalloc/test/unit/ph.c
type node_t (line 5) | typedef struct node_s node_t;
type node_s (line 7) | struct node_s {
function node_cmp (line 14) | static int
function node_cmp_magic (line 30) | static int
type heap_t (line 39) | typedef ph(node_t) heap_t;
function node_print (line 42) | static void
function heap_print (line 64) | static void
function node_validate (line 87) | static unsigned
function heap_validate (line 115) | static unsigned
function TEST_BEGIN (line 141) | TEST_BEGIN(test_ph_empty) {
function TEST_END (line 149) | TEST_END
function node_t (line 158) | static node_t *
function node_t (line 165) | static node_t *
function TEST_BEGIN (line 172) | TEST_BEGIN(test_ph_random) {
function TEST_END (line 311) | TEST_END
FILE: deps/jemalloc/test/unit/prng.c
function test_prng_lg_range_u32 (line 3) | static void
function test_prng_lg_range_u64 (line 40) | static void
function test_prng_lg_range_zu (line 76) | static void
function TEST_BEGIN (line 114) | TEST_BEGIN(test_prng_lg_range_u32_nonatomic) {
function TEST_END (line 117) | TEST_END
function TEST_END (line 122) | TEST_END
function TEST_END (line 127) | TEST_END
function TEST_END (line 132) | TEST_END
function TEST_END (line 137) | TEST_END
function test_prng_range_u64 (line 159) | static void
function test_prng_range_zu (line 179) | static void
function TEST_BEGIN (line 199) | TEST_BEGIN(test_prng_range_u32_nonatomic) {
function TEST_END (line 202) | TEST_END
function TEST_END (line 207) | TEST_END
function TEST_END (line 212) | TEST_END
function TEST_END (line 217) | TEST_END
function TEST_END (line 222) | TEST_END
FILE: deps/jemalloc/test/unit/prof_accum.c
function prof_dump_open_intercept (line 8) | static int
function TEST_BEGIN (line 52) | TEST_BEGIN(test_idump) {
function TEST_END (line 75) | TEST_END
FILE: deps/jemalloc/test/unit/prof_active.c
function mallctl_bool_get (line 3) | static void
function mallctl_bool_set (line 15) | static void
function mallctl_prof_active_get_impl (line 30) | static void
function mallctl_prof_active_set_impl (line 38) | static void
function mallctl_thread_prof_active_get_impl (line 47) | static void
function mallctl_thread_prof_active_set_impl (line 56) | static void
function prof_sampling_probe_impl (line 65) | static void
function TEST_BEGIN (line 81) | TEST_BEGIN(test_prof_active) {
function TEST_END (line 111) | TEST_END
FILE: deps/jemalloc/test/unit/prof_gdump.c
function prof_dump_open_intercept (line 5) | static int
function TEST_BEGIN (line 17) | TEST_BEGIN(test_gdump) {
function TEST_END (line 68) | TEST_END
FILE: deps/jemalloc/test/unit/prof_idump.c
function prof_dump_open_intercept (line 5) | static int
function TEST_BEGIN (line 17) | TEST_BEGIN(test_idump) {
function TEST_END (line 36) | TEST_END
FILE: deps/jemalloc/test/unit/prof_log.c
function assert_rep (line 6) | static void assert_rep() {
function assert_log_empty (line 10) | static void assert_log_empty() {
function f (line 21) | static void f() {
function TEST_BEGIN (line 31) | TEST_BEGIN(test_prof_log_many_logs) {
function TEST_BEGIN (line 71) | TEST_BEGIN(test_prof_log_many_threads) {
function TEST_END (line 91) | TEST_END
function f1 (line 98) | static void f1() {
function f2 (line 104) | static void f2() {
function TEST_BEGIN (line 109) | TEST_BEGIN(test_prof_log_many_traces) {
function TEST_END (line 139) | TEST_END
FILE: deps/jemalloc/test/unit/prof_reset.c
function prof_dump_open_intercept (line 3) | static int
function set_prof_active (line 13) | static void
function get_lg_prof_sample (line 19) | static size_t
function do_prof_reset (line 30) | static void
function TEST_BEGIN (line 39) | TEST_BEGIN(test_prof_reset_basic) {
function prof_dump_header_intercept (line 86) | static bool
function TEST_BEGIN (line 95) | TEST_BEGIN(test_prof_reset_cleanup) {
function TEST_BEGIN (line 182) | TEST_BEGIN(test_prof_reset) {
function TEST_BEGIN (line 227) | TEST_BEGIN(test_xallocx) {
function main (line 276) | int
FILE: deps/jemalloc/test/unit/prof_tctx.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_prof_realloc) {
function TEST_END (line 40) | TEST_END
FILE: deps/jemalloc/test/unit/prof_thread_name.c
function mallctl_thread_name_get_impl (line 3) | static void
function mallctl_thread_name_set_impl (line 20) | static void
function TEST_BEGIN (line 32) | TEST_BEGIN(test_prof_thread_name_validation) {
function TEST_BEGIN (line 96) | TEST_BEGIN(test_prof_thread_name_threaded) {
function main (line 115) | int
FILE: deps/jemalloc/test/unit/ql.c
type list_t (line 8) | typedef struct list_s list_t;
type list_head_t (line 9) | typedef ql_head(list_t) list_head_t;
type list_s (line 11) | struct list_s {
function test_empty_list (line 16) | static void
function TEST_BEGIN (line 38) | TEST_BEGIN(test_ql_empty) {
function TEST_END (line 44) | TEST_END
function test_entries_list (line 56) | static void
function TEST_BEGIN (line 92) | TEST_BEGIN(test_ql_tail_insert) {
function TEST_END (line 105) | TEST_END
function TEST_END (line 124) | TEST_END
function TEST_END (line 139) | TEST_END
function TEST_END (line 158) | TEST_END
function TEST_END (line 193) | TEST_END
FILE: deps/jemalloc/test/unit/qr.c
type ring_t (line 10) | typedef struct ring_s ring_t;
type ring_s (line 12) | struct ring_s {
function init_entries (line 17) | static void
function test_independent_entries (line 27) | static void
function TEST_BEGIN (line 64) | TEST_BEGIN(test_qr_one) {
function TEST_END (line 70) | TEST_END
function TEST_BEGIN (line 105) | TEST_BEGIN(test_qr_after_insert) {
function TEST_END (line 115) | TEST_END
function TEST_END (line 144) | TEST_END
function TEST_END (line 182) | TEST_END
function TEST_BEGIN (line 206) | TEST_BEGIN(test_qr_meld_split) {
function TEST_END (line 233) | TEST_END
FILE: deps/jemalloc/test/unit/rb.c
type node_t (line 16) | typedef struct node_s node_t;
type node_s (line 18) | struct node_s {
function node_cmp (line 25) | static int
type tree_t (line 44) | typedef rb_tree(node_t) tree_t;
function TEST_BEGIN (line 47) | TEST_BEGIN(test_rb_empty) {
function TEST_END (line 69) | TEST_END
function node_t (line 120) | static node_t *
function tree_iterate (line 147) | static unsigned
function tree_iterate_reverse (line 157) | static unsigned
function node_remove (line 167) | static void
function node_t (line 199) | static node_t *
function node_t (line 209) | static node_t *
function destroy_cb (line 219) | static void
function TEST_BEGIN (line 227) | TEST_BEGIN(test_rb_random) {
function TEST_END (line 348) | TEST_END
FILE: deps/jemalloc/test/unit/retained.c
function do_arena_create (line 13) | static unsigned
function do_arena_destroy (line 23) | static void
function do_refresh (line 36) | static void
function do_get_size_impl (line 43) | static size_t
function do_get_active (line 59) | static size_t
function do_get_mapped (line 64) | static size_t
function TEST_BEGIN (line 100) | TEST_BEGIN(test_retained) {
function TEST_END (line 178) | TEST_END
FILE: deps/jemalloc/test/unit/rtree.c
function rtree_node_elm_t (line 13) | static rtree_node_elm_t *
function rtree_node_dalloc_intercept (line 29) | static void
function rtree_leaf_elm_t (line 40) | static rtree_leaf_elm_t *
function rtree_leaf_dalloc_intercept (line 56) | static void
function TEST_BEGIN (line 67) | TEST_BEGIN(test_rtree_read_empty) {
function TEST_BEGIN (line 86) | TEST_BEGIN(test_rtree_extrema) {
function TEST_END (line 119) | TEST_END
function TEST_END (line 156) | TEST_END
function TEST_END (line 210) | TEST_END
FILE: deps/jemalloc/test/unit/safety_check.c
function fake_abort (line 11) | void fake_abort(const char *message) {
function TEST_BEGIN (line 16) | TEST_BEGIN(test_malloc_free_overflow) {
function TEST_END (line 30) | TEST_END
function TEST_END (line 46) | TEST_END
function TEST_END (line 62) | TEST_END
function TEST_END (line 79) | TEST_END
function TEST_END (line 96) | TEST_END
function TEST_END (line 113) | TEST_END
function TEST_END (line 128) | TEST_END
function TEST_END (line 143) | TEST_END
FILE: deps/jemalloc/test/unit/sc.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_update_slab_size) {
function TEST_END (line 27) | TEST_END
FILE: deps/jemalloc/test/unit/seq.c
type data_t (line 5) | typedef struct data_s data_t;
type data_s (line 6) | struct data_s {
function set_data (line 10) | static void
function assert_data (line 17) | static void
type thd_data_t (line 27) | typedef struct thd_data_s thd_data_t;
type thd_data_s (line 28) | struct thd_data_s {
function TEST_BEGIN (line 61) | TEST_BEGIN(test_seq_threaded) {
function TEST_END (line 74) | TEST_END
function TEST_END (line 89) | TEST_END
FILE: deps/jemalloc/test/unit/size_classes.c
function get_max_size_class (line 3) | static size_t
function TEST_BEGIN (line 25) | TEST_BEGIN(test_size_classes) {
function TEST_END (line 81) | TEST_END
function TEST_END (line 142) | TEST_END
function TEST_END (line 180) | TEST_END
FILE: deps/jemalloc/test/unit/slab.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_arena_slab_regind) {
function TEST_END (line 27) | TEST_END
FILE: deps/jemalloc/test/unit/smoothstep.c
function TEST_BEGIN (line 10) | TEST_BEGIN(test_smoothstep_integral) {
function TEST_END (line 37) | TEST_END
function TEST_END (line 58) | TEST_END
function TEST_END (line 94) | TEST_END
FILE: deps/jemalloc/test/unit/spin.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_spin) {
function TEST_END (line 12) | TEST_END
FILE: deps/jemalloc/test/unit/stats.c
function TEST_BEGIN (line 3) | TEST_BEGIN(test_stats_summary) {
function TEST_END (line 26) | TEST_END
function TEST_END (line 66) | TEST_END
function TEST_END (line 129) | TEST_END
function no_lazy_lock (line 136) | static void
function TEST_BEGIN (line 144) | TEST_BEGIN(test_stats_arenas_small) {
function TEST_END (line 187) | TEST_END
function TEST_END (line 222) | TEST_END
function TEST_BEGIN (line 229) | TEST_BEGIN(test_stats_arenas_bins) {
function TEST_END (line 321) | TEST_END
function TEST_END (line 362) | TEST_END
FILE: deps/jemalloc/test/unit/stats_print.c
type token_type_t (line 5) | typedef enum {
type parser_t (line 22) | typedef struct parser_s parser_t;
type token_t (line 23) | typedef struct {
type parser_s (line 32) | struct parser_s {
function token_init (line 42) | static void
function token_error (line 53) | static void
function parser_init (line 75) | static void
function parser_fini (line 85) | static void
function parser_append (line 92) | static bool
function parser_tokenize (line 107) | static bool
function parser_parse_value (line 668) | static bool
function parser_parse_pair (line 687) | static bool
function parser_parse_values (line 705) | static bool
function parser_parse_array (line 732) | static bool
function parser_parse_pairs (line 748) | static bool
function parser_parse_object (line 783) | static bool
function parser_parse (line 801) | static bool
function TEST_BEGIN (line 826) | TEST_BEGIN(test_json_parser) {
function TEST_END (line 920) | TEST_END
function TEST_BEGIN (line 930) | TEST_BEGIN(test_stats_print_json) {
function TEST_END (line 992) | TEST_END
FILE: deps/jemalloc/test/unit/test_hooks.c
function hook (line 5) | static void
function func_to_hook (line 10) | static int
function TEST_BEGIN (line 17) | TEST_BEGIN(unhooked_call) {
function TEST_END (line 23) | TEST_END
function TEST_END (line 31) | TEST_END
FILE: deps/jemalloc/test/unit/ticker.c
function TEST_BEGIN (line 5) | TEST_BEGIN(test_ticker_tick) {
function TEST_END (line 28) | TEST_END
function TEST_END (line 46) | TEST_END
function TEST_END (line 65) | TEST_END
FILE: deps/jemalloc/test/unit/tsd.c
function data_cleanup (line 10) | void
function TEST_BEGIN (line 72) | TEST_BEGIN(test_tsd_main_thread) {
function TEST_END (line 75) | TEST_END
function TEST_END (line 90) | TEST_END
function TEST_BEGIN (line 125) | TEST_BEGIN(test_tsd_reincarnation) {
function TEST_END (line 130) | TEST_END
function TEST_BEGIN (line 189) | TEST_BEGIN(test_tsd_global_slow) {
function TEST_END (line 252) | TEST_END
FILE: deps/jemalloc/test/unit/witness.c
function witness_lock_error_intercept (line 13) | static void
function witness_owner_error_intercept (line 19) | static void
function witness_not_owner_error_intercept (line 24) | static void
function witness_depth_error_intercept (line 29) | static void
function witness_comp (line 35) | static int
function witness_comp_reverse (line 45) | static int
function TEST_BEGIN (line 56) | TEST_BEGIN(test_witness) {
function TEST_END (line 94) | TEST_END
function TEST_END (line 146) | TEST_END
function TEST_END (line 177) | TEST_END
function TEST_END (line 212) | TEST_END
function TEST_END (line 236) | TEST_END
function TEST_END (line 269) | TEST_END
FILE: deps/jemalloc/test/unit/zero.c
function test_zero (line 3) | static void
function TEST_BEGIN (line 42) | TEST_BEGIN(test_zero_small) {
function TEST_END (line 46) | TEST_END
function TEST_END (line 52) | TEST_END
FILE: deps/linenoise/example.c
function completion (line 7) | void completion(const char *buf, linenoiseCompletions *lc) {
function main (line 23) | int main(int argc, char **argv) {
FILE: deps/linenoise/linenoise.c
type termios (line 127) | struct termios
type linenoiseState (line 139) | struct linenoiseState {
type KEY_ACTION (line 154) | enum KEY_ACTION{
type linenoiseState (line 178) | struct linenoiseState
function linenoiseMaskModeEnable (line 205) | void linenoiseMaskModeEnable(void) {
function linenoiseMaskModeDisable (line 210) | void linenoiseMaskModeDisable(void) {
function linenoiseSetMultiLine (line 215) | void linenoiseSetMultiLine(int ml) {
function isUnsupportedTerm (line 221) | static int isUnsupportedTerm(void) {
function enableRawMode (line 232) | static int enableRawMode(int fd) {
function disableRawMode (line 267) | static void disableRawMode(int fd) {
function getCursorPosition (line 276) | static int getCursorPosition(int ifd, int ofd) {
function getColumns (line 300) | static int getColumns(int ifd, int ofd) {
function linenoiseClearScreen (line 334) | void linenoiseClearScreen(void) {
function linenoiseBeep (line 342) | static void linenoiseBeep(void) {
function freeCompletions (line 350) | static void freeCompletions(linenoiseCompletions *lc) {
function completeLine (line 364) | static int completeLine(struct linenoiseState *ls) {
function linenoiseSetCompletionCallback (line 423) | void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) {
function linenoiseSetHintsCallback (line 429) | void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) {
function linenoiseSetFreeHintsCallback (line 435) | void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) {
function linenoiseAddCompletion (line 443) | void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) {
type abuf (line 465) | struct abuf {
function abInit (line 470) | static void abInit(struct abuf *ab) {
function abAppend (line 475) | static void abAppend(struct abuf *ab, const char *s, int len) {
function abFree (line 484) | static void abFree(struct abuf *ab) {
function refreshShowHints (line 490) | void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int ple...
function refreshSingleLine (line 518) | static void refreshSingleLine(struct linenoiseState *l) {
function refreshMultiLine (line 563) | static void refreshMultiLine(struct linenoiseState *l) {
function refreshLine (line 653) | static void refreshLine(struct linenoiseState *l) {
function linenoiseEditInsert (line 663) | int linenoiseEditInsert(struct linenoiseState *l, char c) {
function linenoiseEditMoveLeft (line 691) | void linenoiseEditMoveLeft(struct linenoiseState *l) {
function linenoiseEditMoveRight (line 699) | void linenoiseEditMoveRight(struct linenoiseState *l) {
function linenoiseEditMoveHome (line 707) | void linenoiseEditMoveHome(struct linenoiseState *l) {
function linenoiseEditMoveEnd (line 715) | void linenoiseEditMoveEnd(struct linenoiseState *l) {
function linenoiseEditHistoryNext (line 726) | void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
function linenoiseEditDelete (line 750) | void linenoiseEditDelete(struct linenoiseState *l) {
function linenoiseEditBackspace (line 760) | void linenoiseEditBackspace(struct linenoiseState *l) {
function linenoiseEditDeletePrevWord (line 772) | void linenoiseEditDeletePrevWord(struct linenoiseState *l) {
function linenoiseEdit (line 794) | static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t ...
function linenoisePrintKeyCodes (line 981) | void linenoisePrintKeyCodes(void) {
function linenoiseRaw (line 1008) | static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) {
function linenoiseFree (line 1095) | void linenoiseFree(void *ptr) {
function freeHistory (line 1103) | static void freeHistory(void) {
function linenoiseAtExit (line 1114) | static void linenoiseAtExit(void) {
function linenoiseHistoryAdd (line 1126) | int linenoiseHistoryAdd(const char *line) {
function linenoiseHistorySetMaxLen (line 1159) | int linenoiseHistorySetMaxLen(int len) {
function linenoiseHistorySave (line 1189) | int linenoiseHistorySave(const char *filename) {
function linenoiseHistoryLoad (line 1209) | int linenoiseHistoryLoad(const char *filename) {
FILE: deps/linenoise/linenoise.h
type linenoiseCompletions (line 46) | typedef struct linenoiseCompletions {
FILE: deps/lua/etc/min.c
function print (line 12) | static int print(lua_State *L)
function main (line 32) | int main(void)
FILE: deps/lua/etc/noparser.c
function LUAI_FUNC (line 21) | LUAI_FUNC void luaX_init (lua_State *L) {
function LUAI_FUNC (line 25) | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const...
function LUAI_FUNC (line 37) | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, voi...
FILE: deps/lua/src/fpconv.c
function fpconv_update_locale (line 52) | static void fpconv_update_locale()
function valid_number_character (line 75) | static inline int valid_number_character(char ch)
function strtod_buffer_size (line 94) | static int strtod_buffer_size(const char *s)
function fpconv_strtod (line 106) | double fpconv_strtod(const char *nptr, char **endptr)
function set_number_format (line 153) | static void set_number_format(char *fmt, int precision)
function fpconv_g_fmt (line 174) | int fpconv_g_fmt(char *str, double num, int precision)
function fpconv_init (line 199) | void fpconv_init()
FILE: deps/lua/src/fpconv.h
function fpconv_init (line 10) | static inline void fpconv_init()
FILE: deps/lua/src/lapi.c
function TValue (line 49) | static TValue *index2adr (lua_State *L, int idx) {
function Table (line 79) | static Table *getcurrenv (lua_State *L) {
function luaA_pushobject (line 89) | void luaA_pushobject (lua_State *L, const TValue *o) {
function LUA_API (line 95) | LUA_API int lua_checkstack (lua_State *L, int size) {
function LUA_API (line 110) | LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
function LUA_API (line 125) | LUA_API void lua_setlevel (lua_State *from, lua_State *to) {
function LUA_API (line 130) | LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
function LUA_API (line 140) | LUA_API lua_State *lua_newthread (lua_State *L) {
function LUA_API (line 159) | LUA_API int lua_gettop (lua_State *L) {
function LUA_API (line 164) | LUA_API void lua_settop (lua_State *L, int idx) {
function LUA_API (line 180) | LUA_API void lua_remove (lua_State *L, int idx) {
function LUA_API (line 191) | LUA_API void lua_insert (lua_State *L, int idx) {
function LUA_API (line 203) | LUA_API void lua_replace (lua_State *L, int idx) {
function LUA_API (line 228) | LUA_API void lua_pushvalue (lua_State *L, int idx) {
function LUA_API (line 242) | LUA_API int lua_type (lua_State *L, int idx) {
function LUA_API (line 248) | LUA_API const char *lua_typename (lua_State *L, int t) {
function LUA_API (line 254) | LUA_API int lua_iscfunction (lua_State *L, int idx) {
function LUA_API (line 260) | LUA_API int lua_isnumber (lua_State *L, int idx) {
function LUA_API (line 267) | LUA_API int lua_isstring (lua_State *L, int idx) {
function LUA_API (line 273) | LUA_API int lua_isuserdata (lua_State *L, int idx) {
function LUA_API (line 279) | LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
function LUA_API (line 287) | LUA_API int lua_equal (lua_State *L, int index1, int index2) {
function LUA_API (line 299) | LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
function LUA_API (line 313) | LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {
function LUA_API (line 323) | LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {
function LUA_API (line 337) | LUA_API int lua_toboolean (lua_State *L, int idx) {
function LUA_API (line 343) | LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
function LUA_API (line 361) | LUA_API size_t lua_objlen (lua_State *L, int idx) {
function LUA_API (line 379) | LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
function LUA_API (line 385) | LUA_API void *lua_touserdata (lua_State *L, int idx) {
function LUA_API (line 395) | LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
function LUA_API (line 401) | LUA_API const void *lua_topointer (lua_State *L, int idx) {
function LUA_API (line 421) | LUA_API void lua_pushnil (lua_State *L) {
function LUA_API (line 429) | LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
function LUA_API (line 437) | LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
function LUA_API (line 445) | LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
function LUA_API (line 454) | LUA_API void lua_pushstring (lua_State *L, const char *s) {
function LUA_API (line 462) | LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
function LUA_API (line 473) | LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
function LUA_API (line 486) | LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
function LUA_API (line 503) | LUA_API void lua_pushboolean (lua_State *L, int b) {
function LUA_API (line 511) | LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
function LUA_API (line 519) | LUA_API int lua_pushthread (lua_State *L) {
function LUA_API (line 534) | LUA_API void lua_gettable (lua_State *L, int idx) {
function LUA_API (line 544) | LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {
function LUA_API (line 557) | LUA_API void lua_rawget (lua_State *L, int idx) {
function LUA_API (line 567) | LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {
function LUA_API (line 578) | LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
function LUA_API (line 587) | LUA_API int lua_getmetatable (lua_State *L, int objindex) {
function LUA_API (line 616) | LUA_API void lua_getfenv (lua_State *L, int idx) {
function LUA_API (line 645) | LUA_API void lua_settable (lua_State *L, int idx) {
function LUA_API (line 657) | LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
function LUA_API (line 671) | LUA_API void lua_rawset (lua_State *L, int idx) {
function LUA_API (line 684) | LUA_API void lua_rawseti (lua_State *L, int idx, int n) {
fu
Copy disabled (too large)
Download .json
Condensed preview — 1622 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (16,580K chars).
[
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 409,
"preview": "---\nname: Bug report\nabout: Help us improve KeyDB by reporting a bug\ntitle: '[BUG]'\nlabels: ''\nassignees: ''\n\n---\n\n**Des"
},
{
"path": ".github/ISSUE_TEMPLATE/crash_report.md",
"chars": 364,
"preview": "---\nname: Crash report\nabout: Submit a crash report\ntitle: '[CRASH]'\nlabels: ''\nassignees: ''\n\n---\n\n**Crash report**\n\nPa"
},
{
"path": ".github/ISSUE_TEMPLATE/feature_request.md",
"chars": 623,
"preview": "---\nname: Feature request\nabout: Suggest a feature for KeyDB\ntitle: '[NEW]'\nlabels: ''\nassignees: ''\n\n---\n\n**The problem"
},
{
"path": ".github/ISSUE_TEMPLATE/other_stuff.md",
"chars": 110,
"preview": "---\nname: Other\nabout: Can't find the right issue type? Use this one!\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n"
},
{
"path": ".github/workflows/ci.yml",
"chars": 2092,
"preview": "name: CI\n\non: [push, pull_request]\n\njobs:\n\n test-ubuntu-latest:\n runs-on: ubuntu-latest\n steps:\n - uses: actio"
},
{
"path": ".gitignore",
"chars": 843,
"preview": ".*.swp\ncore\n*.o\n*.xo\n*.so\n*.d\n!**/bash_completion.d\n!**/logrotate.d\n!**/keydb.service.d\n!**/keydb-sentinel.service.d\n*.l"
},
{
"path": ".gitmodules",
"chars": 223,
"preview": "[submodule \"deps/rocksdb\"]\n\tpath = deps/rocksdb\n\turl = https://github.com/facebook/rocksdb.git\n[submodule \"deps/depot_to"
},
{
"path": "00-RELEASENOTES",
"chars": 33623,
"preview": "Redis 6.2 release notes\n=======================\n\n-----------------------------------------------------------------------"
},
{
"path": "BUGS",
"chars": 51,
"preview": "Please check https://github.com/redis/redis/issues\n"
},
{
"path": "CONDUCT",
"chars": 5022,
"preview": "Contributor Covenant Code of Conduct\nOur Pledge\nWe as members, contributors, and leaders pledge to make participation in"
},
{
"path": "COPYING",
"chars": 1602,
"preview": "Copyright (c) 2006-2020, Salvatore Sanfilippo\nCopyright (C) 2019-2021, John Sully\nCopyright (C) 2020-2021, EQ Alpha Tech"
},
{
"path": "INSTALL",
"chars": 11,
"preview": "See README\n"
},
{
"path": "Makefile",
"chars": 211,
"preview": "# Top level makefile, this just calls into src/Makefile where the real work is done. Changes should be made there.\n\ndefa"
},
{
"path": "README.md",
"chars": 15638,
"preview": "\n![CI](https://github.com/JohnSully/KeyDB/w"
},
{
"path": "TLS.md",
"chars": 2218,
"preview": "TLS Support\n===========\n\nGetting Started\n---------------\n\n### Building\n\nTLS support is enabled in the default build. To "
},
{
"path": "build.yaml",
"chars": 3819,
"preview": "# Doc: https://wiki.sc-corp.net/pages/viewpage.action?pageId=121500284\nversion: 1\nmachamp:\n keydb-build:\n # Optional"
},
{
"path": "ci.yaml",
"chars": 1607,
"preview": "# Doc: https://wiki.sc-corp.net/display/TOOL/ci.yaml+User+Guide\nversion: 1\non:\n # https://wiki.sc-corp.net/display/TOOL"
},
{
"path": "deps/Makefile",
"chars": 3405,
"preview": "# Redis dependency Makefile\n\nuname_S:= $(shell sh -c 'uname -s 2>/dev/null || echo not')\nuname_M := $(shell sh -c 'uname"
},
{
"path": "deps/README.md",
"chars": 4411,
"preview": "This directory contains all Redis dependencies, except for the libc that\nshould be provided by the operating system.\n\n* "
},
{
"path": "deps/concurrentqueue/blockingconcurrentqueue.h",
"chars": 21506,
"preview": "// Provides an efficient blocking version of moodycamel::ConcurrentQueue.\n// ©2015-2020 Cameron Desrochers. Distributed "
},
{
"path": "deps/concurrentqueue/concurrentqueue.h",
"chars": 152140,
"preview": "// Provides a C++11 implementation of a multi-producer, multi-consumer lock-free queue.\n// An overview, including benchm"
},
{
"path": "deps/concurrentqueue/lightweightsemaphore.h",
"chars": 11398,
"preview": "// Provides an efficient implementation of a semaphore (LightweightSemaphore).\n// This is an extension of Jeff Preshing'"
},
{
"path": "deps/cpp-statsd-client/.clang-format",
"chars": 3020,
"preview": "AccessModifierOffset: -4\nAllowAllParametersOfDeclarationOnNextLine: false\nAllowShortFunctionsOnASingleLine: Empty\nBinPac"
},
{
"path": "deps/cpp-statsd-client/.github/workflows/coverage.yml",
"chars": 973,
"preview": "name: Coverage\n\non: [push, pull_request]\njobs:\n coverage:\n runs-on: ubuntu-20.04\n steps:\n - uses: actions/ch"
},
{
"path": "deps/cpp-statsd-client/.github/workflows/lint.yml",
"chars": 296,
"preview": "name: Lint\n\non: [push, pull_request]\njobs:\n lint:\n runs-on: ubuntu-20.04\n steps:\n - uses: actions/checkout@v"
},
{
"path": "deps/cpp-statsd-client/.github/workflows/linux.yml",
"chars": 618,
"preview": "name: Linux\n\non: [push, pull_request]\njobs:\n linux:\n runs-on: ubuntu-20.04\n steps:\n - uses: actions/checkout"
},
{
"path": "deps/cpp-statsd-client/.github/workflows/windows.yml",
"chars": 467,
"preview": "name: Windows\n\non: [push, pull_request]\njobs:\n windows:\n runs-on: windows-latest\n steps:\n - uses: actions/ch"
},
{
"path": "deps/cpp-statsd-client/.gitignore",
"chars": 3,
"preview": "bin"
},
{
"path": "deps/cpp-statsd-client/CMakeLists.txt",
"chars": 3341,
"preview": "# Basic project setup\ncmake_minimum_required(VERSION 3.5)\nproject(cpp-statsd-client\n VERSION 1.0.2\n LANGUA"
},
{
"path": "deps/cpp-statsd-client/LICENSE.md",
"chars": 1070,
"preview": "MIT License\n\nCopyright (c) 2017 Vincent Thiery\n\nPermission is hereby granted, free of charge, to any person obtaining a "
},
{
"path": "deps/cpp-statsd-client/Makefile",
"chars": 479,
"preview": "# simple makefile to build, test and clean\n\nBUILD_MODE ?= Release\nENABLE_COVERAGE ?= On\n\nbuild: clean\n\t@echo \"Build in $"
},
{
"path": "deps/cpp-statsd-client/README.md",
"chars": 6026,
"preview": "# C++ StatsD Client\n\n![logo](https://raw.githubusercontent.com/vthiery/cpp-statsd-client/master/images/logo.svg?sanitize"
},
{
"path": "deps/cpp-statsd-client/cmake/CodeCoverage.cmake",
"chars": 29304,
"preview": "# Copyright (c) 2012 - 2017, Lars Bilke\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, wi"
},
{
"path": "deps/cpp-statsd-client/cmake/Config.cmake.in",
"chars": 709,
"preview": "# Copyright (c) 2016, Ruslan Baratov\n#\n# Licensed under the MIT License (the \"License\"); you may not use this file excep"
},
{
"path": "deps/cpp-statsd-client/cmake/cpp-statsd-clientConfig.cmake.in",
"chars": 125,
"preview": "@PACKAGE_INIT@\n\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake\")\ncheck_required_components(\"@PROJECT_NAM"
},
{
"path": "deps/cpp-statsd-client/include/cpp-statsd-client/StatsdClient.hpp",
"chars": 11258,
"preview": "#ifndef STATSD_CLIENT_HPP\n#define STATSD_CLIENT_HPP\n\n#include <cpp-statsd-client/UDPSender.hpp>\n#include <cstdint>\n#incl"
},
{
"path": "deps/cpp-statsd-client/include/cpp-statsd-client/UDPSender.hpp",
"chars": 9542,
"preview": "#ifndef UDP_SENDER_HPP\n#define UDP_SENDER_HPP\n\n#ifdef _WIN32\n#define NOMINMAX\n#include <io.h>\n#include <winsock2.h>\n#inc"
},
{
"path": "deps/cpp-statsd-client/tests/StatsdServer.hpp",
"chars": 2345,
"preview": "#ifndef STATSD_SERVER_HPP\n#define STATSD_SERVER_HPP\n\n// It might make sense to include this test class in the UDPSender "
},
{
"path": "deps/cpp-statsd-client/tests/testStatsdClient.cpp",
"chars": 6585,
"preview": "#include <iostream>\n\n#include \"StatsdServer.hpp\"\n#include \"cpp-statsd-client/StatsdClient.hpp\"\n\nusing namespace Statsd;\n"
},
{
"path": "deps/hdr_histogram/COPYING.txt",
"chars": 7048,
"preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
},
{
"path": "deps/hdr_histogram/LICENSE.txt",
"chars": 2161,
"preview": "The code in this repository code was Written by Gil Tene, Michael Barker,\nand Matt Warren, and released to the public do"
},
{
"path": "deps/hdr_histogram/Makefile",
"chars": 254,
"preview": "STD=\nWARN= -Wall\nOPT= -Os\n\nR_CFLAGS= $(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS)\nR_LDFLAGS= $(LDFLAGS)\nDEBUG= -g\n\nR_CC=$(CC"
},
{
"path": "deps/hdr_histogram/README.md",
"chars": 498,
"preview": "HdrHistogram_c v0.11.0\n\n----------------------------------------------\n\nThis port contains a subset of the 'C' version o"
},
{
"path": "deps/hdr_histogram/hdr_atomic.h",
"chars": 3842,
"preview": "/**\n * hdr_atomic.h\n * Written by Philip Orwig and released to the public domain,\n * as explained at http://creativecomm"
},
{
"path": "deps/hdr_histogram/hdr_histogram.c",
"chars": 34757,
"preview": "/**\n * hdr_histogram.c\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativ"
},
{
"path": "deps/hdr_histogram/hdr_histogram.h",
"chars": 17175,
"preview": "/**\n * hdr_histogram.h\n * Written by Michael Barker and released to the public domain,\n * as explained at http://creativ"
},
{
"path": "deps/hiredis/.gitignore",
"chars": 84,
"preview": "/hiredis-test\n/examples/hiredis-example*\n/*.o\n/*.so\n/*.dylib\n/*.a\n/*.pc\n*.dSYM\ntags\n"
},
{
"path": "deps/hiredis/.travis.yml",
"chars": 3384,
"preview": "language: c\ncompiler:\n - gcc\n - clang\n\nos:\n - linux\n - osx\n\ndist: bionic\n\nbranches:\n only:\n - staging\n - tryi"
},
{
"path": "deps/hiredis/CHANGELOG.md",
"chars": 23452,
"preview": "## [1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) - (2020-08-03)\n\nAnnouncing Hiredis v1.0.0, which adds support f"
},
{
"path": "deps/hiredis/CMakeLists.txt",
"chars": 5241,
"preview": "CMAKE_MINIMUM_REQUIRED(VERSION 3.4.0)\nINCLUDE(GNUInstallDirs)\nPROJECT(hiredis)\n\nOPTION(ENABLE_SSL \"Build hiredis_ssl for"
},
{
"path": "deps/hiredis/COPYING",
"chars": 1588,
"preview": "Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\nCopyright (c) 2010-2011, Pieter Noordhuis <pcno"
},
{
"path": "deps/hiredis/Makefile",
"chars": 11740,
"preview": "# Hiredis Makefile\n# Copyright (C) 2010-2011 Salvatore Sanfilippo <antirez at gmail dot com>\n# Copyright (C) 2010-2011 P"
},
{
"path": "deps/hiredis/README.md",
"chars": 28025,
"preview": "[](https://travis-ci.org/redis/hiredis)\n\n**This Readme reflects "
},
{
"path": "deps/hiredis/adapters/ae.h",
"chars": 4271,
"preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
},
{
"path": "deps/hiredis/adapters/glib.h",
"chars": 3854,
"preview": "#ifndef __HIREDIS_GLIB_H__\n#define __HIREDIS_GLIB_H__\n\n#include <glib.h>\n\n#include \"../hiredis.h\"\n#include \"../async.h\"\n"
},
{
"path": "deps/hiredis/adapters/ivykis.h",
"chars": 2327,
"preview": "#ifndef __HIREDIS_IVYKIS_H__\n#define __HIREDIS_IVYKIS_H__\n#include <iv.h>\n#include \"../hiredis.h\"\n#include \"../async.h\"\n"
},
{
"path": "deps/hiredis/adapters/libev.h",
"chars": 5498,
"preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
},
{
"path": "deps/hiredis/adapters/libevent.h",
"chars": 5601,
"preview": "/*\n * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>\n *\n * All rights reserved.\n *\n * Redistri"
},
{
"path": "deps/hiredis/adapters/libuv.h",
"chars": 2580,
"preview": "#ifndef __HIREDIS_LIBUV_H__\n#define __HIREDIS_LIBUV_H__\n#include <stdlib.h>\n#include <uv.h>\n#include \"../hiredis.h\"\n#inc"
},
{
"path": "deps/hiredis/adapters/macosx.h",
"chars": 3870,
"preview": "//\n// Created by Дмитрий Бахвалов on 13.07.15.\n// Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#ifnde"
},
{
"path": "deps/hiredis/adapters/qt.h",
"chars": 4233,
"preview": "/*-\n * Copyright (C) 2014 Pietro Cerutti <gahr@gahr.ch>\n *\n * Redistribution and use in source and binary forms, with or"
},
{
"path": "deps/hiredis/alloc.c",
"chars": 2800,
"preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
},
{
"path": "deps/hiredis/alloc.h",
"chars": 2982,
"preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
},
{
"path": "deps/hiredis/appveyor.yml",
"chars": 743,
"preview": "# Appveyor configuration file for CI build of hiredis on Windows (under Cygwin)\nenvironment:\n matrix:\n - CYG_B"
},
{
"path": "deps/hiredis/async.c",
"chars": 28870,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/async.h",
"chars": 6027,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/async_private.h",
"chars": 3367,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/dict.c",
"chars": 10826,
"preview": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-rand"
},
{
"path": "deps/hiredis/dict.h",
"chars": 4691,
"preview": "/* Hash table implementation.\n *\n * This file implements in memory hash tables with insert/del/replace/find/\n * get-rand"
},
{
"path": "deps/hiredis/examples/CMakeLists.txt",
"chars": 1327,
"preview": "INCLUDE(FindPkgConfig)\n# Check for GLib\n\nPKG_CHECK_MODULES(GLIB2 glib-2.0)\nif (GLIB2_FOUND)\n INCLUDE_DIRECTORIES(${GL"
},
{
"path": "deps/hiredis/examples/example-ae.c",
"chars": 1583,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
},
{
"path": "deps/hiredis/examples/example-glib.c",
"chars": 1632,
"preview": "#include <stdlib.h>\n\n#include <hiredis.h>\n#include <async.h>\n#include <adapters/glib.h>\n\nstatic GMainLoop *mainloop;\n\nst"
},
{
"path": "deps/hiredis/examples/example-ivykis.c",
"chars": 1440,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
},
{
"path": "deps/hiredis/examples/example-libev.c",
"chars": 1427,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
},
{
"path": "deps/hiredis/examples/example-libevent-ssl.c",
"chars": 2322,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <hiredis_s"
},
{
"path": "deps/hiredis/examples/example-libevent.c",
"chars": 1750,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
},
{
"path": "deps/hiredis/examples/example-libuv.c",
"chars": 1468,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <signal.h>\n\n#include <hiredis.h>\n#include <async.h>\n"
},
{
"path": "deps/hiredis/examples/example-macosx.c",
"chars": 1639,
"preview": "//\n// Created by Дмитрий Бахвалов on 13.07.15.\n// Copyright (c) 2015 Dmitry Bakhvalov. All rights reserved.\n//\n\n#inclu"
},
{
"path": "deps/hiredis/examples/example-push.c",
"chars": 6028,
"preview": "/*\n * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>\n *\n * All rights reserved.\n *\n * Redist"
},
{
"path": "deps/hiredis/examples/example-qt.cpp",
"chars": 1047,
"preview": "#include <iostream>\nusing namespace std;\n\n#include <QCoreApplication>\n#include <QTimer>\n\n#include \"example-qt.h\"\n\nvoid g"
},
{
"path": "deps/hiredis/examples/example-qt.h",
"chars": 620,
"preview": "#ifndef __HIREDIS_EXAMPLE_QT_H\n#define __HIREDIS_EXAMPLE_QT_H\n\n#include <adapters/qt.h>\n\nclass ExampleQt : public QObjec"
},
{
"path": "deps/hiredis/examples/example-ssl.c",
"chars": 3104,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include <hiredis.h>\n#include <hiredis_ssl.h>\n#include <win3"
},
{
"path": "deps/hiredis/examples/example.c",
"chars": 2614,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <hiredis.h>\n#include <win32.h>\n\nint main(int argc, c"
},
{
"path": "deps/hiredis/fmacros.h",
"chars": 225,
"preview": "#ifndef __HIREDIS_FMACRO_H\n#define __HIREDIS_FMACRO_H\n\n#define _XOPEN_SOURCE 600\n#define _POSIX_C_SOURCE 200112L\n\n#if de"
},
{
"path": "deps/hiredis/hiredis-config.cmake.in",
"chars": 308,
"preview": "@PACKAGE_INIT@\n\nset_and_check(hiredis_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\nIF (NOT TARGET hiredis::hiredis)\n\tINC"
},
{
"path": "deps/hiredis/hiredis.c",
"chars": 35676,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2014, Pieter Noordh"
},
{
"path": "deps/hiredis/hiredis.h",
"chars": 12753,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2014, Pieter Noordh"
},
{
"path": "deps/hiredis/hiredis.pc.in",
"chars": 369,
"preview": "prefix=@CMAKE_INSTALL_PREFIX@\ninstall_libdir=@CMAKE_INSTALL_LIBDIR@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/${instal"
},
{
"path": "deps/hiredis/hiredis_ssl-config.cmake.in",
"chars": 340,
"preview": "@PACKAGE_INIT@\n\nset_and_check(hiredis_ssl_INCLUDEDIR \"@PACKAGE_INCLUDE_INSTALL_DIR@\")\n\nIF (NOT TARGET hiredis::hiredis_s"
},
{
"path": "deps/hiredis/hiredis_ssl.h",
"chars": 4615,
"preview": "\n/*\n * Copyright (c) 2019, Redis Labs\n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms"
},
{
"path": "deps/hiredis/hiredis_ssl.pc.in",
"chars": 306,
"preview": "prefix=@CMAKE_INSTALL_PREFIX@\nexec_prefix=${prefix}\nlibdir=${exec_prefix}/lib\nincludedir=${prefix}/include\npkgincludedir"
},
{
"path": "deps/hiredis/net.c",
"chars": 19141,
"preview": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfili"
},
{
"path": "deps/hiredis/net.h",
"chars": 2762,
"preview": "/* Extracted from anet.c to work properly with Hiredis error reporting.\n *\n * Copyright (c) 2009-2011, Salvatore Sanfili"
},
{
"path": "deps/hiredis/read.c",
"chars": 21885,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/read.h",
"chars": 4918,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/sds.c",
"chars": 41609,
"preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
},
{
"path": "deps/hiredis/sds.h",
"chars": 9946,
"preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
},
{
"path": "deps/hiredis/sdsalloc.h",
"chars": 2130,
"preview": "/* SDSLib 2.0 -- A C dynamic strings library\n *\n * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot c"
},
{
"path": "deps/hiredis/sockcompat.c",
"chars": 8972,
"preview": "/*\n * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>\n *\n * All rights reserved.\n *\n * Redistribution and u"
},
{
"path": "deps/hiredis/sockcompat.h",
"chars": 4329,
"preview": "/*\n * Copyright (c) 2019, Marcus Geelnard <m at bitsnbites dot eu>\n *\n * All rights reserved.\n *\n * Redistribution and u"
},
{
"path": "deps/hiredis/ssl.c",
"chars": 14359,
"preview": "/*\n * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>\n * Copyright (c) 2010-2011, Pieter Noordh"
},
{
"path": "deps/hiredis/test.c",
"chars": 48667,
"preview": "#include \"fmacros.h\"\n#include \"sockcompat.h\"\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#ifndef _WIN32\n#"
},
{
"path": "deps/hiredis/test.sh",
"chars": 2009,
"preview": "#!/bin/sh -ue\n\nREDIS_SERVER=${REDIS_SERVER:-redis-server}\nREDIS_PORT=${REDIS_PORT:-56379}\nREDIS_SSL_PORT=${REDIS_SSL_POR"
},
{
"path": "deps/hiredis/win32.h",
"chars": 1042,
"preview": "#ifndef _WIN32_HELPER_INCLUDE\n#define _WIN32_HELPER_INCLUDE\n#ifdef _MSC_VER\n\n#include <winsock2.h> /* for struct timeval"
},
{
"path": "deps/jemalloc/.appveyor.yml",
"chars": 985,
"preview": "version: '{build}'\n\nenvironment:\n matrix:\n - MSYSTEM: MINGW64\n CPU: x86_64\n MSVC: amd64\n CONFIG_FLAGS: --enab"
},
{
"path": "deps/jemalloc/.autom4te.cfg",
"chars": 107,
"preview": "begin-language: \"Autoconf-without-aclocal-m4\"\nargs: --no-cache\nend-language: \"Autoconf-without-aclocal-m4\"\n"
},
{
"path": "deps/jemalloc/.cirrus.yml",
"chars": 656,
"preview": "env:\n CIRRUS_CLONE_DEPTH: 1\n ARCH: amd64\n\ntask:\n freebsd_instance:\n matrix:\n image: freebsd-12-0-release-amd6"
},
{
"path": "deps/jemalloc/.gitattributes",
"chars": 19,
"preview": "* text=auto eol=lf\n"
},
{
"path": "deps/jemalloc/.gitignore",
"chars": 1871,
"preview": "/bin/jemalloc-config\n/bin/jemalloc.sh\n/bin/jeprof\n\n/config.stamp\n/config.log\n/config.status\n/configure\n\n/doc/html.xsl\n/d"
},
{
"path": "deps/jemalloc/.travis.yml",
"chars": 12982,
"preview": "language: generic\ndist: precise\n\nmatrix:\n include:\n - os: linux\n env: CC=gcc CXX=g++ COMPILER_FLAGS=\"\" CONFIGUR"
},
{
"path": "deps/jemalloc/COPYING",
"chars": 1709,
"preview": "Unless otherwise specified, files in the jemalloc source distribution are\nsubject to the following license:\n------------"
},
{
"path": "deps/jemalloc/ChangeLog",
"chars": 74379,
"preview": "Following are change highlights associated with official releases. Important\nbug fixes are all mentioned, but some inte"
},
{
"path": "deps/jemalloc/INSTALL.md",
"chars": 14796,
"preview": "Building and installing a packaged release of jemalloc can be as simple as\ntyping the following while in the root direct"
},
{
"path": "deps/jemalloc/Makefile.in",
"chars": 22662,
"preview": "# Clear out all vpaths, then set just one (default vpath) for the main build\n# directory.\nvpath\nvpath % .\n\n# Clear the d"
},
{
"path": "deps/jemalloc/README",
"chars": 1047,
"preview": "jemalloc is a general purpose malloc(3) implementation that emphasizes\nfragmentation avoidance and scalable concurrency "
},
{
"path": "deps/jemalloc/TUNING.md",
"chars": 5920,
"preview": "This document summarizes the common approaches for performance fine tuning with\njemalloc (as of 5.1.0). The default con"
},
{
"path": "deps/jemalloc/VERSION",
"chars": 11,
"preview": "5.2.1-0-g0\n"
},
{
"path": "deps/jemalloc/autogen.sh",
"chars": 266,
"preview": "#!/bin/sh\n\nfor i in autoconf; do\n echo \"$i\"\n $i\n if [ $? -ne 0 ]; then\n\techo \"Error $? in $i\"\n\texit 1\n fi\ndo"
},
{
"path": "deps/jemalloc/bin/jemalloc-config.in",
"chars": 1598,
"preview": "#!/bin/sh\n\nusage() {\n\tcat <<EOF\nUsage:\n @BINDIR@/jemalloc-config <option>\nOptions:\n --help | -h : Print usage.\n --ve"
},
{
"path": "deps/jemalloc/bin/jemalloc.sh.in",
"chars": 151,
"preview": "#!/bin/sh\n\nprefix=@prefix@\nexec_prefix=@exec_prefix@\nlibdir=@libdir@\n\n@LD_PRELOAD_VAR@=${libdir}/libjemalloc.@SOREV@\nexp"
},
{
"path": "deps/jemalloc/bin/jeprof.in",
"chars": 179389,
"preview": "#! /usr/bin/env perl\n\n# Copyright (c) 1998-2007, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source"
},
{
"path": "deps/jemalloc/build-aux/config.guess",
"chars": 43940,
"preview": "#! /bin/sh\n# Attempt to guess a canonical system name.\n# Copyright 1992-2016 Free Software Foundation, Inc.\n\ntimestamp"
},
{
"path": "deps/jemalloc/build-aux/config.sub",
"chars": 36339,
"preview": "#! /bin/sh\n# Configuration validation subroutine script.\n# Copyright 1992-2016 Free Software Foundation, Inc.\n\ntimesta"
},
{
"path": "deps/jemalloc/build-aux/install-sh",
"chars": 5585,
"preview": "#! /bin/sh\n#\n# install - install a program, script, or datafile\n# This comes from X11R5 (mit/util/scripts/install.sh).\n#"
},
{
"path": "deps/jemalloc/config.stamp.in",
"chars": 0,
"preview": ""
},
{
"path": "deps/jemalloc/configure",
"chars": 380298,
"preview": "#! /bin/sh\n# Guess values for system-dependent variables and create Makefiles.\n# Generated by GNU Autoconf 2.69.\n#\n#\n# C"
},
{
"path": "deps/jemalloc/configure.ac",
"chars": 74412,
"preview": "dnl Process this file with autoconf to produce a configure script.\nAC_PREREQ(2.68)\nAC_INIT([Makefile.in])\n\nAC_CONFIG_AUX"
},
{
"path": "deps/jemalloc/doc/html.xsl.in",
"chars": 249,
"preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n <xsl:import href=\"@XSLROOT@/html/docbo"
},
{
"path": "deps/jemalloc/doc/jemalloc.xml.in",
"chars": 160593,
"preview": "<?xml version='1.0' encoding='UTF-8'?>\n<?xml-stylesheet type=\"text/xsl\"\n href=\"http://docbook.sourceforge.net/rel"
},
{
"path": "deps/jemalloc/doc/manpages.xsl.in",
"chars": 207,
"preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n <xsl:import href=\"@XSLROOT@/manpages/d"
},
{
"path": "deps/jemalloc/doc/stylesheet.xsl",
"chars": 415,
"preview": "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" version=\"1.0\">\n <xsl:param name=\"funcsynopsis.style\">a"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_externs.h",
"chars": 4943,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n#define JEMALLOC_INTERNAL_ARENA_EXTERNS_H\n\n#include \"jemalloc/internal/bin.h\"\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_a.h",
"chars": 1474,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_A_H\n\nstatic inline unsigned\narena_in"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_inlines_b.h",
"chars": 11820,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n#define JEMALLOC_INTERNAL_ARENA_INLINES_B_H\n\n#include \"jemalloc/internal/jem"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_stats.h",
"chars": 8109,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_STATS_H\n#define JEMALLOC_INTERNAL_ARENA_STATS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_structs_a.h",
"chars": 293,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_STRUCTS_A_H\n#define JEMALLOC_INTERNAL_ARENA_STRUCTS_A_H\n\n#include \"jemalloc/internal/bit"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_structs_b.h",
"chars": 6792,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_STRUCTS_B_H\n#define JEMALLOC_INTERNAL_ARENA_STRUCTS_B_H\n\n#include \"jemalloc/internal/are"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/arena_types.h",
"chars": 1710,
"preview": "#ifndef JEMALLOC_INTERNAL_ARENA_TYPES_H\n#define JEMALLOC_INTERNAL_ARENA_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n/* M"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/assert.h",
"chars": 1330,
"preview": "#include \"jemalloc/internal/malloc_io.h\"\n#include \"jemalloc/internal/util.h\"\n\n/*\n * Define a custom assert() in order to"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/atomic.h",
"chars": 2722,
"preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_H\n\n#define ATOMIC_INLINE JEMALLOC_ALWAYS_INLINE\n\n#de"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/atomic_c11.h",
"chars": 3546,
"preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_C11_H\n#define JEMALLOC_INTERNAL_ATOMIC_C11_H\n\n#include <stdatomic.h>\n\n#define ATOMIC_IN"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_atomic.h",
"chars": 4153,
"preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_ATOMIC_H\n\n#include \"jemalloc/internal"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/atomic_gcc_sync.h",
"chars": 6363,
"preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n#define JEMALLOC_INTERNAL_ATOMIC_GCC_SYNC_H\n\n#define ATOMIC_INIT(...) {__VA_"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/atomic_msvc.h",
"chars": 5540,
"preview": "#ifndef JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n#define JEMALLOC_INTERNAL_ATOMIC_MSVC_H\n\n#define ATOMIC_INIT(...) {__VA_ARGS__}\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/background_thread_externs.h",
"chars": 1326,
"preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_EXTERNS_H\n\nextern bool"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/background_thread_inlines.h",
"chars": 2136,
"preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_INLINES_H\n\nJEMALLOC_AL"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/background_thread_structs.h",
"chars": 1784,
"preview": "#ifndef JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n#define JEMALLOC_INTERNAL_BACKGROUND_THREAD_STRUCTS_H\n\n/* This fil"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/base_externs.h",
"chars": 946,
"preview": "#ifndef JEMALLOC_INTERNAL_BASE_EXTERNS_H\n#define JEMALLOC_INTERNAL_BASE_EXTERNS_H\n\nextern metadata_thp_mode_t opt_metada"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/base_inlines.h",
"chars": 312,
"preview": "#ifndef JEMALLOC_INTERNAL_BASE_INLINES_H\n#define JEMALLOC_INTERNAL_BASE_INLINES_H\n\nstatic inline unsigned\nbase_ind_get(c"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/base_structs.h",
"chars": 1556,
"preview": "#ifndef JEMALLOC_INTERNAL_BASE_STRUCTS_H\n#define JEMALLOC_INTERNAL_BASE_STRUCTS_H\n\n#include \"jemalloc/internal/jemalloc_"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/base_types.h",
"chars": 1105,
"preview": "#ifndef JEMALLOC_INTERNAL_BASE_TYPES_H\n#define JEMALLOC_INTERNAL_BASE_TYPES_H\n\ntypedef struct base_block_s base_block_t;"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/bin.h",
"chars": 3690,
"preview": "#ifndef JEMALLOC_INTERNAL_BIN_H\n#define JEMALLOC_INTERNAL_BIN_H\n\n#include \"jemalloc/internal/bin_stats.h\"\n#include \"jema"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/bin_stats.h",
"chars": 1383,
"preview": "#ifndef JEMALLOC_INTERNAL_BIN_STATS_H\n#define JEMALLOC_INTERNAL_BIN_STATS_H\n\n#include \"jemalloc/internal/mutex_prof.h\"\n\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/bin_types.h",
"chars": 474,
"preview": "#ifndef JEMALLOC_INTERNAL_BIN_TYPES_H\n#define JEMALLOC_INTERNAL_BIN_TYPES_H\n\n#include \"jemalloc/internal/sc.h\"\n\n#define "
},
{
"path": "deps/jemalloc/include/jemalloc/internal/bit_util.h",
"chars": 5348,
"preview": "#ifndef JEMALLOC_INTERNAL_BIT_UTIL_H\n#define JEMALLOC_INTERNAL_BIT_UTIL_H\n\n#include \"jemalloc/internal/assert.h\"\n\n#defin"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/bitmap.h",
"chars": 11230,
"preview": "#ifndef JEMALLOC_INTERNAL_BITMAP_H\n#define JEMALLOC_INTERNAL_BITMAP_H\n\n#include \"jemalloc/internal/arena_types.h\"\n#inclu"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/cache_bin.h",
"chars": 3779,
"preview": "#ifndef JEMALLOC_INTERNAL_CACHE_BIN_H\n#define JEMALLOC_INTERNAL_CACHE_BIN_H\n\n#include \"jemalloc/internal/ql.h\"\n\n/*\n * Th"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/ckh.h",
"chars": 3265,
"preview": "#ifndef JEMALLOC_INTERNAL_CKH_H\n#define JEMALLOC_INTERNAL_CKH_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/* Cuckoo hashing i"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/ctl.h",
"chars": 3705,
"preview": "#ifndef JEMALLOC_INTERNAL_CTL_H\n#define JEMALLOC_INTERNAL_CTL_H\n\n#include \"jemalloc/internal/jemalloc_internal_types.h\"\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/div.h",
"chars": 1172,
"preview": "#ifndef JEMALLOC_INTERNAL_DIV_H\n#define JEMALLOC_INTERNAL_DIV_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * This modul"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/emitter.h",
"chars": 13374,
"preview": "#ifndef JEMALLOC_INTERNAL_EMITTER_H\n#define JEMALLOC_INTERNAL_EMITTER_H\n\n#include \"jemalloc/internal/ql.h\"\n\ntypedef enum"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_dss.h",
"chars": 728,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_DSS_H\n#define JEMALLOC_INTERNAL_EXTENT_DSS_H\n\ntypedef enum {\n\tdss_prec_disabled = 0,\n\t"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_externs.h",
"chars": 3841,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTENT_EXTERNS_H\n\n#include \"jemalloc/internal/mutex"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_inlines.h",
"chars": 13720,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_INLINES_H\n#define JEMALLOC_INTERNAL_EXTENT_INLINES_H\n\n#include \"jemalloc/internal/mutex"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_mmap.h",
"chars": 328,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTENT_MMAP_EXTERNS_H\n\nextern bool opt_retain;"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_structs.h",
"chars": 8665,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_STRUCTS_H\n#define JEMALLOC_INTERNAL_EXTENT_STRUCTS_H\n\n#include \"jemalloc/internal/atomi"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/extent_types.h",
"chars": 700,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTENT_TYPES_H\n#define JEMALLOC_INTERNAL_EXTENT_TYPES_H\n\ntypedef struct extent_s extent_t;\ntyp"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/hash.h",
"chars": 8083,
"preview": "#ifndef JEMALLOC_INTERNAL_HASH_H\n#define JEMALLOC_INTERNAL_HASH_H\n\n#include \"jemalloc/internal/assert.h\"\n\n/*\n * The foll"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/hook.h",
"chars": 5543,
"preview": "#ifndef JEMALLOC_INTERNAL_HOOK_H\n#define JEMALLOC_INTERNAL_HOOK_H\n\n#include \"jemalloc/internal/tsd.h\"\n\n/*\n * This API is"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_decls.h",
"chars": 2188,
"preview": "#ifndef JEMALLOC_INTERNAL_DECLS_H\n#define JEMALLOC_INTERNAL_DECLS_H\n\n#include <math.h>\n#ifdef _WIN32\n# include <windows"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h.in",
"chars": 10529,
"preview": "#ifndef JEMALLOC_INTERNAL_DEFS_H_\n#define JEMALLOC_INTERNAL_DEFS_H_\n/*\n * If JEMALLOC_PREFIX is defined via --with-jemal"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_externs.h",
"chars": 1797,
"preview": "#ifndef JEMALLOC_INTERNAL_EXTERNS_H\n#define JEMALLOC_INTERNAL_EXTERNS_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include "
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_includes.h",
"chars": 4291,
"preview": "#ifndef JEMALLOC_INTERNAL_INCLUDES_H\n#define JEMALLOC_INTERNAL_INCLUDES_H\n\n/*\n * jemalloc can conceptually be broken int"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_a.h",
"chars": 4499,
"preview": "#ifndef JEMALLOC_INTERNAL_INLINES_A_H\n#define JEMALLOC_INTERNAL_INLINES_A_H\n\n#include \"jemalloc/internal/atomic.h\"\n#incl"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_b.h",
"chars": 2295,
"preview": "#ifndef JEMALLOC_INTERNAL_INLINES_B_H\n#define JEMALLOC_INTERNAL_INLINES_B_H\n\n#include \"jemalloc/internal/rtree.h\"\n\n/* Ch"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_inlines_c.h",
"chars": 8925,
"preview": "#ifndef JEMALLOC_INTERNAL_INLINES_C_H\n#define JEMALLOC_INTERNAL_INLINES_C_H\n\n#include \"jemalloc/internal/hook.h\"\n#includ"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_macros.h",
"chars": 4088,
"preview": "#ifndef JEMALLOC_INTERNAL_MACROS_H\n#define JEMALLOC_INTERNAL_MACROS_H\n\n#ifdef JEMALLOC_DEBUG\n# define JEMALLOC_ALWAYS_I"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_internal_types.h",
"chars": 3505,
"preview": "#ifndef JEMALLOC_INTERNAL_TYPES_H\n#define JEMALLOC_INTERNAL_TYPES_H\n\n#include \"jemalloc/internal/quantum.h\"\n\n/* Page siz"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/jemalloc_preamble.h.in",
"chars": 4041,
"preview": "#ifndef JEMALLOC_PREAMBLE_H\n#define JEMALLOC_PREAMBLE_H\n\n#include \"jemalloc_internal_defs.h\"\n#include \"jemalloc/internal"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/large_externs.h",
"chars": 1429,
"preview": "#ifndef JEMALLOC_INTERNAL_LARGE_EXTERNS_H\n#define JEMALLOC_INTERNAL_LARGE_EXTERNS_H\n\n#include \"jemalloc/internal/hook.h\""
},
{
"path": "deps/jemalloc/include/jemalloc/internal/log.h",
"chars": 3754,
"preview": "#ifndef JEMALLOC_INTERNAL_LOG_H\n#define JEMALLOC_INTERNAL_LOG_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemallo"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/malloc_io.h",
"chars": 2972,
"preview": "#ifndef JEMALLOC_INTERNAL_MALLOC_IO_H\n#define JEMALLOC_INTERNAL_MALLOC_IO_H\n\n#ifdef _WIN32\n# ifdef _WIN64\n# define F"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/mutex.h",
"chars": 9618,
"preview": "#ifndef JEMALLOC_INTERNAL_MUTEX_H\n#define JEMALLOC_INTERNAL_MUTEX_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jem"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/mutex_pool.h",
"chars": 2875,
"preview": "#ifndef JEMALLOC_INTERNAL_MUTEX_POOL_H\n#define JEMALLOC_INTERNAL_MUTEX_POOL_H\n\n#include \"jemalloc/internal/hash.h\"\n#incl"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/mutex_prof.h",
"chars": 3637,
"preview": "#ifndef JEMALLOC_INTERNAL_MUTEX_PROF_H\n#define JEMALLOC_INTERNAL_MUTEX_PROF_H\n\n#include \"jemalloc/internal/atomic.h\"\n#in"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/nstime.h",
"chars": 1304,
"preview": "#ifndef JEMALLOC_INTERNAL_NSTIME_H\n#define JEMALLOC_INTERNAL_NSTIME_H\n\n/* Maximum supported number of seconds (~584 year"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/pages.h",
"chars": 3127,
"preview": "#ifndef JEMALLOC_INTERNAL_PAGES_EXTERNS_H\n#define JEMALLOC_INTERNAL_PAGES_EXTERNS_H\n\n/* Page size. LG_PAGE is determine"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/ph.h",
"chars": 12557,
"preview": "/*\n * A Pairing Heap implementation.\n *\n * \"The Pairing Heap: A New Form of Self-Adjusting Heap\"\n * https://www.cs.cmu.e"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/private_namespace.sh",
"chars": 95,
"preview": "#!/bin/sh\n\nfor symbol in `cat \"$@\"` ; do\n echo \"#define ${symbol} JEMALLOC_N(${symbol})\"\ndone\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/private_symbols.sh",
"chars": 1148,
"preview": "#!/bin/sh\n#\n# Generate private_symbols[_jet].awk.\n#\n# Usage: private_symbols.sh <sym_prefix> <sym>*\n#\n# <sym_prefix> is "
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prng.h",
"chars": 4804,
"preview": "#ifndef JEMALLOC_INTERNAL_PRNG_H\n#define JEMALLOC_INTERNAL_PRNG_H\n\n#include \"jemalloc/internal/atomic.h\"\n#include \"jemal"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prof_externs.h",
"chars": 3882,
"preview": "#ifndef JEMALLOC_INTERNAL_PROF_EXTERNS_H\n#define JEMALLOC_INTERNAL_PROF_EXTERNS_H\n\n#include \"jemalloc/internal/mutex.h\"\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prof_inlines_a.h",
"chars": 2498,
"preview": "#ifndef JEMALLOC_INTERNAL_PROF_INLINES_A_H\n#define JEMALLOC_INTERNAL_PROF_INLINES_A_H\n\n#include \"jemalloc/internal/mutex"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prof_inlines_b.h",
"chars": 6579,
"preview": "#ifndef JEMALLOC_INTERNAL_PROF_INLINES_B_H\n#define JEMALLOC_INTERNAL_PROF_INLINES_B_H\n\n#include \"jemalloc/internal/safet"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prof_structs.h",
"chars": 5139,
"preview": "#ifndef JEMALLOC_INTERNAL_PROF_STRUCTS_H\n#define JEMALLOC_INTERNAL_PROF_STRUCTS_H\n\n#include \"jemalloc/internal/ckh.h\"\n#i"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/prof_types.h",
"chars": 1778,
"preview": "#ifndef JEMALLOC_INTERNAL_PROF_TYPES_H\n#define JEMALLOC_INTERNAL_PROF_TYPES_H\n\ntypedef struct prof_bt_s prof_bt_t;\ntyped"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/public_namespace.sh",
"chars": 129,
"preview": "#!/bin/sh\n\nfor nm in `cat $1` ; do\n n=`echo ${nm} |tr ':' ' ' |awk '{print $1}'`\n echo \"#define je_${n} JEMALLOC_N(${n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/public_unnamespace.sh",
"chars": 111,
"preview": "#!/bin/sh\n\nfor nm in `cat $1` ; do\n n=`echo ${nm} |tr ':' ' ' |awk '{print $1}'`\n echo \"#undef je_${n}\"\ndone\n"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/ql.h",
"chars": 2504,
"preview": "#ifndef JEMALLOC_INTERNAL_QL_H\n#define JEMALLOC_INTERNAL_QL_H\n\n#include \"jemalloc/internal/qr.h\"\n\n/* List definitions. *"
},
{
"path": "deps/jemalloc/include/jemalloc/internal/qr.h",
"chars": 2350,
"preview": "#ifndef JEMALLOC_INTERNAL_QR_H\n#define JEMALLOC_INTERNAL_QR_H\n\n/* Ring definitions. */\n#define qr(a_type)\t\t\t\t\t\t\t\\\nstruct"
}
]
// ... and 1422 more files (download for full content)
About this extraction
This page contains the full source code of the Snapchat/KeyDB GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1622 files (16.1 MB), approximately 4.0M tokens, and a symbol index with 11352 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.